From: Sergey Glukhov Date: December 14 2010 9:33am Subject: bzr commit into mysql-5.1-bugteam branch (sergey.glukhov:3520) Bug#52157 Bug#54475 Bug#57352 Bug#57703 List-Archive: http://lists.mysql.com/commits/126731 X-Bug: 52157,54475,57352,57703 Message-Id: <201012140942.oBE9glfB025931@rcsinet13.oracle.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============4193132299716373251==" --===============4193132299716373251== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline #At file:///home/gluh/MySQL/mysql-5.1-bugteam/ based on revid:tor.didriksen@stripped 3520 Sergey Glukhov 2010-12-14 Fixed following problems: --Bug#52157 various crashes and assertions with multi-table update, stored function --Bug#54475 improper error handling causes cascading crashing failures in innodb/ndb --Bug#57703 create view cause Assertion failed: 0, file .\item_subselect.cc, line 846 --Bug#57352 valgrind warnings when creating view --Recently discovered problem when a nested materialized derived table is used before being populated and it leads to incorrect result We have several modes when we should disable subquery evaluation. The reasons for disabling are different. It could be uselessness of the evaluation as in case of 'CREATE VIEW' or 'PREPARE stmt', or we should disable subquery evaluation if tables are not locked yet as it happens in bug#54475, or too early evaluation of subqueries can lead to wrong result as it happened in Bug#19077. Main problem is that if subquery items are treated as const they are evaluated in ::fix_fields(), ::fix_length_and_dec() of the parental items as a lot of these methods have Item::val_...() calls inside. We have to make subqueries non-const to prevent unnecessary subquery evaluation. At the moment we have different methods for this. Here is a list of these modes: 1. PREPARE stmt; We use UNCACHEABLE_PREPARE flag. It is set during parsing in sql_parse.cc, mysql_new_select() for each SELECT_LEX object and cleared at the end of PREPARE in sql_prepare.cc, init_stmt_after_parse(). If this flag is set subquery becomes non-const and evaluation does not happen. 2. CREATE|ALTER VIEW, SHOW CREATE VIEW, I_S tables which process FRM files We use LEX::view_prepare_mode field. We set it before view preparation and check this flag in ::fix_fields(), ::fix_length_and_dec(). Some bugs are fixed using this approach, some are not(Bug#57352, Bug#57703). The problem here is that we have a lot of ::fix_fields(), ::fix_length_and_dec() where we use Item::val_...() calls for const items. 3. Derived tables with subquery = wrong result(Bug19077) The reason of this bug is too early subquery evaluation. It was fixed by adding Item::with_subselect field The check of this field in appropriate places prevents const item evaluation if the item have subquery. The fix for Bug19077 fixes only the problem with convert_constant_item() function and does not cover other places(::fix_fields(), ::fix_length_and_dec() again) where subqueries could be evaluated. Example: CREATE TABLE t1 (i INT, j BIGINT); INSERT INTO t1 VALUES (1, 2), (2, 2), (3, 2); SELECT * FROM (SELECT MIN(i) FROM t1 WHERE j = SUBSTRING('12', (SELECT * FROM (SELECT MIN(j) FROM t1) t2))) t3; DROP TABLE t1; 4. Derived tables with subquery where subquery is evaluated before table locking(Bug#54475, Bug#52157) Suggested solution is following: -Introduce new field LEX::context_analysis_only with the following possible flags: #define CONTEXT_ANALYSIS_ONLY_PREPARE 1 #define CONTEXT_ANALYSIS_ONLY_VIEW 2 #define CONTEXT_ANALYSIS_ONLY_DERIVED 4 -Set/clean these flags when we perform context analysis operation -Item_subselect::const_item() returns result depending on LEX::context_analysis_only. If context_analysis_only is set then we return FALSE that means that subquery is non-const. As all subquery types are wrapped by Item_subselect it allow as to make subquery non-const when it's necessary. @ mysql-test/r/derived.result test case @ mysql-test/r/multi_update.result test case @ mysql-test/r/view.result test case @ mysql-test/suite/innodb/r/innodb_multi_update.result test case @ mysql-test/suite/innodb/t/innodb_multi_update.test test case @ mysql-test/suite/innodb_plugin/r/innodb_multi_update.result test case @ mysql-test/suite/innodb_plugin/t/innodb_multi_update.test test case @ mysql-test/t/derived.test test case @ mysql-test/t/multi_update.test test case @ mysql-test/t/view.test test case @ sql/item.cc --removed unnecessary code @ sql/item_cmpfunc.cc --removed unnecessary checks --THD::is_context_analysis_only() is replaced with LEX::is_ps_or_view_context_analysis() @ sql/item_func.cc --refactored context analysis checks @ sql/item_row.cc --removed unnecessary checks @ sql/item_subselect.cc --removed unnecessary code --added DBUG_ASSERT into Item_subselect::exec() which asserts that subquery execution can not happen if LEX::context_analysis_only is set, i.e. at context analysis stage. --Item_subselect::const_item() Return FALSE if LEX::context_analysis_only is set. It prevents subquery evaluation in ::fix_fields & ::fix_length_and_dec at context analysis stage. @ sql/item_subselect.h --removed unnecessary code @ sql/mysql_priv.h --Added new set of flags. @ sql/sql_class.h --removed unnecessary code @ sql/sql_derived.cc --added LEX::context_analysis_only analysis intialization/cleanup @ sql/sql_lex.cc --init LEX::context_analysis_only field @ sql/sql_lex.h --New LEX::context_analysis_only field @ sql/sql_parse.cc --removed unnecessary code @ sql/sql_prepare.cc --removed unnecessary code --added LEX::context_analysis_only analysis intialization/cleanup @ sql/sql_select.cc --refactored context analysis checks @ sql/sql_show.cc --added LEX::context_analysis_only analysis intialization/cleanup @ sql/sql_view.cc --added LEX::context_analysis_only analysis intialization/cleanup modified: mysql-test/r/derived.result mysql-test/r/multi_update.result mysql-test/r/view.result mysql-test/suite/innodb/r/innodb_multi_update.result mysql-test/suite/innodb/t/innodb_multi_update.test mysql-test/suite/innodb_plugin/r/innodb_multi_update.result mysql-test/suite/innodb_plugin/t/innodb_multi_update.test mysql-test/t/derived.test mysql-test/t/multi_update.test mysql-test/t/view.test sql/item.cc sql/item_cmpfunc.cc sql/item_func.cc sql/item_row.cc sql/item_subselect.cc sql/item_subselect.h sql/mysql_priv.h sql/sql_class.h sql/sql_derived.cc sql/sql_lex.cc sql/sql_lex.h sql/sql_parse.cc sql/sql_prepare.cc sql/sql_select.cc sql/sql_show.cc sql/sql_view.cc === modified file 'mysql-test/r/derived.result' --- a/mysql-test/r/derived.result 2009-07-11 18:44:29 +0000 +++ b/mysql-test/r/derived.result 2010-12-14 09:33:03 +0000 @@ -400,4 +400,15 @@ SELECT 0 FROM (SELECT 0) t61; 0 0 +# +# A nested materialized derived table is used before being populated. +# (addon for bug#19077) +# +CREATE TABLE t1 (i INT, j BIGINT); +INSERT INTO t1 VALUES (1, 2), (2, 2), (3, 2); +SELECT * FROM (SELECT MIN(i) FROM t1 +WHERE j = SUBSTRING('12', (SELECT * FROM (SELECT MIN(j) FROM t1) t2))) t3; +MIN(i) +1 +DROP TABLE t1; # End of 5.0 tests === modified file 'mysql-test/r/multi_update.result' --- a/mysql-test/r/multi_update.result 2010-09-07 07:58:05 +0000 +++ b/mysql-test/r/multi_update.result 2010-12-14 09:33:03 +0000 @@ -659,4 +659,15 @@ Error 1242 Subquery returns more than 1 Error 1242 Subquery returns more than 1 row DROP TABLE t1, t2, t3; SET SESSION sql_safe_updates = DEFAULT; +# +# Bug#52157 various crashes and assertions with multi-table update, stored function +# +CREATE FUNCTION f1 () RETURNS BLOB RETURN 1; +CREATE TABLE t1 (f1 DATE); +INSERT INTO t1 VALUES('2001-01-01'); +UPDATE (SELECT 1 FROM t1 WHERE f1 = (SELECT f1() FROM t1)) x, t1 SET f1 = 1; +Warnings: +Warning 1292 Truncated incorrect datetime value: '1' +DROP FUNCTION f1; +DROP TABLE t1; end of tests === modified file 'mysql-test/r/view.result' --- a/mysql-test/r/view.result 2010-11-30 17:51:25 +0000 +++ b/mysql-test/r/view.result 2010-12-14 09:33:03 +0000 @@ -3884,6 +3884,19 @@ CREATE VIEW v1 AS SELECT 1 from t1 WHERE t1.b <=> (SELECT a FROM t1 WHERE a < SOME(SELECT '1')); DROP VIEW v1; DROP TABLE t1; +# +# Bug#57703 create view cause Assertion failed: 0, file .\item_subselect.cc, line 846 +# +CREATE TABLE t1(a int); +CREATE VIEW v1 AS SELECT 1 FROM t1 GROUP BY +SUBSTRING(1 FROM (SELECT 3 FROM t1 WHERE a >= ANY(SELECT 1))); +DROP VIEW v1; +DROP TABLE t1; +# +# Bug#57352 valgrind warnings when creating view +# +CREATE VIEW v1 AS SELECT 1 IN (1 LIKE 2,0) AS f; +DROP VIEW v1; # ----------------------------------------------------------------- # -- End of 5.1 tests. # ----------------------------------------------------------------- === modified file 'mysql-test/suite/innodb/r/innodb_multi_update.result' --- a/mysql-test/suite/innodb/r/innodb_multi_update.result 2010-05-05 10:40:01 +0000 +++ b/mysql-test/suite/innodb/r/innodb_multi_update.result 2010-12-14 09:33:03 +0000 @@ -74,3 +74,11 @@ a b 4 14 5 15 drop table bug38999_1,bug38999_2; +# +# Bug#54475 improper error handling causes cascading crashing failures in innodb/ndb +# +CREATE TABLE t1(f1 INT) ENGINE=INNODB; +INSERT INTO t1 VALUES(1); +UPDATE (SELECT ((SELECT 1 FROM t1), 1) FROM t1 WHERE (SELECT 1 FROM t1)) x, (SELECT 1) AS d SET d.f1 = 1; +ERROR 21000: Operand should contain 1 column(s) +DROP TABLE t1; === modified file 'mysql-test/suite/innodb/t/innodb_multi_update.test' --- a/mysql-test/suite/innodb/t/innodb_multi_update.test 2010-05-05 10:40:01 +0000 +++ b/mysql-test/suite/innodb/t/innodb_multi_update.test 2010-12-14 09:33:03 +0000 @@ -27,3 +27,14 @@ select * from bug38999_1; select * from bug38999_2; drop table bug38999_1,bug38999_2; + + +--echo # +--echo # Bug#54475 improper error handling causes cascading crashing failures in innodb/ndb +--echo # +CREATE TABLE t1(f1 INT) ENGINE=INNODB; +INSERT INTO t1 VALUES(1); +--error ER_OPERAND_COLUMNS +UPDATE (SELECT ((SELECT 1 FROM t1), 1) FROM t1 WHERE (SELECT 1 FROM t1)) x, (SELECT 1) AS d SET d.f1 = 1; +DROP TABLE t1; + === modified file 'mysql-test/suite/innodb_plugin/r/innodb_multi_update.result' --- a/mysql-test/suite/innodb_plugin/r/innodb_multi_update.result 2010-05-05 10:44:25 +0000 +++ b/mysql-test/suite/innodb_plugin/r/innodb_multi_update.result 2010-12-14 09:33:03 +0000 @@ -74,3 +74,11 @@ a b 4 14 5 15 drop table bug38999_1,bug38999_2; +# +# Bug#54475 improper error handling causes cascading crashing failures in innodb/ndb +# +CREATE TABLE t1(f1 INT) ENGINE=INNODB; +INSERT INTO t1 VALUES(1); +UPDATE (SELECT ((SELECT 1 FROM t1), 1) FROM t1 WHERE (SELECT 1 FROM t1)) x, (SELECT 1) AS d SET d.f1 = 1; +ERROR 21000: Operand should contain 1 column(s) +DROP TABLE t1; === modified file 'mysql-test/suite/innodb_plugin/t/innodb_multi_update.test' --- a/mysql-test/suite/innodb_plugin/t/innodb_multi_update.test 2010-06-03 09:46:37 +0000 +++ b/mysql-test/suite/innodb_plugin/t/innodb_multi_update.test 2010-12-14 09:33:03 +0000 @@ -27,3 +27,14 @@ select * from bug38999_1; select * from bug38999_2; drop table bug38999_1,bug38999_2; + + +--echo # +--echo # Bug#54475 improper error handling causes cascading crashing failures in innodb/ndb +--echo # +CREATE TABLE t1(f1 INT) ENGINE=INNODB; +INSERT INTO t1 VALUES(1); +--error ER_OPERAND_COLUMNS +UPDATE (SELECT ((SELECT 1 FROM t1), 1) FROM t1 WHERE (SELECT 1 FROM t1)) x, (SELECT 1) AS d SET d.f1 = 1; +DROP TABLE t1; + === modified file 'mysql-test/t/derived.test' --- a/mysql-test/t/derived.test 2009-07-11 18:44:29 +0000 +++ b/mysql-test/t/derived.test 2010-12-14 09:33:03 +0000 @@ -301,4 +301,15 @@ SELECT 0 FROM (SELECT 0) t56, (SELECT 0) t57, (SELECT 0) t58, (SELECT 0) t59, (SELECT 0) t60, (SELECT 0) t61; # 61 == MAX_TABLES +--echo # +--echo # A nested materialized derived table is used before being populated. +--echo # (addon for bug#19077) +--echo # + +CREATE TABLE t1 (i INT, j BIGINT); +INSERT INTO t1 VALUES (1, 2), (2, 2), (3, 2); +SELECT * FROM (SELECT MIN(i) FROM t1 +WHERE j = SUBSTRING('12', (SELECT * FROM (SELECT MIN(j) FROM t1) t2))) t3; +DROP TABLE t1; + --echo # End of 5.0 tests === modified file 'mysql-test/t/multi_update.test' --- a/mysql-test/t/multi_update.test 2010-09-07 07:58:05 +0000 +++ b/mysql-test/t/multi_update.test 2010-12-14 09:33:03 +0000 @@ -673,4 +673,15 @@ SET t3.a = 0; DROP TABLE t1, t2, t3; SET SESSION sql_safe_updates = DEFAULT; +--echo # +--echo # Bug#52157 various crashes and assertions with multi-table update, stored function +--echo # + +CREATE FUNCTION f1 () RETURNS BLOB RETURN 1; +CREATE TABLE t1 (f1 DATE); +INSERT INTO t1 VALUES('2001-01-01'); +UPDATE (SELECT 1 FROM t1 WHERE f1 = (SELECT f1() FROM t1)) x, t1 SET f1 = 1; +DROP FUNCTION f1; +DROP TABLE t1; + --echo end of tests === modified file 'mysql-test/t/view.test' --- a/mysql-test/t/view.test 2010-04-06 07:26:59 +0000 +++ b/mysql-test/t/view.test 2010-12-14 09:33:03 +0000 @@ -3925,6 +3925,22 @@ WHERE t1.b <=> (SELECT a FROM t1 WHERE a DROP VIEW v1; DROP TABLE t1; +--echo # +--echo # Bug#57703 create view cause Assertion failed: 0, file .\item_subselect.cc, line 846 +--echo # + +CREATE TABLE t1(a int); +CREATE VIEW v1 AS SELECT 1 FROM t1 GROUP BY +SUBSTRING(1 FROM (SELECT 3 FROM t1 WHERE a >= ANY(SELECT 1))); +DROP VIEW v1; +DROP TABLE t1; + +--echo # +--echo # Bug#57352 valgrind warnings when creating view +--echo # +CREATE VIEW v1 AS SELECT 1 IN (1 LIKE 2,0) AS f; +DROP VIEW v1; + --echo # ----------------------------------------------------------------- --echo # -- End of 5.1 tests. --echo # ----------------------------------------------------------------- === modified file 'sql/item.cc' --- a/sql/item.cc 2010-11-18 13:11:18 +0000 +++ b/sql/item.cc 2010-12-14 09:33:03 +0000 @@ -1712,16 +1712,7 @@ bool agg_item_set_converter(DTCollation if (!(conv= (*arg)->safe_charset_converter(coll.collation)) && ((*arg)->collation.repertoire == MY_REPERTOIRE_ASCII)) - { - /* - We should disable const subselect item evaluation because - subselect transformation does not happen in view_prepare_mode - and thus val_...() methods can not be called for const items. - */ - bool resolve_const= ((*arg)->type() == Item::SUBSELECT_ITEM && - thd->lex->view_prepare_mode) ? FALSE : TRUE; - conv= new Item_func_conv_charset(*arg, coll.collation, resolve_const); - } + conv= new Item_func_conv_charset(*arg, coll.collation, 1); if (!conv) { === modified file 'sql/item_cmpfunc.cc' --- a/sql/item_cmpfunc.cc 2010-09-09 12:48:06 +0000 +++ b/sql/item_cmpfunc.cc 2010-12-14 09:33:03 +0000 @@ -401,7 +401,7 @@ static bool convert_constant_item(THD *t Field *field= field_item->field; int result= 0; - if (!(*item)->with_subselect && (*item)->const_item()) + if ((*item)->const_item()) { TABLE *table= field->table; ulong orig_sql_mode= thd->variables.sql_mode; @@ -497,7 +497,7 @@ void Item_bool_func2::fix_length_and_dec } thd= current_thd; - if (!thd->is_context_analysis_only()) + if (!thd->lex->is_ps_or_view_context_analysis()) { if (args[0]->real_item()->type() == FIELD_ITEM) { @@ -801,7 +801,7 @@ Arg_comparator::can_compare_as_dates(Ite confuse storage engines since in context analysis mode tables aren't locked. */ - if (!thd->is_context_analysis_only() && + if (!thd->lex->is_ps_or_view_context_analysis() && cmp_type != CMP_DATE_WITH_DATE && str_arg->const_item() && (str_arg->type() != Item::FUNC_ITEM || ((Item_func*)str_arg)->functype() != Item_func::GUSERVAR_FUNC)) @@ -1027,7 +1027,7 @@ Item** Arg_comparator::cache_converted_c Item_result type) { /* Don't need cache if doing context analysis only. */ - if (!thd_arg->is_context_analysis_only() && + if (!thd->lex->is_ps_or_view_context_analysis() && (*value)->const_item() && type != (*value)->result_type()) { Item_cache *cache= Item_cache::get_cache(*value, type); @@ -4686,7 +4686,7 @@ bool Item_func_like::fix_fields(THD *thd return TRUE; } - if (escape_item->const_item() && !thd->lex->view_prepare_mode) + if (escape_item->const_item()) { /* If we are on execution stage */ String *escape_str= escape_item->val_str(&cmp.value1); === modified file 'sql/item_func.cc' --- a/sql/item_func.cc 2010-11-26 12:51:48 +0000 +++ b/sql/item_func.cc 2010-12-14 09:33:03 +0000 @@ -6066,7 +6066,7 @@ Item_func_sp::fix_fields(THD *thd, Item if (res) DBUG_RETURN(res); - if (thd->lex->view_prepare_mode) + if (thd->lex->context_analysis_only & CONTEXT_ANALYSIS_ONLY_VIEW) { /* Here we check privileges of the stored routine only during view === modified file 'sql/item_row.cc' --- a/sql/item_row.cc 2010-03-19 06:21:37 +0000 +++ b/sql/item_row.cc 2010-12-14 09:33:03 +0000 @@ -73,12 +73,8 @@ bool Item_row::fix_fields(THD *thd, Item used_tables_cache |= item->used_tables(); const_item_cache&= item->const_item() && !with_null; not_null_tables_cache|= item->not_null_tables(); - /* - Some subqueries transformations aren't done in the view_prepare_mode thus - is_null() will fail. So we skip is_null() calculation for CREATE VIEW as - not necessary. - */ - if (const_item_cache && !thd->lex->view_prepare_mode) + + if (const_item_cache) { if (item->cols() > 1) with_null|= item->null_inside(); === modified file 'sql/item_subselect.cc' --- a/sql/item_subselect.cc 2010-10-18 12:12:27 +0000 +++ b/sql/item_subselect.cc 2010-12-14 09:33:03 +0000 @@ -123,20 +123,6 @@ void Item_subselect::cleanup() } -/* - We cannot use generic Item::safe_charset_converter() because - Subselect transformation does not happen in view_prepare_mode - and thus we can not evaluate val_...() for const items. -*/ - -Item *Item_subselect::safe_charset_converter(CHARSET_INFO *tocs) -{ - Item_func_conv_charset *conv= - new Item_func_conv_charset(this, tocs, thd->lex->view_prepare_mode ? 0 : 1); - return conv->safe ? conv : NULL; -} - - void Item_singlerow_subselect::cleanup() { DBUG_ENTER("Item_singlerow_subselect::cleanup"); @@ -271,6 +257,7 @@ bool Item_subselect::exec() if (thd->is_error() || thd->killed) return 1; + DBUG_ASSERT(!thd->lex->context_analysis_only); /* Simulate a failure in sub-query execution. Used to test e.g. out of memory or query being killed conditions. @@ -307,7 +294,7 @@ table_map Item_subselect::used_tables() bool Item_subselect::const_item() const { - return const_item_cache; + return thd->lex->context_analysis_only ? FALSE : const_item_cache; } Item *Item_subselect::get_tmp_table_item(THD *thd_arg) @@ -1638,7 +1625,8 @@ bool Item_in_subselect::fix_fields(THD * { bool result = 0; - if (thd_arg->lex->view_prepare_mode && left_expr && !left_expr->fixed) + if ((thd_arg->lex->context_analysis_only & CONTEXT_ANALYSIS_ONLY_VIEW) && + left_expr && !left_expr->fixed) result = left_expr->fix_fields(thd_arg, &left_expr); return result || Item_subselect::fix_fields(thd_arg, ref); === modified file 'sql/item_subselect.h' --- a/sql/item_subselect.h 2010-04-06 07:26:59 +0000 +++ b/sql/item_subselect.h 2010-12-14 09:33:03 +0000 @@ -126,7 +126,6 @@ public: virtual void reset_value_registration() {} enum_parsing_place place() { return parsing_place; } bool walk(Item_processor processor, bool walk_subquery, uchar *arg); - Item *safe_charset_converter(CHARSET_INFO *tocs); /** Get the SELECT_LEX structure associated with this Item. === modified file 'sql/mysql_priv.h' --- a/sql/mysql_priv.h 2010-10-07 08:13:11 +0000 +++ b/sql/mysql_priv.h 2010-12-14 09:33:03 +0000 @@ -566,17 +566,42 @@ protected: #define MY_CHARSET_BIN_MB_MAXLEN 1 +/* + Flags below are set when we perform + context analysis of the statement and make + subqueries non-const. It prevents subquery + evaluation at context analysis stage. +*/ + +/* + Don't evaluate this subquery during statement prepare even if + it's a constant one. The flag is switched off in the end of + mysqld_stmt_prepare. +*/ +#define CONTEXT_ANALYSIS_ONLY_PREPARE 1 +/* + Special JOIN::prepare mode: changing of query is prohibited. + When creating a view, we need to just check its syntax omitting + any optimizations: afterwards definition of the view will be + reconstructed by means of ::print() methods and written to + to an .frm file. We need this definition to stay untouched. +*/ +#define CONTEXT_ANALYSIS_ONLY_VIEW 2 +/* + Don't evaluate this subquery during derived table prepare even if + it's a constant one. +*/ +#define CONTEXT_ANALYSIS_ONLY_DERIVED 4 + // uncachable cause #define UNCACHEABLE_DEPENDENT 1 #define UNCACHEABLE_RAND 2 #define UNCACHEABLE_SIDEEFFECT 4 /// forcing to save JOIN for explain #define UNCACHEABLE_EXPLAIN 8 -/** Don't evaluate subqueries in prepare even if they're not correlated */ -#define UNCACHEABLE_PREPARE 16 /* For uncorrelated SELECT in an UNION with some correlated SELECTs */ -#define UNCACHEABLE_UNITED 32 -#define UNCACHEABLE_CHECKOPTION 64 +#define UNCACHEABLE_UNITED 16 +#define UNCACHEABLE_CHECKOPTION 32 /* Used to check GROUP BY list in the MODE_ONLY_FULL_GROUP_BY mode */ #define UNDEF_POS (-1) === modified file 'sql/sql_class.h' --- a/sql/sql_class.h 2010-10-23 12:55:44 +0000 +++ b/sql/sql_class.h 2010-12-14 09:33:03 +0000 @@ -2180,8 +2180,6 @@ public: (variables.sql_mode & MODE_STRICT_ALL_TABLES))); } void set_status_var_init(); - bool is_context_analysis_only() - { return stmt_arena->is_stmt_prepare() || lex->view_prepare_mode; } void reset_n_backup_open_tables_state(Open_tables_state *backup); void restore_backup_open_tables_state(Open_tables_state *backup); void reset_sub_statement_state(Sub_statement_state *backup, uint new_state); === modified file 'sql/sql_derived.cc' --- a/sql/sql_derived.cc 2010-06-10 20:45:22 +0000 +++ b/sql/sql_derived.cc 2010-12-14 09:33:03 +0000 @@ -147,10 +147,11 @@ bool mysql_derived_prepare(THD *thd, LEX if (!(derived_result= new select_union)) DBUG_RETURN(TRUE); // out of memory + lex->context_analysis_only|= CONTEXT_ANALYSIS_ONLY_DERIVED; // st_select_lex_unit::prepare correctly work for single select if ((res= unit->prepare(thd, derived_result, 0))) goto exit; - + lex->context_analysis_only&= ~CONTEXT_ANALYSIS_ONLY_DERIVED; if ((res= check_duplicate_names(unit->types, 0))) goto exit; === modified file 'sql/sql_lex.cc' --- a/sql/sql_lex.cc 2010-07-30 20:33:10 +0000 +++ b/sql/sql_lex.cc 2010-12-14 09:33:03 +0000 @@ -305,7 +305,7 @@ void lex_start(THD *thd) lex->select_lex.group_list.empty(); lex->describe= 0; lex->subqueries= FALSE; - lex->view_prepare_mode= FALSE; + lex->context_analysis_only= 0; lex->derived_tables= 0; lex->lock_option= TL_READ; lex->safe_to_cache_query= 1; === modified file 'sql/sql_lex.h' --- a/sql/sql_lex.h 2010-08-18 04:56:06 +0000 +++ b/sql/sql_lex.h 2010-12-14 09:33:03 +0000 @@ -1715,14 +1715,8 @@ typedef struct st_lex : public Query_tab bool verbose, no_write_to_binlog; bool tx_chain, tx_release; - /* - Special JOIN::prepare mode: changing of query is prohibited. - When creating a view, we need to just check its syntax omitting - any optimizations: afterwards definition of the view will be - reconstructed by means of ::print() methods and written to - to an .frm file. We need this definition to stay untouched. - */ - bool view_prepare_mode; + + uint8 context_analysis_only; bool safe_to_cache_query; bool subqueries, ignore; st_parsing_options parsing_options; @@ -1843,6 +1837,13 @@ typedef struct st_lex : public Query_tab delete_dynamic(&plugins); } + inline bool is_ps_or_view_context_analysis() + { + return (context_analysis_only & + (CONTEXT_ANALYSIS_ONLY_PREPARE | + CONTEXT_ANALYSIS_ONLY_VIEW)); + } + inline void uncacheable(uint8 cause) { safe_to_cache_query= 0; === modified file 'sql/sql_parse.cc' --- a/sql/sql_parse.cc 2010-10-23 12:55:44 +0000 +++ b/sql/sql_parse.cc 2010-12-14 09:33:03 +0000 @@ -5865,13 +5865,6 @@ mysql_new_select(LEX *lex, bool move_dow DBUG_RETURN(1); } select_lex->nest_level= lex->nest_level; - /* - Don't evaluate this subquery during statement prepare even if - it's a constant one. The flag is switched off in the end of - mysqld_stmt_prepare. - */ - if (thd->stmt_arena->is_stmt_prepare()) - select_lex->uncacheable|= UNCACHEABLE_PREPARE; if (move_down) { SELECT_LEX_UNIT *unit; === modified file 'sql/sql_prepare.cc' --- a/sql/sql_prepare.cc 2010-11-03 10:24:47 +0000 +++ b/sql/sql_prepare.cc 2010-12-14 09:33:03 +0000 @@ -1688,7 +1688,7 @@ static bool mysql_test_create_view(Prepa if (open_normal_and_derived_tables(thd, tables, 0)) goto err; - lex->view_prepare_mode= 1; + lex->context_analysis_only|= CONTEXT_ANALYSIS_ONLY_VIEW; res= select_like_stmt_test(stmt, 0, 0); err: @@ -2234,19 +2234,6 @@ end: } -/** Init PS/SP specific parse tree members. */ - -static void init_stmt_after_parse(LEX *lex) -{ - SELECT_LEX *sl= lex->all_selects_list; - /* - Switch off a temporary flag that prevents evaluation of - subqueries in statement prepare. - */ - for (; sl; sl= sl->next_select_in_list()) - sl->uncacheable&= ~UNCACHEABLE_PREPARE; -} - /** SQLCOM_PREPARE implementation. @@ -3080,6 +3067,7 @@ bool Prepared_statement::prepare(const c parser_state.m_lip.stmt_prepare_mode= TRUE; lex_start(thd); + lex->context_analysis_only|= CONTEXT_ANALYSIS_ONLY_PREPARE; error= parse_sql(thd, & parser_state, NULL) || thd->is_error() || @@ -3132,7 +3120,7 @@ bool Prepared_statement::prepare(const c if (error == 0) { setup_set_params(); - init_stmt_after_parse(lex); + lex->context_analysis_only&= ~CONTEXT_ANALYSIS_ONLY_PREPARE; state= Query_arena::PREPARED; flags&= ~ (uint) IS_IN_USE; /* === modified file 'sql/sql_select.cc' --- a/sql/sql_select.cc 2010-11-26 12:51:48 +0000 +++ b/sql/sql_select.cc 2010-12-14 09:33:03 +0000 @@ -538,7 +538,8 @@ JOIN::prepare(Item ***rref_pointer_array thd->lex->allow_sum_func= save_allow_sum_func; } - if (!thd->lex->view_prepare_mode && !(select_options & SELECT_DESCRIBE)) + if (!(thd->lex->context_analysis_only & CONTEXT_ANALYSIS_ONLY_VIEW) && + !(select_options & SELECT_DESCRIBE)) { Item_subselect *subselect; /* Is it subselect? */ === modified file 'sql/sql_show.cc' --- a/sql/sql_show.cc 2010-11-30 17:51:25 +0000 +++ b/sql/sql_show.cc 2010-12-14 09:33:03 +0000 @@ -718,7 +718,7 @@ mysqld_show_create(THD *thd, TABLE_LIST table_list->table_name)); /* We want to preserve the tree for views. */ - thd->lex->view_prepare_mode= TRUE; + thd->lex->context_analysis_only|= CONTEXT_ANALYSIS_ONLY_VIEW; { Show_create_error_handler view_error_suppressor(thd, table_list); @@ -3315,7 +3315,7 @@ int get_all_tables(THD *thd, TABLE_LIST uint derived_tables= lex->derived_tables; int error= 1; Open_tables_state open_tables_state_backup; - bool save_view_prepare_mode= lex->view_prepare_mode; + uint8 save_context_analysis_only= lex->context_analysis_only; Query_tables_list query_tables_list_backup; #ifndef NO_EMBEDDED_ACCESS_CHECKS Security_context *sctx= thd->security_ctx; @@ -3323,7 +3323,7 @@ int get_all_tables(THD *thd, TABLE_LIST uint table_open_method; DBUG_ENTER("get_all_tables"); - lex->view_prepare_mode= TRUE; + lex->context_analysis_only|= CONTEXT_ANALYSIS_ONLY_VIEW; lex->reset_n_backup_query_tables_list(&query_tables_list_backup); /* @@ -3540,7 +3540,7 @@ err: lex->restore_backup_query_tables_list(&query_tables_list_backup); lex->derived_tables= derived_tables; lex->all_selects_list= old_all_select_lex; - lex->view_prepare_mode= save_view_prepare_mode; + lex->context_analysis_only= save_context_analysis_only; lex->sql_command= save_sql_command; DBUG_RETURN(error); } === modified file 'sql/sql_view.cc' --- a/sql/sql_view.cc 2010-06-11 12:52:06 +0000 +++ b/sql/sql_view.cc 2010-12-14 09:33:03 +0000 @@ -545,7 +545,7 @@ bool mysql_create_view(THD *thd, TABLE_L } /* prepare select to resolve all fields */ - lex->view_prepare_mode= 1; + lex->context_analysis_only|= CONTEXT_ANALYSIS_ONLY_VIEW; if (unit->prepare(thd, 0, 0)) { /* --===============4193132299716373251== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/sergey.glukhov@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: sergey.glukhov@stripped\ # wmo9mqcb8rz0wv9f # target_branch: file:///home/gluh/MySQL/mysql-5.1-bugteam/ # testament_sha1: 4d18d0cba909351da255fa54d61d237bd6672634 # timestamp: 2010-12-14 12:33:16 +0300 # base_revision_id: tor.didriksen@stripped\ # 81lprlbune7r98dl # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWQYec6UAGJDfgHBweff///// 3+S/////YCgumw7e+9ro+rtx0N65Va3nS733fPbEr3W+2q66XsHmsHfWHZ7ujrRPYdWweh9nR59k aBTW2HrttPjOXvWr3Hu3zd73Pd316j7zDo9tVtIMihljZY9wbWV313GJ72PL2YANHhJITRNMQnpi ANCp+k01Pak/U1M0TQA0DQwQ0xAlEAAgIJoACmInogAAAAaAABkAkTRMg1PUzKBo9IAAAAAAAAAk JCCBGiZkpmVH6EZEaGTT1NNqAyAeoANDQRSIEwmgEwTJoNAk9JtSg0bRDI9QAeUBoCKQQAIjBBKn +TKp/qeiano1RtRtI0HmpDyn6UABoiH4Mg87XXF58WNLQKR27Q2geQZq0+727d1LsLjabft1fxxW MqjMFz0+ZnAe2Lg2wpjTI6BzKxZoMKDAOkh6fT/mb0P/r0Z9Unt99eH3euu5m9R6/V762fn1y6GX wzuY+M1b4c1v1Odv16fdPlwJmNm60eJtbmbRW7EX4OMMeFqc25+MDzKd8Lencd1/UT29xDV4a0dN 08uBC0czdGTJTwLoMae/vrls20G7uOE+sm6pRirMRszEa+qIkgGp49vzWOvojvMcumOqHnJlvmOr qJ2VGihj+RiwYgF2g4nGRr+xLdkyfuMBmtkyv215rIS6H1sDskEjpZ1MSM/REJf82eQNR66tNdnq qFFqbvULGgQHoYY7nYMyO8valVwqGBEMsNhcGzTF1GLQe99HMOi1rvzzr9uW3rqyHQmeAieIoIn9 C4n5VR5kQfjIUphCIE9vRQk5csMXBhz9ZQn+oRwPoeTxH5hDAwH0A3G4u5xeMYDyafuEf+hHwEJp jTYNsabTTbSG2220222DgiCIWIQiIYMzRb+AJlIVOff49+PdfLEW4YdQMfp1wbBZSvG9Nt3fps5b 0wj3usZZ23sjasoMIq13UaCTRG2QNBmmP5jKOXJWK+uL1xCMWI/OVlmdBYOjSKzz6Jd32wzdtIZM bLsrzm29gmM62jRoOnhheQw7bNCtdIO2VLJ4eju1LQM7wuWmTpx092JkwdFYq98PTXtTvfo6jlz6 wndQB3Ld7hpTOSBuFwxrrwLeewxdRjYBuMxQwzHUt9L17eB8d6GdAaH693T8Oh7BZKDDxIRMGMOZ WYXltLhblxQWUyKWzu8c/g99oQ+W8fb2z5DGLkS4v2Nhn7g53YBca+bXuU3KXmZrQoCgIPiYFJVQ eZZPq58+vjfs5suDWrss430urO2mKNeUWeM7Uure/53dFKSs1KpVV8CbXJkPcqERBl0whm6Uqkhj BOOw60vQiTUx2tOz5mTVUwh4JoHaHeEIC1SOowy1ZNkF6iBBBxJo9cpfdcg4X6DsLgwwXTCEC3Km e5UOELtaDc3DqmsYxw0fHEPPhiio2IxhHAqmbFOcAMRb9ZDZ1nKlER2beVKRQj1ihzwPfoaWyajM 1ind2QqZVHOhOLd9UzTTJ/pUR6auqwvIVLPNIF1PJJ0+wIJo8t+8w27y6pkrj/T2ZOazeDhWi7P6 QeQJ5HTIQSsVRrE49rp8aMG4uyW0OjhrYvor38rogm3jMxvkY9ox7qVa7+Z0roub3lyZH1TiYnPE wd61RBgf8oSAmMIwp1js2xh4SOAI4Wwb9o1u0cfQyWhxer5vccsa7MrzS9qtrgxcCrCuq+MD8Khv VKcG2KwK2hUtGF9CcxS1WiSeCJJX6NWYT8FrQPz9D2DL1He7mcz/L5OEnlaBGSD3aYwbTbgMBmy2 ee2p83izbjTlb9Pz+T8n1eCDT5U2NibmZv4ws6Y2NmbKZZuz8RCulsfbHH4eOnSVYXaoSyOiz7HS XgkUMIEtq5CYmmMbG22xjbfgJEg217Ag2g7y3qYrWaTehhy2Du1l61yHC7+jgMMYSA/uJ41OcrUr 30zxLzEIQt32H5URtCA/AgTQhYCH+cGZZD93tHRq8AXZJFIcXb8hB+FlKUhxM4YE8O+ogotqCL44 qF5UzSihUFw7mfBXlxDkQ2rUyNJ+4/cHYPQLz2tGp/UEg1ZG1xaA956DnsdHfpYCvDg5T4uP16Ui GGBSFMwZvQj/3ulPB1sAwMDOZGwzYGjJCQw/rl3J8D3DIgYFQ+GzJ3h9dn84B9WdEhraKKXUNCT8 zSnK/aAZ4dR2wP+aboiCIHJyynm39E1DWoaRg2tjNpnypsEKp1MkMx7eXGwkuhqZjgJV9LwDBR2W YRmiKAmmnWcBK5ZUsvVRYzVOsTM0HXRr0SvkczhblONS02rZesUEU/6Z6V9k5HZY8qd3gxrFu16K 5IFixYyZMmDBYGXmHWBLuN47ZgBAiIERCkoAA5uF4Y8UV/Xwx0mzZM3FpKdLmw+4JmJuexpqKNk7 lCqgNRRsn6g8Q3iFt3hwmR3hRRR0iqp50R4g+GBCyEjCC6MYhk+/fn2BffDUQ1QxiQnMhF7JpovE t0jkD2nZCIwoYUutr95Y31cBrSU6F2BYUKmArIcCESyaBiRqMOwogx+Bc3FWmeebPOGRqmZJIzaC CSaACIAgmCA5liH4ixRWipBVRB1jVyg+j1TGUhsW1wBKimklnsEbcyg1db4jda0QqXI0kMEUsgby 0tJYHSwvV6lbhsKwSKYnEnO2+c7EMCpmUMhsWdpWpR1llpkOxGaIMlctuLomCccO97szo0KW8uYA WRhvLlXQoVsgF1a5OeJhMThiSHliDCBYuMGkdBg0yMzMmfsYlqkCAkC0fNx5uvYLzAJWUEZ8tVmk tQiUGEKVq2i6/OnQyj0Mepbq4us5zZPpCYGwKfOUBKijQaNRAaXjlrLUP1aGBeN4EIQQEYLRD68V 3b8o9ktxaCTyST98B4QoD3ayVVM5TLKK2YrdrVkNVr6+p4d4hYdQToiXo16k0c7MvARWkFGDQuMR KXyz+NDI8C3m5dmai5Dm3RrBcMbXFhMpUmSKP07zlqeeWuOu7fPIj6O7yumsa3JrfTWkUYKgRHEk mT2DpU20LaNOOcrMSrYAugLJHnEQM5FmRYDDlzq4oVhSiA9HIGTyqjwkFjIU+l78DLJMOOJ0JwNO rugmIVOSIhQMrDKU0m4+2l5flrLJt2odC98kdAcQ0bc97SOuXy/rFVmJ1YbCIlrbnbG0GPk9YSIb k3TiJNgjpOZBlLS4xIN4SNJgWMHeIhp4cTIsYCJkPLHn11EANDMeUJHQ4+JYonft4lM+RjRzHs6D z6VVSkUTOzmT5vhWj2MbBJRaX2vBuQ82qRSvnhXdJp6loCThAHAS9egmLeZbIFKuqFHM0LmSujbG uLAS96kGoQaqU7DWtxIzQGsQKyeLsLgiUwfEV8HrkZOoPNbDBMztI4IDB9YSVrqF2HRNke1ZZ5I0 VFMlR4x0tjuTJMoSBjUQofMnaRGmIFybC7PRaFhikyQZGG0PBJ2yLZ3EcXgxJkzQYe+A2nGgygu/ GBzJa2NfWtksumdTCCJuUGkCA00TgQeUDmeJiQXFwTMj9j6vyMiWZO40O07SRkaFA+LsOZLTV63b 5Pe6vg9jcAT0fA2eTe+rc7zlz4dO44SsCMvZ1zo5y1N45W454ZrYeRZUN69nFbr+hXFAF89NZmRq lxpm2ALvNO0sLULEvVcvbwpg+A2ZJg1Bo8ezrFHGEnHA5yMEuYIUKIHj4zKiVMojia2XgAiUiHE8 WGhPBmaGyVuOfdSZAYalT5EnUsSKhMcNOQ0bAy1CC2sMG77zDvT4JTlShOpxNTlI3HWOwkmoakSd BHo8mO5GDY67tp3pA4nUkDoAVMGiZkjbA0kc+fRKDrlyZoLjeUEm8A9Dwdxwb3sAJPNvNpuyuVxZ /LrvOQ5jmfcRAnKOrBNGfVWaGvR001ps9mbaXZazq4bFlnuhC8h6V3OFo5ajuJJUTRqAW6AXyrst urnnMfeWR3jDO6JbQ3CJmUIqe0w6hxQSFB44zEUf8E1HGaOiLh3mwccNmIjTIwGDrKkKiRWvanFm xEmHl5eDy5iwWmToJqSGHC5G/CWdS1DkMRM57ZcyBuUFgTLznWFiIKXYPZJbjTUqPISWKdojMNVH cleoxNdamJkeTkSDU6zAwKEEi95ZCkqKTOUGUmXnJrO1weYBlONz2nB6P3tbQFD6trwIa3g2XN7J 4vR40Zljd2c8LjsqK5Tx1Z2rS42iMyCDRwte+phJdJ6L6lklzGLIVGlBh1DSAJieZ1ilpxTNWfMD ZoDhZJhpM9WxsmdoBLBsNxsYrQJmL7QgMNSuhqTKjuNU7ZeOVFFiJp6OCBkCkLjQaDc5Cb5vK+V5 SFFFTU5khyMQQeKgaZjtxxLJzi7Dc+h2VyKgtg1DgZIRPlTqEeaEyBMcMI6JFGBUcO700FZSatVZ W8TK83g+7J8xwdrpKntdTqdjN6Pp4L+rgcVFqdrOrqg7tLtlMY6McNuQ4lkZSqVdYaxA5mHaUaFL jxLyhdlMm2EC90y64zIuYQr7ja6pmZDJlTQ7ypumJYI8iQ4Sm1yIYNJoQGirYaHgnlfQ0GFrWFHB 3pNxg9ye66W0Kc41EY1rdBorCIp1+u5PCQJZhQ+MSiA1TUUGCktDUrSI0tguJQamZfWVHroCyo6P XxaFTecTczeZUoerBkYPRsGZ3Z3kFkGJg7zrp0aVcn0fWraAHMHWaOYFM+HDy7jxoho2JslNTLEu 6zY5bDG6upvRFiwSjnUoIiOkPBRyPNB0DyIxIilVhMcgKVHXcj2D0Gly0Dc8MVIC+8AvOSFwiHRJ aAo86yxMxM5pDOTFmiQTAtzsKHFCZWblRhxE7EfLgoPCzb0Mx4YHc09UlmcjTOaroEx5HgTmUBMR pHh163x24WRGHLHzvw7uNunts3++uV+OOrKCrwRzR3M6jqUO4qcBQUyPEmEyxQkMJj6HmmBRWcSy sqHIw975NjrdDterWZ+90ux0dtWZoaXKcDjPBsZeRvhYTijRoSAu6gob1O9OlwmQkwgRAlKNYNkO kdZqJqQiVi1ZjDB8jaSR7VaVLCYGGxudY4iVFHHixMvapMiZmZUjLuOTDIVyLQWQ7VxgqOo5WDDM VNDfuMx7whs8aTMjcwPLFShIyu4aRoPk5ieTDYMqGZI8NCocPfqYMyRE0LiljQcXJjUUcMBg8eaE zM6FQER/mWzM3LKqnksbdmtmNyXl9wkUNIl5i+00sQIg9iTYQYI18WEGjxxppRILkWNipoPOKlxB ElLImMdk5VfzJlIDAXnQ0MzgQHumRERLmo6+5Ya7O8CYiJI22zGzNTQ4I4mbXrgkaXiOxy+TD5uj nmPsZkjApU2Nh5ucDbbM1GDPZEQRoQID+Bw4AJRvMWLpvU7NUsg9+iyxlJ0FkH0wB2HK5Abz6hD1 X3fuxH77+2vAp9ezU2FTuahw8wKi94VbgIUEceNK5WSLmeiYYEldITKu8Z2xVmwBMAg0GudwGQkF Za5Xa1ld52Ydr4L3WeWzqtMtLVpc0QlWQjSYWoaoOB8/4/S9Po7Xa7yI3iMYxrgxs8CiDR6QtEq5 8khdvuZqxe4pEVeLn0mefBJRjGNDY2MGmwGM8AiMP2EYRSSEQZw8/2iOQ+4Q5wjL1PeAvucXyJMg VnHWCCs/aKYP5v6Ov+CHqof1KH0Lz9EIEmeQ4KEEdVE+hzfYBECEIkMHgP9XX80CZ/1FiGjNGDZ+ Bxxxqb1ktuGXX2Mw40fsYbUB9UPdmAjUGj62cRXOIMyS9AtJhzHrH/0xmoTSUD/AUlL4UJFoZsgT lK0RK8wuETALUKaFqnEMy1S05IUmNwc0TFHBQhulcIn2xohYyMCK9wfVS6i7FEzuBQf7rr/MK0/Q M6FQUMA4JcobWhR9kWwREQyINxtoKdBE6VBmwQexHUhQxUJAYwI42D1ksSpVJAWqFVgkhgE6KEwu DcWk1CihCFpnqhvLg/hsXiBcmyhNQmgSO2QdNxqaIGyEhkWtO6JM2q7EBBDCYAnahYEtkqHjgECB 3IGZzKq9d/UTYMhNJr1vgHJhtIEggAgrQ3El/RQyG9JtZtUOWE6I1ABmQgdBgkZCVFMFG/SihO/h cFENEwD9yhQyMSDxsTFDUgq8A6uZcPMKobgqSQYMYbjDSCgMJMY4AGhvNRIP4r6TFQ5lvQ5hQ2UO RMrDtKQnqKH+CfL7D680klP9qfHsflYlaVH96WDUKzfvgUkKQMQQiVkXET9oImgAXaPloVi0FsaL opPdqitUqIwkKONKwATfzFapenaH1EJ+H9v3hvPmzp+GYLuLT5hMRuPmWm4/Fsf6fmfvJNpgSbTM Jl5kcz95Q6P0dzjUzPze5uL7Sp+P83UUINjQmZnYHUXna3cD6bzkdDY704kLRlz1Mszpq3/leZNi BBkKFGgttwnkRs2mYmylhiQ/CDHbN0A1q1UdyLxahvAqf1fOr5L3Vu9DiQ0AyNiYB1AHNAjZ0qqK ZKZ0QtkhBEk8hoIa2QQjsJYhA+Rac+vpkHDMyGAnYBL2U41WEhzPxwMXLnFj2iYlkfdBvANwGJ3J QLocAiJeZz/QrfRALJTLYmbSxqxEZVhfXEDXD5p6NoHE7nUeozPyfo7VbH0n+zEdL0j4SQ3HieRy K+gbz1PiXv6ORULz4fXIuMwmWu9kFxvCw9T6jCQBUudKkjaqfBPeamDQyLlx44BEeGoiER5mWPgw YRPUYNMjdORMUsTwVLDyZyOB6J8U7iZE2LkOZUYgbm50NxR4dFEwnrlRGVEGoKB0dw9HRS1OPh4C m2tkIaWlMLntZt71EU7dYPi6JpNBLxIOw2tJrJHqzPjR2dppPFtJpBpNY8eMcF82EIDF6lGGMZKb h5AMZSSERtiqJycjlMrHAmNy7DMjSDMASsBUZwoJQErS0+iI7t2UyFAMvbvLjMS7PIsPBxI2nE3k 796lh8aO6CKtx4+jJvtnbzsRLv2+s12pBqdR53WjWy3UmGSVQQ/NM5pC9kECiVxn6ecpBM+h8rLP KIIirBcVmoWcqU20v8zPrLrxYHBNOs9mlvAdTAbJhrdKUdpD6vR7318Xl7+k2dnuwh8QhvToYoQi GQiUcGDGMaDc0EmIimcn21AeApNK4SwIE9j1Mxabt1RfmJG5mUPXuVeQQJpuQHDDQ9jrSpI9UHmh hHin1FhUsuIEOYLI+DQo5mRaaCHKFz4AtDicClSZaZGdhQyLHJEediZVMDcfYgHTiWp6oXMCnAtO gd44FBhoYhqUNk/GG9drTPgMJJE4InF6gMigwQRr6l1ucnTFxmKjsJzaMfD2aXi/R4qOc02JwxaA 4PJ4N7la0qMhg+LbXHxjKYVmZj4XtXN9z5HU8qT+Wo/UJ602wd7VgYCIkbkFlyO6hKVRawILMlmX gHVEBy6QyM8b8CIcc+mAapvYO2NJCw1BVczQwk2kZODE8G7nZbSMZ0cagbKyAgIoQQmKQI8ziaDk db1LTFNuMhMOUUuYwPKlmH0HhXI73ZaSyYaLunXGEeLqSbYEvPXedKu5zqkT2OBz3HJPySKVDpqm p2psnXAwaEw5cseeBifH6jecZ16cxHwEdXjAp0gl5F4I9cUXlrNXcfFeWMTCWUhPMtE6GJccTOW9 sBSVFR+rkJ7qGrMunDHvlKIVMPh64pqKpkrapUG5ZTrfIgFscNug7QQAWtv6s70bkokvEFyKRBKB grBVUGGponqVmd3Mwnb2xKmpNnrVZJY1AGmZQq+J1iWpM7H3sOVHed7hpuj0+Utg+CneI4am8GCF 0gNTzcxeUtArJeJDCH583m4hLlMZAvi+bycSgPONToXYpZZ47Fatf74Z8yh4P7dSK2MTC0PxIV5G xPqXW2LkyKHZgxTnqSNCcpH6j+Ppteyl91mL8GvlgoyEu1ASdHtmuapl9YA7K2mk9oNTsQJBXCLi 3f0SZREKkYIvxXI/AuQBx0Qiusjxc3UvNpCEEEfjHOCZEQs6BGiNA+ggEhHwJHU9j7jSnyEcxgn2 OOwyHI3m8oJeaoOYQHqYAxkpKPIEwxjJTsE+KNCpMUykYubDhxYwPFCRIUzGpIzMpDwJEx5AOP1S KOKlgiUGo8gPRBIDhhgySMmc9biQblGsgl9z6gFkne+zoHvSH+Aj4y+RGQjJR1CRISD5j2errZrD lbmQBD8vqUoXXJ7ky/SejvfLS5WgyHEzvClt1yhhiIvD0fEz/MIlsQapCzkKS0FEmZ7Nb1bH1Huc Lgv3PkPowzEe00ZIBveExVp4OhuydWxmYansdqK9B3OL5ycEDVy9373F0ONuLDGo3UTSt5AGp9Xe 4hr9sSCBnPWFEAxQL2QNBuMBmSgd7eTd7Vbe1gWxvFHkk8GQSoSQ8Fc38FdBz/NExg2xmfmH2NBs D1nzNGHYm6bkzDvfKhRKIe+2xhQm0DrFWEsdnVsNzoflqdbudhN52eYq/DKeIBMJMm808HfQnBxv yfYyw1bRXZpIN6e7rCCV3qHCFEK2PJpsUtLAp0iukPzhiE2RkRfE8mxrdzcij5MSkmIXgSIUiCJP QmWvai8W4CM9uq/HWWBRGnWjq3Wt3LOXzW74FfYG3hwHqNHsXs88kkkkoJEEBlaMsHmQnd8Wa86J ohYBYSx6Od+rqdhkONOA2NJqEFETBpQAWn3lvDuQl8S7u3IB7eIcmWPtI9r7e5cqKpVIpIpPsVKq kyqciH2bjo0asTM9GaUsInR5qd0f1w/LsC3eIyCp7WrAY6Pk90M5ZG3nmbv4jt7Wb7aWppb2ze1v q+55vy+Dqz2+rqcXZzfdMGK3AqaNjxdpjW2YAFIdr6P4GV3ir1RbJ97nebt+zpD7Jzfq52x1uzNq cQ6viTcrJuaHZR98iVSjEKHMLj8Hc9TjueLIUyYHvcfBxfloaIjML20PWHenc4YOL0bwqMH2Y+1s q1S11RfRSDFBCBGZdlmCPiUjWgzatL+z/m1O9KpBX9g2EXBKGQVCbDePiYupobTWxkfGWdJ0gc9T Ux3uenn8x0pc1NDBu6F4bLg8/R+JnsWKmsCckA824A7D8faiup1pGb2Pm1HreSFfOSRC1YHg0cgB mNbUaohS1ESB9nF/lbnJS1QoHY+4c1tJsX80NrYabRGstKDIo00Ma3zffM67KvcM4BwcXe7WuR2M wC0BfDEM4GjQo+qS2AGZIdoC4tb2kXuVweAcuji5hfngyPmJxNinyWq8nkSPsWmmi0qCo+/5unyP mHa3XKClWZTG3AgmMiHYahZ1azDGKPKYiV2uAilAiI6edvV5fbvdo5ctyLgxiAOgRuLnk5gacxyZ hNC8goxCLCcEnJJg4FXyQxsgplIey0AKECQ3SCxN7y1Sge1j2NyAVzQoqyzVchJsy11AJPB3uKBg Z6Egv+LNmILEGrJjGIUonogJFgptb/nqkkulZBpayljBqaeDwfl0V9+9QgkQsUh4Pg8iu+0Ar5m+ YC7OTwkBUx4lSr1GsMrman6GRD6QKn0TZocEztYkIft21m+SI0GwaMP8o+CGkCbFT4ZFHzFpAhWc BeoB06EFHuu6MJfBF83k8SGrvs4SmQEJE8W5PVBCSLRITvZJoY0Y3B0Ix5ZvnDubrzsDrYvYBWhH MCQsVBXIDJmqHrArS8LqaShwCRWtZ1rflXiVJvgH3kowC8FlIRwQC5R6j49NTkguT8iLSMOAB6sD cmL0LyJPY6HbveXBz4l2d2Hi+jUZmtqj4M6cXdIvfQwAObwMjxzASDfOaaXU41LkSqdSYPiZE0j7 MnS1vGZ3Fmc9eJodgBreTZleh5Od8dai0PQYczkbG94PB1HBvcHnnfg3u93gg9GANHc2tg3DNyAN mHF6nm+I1uZy4oDYyNxFRU72nYByGRc5xyhtT1yRIr07Td3GLjZcojGcHH1AlW7kytCEoQEEpSgC ljOSdcBLeUVJVwb3kJOmIVHSDZ0SHxSIFj5goDx9pqNhYQgBe7M2LQGTbIPuebq1wfM5TS1Eh5tG oTYMzzh5gF651XkATrHyYzHnoniaJL5NyzSt0vo8nMa3jsXPBoQ9a8FRSaWWwPbXvrkKGGMBgYYm 5PYAl8IybuICsWbGkbfvD4eWxp9pt5EVmBQSuky5dDpxOjyi1wo1sU1fZVNsRtY227Z5WDUMF0zf ZFgT/aZ21wSD0KEN3bdbWMKFqAdyQmdjJ6nFEOhU4pdVEhNAyZWrN6HKIhhhiEM89j6HqowI+X7I TFakxG6H2Hwer7NiEQIYiO0zgWBNLt7uvw1ov0AGsR5HF4inbA9y9XevQuG9dHr42XxKepdS9neJ He+ckkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk7F3AHaJUAWpXkUkUkUtW6ytW6lV0WpVIpIymhrdJg kIh5Mg856EgTfIywTFggSBgcGJMmSHGRwMyLJppOhNc8DELUIYhoIpI+cRg0rsU2pNKtnO90+yys iKMOiMj0iK8dst1c0M4sKqbB4i5YSGMipOipmYVnS8hAMl5umq2uZOTWwwMPHW000yisQnrCYkfQ 0CrvqZPN8n73Xcd5W6NNpKpEMlxYI4RCWVSagR0ycE6MBJrYGI6tN6CQFlndQ2wVhFUGtmxBEwDk wDEJEIw0JPYaTY7xPMXYS4ZJBXUFNgRnq4AVFPrIDrdkpaHj7yX3xDKSnKGiEOL8gGDdV5MxXELn fZpM03XaHJNNnvOyZHmMDFlOfy/cPk6Fv2LAcaYHU+CshakNQ95N5Pvbb7DZ72+bPYkCzPtaNjwA 9rt7mHHXw5umji8wD7Xsdi5qzVmAmr9hF2tfj9X4VMHO5XK/vUiBP5MhMwHSYj3tIq9HOO1wqVOq Aa2s3uppEqU1wGVwEqCH7hWrwc1qQ6ncmZpbB6SSWfhM7re4Am6xxbncOp+h0xjmnLMBJsdLg/Rh r6ALhaIBHgWvgrAam7QBgNgEK1NjDOIl6vm6HW727q3GA74OKfHR+JSZTTTY50Xg/hz1OTueLmdT uO11vR2PN+p07dCYkLOcpxCwwQp3nk83q9GyzL7jkXz5h7mRkhgbZAdIiDc1uxkzqe91zA50ORse brfNoAXO9rqb2bW3BY63UAthucjstsHYi5HK8uLi+bS6mltE6v5bWt9Xo+jX6ul5OcoDcxI1PVz1 s3iahs8G973INpua3U+DzaVvgRSR5VwW495aA3j0ECUgjBsGNNOnuomjmCAlEFSqxxGbZY/zVn3F I6mg8dz2O7W921yPNhz5Nvdn791T35HIANCLYTzcmPN3tY7DcAuHYz37E30va+fQpFebwZN7eeTs 4m5zPoZh5mlsbnsT1cthcLpcv/F3JFOFCQBh5zpQ --===============4193132299716373251==--