MDEV-13298 Change sp_head::m_chistics from a pointer to a structure

Author: Alexander Barkov

sql/event_data_objects.cc

@@ -1426,7 +1426,13 @@ Event_job_data::execute(THD *thd, bool drop)
     sphead->m_flags|= sp_head::LOG_SLOW_STATEMENTS;
     sphead->m_flags|= sp_head::LOG_GENERAL_LOG;
 
-    sphead->set_info(0, 0, &thd->lex->sp_chistics, sql_mode);
+    /*
+      construct_sp_sql() + parse_sql() set suid to SP_IS_NOT_SUID,
+      because we have the security context already set to the event
+      definer here. See more comments in construct_sp_sql().
+    */
+    DBUG_ASSERT(sphead->suid() == SP_IS_NOT_SUID);
+    sphead->m_sql_mode= sql_mode;
     sphead->set_creation_ctx(creation_ctx);
     sphead->optimize();
 

sql/field.h

@@ -818,6 +818,8 @@ class Field: public Value_source
   { return store(ls->str, ls->length, cs); }
   int store(const LEX_CSTRING *ls, CHARSET_INFO *cs)
   { return store(ls->str, ls->length, cs); }
+  int store(const LEX_CSTRING &ls, CHARSET_INFO *cs)
+  { return store(ls.str, ls.length, cs); }
   virtual double val_real(void)=0;
   virtual longlong val_int(void)=0;
   virtual bool val_bool(void)= 0;

sql/item_func.cc

@@ -6316,7 +6316,7 @@ Item_func_sp::init_result_field(THD *thd)
 
 bool Item_func_sp::is_expensive()
 {
-  return !m_sp->m_chistics->detistic ||
+  return !m_sp->detistic() ||
           current_thd->locked_tables_mode < LTM_LOCK_TABLES;
 }
 
@@ -6390,8 +6390,8 @@ Item_func_sp::execute_impl(THD *thd)
   Sub_statement_state statement_state;
   Security_context *save_security_ctx= thd->security_ctx;
   enum enum_sp_data_access access=
-    (m_sp->m_chistics->daccess == SP_DEFAULT_ACCESS) ?
-     SP_DEFAULT_ACCESS_MAPPING : m_sp->m_chistics->daccess;
+    (m_sp->daccess() == SP_DEFAULT_ACCESS) ?
+     SP_DEFAULT_ACCESS_MAPPING : m_sp->daccess();
 
   DBUG_ENTER("Item_func_sp::execute_impl");
 
@@ -6408,7 +6408,7 @@ Item_func_sp::execute_impl(THD *thd)
     statement-based replication (SBR) is active.
   */
 
-  if (!m_sp->m_chistics->detistic && !trust_function_creators &&
+  if (!m_sp->detistic() && !trust_function_creators &&
       (access == SP_CONTAINS_SQL || access == SP_MODIFIES_SQL_DATA) &&
       (mysql_bin_log.is_open() &&
        thd->variables.binlog_format == BINLOG_FORMAT_STMT))
@@ -6590,7 +6590,7 @@ Item_func_sp::fix_fields(THD *thd, Item **ref)
 #endif /* ! NO_EMBEDDED_ACCESS_CHECKS */
   }
 
-  if (!m_sp->m_chistics->detistic)
+  if (!m_sp->detistic())
   {
     used_tables_cache |= RAND_TABLE_BIT;
     const_item_cache= FALSE;
@@ -6604,7 +6604,7 @@ void Item_func_sp::update_used_tables()
 {
   Item_func::update_used_tables();
 
-  if (!m_sp->m_chistics->detistic)
+  if (!m_sp->detistic())
   {
     used_tables_cache |= RAND_TABLE_BIT;
     const_item_cache= FALSE;

sql/sp.cc

@@ -487,9 +487,8 @@ db_find_routine_aux(THD *thd, stored_procedure_type type, const sp_name *name,
   */
   if (name->m_name.length > table->field[1]->field_length)
     DBUG_RETURN(SP_KEY_NOT_FOUND);
-  table->field[0]->store(name->m_db.str, name->m_db.length, &my_charset_bin);
-  table->field[1]->store(name->m_name.str, name->m_name.length,
-                         &my_charset_bin);
+  table->field[0]->store(name->m_db, &my_charset_bin);
+  table->field[1]->store(name->m_name, &my_charset_bin);
   table->field[2]->store((longlong) type, TRUE);
   key_copy(key, table->record[0], table->key_info,
            table->key_info->key_length);
@@ -533,7 +532,7 @@ db_find_routine(THD *thd, stored_procedure_type type, const sp_name *name,
   const char *definer;
   longlong created;
   longlong modified;
-  st_sp_chistics chistics;
+  Sp_chistics chistics;
   char *ptr;
   uint length;
   char buff[65];
@@ -567,7 +566,6 @@ db_find_routine(THD *thd, stored_procedure_type type, const sp_name *name,
     goto done;
   }
 
-  bzero((char *)&chistics, sizeof(chistics));
   if ((ptr= get_field(thd->mem_root,
 		      table->field[MYSQL_PROC_FIELD_ACCESS])) == NULL)
   {
@@ -849,7 +847,7 @@ db_load_routine(THD *thd, stored_procedure_type type,
                      params, strlen(params),
                      returns, strlen(returns),
                      body, strlen(body),
-                     &chistics, definer_user_name, definer_host_name,
+                     chistics, definer_user_name, definer_host_name,
                      sql_mode))
   {
     ret= SP_INTERNAL_ERROR;
@@ -902,7 +900,7 @@ db_load_routine(THD *thd, stored_procedure_type type,
     }
 
     (*sphp)->set_definer(definer_user_name, definer_host_name);
-    (*sphp)->set_info(created, modified, &chistics, sql_mode);
+    (*sphp)->set_info(created, modified, chistics, sql_mode);
     (*sphp)->set_creation_ctx(creation_ctx);
     (*sphp)->optimize();
     /*
@@ -1139,41 +1137,41 @@ sp_create_routine(THD *thd, stored_procedure_type type, sp_head *sp)
 
     store_failed=
       table->field[MYSQL_PROC_FIELD_DB]->
-        store(sp->m_db.str, sp->m_db.length, system_charset_info);
+        store(sp->m_db, system_charset_info);
 
     store_failed= store_failed ||
       table->field[MYSQL_PROC_FIELD_NAME]->
-        store(sp->m_name.str, sp->m_name.length, system_charset_info);
+        store(sp->m_name, system_charset_info);
 
     store_failed= store_failed ||
       table->field[MYSQL_PROC_MYSQL_TYPE]->
         store((longlong)type, TRUE);
 
     store_failed= store_failed ||
       table->field[MYSQL_PROC_FIELD_SPECIFIC_NAME]->
-        store(sp->m_name.str, sp->m_name.length, system_charset_info);
+        store(sp->m_name, system_charset_info);
 
-    if (sp->m_chistics->daccess != SP_DEFAULT_ACCESS)
+    if (sp->daccess() != SP_DEFAULT_ACCESS)
     {
       store_failed= store_failed ||
         table->field[MYSQL_PROC_FIELD_ACCESS]->
-          store((longlong)sp->m_chistics->daccess, TRUE);
+          store((longlong)sp->daccess(), TRUE);
     }
 
     store_failed= store_failed ||
       table->field[MYSQL_PROC_FIELD_DETERMINISTIC]->
-        store((longlong)(sp->m_chistics->detistic ? 1 : 2), TRUE);
+        store((longlong)(sp->detistic() ? 1 : 2), TRUE);
 
-    if (sp->m_chistics->suid != SP_IS_DEFAULT_SUID)
+    if (sp->suid() != SP_IS_DEFAULT_SUID)
     {
       store_failed= store_failed ||
         table->field[MYSQL_PROC_FIELD_SECURITY_TYPE]->
-          store((longlong)sp->m_chistics->suid, TRUE);
+          store((longlong)sp->suid(), TRUE);
     }
 
     store_failed= store_failed ||
       table->field[MYSQL_PROC_FIELD_PARAM_LIST]->
-        store(sp->m_params.str, sp->m_params.length, system_charset_info);
+        store(sp->m_params, system_charset_info);
 
     if (sp->m_type == TYPE_ENUM_FUNCTION)
     {
@@ -1186,11 +1184,11 @@ sp_create_routine(THD *thd, stored_procedure_type type, sp_head *sp)
 
     store_failed= store_failed ||
       table->field[MYSQL_PROC_FIELD_BODY]->
-        store(sp->m_body.str, sp->m_body.length, system_charset_info);
+        store(sp->m_body, system_charset_info);
 
     store_failed= store_failed ||
       table->field[MYSQL_PROC_FIELD_DEFINER]->
-        store(definer.str, definer.length, system_charset_info);
+        store(definer, system_charset_info);
 
     ((Field_timestamp *)table->field[MYSQL_PROC_FIELD_CREATED])->set_time();
     ((Field_timestamp *)table->field[MYSQL_PROC_FIELD_MODIFIED])->set_time();
@@ -1199,26 +1197,25 @@ sp_create_routine(THD *thd, stored_procedure_type type, sp_head *sp)
       table->field[MYSQL_PROC_FIELD_SQL_MODE]->
         store((longlong)saved_mode, TRUE);
 
-    if (sp->m_chistics->comment.str)
+    if (sp->comment().str)
     {
       store_failed= store_failed ||
         table->field[MYSQL_PROC_FIELD_COMMENT]->
-          store(sp->m_chistics->comment.str, sp->m_chistics->comment.length,
-                system_charset_info);
+          store(sp->comment(), system_charset_info);
     }
 
     if ((sp->m_type == TYPE_ENUM_FUNCTION) &&
         !trust_function_creators && mysql_bin_log.is_open())
     {
-      if (!sp->m_chistics->detistic)
+      if (!sp->detistic())
       {
 	/*
 	  Note that this test is not perfect; one could use
 	  a non-deterministic read-only function in an update statement.
 	*/
 	enum enum_sp_data_access access=
-	  (sp->m_chistics->daccess == SP_DEFAULT_ACCESS) ?
-	  SP_DEFAULT_ACCESS_MAPPING : sp->m_chistics->daccess;
+	  (sp->daccess() == SP_DEFAULT_ACCESS) ?
+	  SP_DEFAULT_ACCESS_MAPPING : sp->daccess();
 	if (access == SP_CONTAINS_SQL ||
 	    access == SP_MODIFIES_SQL_DATA)
 	{
@@ -1255,7 +1252,7 @@ sp_create_routine(THD *thd, stored_procedure_type type, sp_head *sp)
     table->field[MYSQL_PROC_FIELD_BODY_UTF8]->set_notnull();
     store_failed= store_failed ||
       table->field[MYSQL_PROC_FIELD_BODY_UTF8]->store(
-        sp->m_body_utf8.str, sp->m_body_utf8.length, system_charset_info);
+        sp->m_body_utf8, system_charset_info);
 
     if (store_failed)
     {
@@ -1291,7 +1288,7 @@ sp_create_routine(THD *thd, stored_procedure_type type, sp_head *sp)
                        sp->m_params.str, sp->m_params.length,
                        retstr.ptr(), retstr.length(),
                        sp->m_body.str, sp->m_body.length,
-                       sp->m_chistics, &(thd->lex->definer->user),
+                       sp->chistics(), &(thd->lex->definer->user),
                        &(thd->lex->definer->host),
                        saved_mode))
     {
@@ -1448,8 +1445,7 @@ sp_update_routine(THD *thd, stored_procedure_type type, const sp_name *name,
       table->field[MYSQL_PROC_FIELD_ACCESS]->
 	store((longlong)chistics->daccess, TRUE);
     if (chistics->comment.str)
-      table->field[MYSQL_PROC_FIELD_COMMENT]->store(chistics->comment.str,
-						    chistics->comment.length,
+      table->field[MYSQL_PROC_FIELD_COMMENT]->store(chistics->comment,
 						    system_charset_info);
     if ((ret= table->file->ha_update_row(table->record[1],table->record[0])) &&
         ret != HA_ERR_RECORD_IS_THE_SAME)
@@ -1792,7 +1788,7 @@ sp_find_routine(THD *thd, stored_procedure_type type, const sp_name *name,
     }
     if (db_load_routine(thd, type, name, &new_sp,
                         sp->m_sql_mode, sp->m_params.str, returns,
-                        sp->m_body.str, *sp->m_chistics,
+                        sp->m_body.str, sp->chistics(),
                         &sp->m_definer.user, &sp->m_definer.host,
                         sp->m_created, sp->m_modified,
                         sp->get_creation_ctx()) == SP_OK)
@@ -2201,15 +2197,15 @@ show_create_sp(THD *thd, String *buf,
               const char *params, ulong paramslen,
               const char *returns, ulong returnslen,
               const char *body, ulong bodylen,
-              const st_sp_chistics *chistics,
+              const st_sp_chistics &chistics,
               const LEX_CSTRING *definer_user,
               const LEX_CSTRING *definer_host,
               sql_mode_t sql_mode)
 {
   sql_mode_t old_sql_mode= thd->variables.sql_mode;
   /* Make some room to begin with */
   if (buf->alloc(100 + dblen + 1 + namelen + paramslen + returnslen + bodylen +
-		 chistics->comment.length + 10 /* length of " DEFINER= "*/ +
+		 chistics.comment.length + 10 /* length of " DEFINER= "*/ +
                  USER_HOST_BUFF_SIZE))
     return FALSE;
 
@@ -2243,7 +2239,7 @@ show_create_sp(THD *thd, String *buf,
     buf->append(returns, returnslen);
   }
   buf->append('\n');
-  switch (chistics->daccess) {
+  switch (chistics.daccess) {
   case SP_NO_SQL:
     buf->append(STRING_WITH_LEN("    NO SQL\n"));
     break;
@@ -2258,14 +2254,14 @@ show_create_sp(THD *thd, String *buf,
     /* Do nothing */
     break;
   }
-  if (chistics->detistic)
+  if (chistics.detistic)
     buf->append(STRING_WITH_LEN("    DETERMINISTIC\n"));
-  if (chistics->suid == SP_IS_NOT_SUID)
+  if (chistics.suid == SP_IS_NOT_SUID)
     buf->append(STRING_WITH_LEN("    SQL SECURITY INVOKER\n"));
-  if (chistics->comment.length)
+  if (chistics.comment.length)
   {
     buf->append(STRING_WITH_LEN("    COMMENT "));
-    append_unescaped(buf, chistics->comment.str, chistics->comment.length);
+    append_unescaped(buf, chistics.comment.str, chistics.comment.length);
     buf->append('\n');
   }
   buf->append(body, bodylen);
@@ -2303,7 +2299,6 @@ sp_load_for_information_schema(THD *thd, TABLE *proc_table, String *db,
 {
   const char *sp_body;
   String defstr;
-  struct st_sp_chistics sp_chistics;
   const LEX_CSTRING definer_user= {STRING_WITH_LEN("")};
   const LEX_CSTRING definer_host= {STRING_WITH_LEN("")}; 
   LEX_CSTRING sp_db_str;
@@ -2326,15 +2321,14 @@ sp_load_for_information_schema(THD *thd, TABLE *proc_table, String *db,
   Stored_program_creation_ctx *creation_ctx= 
     Stored_routine_creation_ctx::load_from_db(thd, &sp_name_obj, proc_table);
   sp_body= (type == TYPE_ENUM_FUNCTION ? "RETURN NULL" : "BEGIN END");
-  bzero((char*) &sp_chistics, sizeof(sp_chistics));
   defstr.set_charset(creation_ctx->get_client_cs());
   if (!show_create_sp(thd, &defstr, type,
                      sp_db_str.str, sp_db_str.length, 
                      sp_name_obj.m_name.str, sp_name_obj.m_name.length, 
                      params, strlen(params),
                      returns, strlen(returns), 
                      sp_body, strlen(sp_body),
-                     &sp_chistics, &definer_user, &definer_host, sql_mode))
+                     Sp_chistics(), &definer_user, &definer_host, sql_mode))
     return 0;
 
   thd->lex= &newlex;

sql/sp.h

@@ -240,7 +240,7 @@ bool show_create_sp(THD *thd, String *buf,
               const char *params, ulong paramslen,
               const char *returns, ulong returnslen,
               const char *body, ulong bodylen,
-              const st_sp_chistics *chistics,
+              const st_sp_chistics &chistics,
               const LEX_CSTRING *definer_user,
               const LEX_CSTRING *definer_host,
 	      sql_mode_t sql_mode);

sql/sp_head.cc

@@ -559,6 +559,8 @@ sp_head::sp_head(stored_procedure_type type)
    m_sp_cache_version(0),
    m_creation_ctx(0),
    unsafe_flags(0),
+   m_created(0),
+   m_modified(0),
    m_recursion_level(0),
    m_next_cached_sp(0),
    m_param_begin(NULL),
@@ -1408,7 +1410,7 @@ set_routine_security_ctx(THD *thd, sp_head *sp, bool is_proc,
                          Security_context **save_ctx)
 {
   *save_ctx= 0;
-  if (sp->m_chistics->suid != SP_IS_NOT_SUID &&
+  if (sp->suid() != SP_IS_NOT_SUID &&
       sp->m_security_ctx.change_security_context(thd, &sp->m_definer.user,
                                                  &sp->m_definer.host,
                                                  &sp->m_db,
@@ -1520,7 +1522,7 @@ sp_head::execute_trigger(THD *thd,
   Security_context *save_ctx= NULL;
 
 
-  if (m_chistics->suid != SP_IS_NOT_SUID &&
+  if (suid() != SP_IS_NOT_SUID &&
       m_security_ctx.change_security_context(thd,
                                              &m_definer.user,
                                              &m_definer.host,
@@ -2432,20 +2434,26 @@ sp_head::sp_add_instr_cpush_for_cursors(THD *thd, sp_pcontext *pcontext)
 }
 
 
+void
+sp_head::set_chistics(const st_sp_chistics &chistics)
+{
+  m_chistics.set(chistics);
+  if (m_chistics.comment.length == 0)
+    m_chistics.comment.str= 0;
+  else
+    m_chistics.comment.str= strmake_root(mem_root,
+                                         m_chistics.comment.str,
+                                         m_chistics.comment.length);
+}
+
+
 void
 sp_head::set_info(longlong created, longlong modified,
-                  const st_sp_chistics *chistics, sql_mode_t sql_mode)
+                  const st_sp_chistics &chistics, sql_mode_t sql_mode)
 {
   m_created= created;
   m_modified= modified;
-  m_chistics= (st_sp_chistics *) memdup_root(mem_root, (char*) chistics,
-                                             sizeof(*chistics));
-  if (m_chistics->comment.length == 0)
-    m_chistics->comment.str= 0;
-  else
-    m_chistics->comment.str= strmake_root(mem_root,
-                                          m_chistics->comment.str,
-                                          m_chistics->comment.length);
+  set_chistics(chistics);
   m_sql_mode= sql_mode;
 }