diff options
Diffstat (limited to 'sql/sql_trigger.cc')
| -rw-r--r-- | sql/sql_trigger.cc | 1358 |
1 files changed, 915 insertions, 443 deletions
diff --git a/sql/sql_trigger.cc b/sql/sql_trigger.cc index bead50e1da8..32389bde44c 100644 --- a/sql/sql_trigger.cc +++ b/sql/sql_trigger.cc @@ -20,12 +20,155 @@ #include "sql_trigger.h" #include "parse_file.h" -static const LEX_STRING triggers_file_type= - {(char *) STRING_WITH_LEN("TRIGGERS")}; +/*************************************************************************/ -const char * const triggers_file_ext= ".TRG"; +template <class T> +inline T *alloc_type(MEM_ROOT *m) +{ + return (T *) alloc_root(m, sizeof (T)); +} /* + NOTE: Since alloc_type() is declared as inline, alloc_root() calls should + be inlined by the compiler. So, implementation of alloc_root() is not + needed. However, let's put the implementation in object file just in case + of stupid MS or other old compilers. +*/ + +template LEX_STRING *alloc_type<LEX_STRING>(MEM_ROOT *m); +template ulonglong *alloc_type<ulonglong>(MEM_ROOT *m); + +inline LEX_STRING *alloc_lex_string(MEM_ROOT *m) +{ + return alloc_type<LEX_STRING>(m); +} + +/*************************************************************************/ +/** + Trigger_creation_ctx -- creation context of triggers. +*/ + +class Trigger_creation_ctx : public Stored_program_creation_ctx, + public Sql_alloc +{ +public: + static Trigger_creation_ctx *create(THD *thd, + const char *db_name, + const char *table_name, + const LEX_STRING *client_cs_name, + const LEX_STRING *connection_cl_name, + const LEX_STRING *db_cl_name); + +public: + virtual Stored_program_creation_ctx *clone(MEM_ROOT *mem_root) + { + return new (mem_root) Trigger_creation_ctx(m_client_cs, + m_connection_cl, + m_db_cl); + } + +protected: + virtual Object_creation_ctx *create_backup_ctx(THD *thd) const + { + return new Trigger_creation_ctx(thd); + } + +private: + Trigger_creation_ctx(THD *thd) + :Stored_program_creation_ctx(thd) + { } + + Trigger_creation_ctx(CHARSET_INFO *client_cs, + CHARSET_INFO *connection_cl, + CHARSET_INFO *db_cl) + :Stored_program_creation_ctx(client_cs, connection_cl, db_cl) + { } +}; + +/************************************************************************** + Trigger_creation_ctx implementation. +**************************************************************************/ + +Trigger_creation_ctx * +Trigger_creation_ctx::create(THD *thd, + const char *db_name, + const char *table_name, + const LEX_STRING *client_cs_name, + const LEX_STRING *connection_cl_name, + const LEX_STRING *db_cl_name) +{ + CHARSET_INFO *client_cs; + CHARSET_INFO *connection_cl; + CHARSET_INFO *db_cl; + + bool invalid_creation_ctx= FALSE; + + if (resolve_charset(client_cs_name->str, + thd->variables.character_set_client, + &client_cs)) + { + sql_print_warning("Trigger for table '%s'.'%s': " + "invalid character_set_client value (%s).", + (const char *) db_name, + (const char *) table_name, + (const char *) client_cs_name->str); + + invalid_creation_ctx= TRUE; + } + + if (resolve_collation(connection_cl_name->str, + thd->variables.collation_connection, + &connection_cl)) + { + sql_print_warning("Trigger for table '%s'.'%s': " + "invalid collation_connection value (%s).", + (const char *) db_name, + (const char *) table_name, + (const char *) connection_cl_name->str); + + invalid_creation_ctx= TRUE; + } + + if (resolve_collation(db_cl_name->str, NULL, &db_cl)) + { + sql_print_warning("Trigger for table '%s'.'%s': " + "invalid database_collation value (%s).", + (const char *) db_name, + (const char *) table_name, + (const char *) db_cl_name->str); + + invalid_creation_ctx= TRUE; + } + + if (invalid_creation_ctx) + { + push_warning_printf(thd, + MYSQL_ERROR::WARN_LEVEL_WARN, + ER_TRG_INVALID_CREATION_CTX, + ER(ER_TRG_INVALID_CREATION_CTX), + (const char *) db_name, + (const char *) table_name); + } + + /* + If we failed to resolve the database collation, load the default one + from the disk. + */ + + if (!db_cl) + db_cl= get_default_db_collation(thd, db_name); + + return new Trigger_creation_ctx(client_cs, connection_cl, db_cl); +} + +/*************************************************************************/ + +static const LEX_STRING triggers_file_type= + { C_STRING_WITH_LEN("TRIGGERS") }; + +const char * const TRG_EXT= ".TRG"; + +/** Table of .TRG file field descriptors. We have here only one field now because in nearest future .TRG files will be merged into .FRM files (so we don't need something @@ -34,37 +177,52 @@ const char * const triggers_file_ext= ".TRG"; static File_option triggers_file_parameters[]= { { - {(char *) STRING_WITH_LEN("triggers") }, + { C_STRING_WITH_LEN("triggers") }, my_offsetof(class Table_triggers_list, definitions_list), FILE_OPTIONS_STRLIST }, { - {(char *) STRING_WITH_LEN("sql_modes") }, + { C_STRING_WITH_LEN("sql_modes") }, my_offsetof(class Table_triggers_list, definition_modes_list), FILE_OPTIONS_ULLLIST }, { - {(char *) STRING_WITH_LEN("definers") }, + { C_STRING_WITH_LEN("definers") }, my_offsetof(class Table_triggers_list, definers_list), FILE_OPTIONS_STRLIST }, + { + { C_STRING_WITH_LEN("client_cs_names") }, + my_offsetof(class Table_triggers_list, client_cs_names), + FILE_OPTIONS_STRLIST + }, + { + { C_STRING_WITH_LEN("connection_cl_names") }, + my_offsetof(class Table_triggers_list, connection_cl_names), + FILE_OPTIONS_STRLIST + }, + { + { C_STRING_WITH_LEN("db_cl_names") }, + my_offsetof(class Table_triggers_list, db_cl_names), + FILE_OPTIONS_STRLIST + }, { { 0, 0 }, 0, FILE_OPTIONS_STRING } }; File_option sql_modes_parameters= { - {(char*) STRING_WITH_LEN("sql_modes") }, + { C_STRING_WITH_LEN("sql_modes") }, my_offsetof(class Table_triggers_list, definition_modes_list), FILE_OPTIONS_ULLLIST }; -/* +/** This must be kept up to date whenever a new option is added to the list above, as it specifies the number of required parameters of the trigger in .trg file. */ -static const int TRG_NUM_REQUIRED_PARAMETERS= 4; +static const int TRG_NUM_REQUIRED_PARAMETERS= 6; /* Structure representing contents of .TRN file which are used to support @@ -77,14 +235,14 @@ struct st_trigname }; static const LEX_STRING trigname_file_type= - {(char *) STRING_WITH_LEN("TRIGGERNAME")}; + { C_STRING_WITH_LEN("TRIGGERNAME") }; -const char * const trigname_file_ext= ".TRN"; +const char * const TRN_EXT= ".TRN"; static File_option trigname_file_parameters[]= { { - {(char *) STRING_WITH_LEN("trigger_table")}, + { C_STRING_WITH_LEN("trigger_table")}, offsetof(struct st_trigname, trigger_table), FILE_OPTIONS_ESTRING }, @@ -94,15 +252,15 @@ static File_option trigname_file_parameters[]= const LEX_STRING trg_action_time_type_names[]= { - { (char *) STRING_WITH_LEN("BEFORE") }, - { (char *) STRING_WITH_LEN("AFTER") } + { C_STRING_WITH_LEN("BEFORE") }, + { C_STRING_WITH_LEN("AFTER") } }; const LEX_STRING trg_event_type_names[]= { - { (char *) STRING_WITH_LEN("INSERT") }, - { (char *) STRING_WITH_LEN("UPDATE") }, - { (char *) STRING_WITH_LEN("DELETE") } + { C_STRING_WITH_LEN("INSERT") }, + { C_STRING_WITH_LEN("UPDATE") }, + { C_STRING_WITH_LEN("DELETE") } }; @@ -114,10 +272,11 @@ public: Handle_old_incorrect_sql_modes_hook(char *file_path) :path(file_path) {}; - virtual bool process_unknown_string(char *&unknown_key, gptr base, + virtual bool process_unknown_string(char *&unknown_key, uchar* base, MEM_ROOT *mem_root, char *end); }; + class Handle_old_incorrect_trigger_table_hook: public Unknown_key_hook { public: @@ -125,30 +284,35 @@ public: LEX_STRING *trigger_table_arg) :path(file_path), trigger_table_value(trigger_table_arg) {}; - virtual bool process_unknown_string(char *&unknown_key, gptr base, + virtual bool process_unknown_string(char *&unknown_key, uchar* base, MEM_ROOT *mem_root, char *end); private: char *path; LEX_STRING *trigger_table_value; }; -/* + +/** Create or drop trigger for table. - SYNOPSIS - mysql_create_or_drop_trigger() - thd - current thread context (including trigger definition in LEX) - tables - table list containing one table for which trigger is created. - create - whenever we create (TRUE) or drop (FALSE) trigger + @param thd current thread context (including trigger definition in LEX) + @param tables table list containing one table for which trigger is created. + @param create whenever we create (TRUE) or drop (FALSE) trigger - NOTE + @note This function is mainly responsible for opening and locking of table and invalidation of all its instances in table cache after trigger creation. Real work on trigger creation/dropping is done inside Table_triggers_list methods. - RETURN VALUE + @todo + TODO: We should check if user has TRIGGER privilege for table here. + Now we just require SUPER privilege for creating/dropping because + we don't have proper privilege checking for triggers in place yet. + + @retval FALSE Success + @retval TRUE error */ bool mysql_create_or_drop_trigger(THD *thd, TABLE_LIST *tables, bool create) @@ -163,6 +327,7 @@ bool mysql_create_or_drop_trigger(THD *thd, TABLE_LIST *tables, bool create) TABLE *table; bool result= TRUE; String stmt_query; + bool need_start_waiting= FALSE; DBUG_ENTER("mysql_create_or_drop_trigger"); @@ -195,14 +360,6 @@ bool mysql_create_or_drop_trigger(THD *thd, TABLE_LIST *tables, bool create) } /* - TODO: We should check if user has TRIGGER privilege for table here. - Now we just require SUPER privilege for creating/dropping because - we don't have proper privilege checking for triggers in place yet. - */ - if (check_global_access(thd, SUPER_ACL)) - DBUG_RETURN(TRUE); - - /* There is no DETERMINISTIC clause for triggers, so can't check it. But a trigger can in theory be used to do nasty things (if it supported DROP for example) so we do the check for privileges. For now there is @@ -222,10 +379,12 @@ bool mysql_create_or_drop_trigger(THD *thd, TABLE_LIST *tables, bool create) /* We don't want perform our operations while global read lock is held so we have to wait until its end and then prevent it from occurring - again until we are done. (Acquiring LOCK_open is not enough because - global read lock is held without holding LOCK_open). + again until we are done, unless we are under lock tables. (Acquiring + LOCK_open is not enough because global read lock is held without holding + LOCK_open). */ - if (wait_if_global_read_lock(thd, 0, 1)) + if (!thd->locked_tables && + !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1))) DBUG_RETURN(TRUE); VOID(pthread_mutex_lock(&LOCK_open)); @@ -255,6 +414,22 @@ bool mysql_create_or_drop_trigger(THD *thd, TABLE_LIST *tables, bool create) } } + /* + Check that the user has TRIGGER privilege on the subject table. + */ + { + bool err_status; + TABLE_LIST **save_query_tables_own_last= thd->lex->query_tables_own_last; + thd->lex->query_tables_own_last= 0; + + err_status= check_table_access(thd, TRIGGER_ACL, tables, 1, FALSE); + + thd->lex->query_tables_own_last= save_query_tables_own_last; + + if (err_status) + goto end; + } + /* We should have only one table in table list. */ DBUG_ASSERT(tables->next_global == 0); @@ -265,16 +440,30 @@ bool mysql_create_or_drop_trigger(THD *thd, TABLE_LIST *tables, bool create) goto end; } - if (lock_table_names(thd, tables)) - goto end; - /* We also don't allow creation of triggers on views. */ tables->required_type= FRMTYPE_TABLE; - if (reopen_name_locked_table(thd, tables, TRUE)) + /* Keep consistent with respect to other DDL statements */ + mysql_ha_rm_tables(thd, tables, TRUE); + + if (thd->locked_tables) { - unlock_table_name(thd, tables); - goto end; + /* Table must be write locked */ + if (name_lock_locked_table(thd, tables)) + goto end; + } + else + { + /* Grab the name lock and insert the placeholder*/ + if (lock_table_names(thd, tables)) + goto end; + + /* Convert the placeholder to a real table */ + if (reopen_name_locked_table(thd, tables, TRUE)) + { + unlock_table_name(thd, tables); + goto end; + } } table= tables->table; @@ -294,63 +483,75 @@ bool mysql_create_or_drop_trigger(THD *thd, TABLE_LIST *tables, bool create) table->triggers->create_trigger(thd, tables, &stmt_query): table->triggers->drop_trigger(thd, tables, &stmt_query)); -end: - - if (!result) + /* Under LOCK TABLES we must reopen the table to activate the trigger. */ + if (!result && thd->locked_tables) { - if (mysql_bin_log.is_open()) + /* Make table suitable for reopening */ + close_data_files_and_morph_locks(thd, tables->db, tables->table_name); + thd->in_lock_tables= 1; + if (reopen_tables(thd, 1, 1)) { - thd->clear_error(); + /* To be safe remove this table from the set of LOCKED TABLES */ + unlink_open_table(thd, tables->table, FALSE); - /* Such a statement can always go directly to binlog, no trans cache. */ - Query_log_event qinfo(thd, stmt_query.ptr(), stmt_query.length(), 0, - FALSE); - mysql_bin_log.write(&qinfo); + /* + Ignore reopen_tables errors for now. It's better not leave master/slave + in a inconsistent state. + */ + thd->clear_error(); } + thd->in_lock_tables= 0; + } + +end: + + if (!result) + { + write_bin_log(thd, TRUE, stmt_query.ptr(), stmt_query.length()); } VOID(pthread_mutex_unlock(&LOCK_open)); - start_waiting_global_read_lock(thd); + + if (need_start_waiting) + start_waiting_global_read_lock(thd); if (!result) - send_ok(thd); + my_ok(thd); DBUG_RETURN(result); } -/* +/** Create trigger for table. - SYNOPSIS - create_trigger() - thd - current thread context (including trigger definition in - LEX) - tables - table list containing one open table for which the - trigger is created. - stmt_query - [OUT] after successful return, this string contains - well-formed statement for creation this trigger. + @param thd current thread context (including trigger definition in + LEX) + @param tables table list containing one open table for which the + trigger is created. + @param[out] stmt_query after successful return, this string contains + well-formed statement for creation this trigger. - NOTE + @note - Assumes that trigger name is fully qualified. - NULL-string means the following LEX_STRING instance: - { str = 0; length = 0 }. + { str = 0; length = 0 }. - In other words, definer_user and definer_host should contain - simultaneously NULL-strings (non-SUID/old trigger) or valid strings - (SUID/new trigger). + simultaneously NULL-strings (non-SUID/old trigger) or valid strings + (SUID/new trigger). - RETURN VALUE - False - success - True - error + @retval + False success + @retval + True error */ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables, String *stmt_query) { LEX *lex= thd->lex; TABLE *table= tables->table; - char dir_buff[FN_REFLEN], file_buff[FN_REFLEN], trigname_buff[FN_REFLEN], - trigname_path[FN_REFLEN]; - LEX_STRING dir, file, trigname_file; + char file_buff[FN_REFLEN], trigname_buff[FN_REFLEN]; + LEX_STRING file, trigname_file; LEX_STRING *trg_def; LEX_STRING definer_user; LEX_STRING definer_host; @@ -359,17 +560,21 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables, LEX_STRING *trg_definer; Item_trigger_field *trg_field; struct st_trigname trigname; + LEX_STRING *trg_client_cs_name; + LEX_STRING *trg_connection_cl_name; + LEX_STRING *trg_db_cl_name; /* Trigger must be in the same schema as target table. */ - if (my_strcasecmp(table_alias_charset, table->s->db, lex->spname->m_db.str)) + if (my_strcasecmp(table_alias_charset, table->s->db.str, + lex->spname->m_db.str)) { my_error(ER_TRG_IN_WRONG_SCHEMA, MYF(0)); return 1; } /* We don't allow creation of several triggers of the same type yet */ - if (bodies[lex->trg_chistics.event][lex->trg_chistics.action_time]) + if (bodies[lex->trg_chistics.event][lex->trg_chistics.action_time] != 0) { my_error(ER_NOT_SUPPORTED_YET, MYF(0), "multiple triggers with the same action time" @@ -456,20 +661,18 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables, sql_create_definition_file() files handles renaming and backup of older versions */ - strxnmov(dir_buff, FN_REFLEN, mysql_data_home, "/", tables->db, "/", NullS); - dir.length= unpack_filename(dir_buff, dir_buff); - dir.str= dir_buff; - file.length= strxnmov(file_buff, FN_REFLEN, tables->table_name, - triggers_file_ext, NullS) - file_buff; + file.length= build_table_filename(file_buff, FN_REFLEN - 1, + tables->db, tables->table_name, + TRG_EXT, 0); file.str= file_buff; - trigname_file.length= strxnmov(trigname_buff, FN_REFLEN, - lex->spname->m_name.str, - trigname_file_ext, NullS) - trigname_buff; + trigname_file.length= build_table_filename(trigname_buff, FN_REFLEN-1, + tables->db, + lex->spname->m_name.str, + TRN_EXT, 0); trigname_file.str= trigname_buff; - strxnmov(trigname_path, FN_REFLEN, dir_buff, trigname_buff, NullS); /* Use the filesystem to enforce trigger namespace constraints. */ - if (!access(trigname_path, F_OK)) + if (!access(trigname_buff, F_OK)) { my_error(ER_TRG_ALREADY_EXISTS, MYF(0)); return 1; @@ -478,8 +681,8 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables, trigname.trigger_table.str= tables->table_name; trigname.trigger_table.length= tables->table_name_length; - if (sql_create_definition_file(&dir, &trigname_file, &trigname_file_type, - (gptr)&trigname, trigname_file_parameters, 0)) + if (sql_create_definition_file(NULL, &trigname_file, &trigname_file_type, + (uchar*)&trigname, trigname_file_parameters, 0)) return 1; /* @@ -490,16 +693,26 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables, QQ: Hmm... probably we should not care about setting up active thread mem_root too. */ - if (!(trg_def= (LEX_STRING *)alloc_root(&table->mem_root, - sizeof(LEX_STRING))) || + if (!(trg_def= alloc_lex_string(&table->mem_root)) || definitions_list.push_back(trg_def, &table->mem_root) || - !(trg_sql_mode= (ulonglong*)alloc_root(&table->mem_root, - sizeof(ulonglong))) || + + !(trg_sql_mode= alloc_type<ulonglong>(&table->mem_root)) || definition_modes_list.push_back(trg_sql_mode, &table->mem_root) || - !(trg_definer= (LEX_STRING*) alloc_root(&table->mem_root, - sizeof(LEX_STRING))) || - definers_list.push_back(trg_definer, &table->mem_root)) + + !(trg_definer= alloc_lex_string(&table->mem_root)) || + definers_list.push_back(trg_definer, &table->mem_root) || + + !(trg_client_cs_name= alloc_lex_string(&table->mem_root)) || + client_cs_names.push_back(trg_client_cs_name, &table->mem_root) || + + !(trg_connection_cl_name= alloc_lex_string(&table->mem_root)) || + connection_cl_names.push_back(trg_connection_cl_name, &table->mem_root) || + + !(trg_db_cl_name= alloc_lex_string(&table->mem_root)) || + db_cl_names.push_back(trg_db_cl_name, &table->mem_root)) + { goto err_with_cleanup; + } *trg_sql_mode= thd->variables.sql_mode; @@ -542,6 +755,21 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables, } /* + Fill character set information: + - client character set contains charset info only; + - connection collation contains pair {character set, collation}; + - database collation contains pair {character set, collation}; + */ + + lex_string_set(trg_client_cs_name, thd->charset()->csname); + + lex_string_set(trg_connection_cl_name, + thd->variables.collation_connection->name); + + lex_string_set(trg_db_cl_name, + get_default_db_collation(thd, tables->db)->name); + + /* Create well-formed trigger definition query. Original query is not appropriated, because definer-clause can be not truncated. */ @@ -558,135 +786,139 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables, append_definer(thd, stmt_query, &definer_user, &definer_host); } - stmt_query->append(thd->lex->stmt_definition_begin, - (char *) thd->lex->sphead->m_body_begin - - thd->lex->stmt_definition_begin + - thd->lex->sphead->m_body.length); + LEX_STRING stmt_definition; + stmt_definition.str= (char*) thd->lex->stmt_definition_begin; + stmt_definition.length= thd->lex->stmt_definition_end + - thd->lex->stmt_definition_begin; + trim_whitespace(thd->charset(), & stmt_definition); + + stmt_query->append(stmt_definition.str, stmt_definition.length); trg_def->str= stmt_query->c_ptr(); trg_def->length= stmt_query->length(); /* Create trigger definition file. */ - if (!sql_create_definition_file(&dir, &file, &triggers_file_type, - (gptr)this, triggers_file_parameters, 0)) + if (!sql_create_definition_file(NULL, &file, &triggers_file_type, + (uchar*)this, triggers_file_parameters, 0)) return 0; err_with_cleanup: - my_delete(trigname_path, MYF(MY_WME)); + my_delete(trigname_buff, MYF(MY_WME)); return 1; } -/* - Deletes the .TRG file for a table - - SYNOPSIS - rm_trigger_file() - path - char buffer of size FN_REFLEN to be used - for constructing path to .TRG file. - db - table's database name - table_name - table's name - - RETURN VALUE - False - success - True - error +/** + Deletes the .TRG file for a table. + + @param path char buffer of size FN_REFLEN to be used + for constructing path to .TRG file. + @param db table's database name + @param table_name table's name + + @retval + False success + @retval + True error */ static bool rm_trigger_file(char *path, const char *db, const char *table_name) { - strxnmov(path, FN_REFLEN, mysql_data_home, "/", db, "/", table_name, - triggers_file_ext, NullS); - unpack_filename(path, path); + build_table_filename(path, FN_REFLEN-1, db, table_name, TRG_EXT, 0); return my_delete(path, MYF(MY_WME)); } -/* - Deletes the .TRN file for a trigger - - SYNOPSIS - rm_trigname_file() - path - char buffer of size FN_REFLEN to be used - for constructing path to .TRN file. - db - trigger's database name - table_name - trigger's name - - RETURN VALUE - False - success - True - error +/** + Deletes the .TRN file for a trigger. + + @param path char buffer of size FN_REFLEN to be used + for constructing path to .TRN file. + @param db trigger's database name + @param table_name trigger's name + + @retval + False success + @retval + True error */ static bool rm_trigname_file(char *path, const char *db, const char *trigger_name) { - strxnmov(path, FN_REFLEN, mysql_data_home, "/", db, "/", trigger_name, - trigname_file_ext, NullS); - unpack_filename(path, path); + build_table_filename(path, FN_REFLEN - 1, db, trigger_name, TRN_EXT, 0); return my_delete(path, MYF(MY_WME)); } -/* +/** Helper function that saves .TRG file for Table_triggers_list object. - SYNOPSIS - save_trigger_file() - triggers Table_triggers_list object for which file should be saved - db Name of database for subject table - table_name Name of subject table + @param triggers Table_triggers_list object for which file should be saved + @param db Name of database for subject table + @param table_name Name of subject table - RETURN VALUE + @retval FALSE Success + @retval TRUE Error */ static bool save_trigger_file(Table_triggers_list *triggers, const char *db, const char *table_name) { - char dir_buff[FN_REFLEN], file_buff[FN_REFLEN]; - LEX_STRING dir, file; - - strxnmov(dir_buff, FN_REFLEN, mysql_data_home, "/", db, "/", NullS); - dir.length= unpack_filename(dir_buff, dir_buff); - dir.str= dir_buff; - file.length= strxnmov(file_buff, FN_REFLEN, table_name, triggers_file_ext, - NullS) - file_buff; - file.str= file_buff; + char file_buff[FN_REFLEN]; + LEX_STRING file; - return sql_create_definition_file(&dir, &file, &triggers_file_type, - (gptr)triggers, triggers_file_parameters, 0); + file.length= build_table_filename(file_buff, FN_REFLEN - 1, db, table_name, + TRG_EXT, 0); + file.str= file_buff; + return sql_create_definition_file(NULL, &file, &triggers_file_type, + (uchar*)triggers, triggers_file_parameters, + 0); } -/* +/** Drop trigger for table. - SYNOPSIS - drop_trigger() - thd - current thread context - (including trigger definition in LEX) - tables - table list containing one open table for which trigger - is dropped. - stmt_query - [OUT] after successful return, this string contains - well-formed statement for creation this trigger. - - RETURN VALUE - False - success - True - error + @param thd current thread context + (including trigger definition in LEX) + @param tables table list containing one open table for which trigger + is dropped. + @param[out] stmt_query after successful return, this string contains + well-formed statement for creation this trigger. + + @todo + Probably instead of removing .TRG file we should move + to archive directory but this should be done as part of + parse_file.cc functionality (because we will need it + elsewhere). + + @retval + False success + @retval + True error */ bool Table_triggers_list::drop_trigger(THD *thd, TABLE_LIST *tables, String *stmt_query) { - LEX *lex= thd->lex; + const char *sp_name= thd->lex->spname->m_name.str; // alias + LEX_STRING *name; - List_iterator_fast<LEX_STRING> it_name(names_list); - List_iterator<LEX_STRING> it_def(definitions_list); - List_iterator<ulonglong> it_mod(definition_modes_list); - List_iterator<LEX_STRING> it_definer(definers_list); char path[FN_REFLEN]; + List_iterator_fast<LEX_STRING> it_name(names_list); + + List_iterator<ulonglong> it_mod(definition_modes_list); + List_iterator<LEX_STRING> it_def(definitions_list); + List_iterator<LEX_STRING> it_definer(definers_list); + List_iterator<LEX_STRING> it_client_cs_name(client_cs_names); + List_iterator<LEX_STRING> it_connection_cl_name(connection_cl_names); + List_iterator<LEX_STRING> it_db_cl_name(db_cl_names); + stmt_query->append(thd->query, thd->query_length); while ((name= it_name++)) @@ -694,9 +926,11 @@ bool Table_triggers_list::drop_trigger(THD *thd, TABLE_LIST *tables, it_def++; it_mod++; it_definer++; + it_client_cs_name++; + it_connection_cl_name++; + it_db_cl_name++; - if (my_strcasecmp(table_alias_charset, lex->spname->m_name.str, - name->str) == 0) + if (my_strcasecmp(table_alias_charset, sp_name, name->str) == 0) { /* Again we don't care much about other things required for @@ -705,6 +939,9 @@ bool Table_triggers_list::drop_trigger(THD *thd, TABLE_LIST *tables, it_def.remove(); it_mod.remove(); it_definer.remove(); + it_client_cs_name.remove(); + it_connection_cl_name.remove(); + it_db_cl_name.remove(); if (definitions_list.is_empty()) { @@ -723,7 +960,7 @@ bool Table_triggers_list::drop_trigger(THD *thd, TABLE_LIST *tables, return 1; } - if (rm_trigname_file(path, tables->db, lex->spname->m_name.str)) + if (rm_trigname_file(path, tables->db, sp_name)) return 1; return 0; } @@ -746,18 +983,17 @@ Table_triggers_list::~Table_triggers_list() } -/* +/** Prepare array of Field objects referencing to TABLE::record[1] instead of record[0] (they will represent OLD.* row values in ON UPDATE trigger and in ON DELETE trigger which will be called during REPLACE execution). - SYNOPSIS - prepare_record1_accessors() - table - pointer to TABLE object for which we are creating fields. + @param table pointer to TABLE object for which we are creating fields. - RETURN VALUE - False - success - True - error + @retval + False success + @retval + True error */ bool Table_triggers_list::prepare_record1_accessors(TABLE *table) { @@ -777,8 +1013,8 @@ bool Table_triggers_list::prepare_record1_accessors(TABLE *table) if (!(*old_fld= (*fld)->new_field(&table->mem_root, table, table == (*fld)->table))) return 1; - (*old_fld)->move_field((my_ptrdiff_t)(table->record[1] - - table->record[0])); + (*old_fld)->move_field_offset((my_ptrdiff_t)(table->record[1] - + table->record[0])); } *old_fld= 0; @@ -786,12 +1022,10 @@ bool Table_triggers_list::prepare_record1_accessors(TABLE *table) } -/* +/** Adjust Table_triggers_list with new TABLE pointer. - SYNOPSIS - set_table() - new_table - new pointer to TABLE instance + @param new_table new pointer to TABLE instance */ void Table_triggers_list::set_table(TABLE *new_table) @@ -805,20 +1039,26 @@ void Table_triggers_list::set_table(TABLE *new_table) } -/* +/** Check whenever .TRG file for table exist and load all triggers it contains. - SYNOPSIS - check_n_load() - thd - current thread context - db - table's database name - table_name - table's name - table - pointer to table object - names_only - stop after loading trigger names - - RETURN VALUE - False - success - True - error + @param thd current thread context + @param db table's database name + @param table_name table's name + @param table pointer to table object + @param names_only stop after loading trigger names + + @todo + A lot of things to do here e.g. how about other funcs and being + more paranoical ? + + @todo + This could be avoided if there is no triggers for UPDATE and DELETE. + + @retval + False success + @retval + True error */ bool Table_triggers_list::check_n_load(THD *thd, const char *db, @@ -832,9 +1072,8 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db, DBUG_ENTER("Table_triggers_list::check_n_load"); - strxnmov(path_buff, FN_REFLEN, mysql_data_home, "/", db, "/", table_name, - triggers_file_ext, NullS); - path.length= unpack_filename(path_buff, path_buff); + path.length= build_table_filename(path_buff, FN_REFLEN - 1, + db, table_name, TRG_EXT, 0); path.str= path_buff; // QQ: should we analyze errno somehow ? @@ -863,11 +1102,15 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db, we should initialize the list for safety: - sql_modes; - definers; + - character sets (client, connection, database); */ triggers->definition_modes_list.empty(); triggers->definers_list.empty(); + triggers->client_cs_names.empty(); + triggers->connection_cl_names.empty(); + triggers->db_cl_names.empty(); - if (parser->parse((gptr)triggers, &table->mem_root, + if (parser->parse((uchar*)triggers, &table->mem_root, triggers_file_parameters, TRG_NUM_REQUIRED_PARAMETERS, &sql_modes_hook)) @@ -886,8 +1129,7 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db, We use one mode (current) for all triggers, because we have not information about mode in old format. */ - if (!(trg_sql_mode= (ulonglong*)alloc_root(&table->mem_root, - sizeof(ulonglong)))) + if (!(trg_sql_mode= alloc_type<ulonglong>(&table->mem_root))) { DBUG_RETURN(1); // EOM } @@ -916,8 +1158,7 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db, LEX_STRING *trg_definer; - if (! (trg_definer= (LEX_STRING*)alloc_root(&table->mem_root, - sizeof(LEX_STRING)))) + if (!(trg_definer= alloc_lex_string(&table->mem_root))) DBUG_RETURN(1); // EOM trg_definer->str= (char*) ""; @@ -935,10 +1176,85 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db, it.rewind(); } + if (!triggers->definitions_list.is_empty() && + (triggers->client_cs_names.is_empty() || + triggers->connection_cl_names.is_empty() || + triggers->db_cl_names.is_empty())) + { + /* + It is old file format => we should fill lists of character sets. + */ + + LEX_STRING *trg_client_cs_name; + LEX_STRING *trg_connection_cl_name; + LEX_STRING *trg_db_cl_name; + + if (!triggers->client_cs_names.is_empty() || + !triggers->connection_cl_names.is_empty() || + !triggers->db_cl_names.is_empty()) + { + my_error(ER_TRG_CORRUPTED_FILE, MYF(0), + (const char *) db, + (const char *) table_name); + + DBUG_RETURN(1); // EOM + } + + push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, + ER_TRG_NO_CREATION_CTX, + ER(ER_TRG_NO_CREATION_CTX), + (const char*) db, + (const char*) table_name); + + if (!(trg_client_cs_name= alloc_lex_string(&table->mem_root)) || + !(trg_connection_cl_name= alloc_lex_string(&table->mem_root)) || + !(trg_db_cl_name= alloc_lex_string(&table->mem_root))) + { + DBUG_RETURN(1); // EOM + } + + /* + Backward compatibility: assume that the query is in the current + character set. + */ + + lex_string_set(trg_client_cs_name, + thd->variables.character_set_client->csname); + + lex_string_set(trg_connection_cl_name, + thd->variables.collation_connection->name); + + lex_string_set(trg_db_cl_name, + thd->variables.collation_database->name); + + while (it++) + { + if (triggers->client_cs_names.push_back(trg_client_cs_name, + &table->mem_root) || + + triggers->connection_cl_names.push_back(trg_connection_cl_name, + &table->mem_root) || + + triggers->db_cl_names.push_back(trg_db_cl_name, + &table->mem_root)) + { + DBUG_RETURN(1); // EOM + } + } + + it.rewind(); + } + DBUG_ASSERT(triggers->definition_modes_list.elements == triggers->definitions_list.elements); DBUG_ASSERT(triggers->definers_list.elements == triggers->definitions_list.elements); + DBUG_ASSERT(triggers->client_cs_names.elements == + triggers->definitions_list.elements); + DBUG_ASSERT(triggers->connection_cl_names.elements == + triggers->definitions_list.elements); + DBUG_ASSERT(triggers->db_cl_names.elements == + triggers->definitions_list.elements); table->triggers= triggers; @@ -951,6 +1267,9 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db, List_iterator_fast<ulonglong> itm(triggers->definition_modes_list); List_iterator_fast<LEX_STRING> it_definer(triggers->definers_list); + List_iterator_fast<LEX_STRING> it_client_cs_name(triggers->client_cs_names); + List_iterator_fast<LEX_STRING> it_connection_cl_name(triggers->connection_cl_names); + List_iterator_fast<LEX_STRING> it_db_cl_name(triggers->db_cl_names); LEX *old_lex= thd->lex, lex; sp_rcontext *save_spcont= thd->spcont; ulong save_sql_mode= thd->variables.sql_mode; @@ -968,15 +1287,22 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db, thd->variables.sql_mode= (ulong)*trg_sql_mode; - Parser_state parser_state(thd, trg_create_str->str, + Parser_state parser_state(thd, + trg_create_str->str, trg_create_str->length); - thd->m_parser_state= &parser_state; + + Trigger_creation_ctx *creation_ctx= + Trigger_creation_ctx::create(thd, + db, + table_name, + it_client_cs_name++, + it_connection_cl_name++, + it_db_cl_name++); + lex_start(thd); thd->spcont= NULL; - int err= MYSQLparse((void *)thd); - thd->m_parser_state= NULL; - if (err || thd->is_fatal_error) + if (parse_sql(thd, & parser_state, creation_ctx)) { /* Currently sphead is always deleted in case of a parse error */ DBUG_ASSERT(lex.sphead == 0); @@ -994,8 +1320,11 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db, lex.sphead->set_info(0, 0, &lex.sp_chistics, (ulong) *trg_sql_mode); - triggers->bodies[lex.trg_chistics.event] - [lex.trg_chistics.action_time]= lex.sphead; + int event= lex.trg_chistics.event; + int action_time= lex.trg_chistics.action_time; + + lex.sphead->set_creation_ctx(creation_ctx); + triggers->bodies[event][action_time]= lex.sphead; if (!trg_definer->length) { @@ -1015,7 +1344,7 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db, schema. */ - lex.sphead->set_definer("", 0); + lex.sphead->set_definer((char*) "", 0); /* Triggers without definer information are executed under the @@ -1031,10 +1360,13 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db, &table->mem_root)) goto err_with_lex_cleanup; - if (!(on_table_name= (LEX_STRING*) alloc_root(&table->mem_root, - sizeof(LEX_STRING)))) + if (!(on_table_name= alloc_lex_string(&table->mem_root))) goto err_with_lex_cleanup; - *on_table_name= lex.ident; + + on_table_name->str= (char*) lex.raw_trg_on_table_name_begin; + on_table_name->length= lex.raw_trg_on_table_name_end + - lex.raw_trg_on_table_name_begin; + if (triggers->on_table_names_list.push_back(on_table_name, &table->mem_root)) goto err_with_lex_cleanup; @@ -1074,7 +1406,7 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db, trg_field; trg_field= trg_field->next_trg_field) { - trg_field->setup_field(thd, table, + trg_field->setup_field(thd, table, &triggers->subject_table_grants[lex.trg_chistics.event] [lex.trg_chistics.action_time]); } @@ -1103,7 +1435,7 @@ err_with_lex_cleanup: be merged into .FRM anyway. */ my_error(ER_WRONG_OBJECT, MYF(0), - table_name, triggers_file_ext+1, "TRIGGER"); + table_name, TRG_EXT + 1, "TRIGGER"); DBUG_RETURN(1); } @@ -1111,24 +1443,23 @@ err_with_lex_cleanup: } -/* - Obtains and returns trigger metadata - - SYNOPSIS - get_trigger_info() - thd - current thread context - event - trigger event type - time_type - trigger action time - name - returns name of trigger - stmt - returns statement of trigger - sql_mode - returns sql_mode of trigger - definer_user - returns definer/creator of trigger. The caller is - responsible to allocate enough space for storing definer - information. - - RETURN VALUE - False - success - True - error +/** + Obtains and returns trigger metadata. + + @param thd current thread context + @param event trigger event type + @param time_type trigger action time + @param trigger_name returns name of trigger + @param trigger_stmt returns statement of trigger + @param sql_mode returns sql_mode of trigger + @param definer returns definer/creator of trigger. The caller is + responsible to allocate enough space for storing + definer information. + + @retval + False success + @retval + True error */ bool Table_triggers_list::get_trigger_info(THD *thd, trg_event_type event, @@ -1136,14 +1467,20 @@ bool Table_triggers_list::get_trigger_info(THD *thd, trg_event_type event, LEX_STRING *trigger_name, LEX_STRING *trigger_stmt, ulong *sql_mode, - LEX_STRING *definer) + LEX_STRING *definer, + LEX_STRING *client_cs_name, + LEX_STRING *connection_cl_name, + LEX_STRING *db_cl_name) { sp_head *body; DBUG_ENTER("get_trigger_info"); if ((body= bodies[event][time_type])) { + Stored_program_creation_ctx *creation_ctx= + bodies[event][time_type]->get_creation_ctx(); + *trigger_name= body->m_name; - *trigger_stmt= body->m_body; + *trigger_stmt= body->m_body_utf8; *sql_mode= body->m_sql_mode; if (body->m_chistics->suid == SP_IS_NOT_SUID) @@ -1157,107 +1494,151 @@ bool Table_triggers_list::get_trigger_info(THD *thd, trg_event_type event, body->m_definer_host.str, NullS) - definer->str; } + lex_string_set(client_cs_name, + creation_ctx->get_client_cs()->csname); + + lex_string_set(connection_cl_name, + creation_ctx->get_connection_cl()->name); + + lex_string_set(db_cl_name, + creation_ctx->get_db_cl()->name); + DBUG_RETURN(0); } DBUG_RETURN(1); } -/* +void Table_triggers_list::get_trigger_info(THD *thd, + int trigger_idx, + LEX_STRING *trigger_name, + ulonglong *sql_mode, + LEX_STRING *sql_original_stmt, + LEX_STRING *client_cs_name, + LEX_STRING *connection_cl_name, + LEX_STRING *db_cl_name) +{ + List_iterator_fast<LEX_STRING> it_trigger_name(names_list); + List_iterator_fast<ulonglong> it_sql_mode(definition_modes_list); + List_iterator_fast<LEX_STRING> it_sql_orig_stmt(definitions_list); + List_iterator_fast<LEX_STRING> it_client_cs_name(client_cs_names); + List_iterator_fast<LEX_STRING> it_connection_cl_name(connection_cl_names); + List_iterator_fast<LEX_STRING> it_db_cl_name(db_cl_names); + + for (int i = 0; i < trigger_idx; ++i) + { + it_trigger_name.next_fast(); + it_sql_mode.next_fast(); + it_sql_orig_stmt.next_fast(); + + it_client_cs_name.next_fast(); + it_connection_cl_name.next_fast(); + it_db_cl_name.next_fast(); + } + + *trigger_name= *(it_trigger_name++); + *sql_mode= *(it_sql_mode++); + *sql_original_stmt= *(it_sql_orig_stmt++); + + *client_cs_name= *(it_client_cs_name++); + *connection_cl_name= *(it_connection_cl_name++); + *db_cl_name= *(it_db_cl_name++); +} + + +int Table_triggers_list::find_trigger_by_name(const LEX_STRING *trg_name) +{ + List_iterator_fast<LEX_STRING> it(names_list); + + for (int i = 0; ; ++i) + { + LEX_STRING *cur_name= it++; + + if (!cur_name) + return -1; + + if (strcmp(cur_name->str, trg_name->str) == 0) + return i; + } +} + +/** Find trigger's table from trigger identifier and add it to the statement table list. - SYNOPSIS - mysql_table_for_trigger() - thd - current thread context - trig - identifier for trigger - if_exists - treat a not existing trigger as a warning if TRUE - table - pointer to TABLE_LIST object for the table trigger (output) - - RETURN VALUE - 0 Success - 1 Error + @param[in] thd Thread context. + @param[in] trg_name Trigger name. + @param[in] if_exists TRUE if SQL statement contains "IF EXISTS" clause. + That means a warning instead of error should be + thrown if trigger with given name does not exist. + @param[out] table Pointer to TABLE_LIST object for the + table trigger. + + @return Operation status + @retval FALSE On success. + @retval TRUE Otherwise. */ -int -add_table_for_trigger(THD *thd, sp_name *trig, bool if_exists, - TABLE_LIST **table) +bool add_table_for_trigger(THD *thd, + const sp_name *trg_name, + bool if_exists, + TABLE_LIST **table) { LEX *lex= thd->lex; - char path_buff[FN_REFLEN]; - LEX_STRING path; - File_parser *parser; - struct st_trigname trigname; - Handle_old_incorrect_trigger_table_hook trigger_table_hook( - path_buff, &trigname.trigger_table); - + char trn_path_buff[FN_REFLEN]; + LEX_STRING trn_path= { trn_path_buff, 0 }; + LEX_STRING tbl_name; + DBUG_ENTER("add_table_for_trigger"); - DBUG_ASSERT(table != NULL); - strxnmov(path_buff, FN_REFLEN, mysql_data_home, "/", trig->m_db.str, "/", - trig->m_name.str, trigname_file_ext, NullS); - path.length= unpack_filename(path_buff, path_buff); - path.str= path_buff; + build_trn_path(thd, trg_name, &trn_path); - if (access(path_buff, F_OK)) + if (check_trn_exists(&trn_path)) { if (if_exists) { push_warning_printf(thd, - MYSQL_ERROR::WARN_LEVEL_NOTE, - ER_TRG_DOES_NOT_EXIST, - ER(ER_TRG_DOES_NOT_EXIST)); + MYSQL_ERROR::WARN_LEVEL_NOTE, + ER_TRG_DOES_NOT_EXIST, + ER(ER_TRG_DOES_NOT_EXIST)); + *table= NULL; - DBUG_RETURN(0); + + DBUG_RETURN(FALSE); } my_error(ER_TRG_DOES_NOT_EXIST, MYF(0)); - DBUG_RETURN(1); - } - - if (!(parser= sql_parse_prepare(&path, thd->mem_root, 1))) - DBUG_RETURN(1); - - if (!is_equal(&trigname_file_type, parser->type())) - { - my_error(ER_WRONG_OBJECT, MYF(0), trig->m_name.str, trigname_file_ext+1, - "TRIGGERNAME"); - DBUG_RETURN(1); + DBUG_RETURN(TRUE); } - if (parser->parse((gptr)&trigname, thd->mem_root, - trigname_file_parameters, 1, - &trigger_table_hook)) - DBUG_RETURN(1); + if (load_table_name_for_trigger(thd, trg_name, &trn_path, &tbl_name)) + DBUG_RETURN(TRUE); /* We need to reset statement table list to be PS/SP friendly. */ lex->query_tables= 0; lex->query_tables_last= &lex->query_tables; - *table= sp_add_to_query_tables(thd, lex, trig->m_db.str, - trigname.trigger_table.str, TL_IGNORE); - if (! *table) - DBUG_RETURN(1); + *table= sp_add_to_query_tables(thd, lex, trg_name->m_db.str, + tbl_name.str, TL_IGNORE); - DBUG_RETURN(0); + DBUG_RETURN(*table ? FALSE : TRUE); } -/* +/** Drop all triggers for table. - SYNOPSIS - drop_all_triggers() - thd - current thread context - db - schema for table - name - name for table + @param thd current thread context + @param db schema for table + @param name name for table - NOTE + @note The calling thread should hold the LOCK_open mutex; - RETURN VALUE - False - success - True - error + @retval + False success + @retval + True error */ bool Table_triggers_list::drop_all_triggers(THD *thd, char *db, char *name) @@ -1270,8 +1651,6 @@ bool Table_triggers_list::drop_all_triggers(THD *thd, char *db, char *name) bzero(&table, sizeof(table)); init_alloc_root(&table.mem_root, 8192, 0); - safe_mutex_assert_owner(&LOCK_open); - if (Table_triggers_list::check_n_load(thd, db, name, &table, 1)) { result= 1; @@ -1309,19 +1688,18 @@ end: } -/* +/** Update .TRG file after renaming triggers' subject table (change name of table in triggers' definitions). - SYNOPSIS - change_table_name_in_triggers() - thd Thread context - db_name Database of subject table - old_table_name Old subject table's name - new_table_name New subject table's name + @param thd Thread context + @param db_name Database of subject table + @param old_table_name Old subject table's name + @param new_table_name New subject table's name - RETURN VALUE + @retval FALSE Success + @retval TRUE Failure */ @@ -1350,7 +1728,12 @@ Table_triggers_list::change_table_name_in_triggers(THD *thd, /* Construct CREATE TRIGGER statement with new table name. */ buff.length(0); + + /* WARNING: 'on_table_name' is supposed to point inside 'def' */ + DBUG_ASSERT(on_table_name->str > def->str); + DBUG_ASSERT(on_table_name->str < (def->str + def->length)); before_on_len= on_table_name->str - def->str; + buff.append(def->str, before_on_len); buff.append(STRING_WITH_LEN("ON ")); append_identifier(thd, &buff, new_table_name->str, new_table_name->length); @@ -1362,8 +1745,8 @@ Table_triggers_list::change_table_name_in_triggers(THD *thd, It is OK to allocate some memory on table's MEM_ROOT since this table instance will be thrown out at the end of rename anyway. */ - new_def.str= memdup_root(&trigger_table->mem_root, buff.ptr(), - buff.length()); + new_def.str= (char*) memdup_root(&trigger_table->mem_root, buff.ptr(), + buff.length()); new_def.length= buff.length(); on_table_name->str= new_def.str + before_on_len; on_table_name->length= on_q_table_name_len; @@ -1386,21 +1769,20 @@ Table_triggers_list::change_table_name_in_triggers(THD *thd, } -/* - Iterate though Table_triggers_list::names_list list and update .TRN files - after renaming triggers' subject table. +/** + Iterate though Table_triggers_list::names_list list and update + .TRN files after renaming triggers' subject table. - SYNOPSIS - change_table_name_in_trignames() - db_name Database of subject table - new_table_name New subject table's name - stopper Pointer to Table_triggers_list::names_list at - which we should stop updating. + @param db_name Database of subject table + @param new_table_name New subject table's name + @param stopper Pointer to Table_triggers_list::names_list at + which we should stop updating. - RETURN VALUE + @retval 0 Success + @retval non-0 Failure, pointer to Table_triggers_list::names_list element - for which update failed. + for which update failed. */ LEX_STRING* @@ -1408,26 +1790,24 @@ Table_triggers_list::change_table_name_in_trignames(const char *db_name, LEX_STRING *new_table_name, LEX_STRING *stopper) { - char dir_buff[FN_REFLEN], trigname_buff[FN_REFLEN]; + char trigname_buff[FN_REFLEN]; struct st_trigname trigname; - LEX_STRING dir, trigname_file; + LEX_STRING trigname_file; LEX_STRING *trigger; List_iterator_fast<LEX_STRING> it_name(names_list); - strxnmov(dir_buff, FN_REFLEN, mysql_data_home, "/", db_name, "/", NullS); - dir.length= unpack_filename(dir_buff, dir_buff); - dir.str= dir_buff; - while ((trigger= it_name++) != stopper) { - trigname_file.length= strxnmov(trigname_buff, FN_REFLEN, trigger->str, - trigname_file_ext, NullS) - trigname_buff; + trigname_file.length= build_table_filename(trigname_buff, FN_REFLEN-1, + db_name, trigger->str, + TRN_EXT, 0); trigname_file.str= trigname_buff; trigname.trigger_table= *new_table_name; - if (sql_create_definition_file(&dir, &trigname_file, &trigname_file_type, - (gptr)&trigname, trigname_file_parameters, 0)) + if (sql_create_definition_file(NULL, &trigname_file, &trigname_file_type, + (uchar*)&trigname, trigname_file_parameters, + 0)) return trigger; } @@ -1435,26 +1815,24 @@ Table_triggers_list::change_table_name_in_trignames(const char *db_name, } -/* +/** Update .TRG and .TRN files after renaming triggers' subject table. - SYNOPSIS - change_table_name() - thd Thread context - db Old database of subject table - old_table Old name of subject table - new_db New database for subject table - new_table New name of subject table + @param[in,out] thd Thread context + @param[in] db Old database of subject table + @param[in] old_table Old name of subject table + @param[in] new_db New database for subject table + @param[in] new_table New name of subject table - NOTE + @note This method tries to leave trigger related files in consistent state, i.e. it either will complete successfully, or will fail leaving files in their initial state. Also this method assumes that subject table is not renamed to itself. + This method needs to be called under an exclusive table name lock. - RETURN VALUE - FALSE Success - TRUE Error + @retval FALSE Success + @retval TRUE Error */ bool Table_triggers_list::change_table_name(THD *thd, const char *db, @@ -1470,7 +1848,19 @@ bool Table_triggers_list::change_table_name(THD *thd, const char *db, bzero(&table, sizeof(table)); init_alloc_root(&table.mem_root, 8192, 0); - safe_mutex_assert_owner(&LOCK_open); + /* + This method interfaces the mysql server code protected by + either LOCK_open mutex or with an exclusive table name lock. + In the future, only an exclusive table name lock will be enough. + */ +#ifndef DBUG_OFF + uchar key[MAX_DBKEY_LENGTH]; + uint key_length= (uint) (strmov(strmov((char*)&key[0], db)+1, + old_table)-(char*)&key[0])+1; + + if (!is_table_name_exclusively_locked_by_this_thread(thd, key, key_length)) + safe_mutex_assert_owner(&LOCK_open); +#endif DBUG_ASSERT(my_strcasecmp(table_alias_charset, db, new_db) || my_strcasecmp(table_alias_charset, old_table, new_table)); @@ -1482,8 +1872,8 @@ bool Table_triggers_list::change_table_name(THD *thd, const char *db, } if (table.triggers) { - LEX_STRING_WITH_INIT old_table_name(old_table, strlen(old_table)); - LEX_STRING_WITH_INIT new_table_name(new_table, strlen(new_table)); + LEX_STRING old_table_name= { (char *) old_table, strlen(old_table) }; + LEX_STRING new_table_name= { (char *) new_table, strlen(new_table) }; /* Since triggers should be in the same schema as their subject tables moving table with them between two schemas raises too many questions. @@ -1529,61 +1919,79 @@ end: } -bool Table_triggers_list::process_triggers(THD *thd, trg_event_type event, +/** + Execute trigger for given (event, time) pair. + + The operation executes trigger for the specified event (insert, update, + delete) and time (after, before) if it is set. + + @param thd + @param event + @param time_type + @param old_row_is_record1 + + @return Error status. + @retval FALSE on success. + @retval TRUE on error. +*/ + +bool Table_triggers_list::process_triggers(THD *thd, + trg_event_type event, trg_action_time_type time_type, bool old_row_is_record1) { - bool err_status= FALSE; + bool err_status; + Sub_statement_state statement_state; sp_head *sp_trigger= bodies[event][time_type]; - if (sp_trigger) - { - Sub_statement_state statement_state; + if (sp_trigger == NULL) + return FALSE; - if (old_row_is_record1) - { - old_field= record1_field; - new_field= trigger_table->field; - } - else - { - new_field= record1_field; - old_field= trigger_table->field; - } - /* - This trigger must have been processed by the pre-locking - algorithm. - */ - DBUG_ASSERT(trigger_table->pos_in_table_list->trg_event_map & - static_cast<uint>(1 << static_cast<int>(event))); - - thd->reset_sub_statement_state(&statement_state, SUB_STMT_TRIGGER); - err_status= sp_trigger->execute_trigger - (thd, trigger_table->s->db, trigger_table->s->table_name, - &subject_table_grants[event][time_type]); - thd->restore_sub_statement_state(&statement_state); + if (old_row_is_record1) + { + old_field= record1_field; + new_field= trigger_table->field; + } + else + { + new_field= record1_field; + old_field= trigger_table->field; } + /* + This trigger must have been processed by the pre-locking + algorithm. + */ + DBUG_ASSERT(trigger_table->pos_in_table_list->trg_event_map & + static_cast<uint>(1 << static_cast<int>(event))); + + thd->reset_sub_statement_state(&statement_state, SUB_STMT_TRIGGER); + + err_status= + sp_trigger->execute_trigger(thd, + &trigger_table->s->db, + &trigger_table->s->table_name, + &subject_table_grants[event][time_type]); + + thd->restore_sub_statement_state(&statement_state); return err_status; } -/* - Mark fields of subject table which we read/set in its triggers as such. - - SYNOPSIS - mark_fields_used() - thd Current thread context - event Type of event triggers for which we are going to ins - - DESCRIPTION - This method marks fields of subject table which are read/set in its - triggers as such (by setting Field::query_id equal to THD::query_id) - and thus informs handler that values for these fields should be - retrieved/stored during execution of statement. +/** + Mark fields of subject table which we read/set in its triggers + as such. + + This method marks fields of subject table which are read/set in its + triggers as such (by properly updating TABLE::read_set/write_set) + and thus informs handler that values for these fields should be + retrieved/stored during execution of statement. + + @param thd Current thread context + @param event Type of event triggers for which we are going to inspect */ -void Table_triggers_list::mark_fields_used(THD *thd, trg_event_type event) +void Table_triggers_list::mark_fields_used(trg_event_type event) { int action_time; Item_trigger_field *trg_field; @@ -1595,61 +2003,34 @@ void Table_triggers_list::mark_fields_used(THD *thd, trg_event_type event) { /* We cannot mark fields which does not present in table. */ if (trg_field->field_idx != (uint)-1) - trigger_table->field[trg_field->field_idx]->query_id = thd->query_id; + { + bitmap_set_bit(trigger_table->read_set, trg_field->field_idx); + if (trg_field->get_settable_routine_parameter()) + bitmap_set_bit(trigger_table->write_set, trg_field->field_idx); + } } } + trigger_table->file->column_bitmaps_signal(); } -/* - Check if field of subject table can be changed in before update trigger. - - SYNOPSIS - is_updated_in_before_update_triggers() - field Field object for field to be checked - - NOTE - Field passed to this function should be bound to the same - TABLE object as Table_triggers_list. - - RETURN VALUE - TRUE Field is changed - FALSE Otherwise -*/ - -bool Table_triggers_list::is_updated_in_before_update_triggers(Field *fld) -{ - Item_trigger_field *trg_fld; - for (trg_fld= trigger_fields[TRG_EVENT_UPDATE][TRG_ACTION_BEFORE]; - trg_fld != 0; - trg_fld= trg_fld->next_trg_field) - { - if (trg_fld->get_settable_routine_parameter() && - trg_fld->field_idx != (uint)-1 && - trigger_table->field[trg_fld->field_idx]->eq(fld)) - return TRUE; - } - return FALSE; -} - - -/* - Trigger BUG#14090 compatibility hook +/** + Trigger BUG#14090 compatibility hook. - SYNOPSIS - Handle_old_incorrect_sql_modes_hook::process_unknown_string() - unknown_key [in/out] reference on the line with unknown - parameter and the parsing point - base [in] base address for parameter writing (structure - like TABLE) - mem_root [in] MEM_ROOT for parameters allocation - end [in] the end of the configuration + @param[in,out] unknown_key reference on the line with unknown + parameter and the parsing point + @param[in] base base address for parameter writing + (structure like TABLE) + @param[in] mem_root MEM_ROOT for parameters allocation + @param[in] end the end of the configuration - NOTE: this hook process back compatibility for incorrectly written - sql_modes parameter (see BUG#14090). + @note + NOTE: this hook process back compatibility for incorrectly written + sql_modes parameter (see BUG#14090). - RETURN + @retval FALSE OK + @retval TRUE Error */ @@ -1657,12 +2038,12 @@ bool Table_triggers_list::is_updated_in_before_update_triggers(Field *fld) bool Handle_old_incorrect_sql_modes_hook::process_unknown_string(char *&unknown_key, - gptr base, + uchar* base, MEM_ROOT *mem_root, char *end) { DBUG_ENTER("Handle_old_incorrect_sql_modes_hook::process_unknown_string"); - DBUG_PRINT("info", ("unknown key:%60s", unknown_key)); + DBUG_PRINT("info", ("unknown key: %60s", unknown_key)); if (unknown_key + INVALID_SQL_MODES_LENGTH + 1 < end && unknown_key[INVALID_SQL_MODES_LENGTH] == '=' && @@ -1691,20 +2072,19 @@ Handle_old_incorrect_sql_modes_hook::process_unknown_string(char *&unknown_key, DBUG_RETURN(FALSE); } -/* +#define INVALID_TRIGGER_TABLE_LENGTH 15 + +/** Trigger BUG#15921 compatibility hook. For details see Handle_old_incorrect_sql_modes_hook::process_unknown_string(). */ - -#define INVALID_TRIGGER_TABLE_LENGTH 15 - bool Handle_old_incorrect_trigger_table_hook:: -process_unknown_string(char *&unknown_key, gptr base, MEM_ROOT *mem_root, +process_unknown_string(char *&unknown_key, uchar* base, MEM_ROOT *mem_root, char *end) { DBUG_ENTER("Handle_old_incorrect_trigger_table_hook::process_unknown_string"); - DBUG_PRINT("info", ("unknown key:%60s", unknown_key)); + DBUG_PRINT("info", ("unknown key: %60s", unknown_key)); if (unknown_key + INVALID_TRIGGER_TABLE_LENGTH + 1 < end && unknown_key[INVALID_TRIGGER_TABLE_LENGTH] == '=' && @@ -1731,3 +2111,95 @@ process_unknown_string(char *&unknown_key, gptr base, MEM_ROOT *mem_root, } DBUG_RETURN(FALSE); } + + +/** + Contruct path to TRN-file. + + @param thd[in] Thread context. + @param trg_name[in] Trigger name. + @param trn_path[out] Variable to store constructed path +*/ + +void build_trn_path(THD *thd, const sp_name *trg_name, LEX_STRING *trn_path) +{ + /* Construct path to the TRN-file. */ + + trn_path->length= build_table_filename(trn_path->str, + FN_REFLEN - 1, + trg_name->m_db.str, + trg_name->m_name.str, + TRN_EXT, + 0); +} + + +/** + Check if TRN-file exists. + + @return + @retval TRUE if TRN-file does not exist. + @retval FALSE if TRN-file exists. +*/ + +bool check_trn_exists(const LEX_STRING *trn_path) +{ + return access(trn_path->str, F_OK) != 0; +} + + +/** + Retrieve table name for given trigger. + + @param thd[in] Thread context. + @param trg_name[in] Trigger name. + @param trn_path[in] Path to the corresponding TRN-file. + @param tbl_name[out] Variable to store retrieved table name. + + @return Error status. + @retval FALSE on success. + @retval TRUE if table name could not be retrieved. +*/ + +bool load_table_name_for_trigger(THD *thd, + const sp_name *trg_name, + const LEX_STRING *trn_path, + LEX_STRING *tbl_name) +{ + File_parser *parser; + struct st_trigname trn_data; + + Handle_old_incorrect_trigger_table_hook trigger_table_hook( + trn_path->str, + &trn_data.trigger_table); + + DBUG_ENTER("load_table_name_for_trigger"); + + /* Parse the TRN-file. */ + + if (!(parser= sql_parse_prepare(trn_path, thd->mem_root, TRUE))) + DBUG_RETURN(TRUE); + + if (!is_equal(&trigname_file_type, parser->type())) + { + my_error(ER_WRONG_OBJECT, MYF(0), + trg_name->m_name.str, + TRN_EXT + 1, + "TRIGGERNAME"); + + DBUG_RETURN(TRUE); + } + + if (parser->parse((uchar*) &trn_data, thd->mem_root, + trigname_file_parameters, 1, + &trigger_table_hook)) + DBUG_RETURN(TRUE); + + /* Copy trigger table name. */ + + *tbl_name= trn_data.trigger_table; + + /* That's all. */ + + DBUG_RETURN(FALSE); +} |