From: Alexander Nozdrin Date: April 15 2011 12:02pm Subject: bzr commit into mysql-5.5 branch (alexander.nozdrin:3450) Bug#11763166 List-Archive: http://lists.mysql.com/commits/135519 X-Bug: 11763166 Message-Id: <201104151202.p3FC2XM8016465@acsmt356.oracle.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============7869559597407638044==" --===============7869559597407638044== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline #At file:///home/alik/MySQL/bzr/00/bug55847/mysql-5.5-bug55847/ based on revid:sergey.glukhov@stripped 3450 Alexander Nozdrin 2011-04-15 A patch for Bug#11763166 (55847: SHOW WARNINGS returns empty result set when SQLEXCEPTION is active. The problem was in a hackish THD::no_warnings_for_error attribute. When it was set, an error was not written to Warning_info -- only Diagnostics_area state was changed. That means, Diagnostics_area might contain error state, which is not present in Warning_info. The user-visible problem was that in some cases SHOW WARNINGS returned empty result set (i.e. there were no warnings) while the previous SQL statement failed. According to the MySQL protocol errors must be presented in warning list. The main idea of this patch is to remove THD::no_warnings_for_error. There were few places where it was used: - sql_admin.cc, handling of REPAIR TABLE USE_FRM. - sql_show.cc, when calling fill_schema_table_from_frm(). - sql_show.cc, when calling fill_table(). The fix is to either use internal-error-handlers, or to use temporary Warning_info storing warnings, which might be ignored. This patch is needed to fix Bug 11763162 (55843). modified: mysql-test/r/warnings.result mysql-test/t/warnings.test sql/sp_head.cc sql/sql_admin.cc sql/sql_class.cc sql/sql_class.h sql/sql_error.cc sql/sql_error.h sql/sql_parse.cc sql/sql_prepare.cc sql/sql_show.cc sql/sql_trigger.cc === modified file 'mysql-test/r/warnings.result' --- a/mysql-test/r/warnings.result 2010-02-24 13:52:27 +0000 +++ b/mysql-test/r/warnings.result 2011-04-15 12:02:22 +0000 @@ -316,3 +316,25 @@ SHOW ERRORS; Level Code Message Error 1051 Unknown table 't1' End of 5.0 tests + +-- Bug#55847 + +DROP TABLE IF EXISTS t1; +DROP FUNCTION IF EXISTS f1; +CREATE TABLE t1(a INT UNIQUE); +CREATE FUNCTION f1(x INT) RETURNS INT +BEGIN +INSERT INTO t1 VALUES(x); +INSERT INTO t1 VALUES(x); +RETURN x; +END| + +SHOW TABLES WHERE f1(11) = 11; +ERROR 23000: Duplicate entry '11' for key 'a' + +SHOW WARNINGS; +Level Code Message +Error 1062 Duplicate entry '11' for key 'a' + +DROP TABLE t1; +DROP FUNCTION f1; === modified file 'mysql-test/t/warnings.test' --- a/mysql-test/t/warnings.test 2009-11-13 10:17:53 +0000 +++ b/mysql-test/t/warnings.test 2011-04-15 12:02:22 +0000 @@ -228,3 +228,43 @@ DROP TABLE t1; SHOW ERRORS; --echo End of 5.0 tests + +# +# Bug#55847: SHOW WARNINGS returns empty result set when SQLEXCEPTION is active +# + +--echo +--echo -- Bug#55847 +--echo + +--disable_warnings +DROP TABLE IF EXISTS t1; +DROP FUNCTION IF EXISTS f1; +--enable_warnings + +CREATE TABLE t1(a INT UNIQUE); + +delimiter |; + +CREATE FUNCTION f1(x INT) RETURNS INT +BEGIN + INSERT INTO t1 VALUES(x); + INSERT INTO t1 VALUES(x); + RETURN x; +END| + +delimiter ;| + +--echo + +--error ER_DUP_ENTRY +SHOW TABLES WHERE f1(11) = 11; + +--echo + +SHOW WARNINGS; + +--echo + +DROP TABLE t1; +DROP FUNCTION f1; === modified file 'sql/sp_head.cc' --- a/sql/sp_head.cc 2011-02-16 16:27:35 +0000 +++ b/sql/sp_head.cc 2011-04-15 12:02:22 +0000 @@ -1,4 +1,4 @@ -/* Copyright 2002-2008 MySQL AB, 2008-2010 Sun Microsystems, Inc. +/* Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -11,7 +11,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "my_global.h" /* NO_EMBEDDED_ACCESS_CHECKS */ #include "sql_priv.h" @@ -1217,7 +1217,8 @@ sp_head::execute(THD *thd, bool merge_da String old_packet; Reprepare_observer *save_reprepare_observer= thd->m_reprepare_observer; Object_creation_ctx *saved_creation_ctx; - Warning_info *saved_warning_info, warning_info(thd->warning_info->warn_id()); + Warning_info *saved_warning_info; + Warning_info warning_info(thd->warning_info->warn_id(), false); /* Just reporting a stack overrun error === modified file 'sql/sql_admin.cc' --- a/sql/sql_admin.cc 2011-03-08 08:41:57 +0000 +++ b/sql/sql_admin.cc 2011-04-15 12:02:22 +0000 @@ -263,7 +263,7 @@ static bool mysql_admin_table(THD* thd, const char *operator_name, thr_lock_type lock_type, bool open_for_modify, - bool no_warnings_for_error, + bool repair_table_use_frm, uint extra_open_options, int (*prepare_func)(THD *, TABLE_LIST *, HA_CHECK_OPT *), @@ -331,18 +331,43 @@ static bool mysql_admin_table(THD* thd, lex->query_tables= table; lex->query_tables_last= &table->next_global; lex->query_tables_own_last= 0; - /* - Under locked tables, we know that the table can be opened, - so any errors opening the table are logical errors. - In these cases it makes sense to report them. - */ - if (!thd->locked_tables_mode) - thd->no_warnings_for_error= no_warnings_for_error; + if (view_operator_func == NULL) table->required_type=FRMTYPE_TABLE; - open_error= open_and_lock_tables(thd, table, TRUE, 0); - thd->no_warnings_for_error= 0; + if (!thd->locked_tables_mode && repair_table_use_frm) + { + /* + If we're not under LOCK TABLES and we're executing REPAIR TABLE + USE_FRM, we need to ignore errors from open_and_lock_tables(). + REPAIR TABLE USE_FRM is a heavy weapon used when a table is + critically damaged, so open_and_lock_tables() will most likely + report errors. Those errors are not interesting for the user + because it's already known that the table is badly damaged. + */ + + Warning_info wi(thd->query_id, false); + Warning_info *wi_saved= thd->warning_info; + + thd->warning_info= &wi; + + open_error= open_and_lock_tables(thd, table, TRUE, 0); + + thd->warning_info= wi_saved; + } + else + { + /* + It's assumed that even if it is REPAIR TABLE USE_FRM, the table + can be opened if we're under LOCK TABLES (otherwise LOCK TABLES + would fail). Thus, the only errors we could have from + open_and_lock_tables() are logical ones, like incorrect locking + mode. It does make sense for the user to see such errors. + */ + + open_error= open_and_lock_tables(thd, table, TRUE, 0); + } + table->next_global= save_next_global; table->next_local= save_next_local; thd->open_options&= ~extra_open_options; === modified file 'sql/sql_class.cc' --- a/sql/sql_class.cc 2011-01-27 13:25:27 +0000 +++ b/sql/sql_class.cc 2011-04-15 12:02:22 +0000 @@ -1,4 +1,4 @@ -/* Copyright (C) 2000-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc. +/* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -11,8 +11,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ - + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /***************************************************************************** ** @@ -522,7 +521,7 @@ THD::THD() #if defined(ENABLED_DEBUG_SYNC) debug_sync_control(0), #endif /* defined(ENABLED_DEBUG_SYNC) */ - main_warning_info(0) + main_warning_info(0, false) { ulong tmp; @@ -581,7 +580,7 @@ THD::THD() client_capabilities= 0; // minimalistic client ull=0; system_thread= NON_SYSTEM_THREAD; - cleanup_done= abort_on_warning= no_warnings_for_error= 0; + cleanup_done= abort_on_warning= 0; peer_port= 0; // For SHOW PROCESSLIST transaction.m_pending_rows_event= 0; transaction.on= 1; @@ -854,10 +853,6 @@ MYSQL_ERROR* THD::raise_condition(uint s query_cache_abort(&query_cache_tls); - /* FIXME: broken special case */ - if (no_warnings_for_error && (level == MYSQL_ERROR::WARN_LEVEL_ERROR)) - DBUG_RETURN(NULL); - /* When simulating OOM, skip writing to error log to avoid mtr errors */ DBUG_EXECUTE_IF("simulate_out_of_memory", DBUG_RETURN(NULL);); === modified file 'sql/sql_class.h' --- a/sql/sql_class.h 2011-03-08 17:39:25 +0000 +++ b/sql/sql_class.h 2011-04-15 12:02:22 +0000 @@ -1,4 +1,4 @@ -/* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved. +/* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -2089,7 +2089,6 @@ public: bool enable_slow_log; /* enable slow log for current statement */ bool abort_on_warning; bool got_warning; /* Set on call to push_warning() */ - bool no_warnings_for_error; /* no warnings on call to my_error() */ /* set during loop of derived table processing */ bool derived_tables_processing; my_bool tablespace_op; /* This is TRUE in DISCARD/IMPORT TABLESPACE */ @@ -2807,6 +2806,7 @@ private: /** The current internal error handler for this thread, or NULL. */ Internal_error_handler *m_internal_handler; + /** The lex to hold the parsed tree of conventional (non-prepared) queries. Whereas for prepared and stored procedure statements we use an own lex === modified file 'sql/sql_error.cc' --- a/sql/sql_error.cc 2010-11-12 14:20:12 +0000 +++ b/sql/sql_error.cc 2011-04-15 12:02:22 +0000 @@ -1,5 +1,4 @@ -/* Copyright (C) 1995-2002 MySQL AB, - Copyright (C) 2008-2009 Sun Microsystems, Inc +/* Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -458,10 +457,11 @@ Diagnostics_area::disable_status() m_status= DA_DISABLED; } -Warning_info::Warning_info(ulonglong warn_id_arg) +Warning_info::Warning_info(ulonglong warn_id_arg, bool allow_unlimited_warnings) :m_statement_warn_count(0), m_current_row_for_warning(1), m_warn_id(warn_id_arg), + m_allow_unlimited_warnings(allow_unlimited_warnings), m_read_only(FALSE) { /* Initialize sub structures */ @@ -543,7 +543,8 @@ MYSQL_ERROR *Warning_info::push_warning( if (! m_read_only) { - if (m_warn_list.elements < thd->variables.max_error_count) + if (m_allow_unlimited_warnings || + m_warn_list.elements < thd->variables.max_error_count) { cond= new (& m_warn_root) MYSQL_ERROR(& m_warn_root); if (cond) @@ -559,6 +560,20 @@ MYSQL_ERROR *Warning_info::push_warning( return cond; } +MYSQL_ERROR *Warning_info::push_warning(THD *thd, const MYSQL_ERROR *sql_condition) +{ + MYSQL_ERROR *new_condition= push_warning(thd, + sql_condition->get_sql_errno(), + sql_condition->get_sqlstate(), + sql_condition->get_level(), + sql_condition->get_message_text()); + + if (new_condition) + new_condition->copy_opt_attributes(sql_condition); + + return new_condition; +} + /* Push the warning to error list if there is still room in the list === modified file 'sql/sql_error.h' --- a/sql/sql_error.h 2010-11-12 12:56:21 +0000 +++ b/sql/sql_error.h 2011-04-15 12:02:22 +0000 @@ -1,5 +1,4 @@ -/* Copyright (C) 2000-2003 MySQL AB, - Copyright (C) 2008-2009 Sun Microsystems, Inc +/* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -12,7 +11,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef SQL_ERROR_H #define SQL_ERROR_H @@ -323,10 +322,13 @@ class Warning_info { /** A memory root to allocate warnings and errors */ MEM_ROOT m_warn_root; + /** List of warnings of all severities (levels). */ List m_warn_list; + /** A break down of the number of warnings per severity (level). */ uint m_warn_count[(uint) MYSQL_ERROR::WARN_LEVEL_END]; + /** The number of warnings of the current statement. Warning_info life cycle differs from statement life cycle -- it may span @@ -334,20 +336,25 @@ class Warning_info m_statement_warn_count 0, whereas m_warn_list is not empty. */ uint m_statement_warn_count; + /* Row counter, to print in errors and warnings. Not increased in create_sort_index(); may differ from examined_row_count. */ ulong m_current_row_for_warning; - /** Used to optionally clear warnings only once per statement. */ + + /** Used to optionally clear warnings only once per statement. */ ulonglong m_warn_id; + /** Indicates if push_warning() allows unlimited number of warnings. */ + bool m_allow_unlimited_warnings; + private: Warning_info(const Warning_info &rhs); /* Not implemented */ Warning_info& operator=(const Warning_info &rhs); /* Not implemented */ public: - Warning_info(ulonglong warn_id_arg); + Warning_info(ulonglong warn_id_arg, bool allow_unlimited_warnings); ~Warning_info(); /** @@ -384,19 +391,13 @@ public: void append_warnings(THD *thd, List *src) { MYSQL_ERROR *err; - MYSQL_ERROR *copy; List_iterator_fast it(*src); /* Don't use ::push_warning() to avoid invocation of condition handlers or escalation of warnings to errors. */ while ((err= it++)) - { - copy= Warning_info::push_warning(thd, err->get_sql_errno(), err->get_sqlstate(), - err->get_level(), err->get_message_text()); - if (copy) - copy->copy_opt_attributes(err); - } + Warning_info::push_warning(thd, err); } /** @@ -462,6 +463,9 @@ public: MYSQL_ERROR::enum_warning_level level, const char* msg); + /** Add a new condition to the current list. */ + MYSQL_ERROR *push_warning(THD *thd, const MYSQL_ERROR *sql_condition); + /** Set the read only status for this statement area. This is a privileged operation, reserved for the implementation of === modified file 'sql/sql_parse.cc' --- a/sql/sql_parse.cc 2011-03-08 17:39:25 +0000 +++ b/sql/sql_parse.cc 2011-04-15 12:02:22 +0000 @@ -1,4 +1,4 @@ -/* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved. +/* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -7223,10 +7223,20 @@ 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 either thd->is_error() is set, or an + internal error handler is set. + + The assert will not catch a situation where parsing fails without an + error reported if an error handler exists. The problem is that the + error handler might have intercepted the error, so thd->is_error() is + not set. However, there is no way to be 100% sure here (the error + handler might be for other errors than parsing one). + */ DBUG_ASSERT(!mysql_parse_status || - (mysql_parse_status && thd->is_error())); + (mysql_parse_status && thd->is_error()) || + (mysql_parse_status && thd->get_internal_handler())); /* Reset parser state. */ === modified file 'sql/sql_prepare.cc' --- a/sql/sql_prepare.cc 2011-03-15 12:57:36 +0000 +++ b/sql/sql_prepare.cc 2011-04-15 12:02:22 +0000 @@ -1,4 +1,4 @@ -/* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. +/* Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -2842,7 +2842,8 @@ void mysql_stmt_get_longdata(THD *thd, c param= stmt->param_array[param_number]; Diagnostics_area new_stmt_da, *save_stmt_da= thd->stmt_da; - Warning_info new_warnning_info(thd->query_id), *save_warinig_info= thd->warning_info; + Warning_info new_warnning_info(thd->query_id, false); + Warning_info *save_warinig_info= thd->warning_info; thd->stmt_da= &new_stmt_da; thd->warning_info= &new_warnning_info; @@ -3900,7 +3901,7 @@ Ed_result_set::Ed_result_set(Listquery_id), + :m_warning_info(thd->query_id, false), m_thd(thd), m_rsets(0), m_current_rset(0) === modified file 'sql/sql_show.cc' --- a/sql/sql_show.cc 2011-04-06 15:11:43 +0000 +++ b/sql/sql_show.cc 2011-04-15 12:02:22 +0000 @@ -3416,6 +3416,45 @@ end: /** + Trigger_error_handler is intended to intercept and silence SQL conditions + that might happen during trigger loading for SHOW statements. + The potential SQL conditions are: + + - ER_PARSE_ERROR -- this error is thrown if a trigger definition file + is damaged or contains invalid CREATE TRIGGER statement. That should + not happen in normal life. + + - ER_TRG_NO_DEFINER -- this warning is thrown when we're loading a + trigger created/imported in/from the version of MySQL, which does not + support trigger definers. + + - ER_TRG_NO_CREATION_CTX -- this warning is thrown when we're loading a + trigger created/imported in/from the version of MySQL, which does not + support trigger creation contexts. +*/ + +class Trigger_error_handler : public Internal_error_handler +{ +public: + bool handle_condition(THD *thd, + uint sql_errno, + const char* sqlstate, + MYSQL_ERROR::enum_warning_level level, + const char* msg, + MYSQL_ERROR ** cond_hdl) + { + if (sql_errno == ER_PARSE_ERROR || + sql_errno == ER_TRG_NO_DEFINER || + sql_errno == ER_TRG_NO_CREATION_CTX) + return true; + + return false; + } +}; + + + +/** @brief Fill I_S tables whose data are retrieved from frm files and storage engine @@ -3570,7 +3609,6 @@ int get_all_tables(THD *thd, TABLE_LIST acl_get(sctx->host, sctx->ip, sctx->priv_user, db_name->str, 0)) #endif { - thd->no_warnings_for_error= 1; List table_names; int res= make_table_name_list(thd, &table_names, lex, &lookup_field_vals, @@ -3619,9 +3657,24 @@ int get_all_tables(THD *thd, TABLE_LIST if (!(table_open_method & ~OPEN_FRM_ONLY) && !with_i_schema) { - if (!fill_schema_table_from_frm(thd, tables, schema_table, db_name, - table_name, schema_table_idx, - can_deadlock)) + /* + Here we need to filter out warnings, which can happen + during loading of triggers in fill_schema_table_from_frm(), + because we don't need those warnings to pollute output of + SELECT from I_S / SHOW-statements. + */ + + Trigger_error_handler err_handler; + thd->push_internal_handler(&err_handler); + + int res= fill_schema_table_from_frm(thd, tables, schema_table, + db_name, table_name, + schema_table_idx, + can_deadlock); + + thd->pop_internal_handler(); + + if (!res) continue; } @@ -3631,7 +3684,6 @@ int get_all_tables(THD *thd, TABLE_LIST Set the parent lex of 'sel' because it is needed by sel.init_query() which is called inside make_table_list. */ - thd->no_warnings_for_error= 1; sel.parent_lex= lex; if (make_table_list(thd, &sel, db_name, table_name)) goto err; @@ -6675,6 +6727,92 @@ int make_schema_select(THD *thd, SELECT_ } +/** + Fill INFORMATION_SCHEMA-table, leave correct Diagnostics_area / + Warning_info state after itself. + + This function is a wrapper around ST_SCHEMA_TABLE::fill_table(), which + may "partially silence" some errors. The thing is that during + fill_table() many errors might be emitted. These errors stem from the + nature of fill_table(). + + For example, SELECT ... FROM INFORMATION_SCHEMA.xxx WHERE TABLE_NAME = 'xxx' + results in a number of 'Table .xxx does not exist' errors, + because fill_table() tries to open the 'xxx' table in every possible + database. + + Those errors are cleared (the error status is cleared from + Diagnostics_area) inside fill_table(), but they remain in Warning_info + (Warning_info is not cleared because it may contain useful warnings). + + This function is responsible for making sure that Warning_info does not + contain warnings corresponding to the cleared errors. + + @note: THD::no_warnings_for_error used to be set before calling + fill_table(), thus those errors didn't go to Warning_info. This is not + the case now (THD::no_warnings_for_error was eliminated as a hack), so we + need to take care of those warnings here. + + @param thd Thread context. + @param table_list I_S table. + @param join_table JOIN/SELECT table. + + @return Error status. + @retval TRUE Error. + @retval FALSE Success. +*/ +static bool do_fill_table(THD *thd, + TABLE_LIST *table_list, + JOIN_TAB *join_table) +{ + // NOTE: fill_table() may generate many "useless" warnings, which will be + // ignored afterwards. On the other hand, there might be "useful" + // warnings, which should be presented to the user. Warning_info usually + // stores no more than THD::variables.max_error_count warnings. + // The problem is that "useless warnings" may occupy all the slots in the + // Warning_info, so "useful warnings" get rejected. In order to avoid + // that problem we create a Warning_info instance, which is capable of + // storing "unlimited" number of warnings. + Warning_info wi(thd->query_id, true); + Warning_info *wi_saved= thd->warning_info; + + thd->warning_info= &wi; + + bool res= table_list->schema_table->fill_table( + thd, table_list, join_table->select_cond); + + thd->warning_info= wi_saved; + + // Pass an error if any. + + if (thd->stmt_da->is_error()) + { + thd->warning_info->push_warning(thd, + thd->stmt_da->sql_errno(), + thd->stmt_da->get_sqlstate(), + MYSQL_ERROR::WARN_LEVEL_ERROR, + thd->stmt_da->message()); + } + + // Pass warnings (if any). + // + // Filter out warnings with WARN_LEVEL_ERROR level, because they + // correspond to the errors which were filtered out in fill_table(). + + + List_iterator_fast it(wi.warn_list()); + MYSQL_ERROR *err; + + while ((err= it++)) + { + if (err->get_level() != MYSQL_ERROR::WARN_LEVEL_ERROR) + thd->warning_info->push_warning(thd, err); + } + + return res; +} + + /* Fill temporary schema tables before SELECT @@ -6697,7 +6835,6 @@ bool get_schema_tables_result(JOIN *join bool result= 0; DBUG_ENTER("get_schema_tables_result"); - thd->no_warnings_for_error= 1; for (JOIN_TAB *tab= join->join_tab; tab < tmp_join_tab; tab++) { if (!tab->table || !tab->table->pos_in_table_list) @@ -6748,8 +6885,7 @@ bool get_schema_tables_result(JOIN *join else table_list->table->file->stats.records= 0; - if (table_list->schema_table->fill_table(thd, table_list, - tab->select_cond)) + if (do_fill_table(thd, table_list, tab)) { result= 1; join->error= 1; @@ -6761,7 +6897,6 @@ bool get_schema_tables_result(JOIN *join table_list->schema_table_state= executed_place; } } - thd->no_warnings_for_error= 0; DBUG_RETURN(result); } === modified file 'sql/sql_trigger.cc' --- a/sql/sql_trigger.cc 2011-03-10 08:07:57 +0000 +++ b/sql/sql_trigger.cc 2011-04-15 12:02:22 +0000 @@ -1225,13 +1225,12 @@ bool Table_triggers_list::check_n_load(T DBUG_RETURN(1); // EOM } - - if (!thd->no_warnings_for_error) - 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); + + 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)) || @@ -1362,12 +1361,12 @@ bool Table_triggers_list::check_n_load(T MySQL, which does not support triggers definers. We should emit warning here. */ - if (!thd->no_warnings_for_error) - push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, - ER_TRG_NO_DEFINER, ER(ER_TRG_NO_DEFINER), - (const char*) db, - (const char*) sp->m_name.str); - + + push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, + ER_TRG_NO_DEFINER, ER(ER_TRG_NO_DEFINER), + (const char*) db, + (const char*) sp->m_name.str); + /* Set definer to the '' to correct displaying in the information schema. --===============7869559597407638044== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/alexander.nozdrin@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: alexander.nozdrin@stripped\ # lqopb0jmt85gj0tw # target_branch: file:///home/alik/MySQL/bzr/00/bug55847/mysql-5.5-\ # bug55847/ # testament_sha1: f1c88bb689ddd53b4b5fd55b26b61e966c354a78 # timestamp: 2011-04-15 16:02:26 +0400 # base_revision_id: sergey.glukhov@stripped\ # 81q5k4d1zmp78vmg # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWVFS5V8ADwv/gHV8BVB7//// f///4L////5gH3xOxfZdxaretammtze7ra6oI2yhewru7gAAaTr6XduZVVS2a27q3ZXt7n3n3vK9 Oj6pTVa9HvNXr04KiO12HJ1vp9dS60R0Bs4ZJoIIm0wJim0FTzTVPymp+qeaFH6kPUNAGgADIDQJ QgEyaJiaJqZNNNSeno0kyHqG1MTQaAAyDQA0BpoJk1JqmGjKelPUNqeoD1AaAAAAAAAAAkRBCNCa aaTJiZGFTzQ1TZU/Unp5RN6Roanqemp6nqNkgY1P1QRUIaEp7TQVP09RPIU2mptqPJCAyMgP1QA0 DTExMQCRIQCaNJkaYTTKeiaJkYp5TxSep+kmh6m1Gj1DTajIA9TUsGNoEv6f79X8qi7/l1R1ict+ minrb88DiFi7VDBqRuWu2v4/Kh5Jhf9+qeu0RkGPpy8MKnsa0GrWqUPTSrR32gnvrERMDm8sCsvV +X3/frjh2fhN/x/ue7jzy3nu35+dqVGxMPTq/6lFurh3uxasjJbI/7CfqEbSNIkDMVaFAgnDvNRF l9H8xafwlsl8Xgc3N6dlyAmxCQgGuPcgwvEq7Myhd20nXp9bWZBBG7kb6tqnZqsunY24mFi+Z9tP 3/L0Bw/70PTQ52XfSs1afV4LWSdzDnvFc0u58PrbgCvREOnn6Yd6a/R/Mw0to4YXllcPPBm/+rLc 03tzmQRraFd8+yBHA7sRDEFSGN7OybvfjBBjNqKtZtuxSRBzglXw7qbpaq8PENeC2yTN9n2dXN42 zq3WDwHZvPVRCBBmQHGuBCPJoPcxJUSGm2k0NNAfUmkQmJsQm0mmIy1dnlxypHSfxJPSzIJrQfNy fNbFKw8eiTjZjt/DavLkyT62cAzt+wJLJk/5Ok135oQHtBfJHghpNoGNNobEB7BxcbfbBAFkAa7k ARG13dGeMPO6Mom/cwSb3LvGNqg1Tq+yusolal4EBOVEmnqV7eVGdV0bLTQXV4VoI1OONKYSQl7F yRWihhYWy8K2Z0DpQWzEuM4c4OIC6pkW1kSUstK1orgsbIwxVzBciD4LGrIhEu2hNdU3hQM5gTp7 kJpPql8447IEvzx+CxRZ0bf4hlo9ef/UkMv9rCfwKFX5UPOeRrPQH6rtK1+iW7WXvKGwVMUcHoKI ROJUOO7CEWAg28SRx1OtHPmjO68IZEH5H+45fbjhdPC48y1GnRCgbZojaeCtW30hkjRw4iaQ9OfS o7pmHLCGAroal7OZMG6EID34rRodNojW9tEhMCJIm4ZuJbyxTUy3Iux2UdxQtyOO2SVITHE7F/P2 e0wIynljavGzEEVpEuBAfwwyOHPB9sYTgrlYuWuLMFiUGrrDL69bG0FSzL0jwwN4rjxw4kF2SAiL bRqcGOufS5EmXKFDE/qhmTVXsQO4z6RmtQ1TuEqPxSRtELilhuXvKaJwHKsVdH3y5aCzq3iz0B90 6KzZdGkdOKsx1x54TU+TyTApsxybf0q2t1wJOc7dV0g7g+F7avjHI67dOrFAJ/OlWFjo5raCxAsh iSYzw5bjWhm6as8i2HrhWxtxHu2uuNoPYZcgRn+3Ad7lMncFRF7ul3Qj8+l8YusBI4p3maCQRNK5 UVSiKdWteUZhjluskQXY48vSnPtYMusQyffh6ANozBBS/bkYo6n61GFbBj5AJPMVeng3l1byW7cN 2kn8ckY7JzWb1LLk/zNKpCY88c4r2+dTNrMkrYV7oxUFVRzdZFh29jqjWs8Y4WwIYwA5FBw7qrwc ccYVp597aCs8pdTkW0DZxajJnDzrgRkSKKwDLw2scTB9JGrekmmcO4k8PmN/Z8HAM9ny+XkwPxCu FK8Wjl8nu88rqxAjMEMWNCGIB7mftAKZU0brI6iyIy3pIuaS2MQDQz9a6BZ5Ki3MwPj1biJo0omQ HMZJne+7DRSg1EKsl0fc64jawrg0oWMDuLRsPIFGRPn+gVjgobCkFkegUcUvj2N3hjNuZ6gwMKdm z47dNOJ9OF9vSlmeBJ+gfjYQPWknL8lAVBK5k0zCe1AGo5NqZdmE+tyx4naZBK93dG7W1IIpSZp9 gMaTUxQjh+45whsbANfDheuWbX36YI+67gqsYL3MCJRIK6husCIOviWF0lwMo1EyAzT0GuwZOGeW 19EM3V8d6yFnb9dps5wJr7y5C9x9afMmuEIaDJWntGGczhAEjgQNAjpUakj2kLfr4d0ruckM/tEG oYar0lFGI5ubPhS9wzXlymq7vmJEBvtlQRLHHE1mePwERBQD5Pl5TUkMZ0kEQeTo8W2IJs4zrHHq QXs30sitspRSKUKWaXmmXvZzDTaUo9iT7duWbokqc/uuxc4gQGGIEBSAOARafbnr4FlVjMLSQSJK FF6zg1bf8fBB4PBkBDAfgdgHa5BL0555goOBBtBdPt44jyeWemeTsNSAwZ1NCwYYMCzQuZodYEVe GNZGGK9mQUyxwuFRZmFQJKAwK6YCE5gvKZIEEgQWkSRJQihJlpuTrPIai5QYs0yMQRGiTMCqj6yQ SVHSHwPfGACcggsCw4hAsd5cmFo4SSpYeFe6ZjJRRh+KVLDOH2FktCYFR8EQqKkEyeOChmUJHgpA IzwMgRL4tr8wSqxFg0hRW4dcCLGqO+mMUM9OYV22GRMZAlQMS2HwjXLErfGciQoAxAb7fdkFTvN/ X4vvPT5TrIImKbDIiBZFGyGHpmYacRbfkz4OOhMZKGGAIlHD8RhjMFiYjJCUoY4MdkeuHXyrBVu0 6fF61Q2Yn8Zkg1O5rixIozEmtN4XIyGYn591DMpyVK63TioImsHjpuvCObYkhqOkMUZKDzV0ZHmY xKFD2+9LA5m4FX4vU7Q8wNzBKnQ8hPczNTgZAxGhzBIOLjERwxYY6YkhEFHnvxT2bTTq26Nu4SWk L6nNYmKKUUk5XxOGUIM59ZywiTYEU5RcxMgxBjAGk0kFroS4RrELkFlkLu9EdgKQSzWz0N8AIjhF cBEslq5x0MOMQpQUZlpWeI6N3D7kRyPIGFgqUwITKo+i1Ug+DOYmO3JQLEiqhKJAyk3BTI67zJ64 oiZGPZmZjwxJnfxf0NjO/1EB3u8zsNRCxuczmqqrZwtwbSNs2L896o1nLEZKohYaKweyb7yfYwlc nzMB467ZOI6kCAUoZYPV4QYHOFSnwrCYUdrcFzhcEF6EaDn5Xr0NB+puSmuBTRz71cXF4mhs7Y2o MdbEdCszjNBcdh+c85Moe0rEYGw/M6G4RKRtN3mPOPP38JxPnKDmeSKNukz0FOinRQ0Y0PHe2E44 GI5xoFSgiUFDDAYbbhERG4DQdL1lHvgy63dUuLCpRYDClDdw8i0R3E2LDoXMdCj8XoMtR48nFV5j 0pLQvM8+REjEiOfEZboJM1JdCJItI3RYiuLkTA12/8Iar5z4Tc2MPetnlxyRbue8vdnOXJqcfS4l E8tXctzEsoqQwI2HPERMDqzM8ZJOZJO04HVIn1jhxyEL0vKBuW0iVwM0uQ4Cp4+Iq+XiY55GOGY4 6z0cjJMsNJzampWJMGbjBxyEyBk45gZmxfIqempAUygOkdh3YHAmZczbA2KgiWO1K95sYZ4lTYyh Vav12NoK2UpQhDRHwetR/A316yJLCkkLKzZI9XYFCEzJLke+hUetyRoNArwYqvNnj0zPQzyLLqVc Nd1oiwJkOnuvgvmhCD8iu+1hUEcaEDQ3zPObje4SPUdCHQQ0HX3FXhhk451i9y70hJRckkywiSJB CwDhTes1Cg1JPJKgdo8iPgUcRRFOVxC2HTPB+ZydiWbFRmgES0BnD9zqHOVbHhQ4pGZhEa3UIjJI icTqumQxfM16eJ6djPQ5nQyOwmSO85HQmegztuKxx249T+jc2dOWkgkKdvZMcryo3Y4Orq2uHlSl 8xcy1uwfNxAtOCioSJSvFJETXmCJDBRx1mwxbBGIlDGA6ouQuJdZHlwLFCxxJlSxrrY0LzS+PBcM XGOL3ugPc+dAlgSypBQdB1yKY0d1ck2EIwLEmB368DOyZnHLEC5jMVwzgHGpHKppozsSepqUqEiR 2ltZBqV7ezu9WGM660H/FxvjEQ+IO1Y/qBwvHXdCSTYynLzUqRbVFxl86ShVsF6CTgtKm6FmkrXx iMPs9+58G/ZIbpgl+H0cC+6hVnA1g7tFGY3ho9I4td/hrOjP0oVxHoZ96/jmtxV0Zy1X1IMU22No sCrDSRKBtZLs+ALyU9HsYhFsdmPqJ7vmCELUN/dpPmcHjib1D8w8X+h8u8Gg2oTcZZBd/KcY2wG2 A2moEFqAfwNS/krBT5BZZigPp+mqX9kFAuA5IdHY/z1/LiJM4OlyoGFAmJQyxfgDwE3gTI3GSwPW XeyHiyxK2YFcBLQpT80mG/dkhoGIMiQCQjFHH1AvIMSwOQS8IEEWgakGhcFgg/6uRVcbeITLkMxG IneJTOAX6wq8/pisI+zK/8OpTQwTSkiJGtxJQtLAWa6Tr2hKqQO35Xqgj/mPK1yGIGIRo5RaCUii JLVAkoJVsEoZNeINy+Raok0hcZx+RAwLALQLgvGYTRuEi4qAo4BwNjbbE1rQU2M6mtCDMFZcakmN EuQGhIL0gmMLgwXjevYQqFBlJCTFSuHTzfNiGguGssmM/e0xn/YlqRCKzXrtCRAzNQQ2jg9KNfMJ Gy4vOVFgGAFQjINwXCP51R5+AhNsYNn/rIefkM7A3CmbtwQjexYo1IMiQvqBi/FhvaIcsNX9PyjQ GQtfrEtIcYMJ5NqVm2AwohnIChvJlr3TArP8j5r3o94fE+2gn7/xkmwZ+woF/wqKiwBwKh9JEh9B UNCyRQKpl9qt9IO8FWCgf0AR9J1OaSnBFGDrRBK+D9+E7sALSVd/7QopgmhpK0d8gT+g2EGJ9yNV 6LaKFq0JYkWclCRcAW6ih1kChtr7fUTcMlFgjoN5v7E3+TxmYsJnkI4eM/I1l5/B+xMgcR1JmRB/ Dj+RvFvnsq0mglaM87Whgg7uqBch/kYd2wLOBySSJluwM1v8DRO8HT3kdh01Ei9BesEk+tbQ2nOD kY2zfwkyfbZ753Qjq+g8yEwUfw6DCcbTRctZHi4fTNSueQupeCqQGXo8is43QnDqKrKFGvUTgsVa EDAvKi2VDXxSkODjmzkxxBUElFzycRdAf6ADTTTQ0ki9kGZpmiWXQ+r2CiQOOXBUQ+s288U04uLs hu8ZB/JEm5/OieYpfeswxqwRdI7RWdRPwMSoYa/w7jRvZ+R2dYJPpM8D6io8R/h9Kh6xxofSROR9 FSZ4e4ZB6xDTEzGC9B5Qy21dxUYnkaS4qKxGUz1ZTPo/w0Eb1dnNpj4FxIx7WNg2JBsQ0HQMscJU nxGaPuc5WO48nNbE6pdt8IA/XAWklmA7HR21kgXJpOQpgc5zbCFJQoVGc8x4GRaTJ8FgeYy8S+Na fmj+LRJVIoZi6pAs5xqPnz4Ejzm01rvTsqJae0Zsy9TVcQ22FieddQ4xthC6mCx5uPcMlUrHacRP SCnXnUQBMPxOYQL+WqMmqjidmYmHHw6gsNRqGQdSwsnzOsd2KXOyVvtMIOhRSSgDkICSZammKCBU ZUJSiI8wNCNbApWwxGHDrJwOcpOV6TaZCg6+yxl3lmDwNWOAicBEeXsPyLmZMwNEKgiSEYDcHlkd oUXvgvLcjnYV5jHsPLQWHQyeojLTfoNZC72JLJzy2IUwpS/jCS39UAFQdMfAmYdNkCyf2Ek2jIuR /BM4b2jJNpn9bOjNbGcPJ1PcHwgszd5V7mHmzAZEefSXusuNgU3QZLTBWWGQEfRoeYzDPbwwhSSm MrYKPCiKOG0ZwQIyzdwjApVIRRRZYVxRjVrO5AEt8r1M9da0eKaiJk7dEX1xXZ1WsikAEKKCe+eg vmunqNzxGkMYHunbyz8HQdt7ZVxbE9Us5AzMes3nl1GgoQenR27+3hrBbULLWVtIjbWMA6kk0EEQ b2XmxngPaEo4mFUNEgdPOJY5oYnlPUJGZPv8jjRX7MObzsGr83W2XRVZnMsY6kounDVJhvchVz5H E3c9RoR2YPuzmIiw7DIeZWCyXpEd9IN9NKdHBgxVIZMg80+a0jKDMpVBBeRVTreh5OHOCV80tVC0 cu2m93kDBQUsVxRUEuneWSS4lt5dksK0TxbZSUG1SKUqridQYzLFUklztai8crDlGm/tak09egJF 3m49X0v/yfAT5Ig/QxsgbByhJQktGWWoza2ljlPQE56Oxh9my9UZS+JJMkDpdJCkVf171Wh0AuMW JpQI8D7rUZbXQAx9bRaTqSSavBLHkPBdCrHV1LqQNMGyCfTG02Ck9puLgOAzFRylwlBAqNxWUYGk 7ReI4Vb/soO89hiT08ckL2mDJoTSmI68TzlXxBfCDEGxYPcgm6DnIF5A1F2hTrG4gglIEwrgs0zR JH3ELgajoWKys8OZ1m3MG5pIYNK3YP3lZ44lfcWWNCDW0UZyJnM7vMVGpYFUJBZLNn50Y6lm4xAh o6wLltPdeNm4w5BMXZmoDNQjuO/tLD3njv2QJZxPN4G68mVtpAZywZyTb9ThGiKmmKgvcxswmfE0 nQoIRa0VtJjG2mmxtapXPh9nFpF2I+LMQs4byiXDJBPc5A11mFgvKhRah+KhHCc1zQicSvOhuKy0 1T86EJ4CLns0RNnifOa6i7D6gtDyS1okiXlEHx9winhQPKrgjk0Chl224pO2zq+R5ixsNbC+5D37 rQTasFqancchRs4dBAEImciv34MVaJROouSPaYXMK2mNNvMQWnpoJLYqqquSSv7NgCDp2XHiZvGd w2SMIRkw8gggguDsbFtXDg5LdWHZL3eVujINA0kxjQmueHqGWiN9ahtDGkMz+wMu2ZruAOv62B+m Lkrl2iOu7wH2bcUlVYA5vV4ms3EgWeDzAl9fGo8ajPkQdbLyw8D4AkxNyTRgPIEHsDHAZhWNvWRx CoYDi0igdCplDbwQ2Yb7roSVsHYzOIwk0+3ceY21x8R0cm/0a6sghwyYkckAcCodOMHEkXgNZkks L0CyQrAwKJoYJo4H7FtxSwFhuG25qaUgUgRJpSARIFolQCYlIt2mhREQVEpQScaqfr1CS7a2Li/g VEy9JlCXO6GWdAGaVjiKg6lM7DuMAvWnZJWLQQW/CIWhixJ0SMhMwuX3MgLbpKrspi7VMU1BZLhe pbb9JdPWzTBHwNtutVrPDGoW1DIgh5SQ3r3/65Of6ddqiWSbL0FMfYMMneMEkqTQEpWCvuu7TicD UrQ7mbCpId3btEd5idhlMgRj+u8t0+daUKSk8TWIhMkW14G08QS4hsKegw5zzGgz1GqCZCIZwuCW 6Ugl/mrDoOsyfqtSlnb63eropKk8jEFDaEWLRQOQcCUwJJoxZWjCihzIp4w2IVCsYHgdpial3GGT oXMewhTVtgUSUQiU6wQklegBABiQabaETGETt9set9hZABYaQL4GiSUgN70IS9DEJRnAopBamtgZ KTBpfoZiz87Y48BJeYsEd51mkRmMx4N9JYDhM2EJKQZIHG1IyQbSDeZiMV0Lag5FCQVe4NGZx5QE PsViIYNuHE2EDho0uRMnBVIgTcDRKr6cT58xGRWCZaDz/YF3qMEdUwMf57zKr0F6LAWtW+vctgeL WOSUgkNayNiVHoYGxMWDAO552uNpKL98Zg1YtYS1JaZ3glb0sPAddMYcSVDjbpD98I96VAgGUgS2 tKQiA6wEQks6425eVlulkUdJUFqtjmgE3snIksVoaz7GItFxu14UGPixHTfPrUG6l4YQs8Qi0X7L Zsl7T8JiS0nK1iArIUGyDmrOjH1TUwemQMBfB7aSPtg2AuzNcjHhaEFg3xeQQ+18htGgTNjxPOQ2 3T4Z8aCsNEwJB1FUiI4dp1qwGNGz5V4a27VVTGK/jKUo+r1dV6uAziO72KmY+J6D3nhQ3G1CSuPE 5Al+jgIuJ7SC01BuNJtBjTGxpNjBjAbG2hs3wQxsY24ZAwZR8CYpylEcIIbYxg0kr2d5SHQCE0QY HzpSkhYL1d83MTaQcdC8xD+qTmZBSBxMTSaSFFwn54RycdA2FMWrxvOpVqkKDUuMVf7QqUUJVDsZ 0+Sj1fOD9VIJlnnnNC4HxMC/SMM8iKHcxH7E+SVqXzADbax24nZw7jGw3IsDuEtWJal4yiApgPOJ IoPiLky2iZ5VoidvcvI08i9LEzMgX7mkNoGxJQDaTGFgEEJsIiMzUUKAfAdCay5cBU/N8e43ToHg 8v2W4EIniPtGWgYOTDQGYh8xUGMZXEBVJQjdrwXScsqMh2YWtHLWDIvZ25GtNaqWDRXRMPKgStET EO0VS5KWKioVWTVzxHnmocQWAUBY62zyAdPC8BL8N7S6W0Vz4lLVqQ2I0JVAhrDEkD+9mlrSzb4U 0KgdobZS0VA8prOL2xiIxQuWoFYNGrDVZ2kVHUE0lFYLhpQuDnnGGfCF8AX6m2222222223/gPYc SYjumzkbOc+HWD+Bv02WWDY2WkQORBhIgoToblgmJg+L19huYp0mhjCjhTrOKYXP1XkK0K2Yg1wS U1xaM5ulz+oPWYdpYiDILcHeljHVQjR2WClrwJz/lPWX3dOGLvavyZjY0CpltJ3o7sRGgdQ9CRET Yrp90zg4wbasPfWk2mJiNojUZ+TqElWdtaBcFZU1ni4BSUeF9zwaYkzdBAwfJqBjSb6zQE4CC4cC aNzQ92c6sGW4Jjg81iRZQjnpZZW9G8irqS0qXzaXOqnBbYAphecxohcJ1gxh8zJD2bCQltU6Zldr GwIGFWBtMSFDEQw+IjRPN2Sq1hLmapUp2DhoaaWxkiZMtgGXiQ4Vk4EFy7C6z1niVTNpf1DDtTuY zFtLtz9Epm+/qrmJNZDfeAwZ6AS1r6qiZkIrJFuXvEQ+7rdjHZ0AdPiR1Tq8eeyU6Q4KdBfaAlq6 x2TE1AdpBAQekqLQ4L2cRSLPvLVpZ0e59q3EgJsseQ6GFjYXkLBtMNwjPFpLZBrgwlB0EessMSgY mnx9tCw768lD2pNHNLruUaR2bTTUfL6yre0l9vH9qzcBl/3lxsJ/I2GvAhChDBZsj6c6gqE/I7OW 7Ye+UJiHIUMGiBNjG22lzwGyQpAZxpG4edrDVCEXjPD+0g+A10KQdZpLQ+kyPrOd57CGQHo2nTXa ajAAPcbjxOOJI9JVWVEHI1nKZlASkNZ0Hznf1Xuzo05cpUeq1WVdJ0OZtcVt0cUEgWDt+ksAlpkG YXjOMQkG4RE9ZHiOIsfmupuGMkmqbSQdAaNt108GnHKLswxt0nvHgfVxH8AOIa5GBSv/i7kinChI KKlyr4A= --===============7869559597407638044==--