From: Dmitry Shulga Date: May 20 2011 10:27am Subject: bzr commit into mysql-5.1 branch (Dmitry.Shulga:3625) Bug#45235 Bug#11753738 List-Archive: http://lists.mysql.com/commits/137773 X-Bug: 45235,11753738 Message-Id: <201105201027.p4KARiUh019113@acsmt358.oracle.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============2176735680021151847==" --===============2176735680021151847== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline #At file:///Users/shulga/projects/mysql/mysql-5.1-bug11753738/ based on revid:luis.soares@stripped 3625 Dmitry Shulga 2011-05-20 Fixed bug#11753738 (formely known as bug#45235) - 5.1 DOES NOT SUPPORT 5.0-ONLY SYNTAX TRIGGERS IN ANY WAY Table with triggers which were using deprecated (5.0-only) syntax became unavailable for any DML and DDL after upgrade to 5.1 version of server. Attempt to execute any statement on such a table resulted in parsing error reported. Since this included DROP TRIGGER and DROP TABLES statements (actually, the latter was allowed but was not functioning properly for such tables) it was impossible to fix the problem without manual operations on .TRG and .TRN files in data directory. The problem was that failure to parse trigger body (due to 5.0-only syntax) when opening trigger file for a table prevented the table from being open. This made all operations on the table impossible (except DROP TABLE which due to peculiarity in its implementation dropped the table but left trigger files around). This patch solves this problem by silencing error which occurs when we parse trigger body during table open. Error message is preserved for the future use and table is marked as having a broken trigger. We also try to analyze parse tree to recover trigger name, which will be needed in order to drop the broken trigger. DML statements which invoke triggers on the table marked as having broken trigger are prohibited and emit saved error message. The same happens for DDL which change triggers except DROP TRIGGER and DROP TABLE which try their best to do what was requested. Table becomes no longer marked as having broken trigger when last such trigger is dropped. @ mysql-test/r/trigger-compat.result Add results for test case for bug#45235 @ mysql-test/t/trigger-compat.test Add test case for bug#45235. @ sql/sp_head.cc Added protection against mem root double restoring. Since restore_thd_mem_root() can be both in case of normal execution way and in case of error handling we need to protect mem root against second consequenced call to restore_thd_mem_root. This can be occured for example when CREATE TRIGGER SQL-statement being parsed and there is a parsing error in trigger body. @ sql/sql_trigger.cc Bug#45235: - New class to implement error suppression and recovery of trigger name. - Comment correction - Errors for trigger manipulation statements - More comment correction - Fix exploiting new class. - indentation correction. - Split up a conjunction in an assert. - Added code for handling completely broken triggers - More errors for trigger manipulation statements. - Method for setting broken triggers flag & error message. @ sql/sql_trigger.h Bug#45235: New members to handle broken triggers and error messages. modified: mysql-test/r/trigger-compat.result mysql-test/r/trigger.result mysql-test/t/trigger-compat.test sql/sp_head.cc sql/sql_parse.cc sql/sql_trigger.cc sql/sql_trigger.h === modified file 'mysql-test/r/trigger-compat.result' --- a/mysql-test/r/trigger-compat.result 2009-02-19 23:24:25 +0000 +++ b/mysql-test/r/trigger-compat.result 2011-05-20 10:27:32 +0000 @@ -43,3 +43,98 @@ DROP TABLE t2; DROP USER mysqltest_dfn@localhost; DROP USER mysqltest_inv@localhost; DROP DATABASE mysqltest_db1; +USE test; +# +# Bug#45235: 5.1 does not support 5.0-only syntax triggers in any way +# +DROP TABLE IF EXISTS t1, t2, t3; +CREATE TABLE t1 ( a INT ); +CREATE TABLE t2 ( a INT ); +CREATE TABLE t3 ( a INT ); +INSERT INTO t1 VALUES (1), (2), (3); +INSERT INTO t2 VALUES (1), (2), (3); +INSERT INTO t3 VALUES (1), (2), (3); +# We simulate importing a trigger from 5.0 by writing a .TRN file for +# each trigger plus a .TRG file the way MySQL 5.0 would have done it, +# with syntax allowed in 5.0 only. +# +# Note that in 5.0 the following lines are missing from t1.TRG: +# +# client_cs_names='latin1' +# connection_cl_names='latin1_swedish_ci' +# db_cl_names='latin1_swedish_ci' +# We will get parse errors for most DDL and DML statements when the table +# has broken triggers. The parse error refers to the first broken +# trigger. +CREATE TRIGGER tr16 AFTER UPDATE ON t1 FOR EACH ROW INSERT INTO t1 VALUES (1); +ERROR 42000: Trigger 'tr13' has an error in its body: 'You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'a USING t1 a' at line 1' +CREATE TRIGGER tr22 BEFORE INSERT ON t2 FOR EACH ROW DELETE FROM non_existing_table; +ERROR 42000: Unknown trigger has an error in its body: 'You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'Not allowed syntax here, and trigger name cant be extracted either.' at line 1' +SHOW TRIGGERS; +Trigger Event Table Statement Timing Created sql_mode Definer character_set_client collation_connection Database Collation +tr11 INSERT t1 DELETE FROM t3 BEFORE NULL root@localhost latin1 latin1_swedish_ci latin1_swedish_ci +tr12 INSERT t1 DELETE FROM t3 AFTER NULL root@localhost latin1 latin1_swedish_ci latin1_swedish_ci +tr14 DELETE t1 DELETE FROM non_existing_table AFTER NULL root@localhost latin1 latin1_swedish_ci latin1_swedish_ci +Warnings: +Warning 1603 Triggers for table `test`.`t1` have no creation context +Warning 1603 Triggers for table `test`.`t2` have no creation context +INSERT INTO t1 VALUES (1); +ERROR 42000: Trigger 'tr13' has an error in its body: 'You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'a USING t1 a' at line 1' +INSERT INTO t2 VALUES (1); +ERROR 42000: Unknown trigger has an error in its body: 'You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'Not allowed syntax here, and trigger name cant be extracted either.' at line 1' +DELETE FROM t1; +ERROR 42000: Trigger 'tr13' has an error in its body: 'You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'a USING t1 a' at line 1' +UPDATE t1 SET a = 1 WHERE a = 1; +ERROR 42000: Trigger 'tr13' has an error in its body: 'You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'a USING t1 a' at line 1' +SELECT * FROM t1; +a +1 +2 +3 +RENAME TABLE t1 TO t1_2; +ERROR 42000: Trigger 'tr13' has an error in its body: 'You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'a USING t1 a' at line 1' +SHOW TRIGGERS; +Trigger Event Table Statement Timing Created sql_mode Definer character_set_client collation_connection Database Collation +tr11 INSERT t1 DELETE FROM t3 BEFORE NULL root@localhost latin1 latin1_swedish_ci latin1_swedish_ci +tr12 INSERT t1 DELETE FROM t3 AFTER NULL root@localhost latin1 latin1_swedish_ci latin1_swedish_ci +tr14 DELETE t1 DELETE FROM non_existing_table AFTER NULL root@localhost latin1 latin1_swedish_ci latin1_swedish_ci +Warnings: +Warning 1603 Triggers for table `test`.`t1` have no creation context +DROP TRIGGER tr11; +Warnings: +Warning 1603 Triggers for table `test`.`t1` have no creation context +DROP TRIGGER tr12; +DROP TRIGGER tr13; +DROP TRIGGER tr14; +DROP TRIGGER tr15; +SHOW TRIGGERS; +Trigger Event Table Statement Timing Created sql_mode Definer character_set_client collation_connection Database Collation +# Make sure there is no trigger file left. +# We write the same trigger files one more time to test DROP TABLE. +DROP TABLE t1; +Warnings: +Warning 1603 Triggers for table `test`.`t1` have no creation context +DROP TABLE t2; +Warnings: +Warning 1603 Triggers for table `test`.`t2` have no creation context +DROP TABLE t3; +# Make sure there is no trigger file left. +CREATE TABLE t1 ( a INT ); +CREATE TABLE t2 ( a INT ); +INSERT INTO t1 VALUES (1), (2), (3); +INSERT INTO t2 VALUES (1), (2), (3); +# We write three trigger files. First trigger is syntaxically incorrect, next trigger is correct +# and last trigger is broken. +# Next we try to execute SHOW CREATE TRGGIR command for broken trigger and then try to drop one. +FLUSH TABLE t1; +SHOW CREATE TRIGGER tr12; +Trigger sql_mode SQL Original Statement character_set_client collation_connection Database Collation +tr12 CREATE DEFINER=`root`@`localhost` TRIGGER tr12 BEFORE INSERT ON t1 FOR EACH ROW DELETE FROM t2 latin1 latin1_swedish_ci latin1_swedish_ci +Warnings: +Warning 1603 Triggers for table `test`.`t1` have no creation context +DROP TRIGGER tr12; +Warnings: +Warning 1603 Triggers for table `test`.`t1` have no creation context +DROP TRIGGER tr11; +DROP TABLE t1; +DROP TABLE t2; === modified file 'mysql-test/r/trigger.result' --- a/mysql-test/r/trigger.result 2010-08-18 04:56:06 +0000 +++ b/mysql-test/r/trigger.result 2011-05-20 10:27:32 +0000 @@ -2134,10 +2134,8 @@ CREATE TRIGGER trg1 BEFORE INSERT ON t2 # Used to crash SHOW TRIGGERS IN db1; Trigger Event Table Statement Timing Created sql_mode Definer character_set_client collation_connection Database Collation -Warnings: -Warning 1064 You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'VALUES (1)' at line 1 INSERT INTO t2 VALUES (1); -ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'VALUES (1)' at line 1 +ERROR 42000: Trigger 'trg1' has an error in its body: 'You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'VALUES (1)' at line 1' SELECT * FROM t1; b # Work around Bug#45235 === modified file 'mysql-test/t/trigger-compat.test' --- a/mysql-test/t/trigger-compat.test 2009-02-19 23:24:25 +0000 +++ b/mysql-test/t/trigger-compat.test 2011-05-20 10:27:32 +0000 @@ -106,4 +106,177 @@ DROP TABLE t2; DROP USER mysqltest_dfn@localhost; DROP USER mysqltest_inv@localhost; DROP DATABASE mysqltest_db1; +USE test; + +--echo # +--echo # Bug#45235: 5.1 does not support 5.0-only syntax triggers in any way +--echo # +let $MYSQLD_DATADIR=`SELECT @@datadir`; + +--disable_warnings +DROP TABLE IF EXISTS t1, t2, t3; +--enable_warnings + +CREATE TABLE t1 ( a INT ); +CREATE TABLE t2 ( a INT ); +CREATE TABLE t3 ( a INT ); +INSERT INTO t1 VALUES (1), (2), (3); +INSERT INTO t2 VALUES (1), (2), (3); +INSERT INTO t3 VALUES (1), (2), (3); + +--echo # We simulate importing a trigger from 5.0 by writing a .TRN file for +--echo # each trigger plus a .TRG file the way MySQL 5.0 would have done it, +--echo # with syntax allowed in 5.0 only. +--echo # +--echo # Note that in 5.0 the following lines are missing from t1.TRG: +--echo # +--echo # client_cs_names='latin1' +--echo # connection_cl_names='latin1_swedish_ci' +--echo # db_cl_names='latin1_swedish_ci' + +--write_file $MYSQLD_DATADIR/test/tr11.TRN +TYPE=TRIGGERNAME +trigger_table=t1 +EOF + +--write_file $MYSQLD_DATADIR/test/tr12.TRN +TYPE=TRIGGERNAME +trigger_table=t1 +EOF + +--write_file $MYSQLD_DATADIR/test/tr13.TRN +TYPE=TRIGGERNAME +trigger_table=t1 +EOF + +--write_file $MYSQLD_DATADIR/test/tr14.TRN +TYPE=TRIGGERNAME +trigger_table=t1 +EOF + +--write_file $MYSQLD_DATADIR/test/tr15.TRN +TYPE=TRIGGERNAME +trigger_table=t1 +EOF + +--write_file $MYSQLD_DATADIR/test/t1.TRG +TYPE=TRIGGERS +triggers='CREATE DEFINER=`root`@`localhost` TRIGGER tr11 BEFORE INSERT ON t1 FOR EACH ROW DELETE FROM t3' 'CREATE DEFINER=`root`@`localhost` TRIGGER tr12 AFTER INSERT ON t1 FOR EACH ROW DELETE FROM t3' 'CREATE DEFINER=`root`@`localhost` TRIGGER tr13 BEFORE DELETE ON t1 FOR EACH ROW DELETE FROM t1 a USING t1 a' 'CREATE DEFINER=`root`@`localhost` TRIGGER tr14 AFTER DELETE ON t1 FOR EACH ROW DELETE FROM non_existing_table' 'CREATE DEFINER=`root`@`localhost` TRIGGER tr15 BEFORE UPDATE ON t1 FOR EACH ROW DELETE FROM non_existing_table a USING non_existing_table a' +sql_modes=0 0 0 0 0 +definers='root@localhost' 'root@localhost' 'root@localhost' 'root@localhost' 'root@localhost' +EOF + +--write_file $MYSQLD_DATADIR/test/t2.TRG +TYPE=TRIGGERS +triggers='Not allowed syntax here, and trigger name cant be extracted either.' +sql_modes=0 +definers='root@localhost' +EOF + +--echo # We will get parse errors for most DDL and DML statements when the table +--echo # has broken triggers. The parse error refers to the first broken +--echo # trigger. +--error ER_PARSE_ERROR +CREATE TRIGGER tr16 AFTER UPDATE ON t1 FOR EACH ROW INSERT INTO t1 VALUES (1); +--error ER_PARSE_ERROR +CREATE TRIGGER tr22 BEFORE INSERT ON t2 FOR EACH ROW DELETE FROM non_existing_table; +SHOW TRIGGERS; +--error ER_PARSE_ERROR +INSERT INTO t1 VALUES (1); +--error ER_PARSE_ERROR +INSERT INTO t2 VALUES (1); +--error ER_PARSE_ERROR +DELETE FROM t1; +--error ER_PARSE_ERROR +UPDATE t1 SET a = 1 WHERE a = 1; +SELECT * FROM t1; +--error ER_PARSE_ERROR +RENAME TABLE t1 TO t1_2; +SHOW TRIGGERS; + +DROP TRIGGER tr11; +DROP TRIGGER tr12; +DROP TRIGGER tr13; +DROP TRIGGER tr14; +DROP TRIGGER tr15; + +SHOW TRIGGERS; + +--echo # Make sure there is no trigger file left. +--list_files $MYSQLD_DATADIR/test/ tr* + +--echo # We write the same trigger files one more time to test DROP TABLE. +--write_file $MYSQLD_DATADIR/test/tr11.TRN +TYPE=TRIGGERNAME +trigger_table=t1 +EOF + +--write_file $MYSQLD_DATADIR/test/tr12.TRN +TYPE=TRIGGERNAME +trigger_table=t1 +EOF + +--write_file $MYSQLD_DATADIR/test/tr13.TRN +TYPE=TRIGGERNAME +trigger_table=t1 +EOF + +--write_file $MYSQLD_DATADIR/test/tr14.TRN +TYPE=TRIGGERNAME +trigger_table=t1 +EOF + +--write_file $MYSQLD_DATADIR/test/tr15.TRN +TYPE=TRIGGERNAME +trigger_table=t1 +EOF + +--write_file $MYSQLD_DATADIR/test/t1.TRG +TYPE=TRIGGERS +triggers='CREATE DEFINER=`root`@`localhost` TRIGGER tr11 BEFORE INSERT ON t1 FOR EACH ROW DELETE FROM t3' 'CREATE DEFINER=`root`@`localhost` TRIGGER tr12 AFTER INSERT ON t1 FOR EACH ROW DELETE FROM t3' 'CREATE DEFINER=`root`@`localhost` TRIGGER tr13 BEFORE DELETE ON t1 FOR EACH ROW DELETE FROM t1 a USING t1 a' 'CREATE DEFINER=`root`@`localhost` TRIGGER tr14 AFTER DELETE ON t1 FOR EACH ROW DELETE FROM non_existing_table' 'CREATE DEFINER=`root`@`localhost` TRIGGER tr15 BEFORE UPDATE ON t1 FOR EACH ROW DELETE FROM non_existing_table a USING non_existing_table a' +sql_modes=0 0 0 0 0 +definers='root@localhost' 'root@localhost' 'root@localhost' 'root@localhost' 'root@localhost' +EOF + +DROP TABLE t1; +DROP TABLE t2; +DROP TABLE t3; + +--echo # Make sure there is no trigger file left. + +--list_files $MYSQLD_DATADIR/test/ tr* + +CREATE TABLE t1 ( a INT ); +CREATE TABLE t2 ( a INT ); +INSERT INTO t1 VALUES (1), (2), (3); +INSERT INTO t2 VALUES (1), (2), (3); + +--echo # We write three trigger files. First trigger is syntaxically incorrect, next trigger is correct +--echo # and last trigger is broken. +--echo # Next we try to execute SHOW CREATE TRGGIR command for broken trigger and then try to drop one. +--write_file $MYSQLD_DATADIR/test/tr11.TRN +TYPE=TRIGGERNAME +trigger_table=t1 +EOF + +--write_file $MYSQLD_DATADIR/test/tr12.TRN +TYPE=TRIGGERNAME +trigger_table=t1 +EOF + +--write_file $MYSQLD_DATADIR/test/t1.TRG +TYPE=TRIGGERS +triggers='CREATE some wrongest trigger_in_the_world' 'CREATE DEFINER=`root`@`localhost` TRIGGER tr11 BEFORE DELETE ON t1 FOR EACH ROW DELETE FROM t1 a USING t1 a' 'CREATE DEFINER=`root`@`localhost` TRIGGER tr12 BEFORE INSERT ON t1 FOR EACH ROW DELETE FROM t2' +sql_modes=0 0 0 +definers='root@localhost' 'root@localhost' 'root@localhost' +EOF + +FLUSH TABLE t1; + +SHOW CREATE TRIGGER tr12; +DROP TRIGGER tr12; +DROP TRIGGER tr11; + +DROP TABLE t1; +DROP TABLE t2; === modified file 'sql/sp_head.cc' --- a/sql/sp_head.cc 2010-11-11 04:52:51 +0000 +++ b/sql/sp_head.cc 2011-05-20 10:27:32 +0000 @@ -2354,6 +2354,21 @@ void sp_head::restore_thd_mem_root(THD *thd) { DBUG_ENTER("sp_head::restore_thd_mem_root"); + + /* + In some cases our parser detects a syntax error and calls + LEX::cleanup_lex_after_parse_error() method only after + finishing parsing the whole routine. In such a situation + sp_head::restore_thd_mem_root() will be called twice - the + first time as part of normal parsing process and the second + time by cleanup_lex_after_parse_error(). + To avoid ruining active arena/mem_root state in this case we + skip restoration of old arena/mem_root if this method has been + already called for this routine. + */ + if (!m_thd) + DBUG_VOID_RETURN; + Item *flist= free_list; // The old list set_query_arena(thd); // Get new free_list and mem_root state= INITIALIZED_FOR_SP; === modified file 'sql/sql_parse.cc' --- a/sql/sql_parse.cc 2011-03-03 08:25:37 +0000 +++ b/sql/sql_parse.cc 2011-05-20 10:27:32 +0000 @@ -7973,10 +7973,14 @@ bool parse_sql(THD *thd, bool mysql_parse_status= MYSQLparse(thd) != 0; - /* Check that if MYSQLparse() failed, thd->is_error() is set. */ + /* + Check that if MYSQLparse() failed, thd->is_error() is set (unless + we have an error handler installed, which might have silenced error). + */ DBUG_ASSERT(!mysql_parse_status || - (mysql_parse_status && thd->is_error())); + (mysql_parse_status && + (thd->is_error() || thd->get_internal_handler()))); /* Reset parser state. */ === modified file 'sql/sql_trigger.cc' --- a/sql/sql_trigger.cc 2010-09-07 08:53:46 +0000 +++ b/sql/sql_trigger.cc 2011-05-20 10:27:32 +0000 @@ -19,6 +19,7 @@ #include "sp_head.h" #include "sql_trigger.h" #include "parse_file.h" +#include "mysys_err.h" /*************************************************************************/ @@ -292,6 +293,53 @@ private: }; +/* + An error handler that catches all non-OOM errors which can occur during + parsing of trigger body. Such errors are ignored and corresponding error + message is used to construct a more verbose error message which contains + name of problematic trigger. This error message is later emitted when + one tries to perform DML or some of DDL on this table. + Also, if possible, grabs name of the trigger being parsed so it can be + used to correctly drop problematic trigger. +*/ +class Deprecated_trigger_syntax_handler : public Internal_error_handler +{ +private: + + char m_message[MYSQL_ERRMSG_SIZE]; + +public: + + LEX_STRING *m_trigger_name; + + Deprecated_trigger_syntax_handler() : m_trigger_name(NULL) {} + + bool handle_error(uint sql_errno, const char *message, + MYSQL_ERROR::enum_warning_level level, THD *thd) + { + if (sql_errno != EE_OUTOFMEMORY && + sql_errno != ER_OUT_OF_RESOURCES) + { + if(thd->lex->spname) + m_trigger_name= &thd->lex->spname->m_name; + if (m_trigger_name) + my_snprintf(m_message, sizeof(m_message), + "Trigger '%s' has an error in its body: '%s'", + m_trigger_name->str, message); + else + my_snprintf(m_message, sizeof(m_message), + "Unknown trigger has an error in its body: '%s'", + message); + return TRUE; + } + return FALSE; + } + + LEX_STRING *get_trigger_name() { return m_trigger_name; } + char *get_error_text() { return m_message; } + +}; + /** Create or drop trigger for table. @@ -552,13 +600,16 @@ end: (SUID/new trigger). @retval - False success + false success @retval - True error + true error */ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables, String *stmt_query) { + if (check_for_broken_triggers()) + return TRUE; + LEX *lex= thd->lex; TABLE *table= tables->table; char file_buff[FN_REFLEN], trigname_buff[FN_REFLEN]; @@ -848,7 +899,7 @@ static bool rm_trigger_file(char *path, @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 + @param trigger_name trigger's name @retval False success @@ -1312,12 +1363,11 @@ bool Table_triggers_list::check_n_load(T lex_start(thd); thd->spcont= NULL; - if (parse_sql(thd, & parser_state, creation_ctx)) - { - /* Currently sphead is always deleted in case of a parse error */ - DBUG_ASSERT(lex.sphead == 0); - goto err_with_lex_cleanup; - } + Deprecated_trigger_syntax_handler error_handler; + thd->push_internal_handler(&error_handler); + bool parse_error= parse_sql(thd, & parser_state, creation_ctx); + thd->pop_internal_handler(); + /* Not strictly necessary to invoke this method here, since we know that we've parsed CREATE TRIGGER and not an @@ -1328,6 +1378,54 @@ bool Table_triggers_list::check_n_load(T */ lex.set_trg_event_type_for_tables(); + if (parse_error) + { + if (!triggers->m_has_unparseable_trigger) + triggers->set_parse_error(error_handler.get_error_text()); + /* Currently sphead is always set to NULL in case of a parse error */ + DBUG_ASSERT(lex.sphead == 0); + if (error_handler.get_trigger_name()) + { + LEX_STRING *trigger_name; + const LEX_STRING *copied_trg_name= error_handler.get_trigger_name(); + + if (!(trigger_name= alloc_lex_string(&table->mem_root)) || + !(trigger_name->str= strmake_root(&table->mem_root, + copied_trg_name->str, + copied_trg_name->length))) + goto err_with_lex_cleanup; + + trigger_name->length= copied_trg_name->length; + + if (triggers->names_list.push_back(trigger_name, + &table->mem_root)) + goto err_with_lex_cleanup; + } + else + { + /* + The Table_triggers_list is not constructed as a list of + trigger objects as one would expect, but rather of lists of + properties of equal length. Thus, even if we don't get the + trigger name, we still fill all in all the lists with + placeholders as we might otherwise create a skew in the + lists. Obviously, this has to be refactored. + */ + LEX_STRING *empty= alloc_lex_string(&table->mem_root); + if (!empty) + goto err_with_lex_cleanup; + + empty->str= const_cast(""); + empty->length= 0; + if (triggers->names_list.push_back(empty, &table->mem_root) || + triggers->on_table_names_list.push_back(empty, + &table->mem_root)) + goto err_with_lex_cleanup; + } + lex_end(&lex); + continue; + } + lex.sphead->set_info(0, 0, &lex.sp_chistics, (ulong) *trg_sql_mode); int event= lex.trg_chistics.event; @@ -1368,8 +1466,8 @@ bool Table_triggers_list::check_n_load(T if (triggers->names_list.push_back(&lex.sphead->m_name, &table->mem_root)) - goto err_with_lex_cleanup; - + goto err_with_lex_cleanup; + if (!(on_table_name= alloc_lex_string(&table->mem_root))) goto err_with_lex_cleanup; @@ -1394,9 +1492,8 @@ bool Table_triggers_list::check_n_load(T char fname[NAME_LEN + 1]; DBUG_ASSERT((!my_strcasecmp(table_alias_charset, lex.query_tables->db, db) || (check_n_cut_mysql50_prefix(db, fname, sizeof(fname)) && - !my_strcasecmp(table_alias_charset, lex.query_tables->db, fname))) && - (!my_strcasecmp(table_alias_charset, lex.query_tables->table_name, - table_name) || + !my_strcasecmp(table_alias_charset, lex.query_tables->db, fname)))); + DBUG_ASSERT((!my_strcasecmp(table_alias_charset, lex.query_tables->table_name, table_name) || (check_n_cut_mysql50_prefix(table_name, fname, sizeof(fname)) && !my_strcasecmp(table_alias_charset, lex.query_tables->table_name, fname)))); #endif @@ -1680,6 +1777,13 @@ bool Table_triggers_list::drop_all_trigg while ((trigger= it_name++)) { + /* + Trigger, which body we failed to parse during call + Table_triggers_list::check_n_load(), might be missing name. + Such triggers have zero-length name and are skipped here. + */ + if (trigger->length == 0) + continue; if (rm_trigname_file(path, db, trigger->str)) { /* @@ -1903,6 +2007,11 @@ bool Table_triggers_list::change_table_n } if (table.triggers) { + if (table.triggers->check_for_broken_triggers()) + { + result= 1; + goto end; + } LEX_STRING old_table_name= { (char *) old_table, strlen(old_table) }; LEX_STRING new_table_name= { (char *) new_table, strlen(new_table) }; /* @@ -1986,6 +2095,9 @@ bool Table_triggers_list::process_trigge trg_action_time_type time_type, bool old_row_is_record1) { + if (check_for_broken_triggers()) + return TRUE; + bool err_status; Sub_statement_state statement_state; sp_head *sp_trigger= bodies[event][time_type]; @@ -2070,6 +2182,22 @@ void Table_triggers_list::mark_fields_us /** + Signals to the Table_triggers_list that a parse error has occured when + reading a trigger from file. This makes the Table_triggers_list enter an + error state flagged by m_has_unparseable_trigger == true. The error message + will be used whenever a statement invoking or manipulating triggers is + issued against the Table_triggers_list's table. + + @param error_message The error message thrown by the parser. + */ +void Table_triggers_list::set_parse_error(char *error_message) +{ + m_has_unparseable_trigger= TRUE; + strcpy(m_parse_error_text, error_message); +} + + +/** Trigger BUG#14090 compatibility hook. @param[in,out] unknown_key reference on the line with unknown === modified file 'sql/sql_trigger.h' --- a/sql/sql_trigger.h 2009-01-14 14:50:51 +0000 +++ b/sql/sql_trigger.h 2011-05-20 10:27:32 +0000 @@ -62,6 +62,27 @@ class Table_triggers_list: public Sql_al */ GRANT_INFO subject_table_grants[TRG_EVENT_MAX][TRG_ACTION_MAX]; + /** + This flag indicates that one of the triggers was not parsed successfully, + and as a precaution the object has entered a state where all trigger + access results in errors until all such triggers are dropped. It is not + safe to add triggers since we don't know if the broken trigger has the + same name or event type. Nor is it safe to invoke any trigger for the + aforementioned reasons. The only safe operations are drop_trigger and + drop_all_triggers. + + @see Table_triggers_list::set_parse_error + */ + bool m_has_unparseable_trigger; + + /** + This error will be displayed when the user tries to manipulate or invoke + triggers on a table that has broken triggers. It will get set only once + per statement and thus will contain the first parse error encountered in + the trigger file. + */ + char m_parse_error_text[MYSQL_ERRMSG_SIZE]; + public: /** Field responsible for storing triggers definitions in file. @@ -84,7 +105,7 @@ public: /* End of character ser context. */ Table_triggers_list(TABLE *table_arg): - record1_field(0), trigger_table(table_arg) + record1_field(0), trigger_table(table_arg), m_has_unparseable_trigger(FALSE) { bzero((char *)bodies, sizeof(bodies)); bzero((char *)trigger_fields, sizeof(trigger_fields)); @@ -140,6 +161,8 @@ public: void mark_fields_used(trg_event_type event); + void set_parse_error(char *error_message); + friend class Item_trigger_field; friend int sp_cache_routines_and_add_tables_for_triggers(THD *thd, LEX *lex, TABLE_LIST *table); @@ -155,6 +178,16 @@ private: const char *new_db_name, LEX_STRING *old_table_name, LEX_STRING *new_table_name); + + bool check_for_broken_triggers() + { + if (m_has_unparseable_trigger) + { + my_message(ER_PARSE_ERROR, m_parse_error_text, MYF(0)); + return TRUE; + } + return FALSE; + } }; extern const LEX_STRING trg_action_time_type_names[]; --===============2176735680021151847== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/dmitry.shulga@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: dmitry.shulga@stripped\ # bbamp8ocyswl5rcf # target_branch: file:///Users/shulga/projects/mysql/mysql-5.1-\ # bug11753738/ # testament_sha1: 3a9edb27911e019a2dfbc388dbb183c8db7c32b4 # timestamp: 2011-05-20 17:27:38 +0700 # base_revision_id: luis.soares@stripped\ # 4g8gpmg0ebg4jitd # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWaV7WyIAEJ9/gHV8UAB///// f+f/+v////5gJP5Mr7657uV7zHW59HIprSbc8+s++9vux32ZH3Y+o7bbK0DPu93wNNNAabMiqQrt tmcb72sGebc7ezuaVbt0l7Ovbe1jMSUN7bs0vcPXe9ddvu6d6bvfbjbV7AYethKEITTE0yMk2jQT Qp4U9PUYp5TTQyBoaDQaNGgG1BKJkBNARomhU/CGVD0gNA8o9JoeoAAAAA0EqYEiZR6RtSNA9QaD RoABoaAAAAAANBJpSEFU/000GVT3pJPyiPUfqmm0nlPUA0PUNGQADQGgGgRJECBNDUwmKYZAp6FP yFPEnpPZJgptT1NGyh5GkDEEiQQCaATIaTCnqeQ0IJ6CntKZonlGxNT9JMjagGg7OY3AffBRPB8Y /vAueMN1ntNB/4DF/i6Fz2HxkMA/QdYGTQ5RMl/Fdg/wcdR9QfB/aSD6YC9LDulep16p5OhpHBzq gQefxEz1VT0RnB12z5bXe/OcPeziqdXYuipxVa0iqnZg08Ps/7Vd7fWmsz8GHJflnXP3k1MZEcTS 5Olk3tyn7dPJvDwqnTVII5mfNzFYfaH+M31+JTH2uMpiu/qzZpyYwjNWNxRSNKwDKv9uyC+k5oUV JdWWGvH4n2EU0HMvA0DTgLh0rjCplsZjjLaKKPdmzYq57XlKrf6PbhGLQ82h4u5nfAxhApwFverj wgFoWLVqYUURbUNtoOx/plpY/CArTu7TlL9m6csXZAsvilqjU44bLNZqs7VXDREmnTFgJYVMs6Gv ShdKd0olWG1B5WfiC/eFVUK2dm3oSxqelseD06sEI3tETWohzBq10X2UxMbtecHv06mokZidnOw6 ZI3Q0Mqsz1RooacFtfJw1wpl0B6dz7U0B4gSAc2a6LQ/dgvoYEQfB4fP6L5arWKqUHv+PosCjqgo BHigItAwlZRYgiCIxIxiwVFEUKEmhGggA481/hSPtvzOAiFADRAhi7g6g6zqDigLgRrwmdL7roA0 /KC3ZNbvEkmP74nx5ufnDhmT1SeJD45GRUIqiigoKHcan8ALht8dlu6w0AWzPS0uj0z8bcKhOsTl LGZay9URWrspVVVGrW7oqwdWVpHwLHWnzgIynOCp/k1D2GjjyHn4h08qZGpapXpiVHrQpUtcGVSO F1+hDn0uqzEpaTm/JAnuIhhTGbz1BeEnRiznFvQSNETWMnJs6ZDN3Jt+fXcgPgOCX0l2nvMA3DSM 0jWxsRUrB5ayAxGchHSAZ2+DI2M8ubiGS4G0DP4Z+FTBmaWgTGS8fyQG45GIG2zRquy+iP4mQsYT cAwRk7OgxMHxxBBqLREREofz5k9gO/brR1xDQZ7xXGw6REju8zekGNtP5YOcDADtOszkx6BCBGkP 7j27Vbnjya3q+3AkRKA23Ztiw4dk0rQh2D/ITTsi+c2YQUC7/VunaRfEnlzLSeRK/oRokiSEhoQG VIMrfYAxgalQWDQ0nP1zsG6jiGyTBjAy79dJGrQwSR8rql2HOLHtlbubdoxRy2jsz6KqewDX5DDc vyLZcIkdunLK+eoEdSI0qMBdgKxsX3xnPrIBVjRWL5UaNjEHJ0p2MhevUuRGEBB1AhJSvxrA5WnK O1+nDWyX/i8iuib4a1Dpn8JVDuFzqlE2F2uaeGJLJhDMhjcEb4QW6QJyP60otpnbiovwlUKdUJiw s4DmY1/9AqeoCtA3KepTx7obWzrBFoETOTnV4yYzEODGFnQIxPo8XMbYzpaQkBHF6MQ0pOLmSITv CpKMVDM0GAxO/ulfCdMb5OvrbEo6VAZcTZ0qpVUlo2tBM5Engk2iyafUlIRFpAFEZ9QdQw2TFS7V EsXpkodJUk2YcKTJKcngNnDyOT18hbYQ0FGweVcdkTlxitSArLbxwI0j6MK6VpcwKm03sqmrzaev TK7K8I4JazI7fGagOBrDrGpc1ERMQMJZJumqD5d0Jg9dzjbrzkudKwVpYotp81wcpXkpCYXOy9Ek BcuBmZB6kRFD9AOlcgPlN5SY02Og4CpIUtxMIBkiAgMaJqApkvbomJLbsJ0qdBE4NuBW/mpD33k3 VT0Ni3b3MS8SlccQI9npkBmbRFFLisbzijA9oVztpNVz6pGTJO+2pORayKUG6QQ01iAwPsPQgCdr uwULGNGoJ4sMuCqEw4MvM075lLfm84wtmfFytVXMYPejxTWyqORkxTB5AfUYHA2GWSK5cCZZdlaW WlDPHIlS/qYcfuqP6nd5xebaO5hDKOxrcKFItAFQDYDCiKdB9vS4U+9TJb5fMyt8OYXF9F3mtTUY VHCqd1kSJ3Qer/9mp5+04REl9IyBYqCHwyxVFVFVEVVRFRH54FsgaT7BQ2D8XwYmOvuVVOIMPXx9 w6+RUT2jUQ9rGUZPLpklGsOUiEIARYBIQ82ncXUOJ/Lnv5Gr17c8cKUtxLcaUx8GNhIGMm0Z6i3m mBbg2s9U6iTwvihg/EYlXMb52PHBt0w5y0MkXNCzlUMqx9TJ1RYLX6XDArkU5nQoZiIQ2CFz4Ymp WNdQxfPKHZ45WGK3CaYQK64+75mNFBp/4v82uTq0jUwLdASNCENJZCg2eaL0VXV5bO5PVyKxBmNU W+8mxlfd/oJN4A+sDWdTB+QF+Lc8ofc+pqxad42rRmanInCTUD5Eibly8twg+K+8O4+oSPwGBsou E7J2SNNE3ySQafAkQUDz4miMBYA1OGelu1mTThb0gQrWaszKz8dmRW4zWpKj2qqLYjNRLJltUlkh amjVfdZOW1V5KCZKEz4TnKL7QMM74ZCgHuzCYCqeRSqDUukcJhmCNK2Umi7xQQX+D7fD84kgzxuS +Uu5Ja1CPAQMFqfDn5vlyUdjpJXgQivkj1x64ZQz7qXSaQzhjFtExh8QGNWPdHLbELqxogaxgFY6 wGyjIFEiHa3EARJMnIQaSRVBLBlhMsA9/ssJvtoKxCLZ+oqkXUWV1s1bmZWnr+6wKAVIAgRlg79x oaj05+NmW7oK5hh1ru2HHHsg4gzey8LBHbbi36nlyUciKU7cr7CLxc6BkZpppLJZxNZtv1mDW31l opCBsaEVtNp3+qnSjFDUCtEh6BRxew/XtvwuS3MME1rW8DL+mJXn2Z4xd2YCq0G7aYVIGPZQMWFK diCFodhMqS6HPMft2eWA8UIIwmJwyn4ATG0fsUrKWgLglazVcDnzYyx84zicSeky6t2/Rr7OaVja pXhInP2SBSajhrLzglBaM82kyokEuOSws0B2vJ7KBfGiIpbrYQVA5PtEMzEFFulClkrLgNwIsaYg YkZYjtTU3isYRuJHqxJnMMtAeN5kYKYwfU6HpiJJO80KNy438UwvIqaOKIGvC9iJKBoBg+BXSas4 qI2ph/UZCroDdBlkWn/hBI2mo/FM5bQuiXA1y2OvjjSEmoUhQY1tAGQ6xBTWcFTaXO9xRAlYYkd8 yOJnyjqR4FULFiAdSRuuO/kccY0WBxSjGp3jRgSjtaEUaVAccTgWO3yY4ETUgbE3pSGwyBXjSk2J m3TnBWM2eOnJbbCJiRVHSIw5ZPoNwEC7GlYMnQC0k5+kumcw0ypHilfS0SHIs6TVZjkM58myM5oU SvmENwHTgcCZMiZExUXXOPaGdM6KnenKcZTqylM9OOKu10LK5JGjaQhK7GUWAL4GGmlpjdhhexbm oGINFQOFaTOM18Idx5HeVDyMkWaZ68JJCSqVeIxGJUn4QIzVjdihryNdkcsoVLJ8JibHE4kTCiTO s3TrS4gaYJ3psme3DhZDiNctGmw2LbtipzUAwY5XDiqZWLTeTqPCiRWldynnbwzMyHhLM6y+ouhp 17jGoptuMcroFMIyIJyMwkpuMjC7El7TnTOayZIwqMaSVZi6ngVdqJFifJHUCMuXKMaHMrMtkdoY c1ECli+ZHrwxYzG5lbZ4xStCgwpPVC6F+kPft4sgTpa5xTHtiapr6k7enJL9WJzfUeFXgxExcuKD wgpImTN25aYD2qVYhgktSJG8a1Xnj0MjLYqSHyI3ONzq0sMkjCWApaZ3UYwN07RAmYV0saDxou0D YmRaAoGpwFNQHgRSuBmXJukQKEzx0lsZ4GfhmY6RLTI6aGSalPHMqRpct1zqQa7dPNz8cN34noSy 5CGtoG8ee6EdH5/JzyNm03uzc5xsIlxKxOfFFLHjXKFQo4FrPEUBqFozWyykARFVl7IsKC2pk2TZ 9Hqbv2Q5W36PJj8sZiKnLnj7ps1BgjiYnjYneyPGYzRpVQ8U6HaYpKG+KYORkZZN2JCmMdOqYyVc /QBU6b/aBL6TdQoz7DXXrisoLMLZkDbGxnxJb1bL4xDW8ADxC3B8v0L7POfDFXPwI/z4gT3fX6uJ pQyPzsfBf6lXkQIoewMh+t/ogekW35AfQfxUNEYEBIafn8RlId3URYBDaWU/7Vc3TK5OzBA/emUX MTEkIFZPqumDP5blDiH7/3ZYhqiOYRCiFBENahuShuDFgv3qH/uK30m//zjOB+YMRpipoUNI4GSU HAIhD1CKf9hTqANkA0gBy0bcSP1I5NCurI3gGsD6IRQO+jzlA86GAEKU0FdYH7tu9A/l/9tyMBWp kRP6lwOmZwVoBxP+saFULMrJASQmgXQIlC58g2JGCQ41F1qLRRxm4nGgUcPAUJr1maizxI0lxOQN 4YSRCCBrOhQ+wxLpzE+SZ9yYbgBiBcUIeUknKKSTQ+JHsA5wTec2YcgjcW+tNOQ1f0UP7H6WELg9 MdSBEciwLa9Ch1wA5xt17aTysOoQ3agCvB5tm1ByQPWUAPIgQiPd3+bq1HaGSBB0NSAXA6R7wBqr NROIMVYRAi94iAVQhJSN7I0eJAPCaHIohtIrliDvQeVAMEDcgXFe8BA1wRzSqEwCIEliUOZ7jrPX ygu81mQHAzLGQFCZl/uOdgVQbkkaSqNpO5/ycMtTPPkGYjeQ4A8NxRiq7FDG5SMVIRIA8wl7gQgG /YhYUPmAIvKllaSjPcAY7nC0DenyMMM8/1KYdI0Pt0mrIDhDnAPGcANAtNGzokWFBEzCDsYBwmkK FUAYG/YA7csejLIAhJGIHE9vrwPceR2JBkTAd8ZIOVKnkie01H2z2vtDd8pYQ/1PoM0wCghKw/Y5 1JFrApwE5KALH5BqzMpCk9g7ByTTNaXDZbC4j64Jo95kIt/crvW8BjDEDRIWLeJDaowi4qFGsqDV VKCkijQY1CglcUk4NBmIJql4EMYLKpCLrVPIIzayEMuVRUVQpRLIcKM0mSOv7IElAXiPvftRiPvg doHdA42kHWhljCbEjM2oMWl95+08/66GzUQfw96zQij8bPEHYdJR5GKyd+LUADpGl5Nt3p/A+DPM 5diqklwsu+uw/kxayvXb2Khof5F6ztPkNJCmCVwhy/JffpWBxXxBmbn/MbAgOrnQBmf0jShuUF9g Kcqy10VvJhA3kYRFLZdAh6P6uZmxQlmsYBwgcREb+RQsGLEOdcEvQEHuidhdPLGkDseXho8X3Ab2 LnmAmog0XsLUjTVFFFZFDiG1Db1OMbasVbgQ0Et2ewHKtu24bZ0yUwkJTiiN1ymCXF1asAikhtTi Wv2GfRtROmPvG/JFsQ5U0tX6/A8geaPb+VRiKTnIF6McAfkHEcu455zYkYgdMoUH6HnEBx3qZBzg tpqwJGk0EB2OLVf8GBsxFJiR2shhICl0jY9J0OpXzsfZ5K9MQOcNKDbH54PpQQKEvTjLtDgNI515 61NiOORNV6SGphTQYSe41jQBqRIpCFzD3uQTe87EjEZyk7guL/QvPe0VyLeRFzLhBYVGhteeCwZK 16PYMPf9gayyFz9PFr4ImIhq2WQjraS4eDUYANkztQQyMStYcEW1nHxb2EZa5Mwj/tBe38NLT8cr G4YRpt9BkQ0NpmcWD0yWTWxtVRyvIEPNO7mQMTuz1mI62F5ML6bWRUYq2l1LgsMJnTLBfDQxDGGi DGWw16/d2abLwJOwaXclAUQ+fwt29p5dB6zvO8vP0OY3biULWgZEOG+qBHKpYmeHCVkRN0iibnb7 q+pUiOaHJMD8IuQYiS4L4MvEOtgrsoQSqbCzrZQhmPAlwxfFJ1gXQ7eWYgjWUEHP/M9wDSg+RVA2 ph9L2stAvydDwqR1KiJiqMIKnZFv2HGKnb4uKQJNUcrwCXGA4d5gGOExB1Kd/t9aBjaejvTO5AZl CtG0JjjhMVCEUjNEilVIBIwasqTJrC7QCBkTcFQFlEtEpYCL4AUg8VFJPTwfBz3WhJTC2rjgKoX0 JT0CIkrApEKMZsba5zV320NtrwFYcW2L5FdWgKUzxzrHQfGAX1cqyTVlIKKiLZKzmTSgTTJwRa2u vTWbtUABrl7QfLzkGBbqty+h5zwtXaP1B4nqXI0FtD5sN2bbzMIDkk0pAuXKOUCsbvMMiYAFA2Ej 2XO82V6rD4CkLl16gKF85xnMdLtLYJ50TQXWXhdPk4vcsXBRlgKQd+gMnbhDtnzVrLwSnjv41kmD V3xg1Cc1zxJqdki0tn6JzJ0oPUReODvCFyPJbMRA8L15vDvKSLNAz1riuMwRmFNZ40kCxDovLcUy YtaZbjZiqWve13s7NPFWooqIKKwjKLawlAv69J3HbNWmgWtUGRhDtIGs6fNuN3yTOy5mjvDlCLWr sblLe17SU5KBQg9foOwlZ2LrLu+nnXamc7NLSb0SgCsZYkBQDqTqxu01akB0MwYpMkyQ1TSwwYBW 3K14gUOVAGbnQ5j5oGJhwMvXa4au9xJH7pRzrBA+GBZCQ/69ws9hLpB3vLEDk4xgQsBUTKgVYxRD I7IWDoxjRYaXElt8sCiMbRZhzqFSBHRVk0JOVwarYQgpnFEBZiVBpNMGvhwn+u4rYBM2kamI/CNU SKAFJquiyc4kNwGZmUCWdVcZweVWSDISEg5SAkQS8UgmlpPWfH3nr9ociQe0qfq9hcqFhlcpk9K7 5k11XntWQGdxkagO1HQpnBAf2pZoPJnmWkpbkXBYO1jyPKNdRFHOKZBv12L+mCrWCKh5lVzOhXiV GIGwDuAZezkol8Z4uh63jczIIJ4hTU8Hg0N4IYEF7ltBBBBmxBydnUzELgBEOwUE0Jysaw69B1qb k6aNnTA8GTtDomR2+YUBRREi9RWWk39pXwCkS9AGs8bCIQtIjBChuAeqwC9p4ZlEg+xgxoBptoG0 BkWi7/ywQs67EISBImwJfy3U3a8IwhJH0uKJTtxyPCgF+sjyKffrUJLa8zg61kXvqtYBYNVLHskv kvUUH4HNhVIsXRqXTwBD4hngLG0fznN5mP19n7IIoURGoC0ASPJNBxp2HesaxoEhM5iEOZMI3oep zHEiLeCXUcHh16zL+eT7okNwKl0SB3dXWBom2DUO9TizDRrKS96mwsl781OqVzwrfNeU5iGg9Wrm DZLmVp67T2eHNaE0LQ0DAY2DbAaTaN3athmH07eY1h+8wRvGmhiKkVGL2T0GnkzlIG3oIXumvnCe JBlMRC0LmBHPgg0pyPC0SLEho3TN2vY5oMfSaTOgyEu9NXgKmSPyWbADrRUOopSw4QVZ0sByCDn4 p73mIZ5HCceZvm83eM1c5q6HYhtcIVvbjGG2oDXCbSOb2SDlkYCOQgt7V5ixerRisgYHEGLnfPe4 PB52fSv2EFgWzCEC+XC7zbvNf5udDcAMJ1tIMQYZNHYyFVd4Etk3WAY2BoQut7STYl0xLnl8Uwjm LccWHV58+VvuuIPTNL5WcdwkNAGyIMjUK0RmWEMDSQflot1vWIaWp7AOUL4WBIebG8bT7QR+aFhl MDkrIfOM+69LU15lWDab1sxNPqjDI8TkZ182RKZkzBypyNnjuNjsytEtKEntjxO/wpQStc5D37j+ Prx73ku5TsKHgkHE2zfPljN6LKMrEC+J9h4TeMtmOoimeaF8IkSbq3Qsd8aK2QnfacrNOn1HaCVs DrD2G5PjaDYB82pPCbVDITiArcWgcA2rd1d9wP2dJ1Gp8vX3P27g0h0dDVgg4hvJSinpzBsxAceK QLgDRshdDLIxkftwLRwI22XVKExgBhQ8QVZDnghkx8j6TBB6ZfNZrDuz6QMk8EOuFiNo0RYsXxm7 XqdZpKCXLXiEgha2RCuHKkBAoDIo6gPoExRxAzxKRG0UwopC68NoF73sJgFr/wdKVwM0ZFN3lpeR MR5DY4h5i7mGvVtgcGFmSFgdzBtBbEPkVY5c2DgBC1F0tFe5yQsW2tlstik3HN+rgfMiUnsjYCIG lUDAqgL2BKWnO2hzrwDysXSuBciaQEBH7hBoVgeKg9URIZEwDYdI+w9yYKjIILyCeB7wuGppQbIt MbxHnByIAyRm44UgQSeG+ByoKkkqe67PCdvmsTTIFJVgQawqALemjB2EZmDOAzhEBWDlaLCF+FoG BjbZBSIwIr5gHNTLD7TobvLM54asQMkDRdg4htp2joRRz5tzVSSQiiUZmW2/xdov4gc2lW59QBdu 0UIXXUz4AOjWhdrVj1rgIVVQhgl7jKJr6D00sQin4ehD3bUybBoHUJMVoDj89++Gtnz02j0hxcjv oLh7Huf8L7Q+vbgdfUqkJoO/SeNxDLOfQvTpCgWBUse89UJPTzSJCMkjRRHx4Q86TyJtNS4AsSyv alyYbTaWgIZrA8h785HYIGFUEOYCS0KWTsALUUX5SFBw1RkiDFZAVgpkWiQQLimCLILIIiERjFRB Vd5klJ3iEPmoH3cpISowdFIVBJAYOhS7AJFKAzCEDs8+x6hM5nMQGEZ3RWWgtghvDAmKhzLNfg48 8YHbDE4AcNevZW47yxSxEWtBIaukgcjTyjcl80QzuCRBWtZAcR7zxa9yU9FB6ghFigyIgQCCBkB9 lSOMc5qEQlaVgeywUS0IwHhAQK08YOzHOd9E98de04gfpH6Rfajbyjox2giUbszy/RnSTsA62BYE P3sCCkrEQESC2qhXJVIh7g8rcveoRsGlhPnJa9UNDQhwd3wk9HdfxrFLDGLYMSU4oxF1bYKKsUgQ zQWCmBzpDJMOUw0zxlhJ2+TPBNCjpa1RFHRIolimvClqRKII8sXsYgJKSmQQvXbbBneqiSaYWLVs otm4u5bhcYEXpNRuyMAomvMX1Fur8+78nmhJw1xMNiuDTdkG9hMmBGmRUhmU2fh5bWh3bdeSGccD rDEt782OejQhMF+WZLf0AmLkmmcsxkQwEvisO1j7nKT2E/Vt6prPTNfE3yg9frk9D12rbbattr2R 0U3WSOqyliBRgC8Jk7PLg5g8AUyEjMlLMjOTCY1EYSL8ydMrQKcfKUuQuLni4yyKUzJM7GIQYmWe DEyhEDDunB2obmYyLqIcBLJxhgYQmZi0vXiD2BYzneYHdoIbxDepoDJgTTJ4pGAs+4/UB05mzEsO xjdk7QuDYSDMhCQ4wCszNrrWquhG1Wt8AWOXVe/JClqYDvOLKSAg6irf6EDIVJ0K2iZeBMAujiis I0PEgqiq14Y5tX0WIhgjn6Re8FuBIkmL/cMAKgUamgf1MDu3aDNWsE478YaEKKWkosLKYiXRwTea KQIBH7Ro7bCxrw2qGGozH9YQSiRVscz0FSJrLBRf2QycAiRcG6g0r8zpceaUURI9JtBhSgOI+geA cDvGASL1xApYBtRQSpgTHyXqWru2OFDckaTQA1fX37EOr0GDdVPliVHTNpNUXepQH9wUplBxNXGw POUSFyLyw2xOwRac4pCcQkcimktVM1y2pGwwHzwU+g63QXKZFfr98xqMzWWd8QsQsQPbhSmBKIIi mdaaim8NBIIGJB7mNhC6PXc3MUxEsyCQ0U/hEPqZDU8gVRQg6WEw7ftsP+76VVwQlpW78FBhXnsh EIRVbiBHe3ZMbfKEE/798B22x1SAn44Vr4Cl1gXq4PSvkkg7ilhme1nk09RrHMfhcVv7xr6g/MHZ yvXoPoXxmYaV7RI5vSZgtLDlrnZl1isUuJCTtDpGpgF7gNPCZzKAP2yiZmUVyFpB3G5WqDCM/jCa uPfFeqiykgkwWfCOt9jDlZpghxCVyH7TN48hKOiZaB9bn62ux9robIeJ6nUppA80Nsch5BCgS0Dj OFFonS4mFg0SZCF05W93zsD3gCO48b3g6IyKbrjvMi4FgIxeph1vY0GeAUJx8DadJc1kpQDTpbYP nljF1R94qo+VaOyipKCsUakMVJkhCGJRgUKUdhhcTD/ITtTI4PEeh21uVY3gF3ipTuA2CB5+ZU+v elvGsK76redKodS+f8TrHp/gQFddtJRCRY/4u5IpwoSFK9rZEA== --===============2176735680021151847==--