From 6a72fbe3968befc63baa3cfed6f0deb76c0b8937 Mon Sep 17 00:00:00 2001 From: unknown Date: Sat, 25 Feb 2012 09:03:06 +0200 Subject: [PATCH 1/2] Fix of LP bug:938518 (also LP bug:791761 and LP bug:806955) Cause of the bug is uninitialized items before evaluation HAVING clasue in case of empty result. --- mysql-test/r/having.result | 61 +++++++++++++++++++++++++++++++++++ mysql-test/t/having.test | 66 +++++++++++++++++++++++++++++++++++++- sql/sql_select.cc | 20 ++++++------ 3 files changed, 137 insertions(+), 10 deletions(-) diff --git a/mysql-test/r/having.result b/mysql-test/r/having.result index fb229cf9e3b..b5d3d6e30c2 100644 --- a/mysql-test/r/having.result +++ b/mysql-test/r/having.result @@ -570,3 +570,64 @@ ORDER BY t1.f1; f1 DROP TABLE t1,t2; End of 5.1 tests +# +# LP bug:938518 HAVING does not reject the result of aggregation +# +CREATE TABLE t1 (pk INT PRIMARY KEY, a INT); +INSERT INTO t1 VALUES (2,7), (4,7), (6,2), (17,0); +SELECT MIN(t.pk) FROM t1, t1 as t WHERE t1.pk = 1; +MIN(t.pk) +NULL +SELECT MIN(t.pk) FROM t1, t1 as t WHERE t1.pk = 1 HAVING MIN(t.pk) < 10; +MIN(t.pk) +drop table t1; +# +# LP bug #791761: MAX over an empty join + HAVING +# +CREATE TABLE t1 (a int, b int , KEY (b)) ; +INSERT INTO t1 VALUES (3,1); +CREATE TABLE t2 (a int NOT NULL ) ; +INSERT INTO t2 VALUES (29); +SELECT MAX(t1.b) FROM t1,t2 WHERE t2.a > 0 HAVING MAX(t1.b) <> 6; +MAX(t1.b) +1 +SELECT MAX(t1.b) FROM t1,t2 WHERE t2.a > 0 HAVING MAX(t1.b) IS NULL; +MAX(t1.b) +EXPLAIN +SELECT MAX(t1.b) FROM t1,t2 WHERE t2.a < 0 HAVING MAX(t1.b) <> 6; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible WHERE noticed after reading const tables +SELECT MAX(t1.b) FROM t1,t2 WHERE t2.a < 0 HAVING MAX(t1.b) <> 6; +MAX(t1.b) +CREATE TABLE t3 ( f3 int) ; +INSERT INTO t3 VALUES (NULL); +SELECT MAX(t1.b) AS f FROM t1 JOIN t2 ON t2.a != 0 +WHERE (SELECT f3 FROM t3) <> 0 HAVING f <> 6 ; +f +DROP TABLE t1,t2,t3; +# +# LP bug:806955 HAVING not observed with aggregate +subquery +# +CREATE TABLE t1 (f3 int, f10 varchar(1), f11 int, KEY (f10) ); +INSERT INTO t1 VALUES (NULL,'a',0),(8,'b',0); +CREATE TABLE t2 (f2 int); +INSERT INTO t2 VALUES (7); +CREATE TABLE t3 (f3 int); +INSERT INTO t3 VALUES (0),(8); +SELECT MIN( t1.f10 ) AS field1 +FROM t1 , t2 +WHERE t2.f2 IN ( SELECT f3 FROM t3 ) +HAVING field1 < 's'; +field1 +explain extended +SELECT MIN( t1.f10 ) AS field1 +FROM t1 , t2 +WHERE t2.f2 IN ( SELECT f3 FROM t3 ) +HAVING field1 < 's'; +id select_type table type possible_keys key key_len ref rows filtered Extra +1 PRIMARY NULL NULL NULL NULL NULL NULL NULL NULL Impossible WHERE noticed after reading const tables +2 DEPENDENT SUBQUERY t3 ALL NULL NULL NULL NULL 2 100.00 Using where +Warnings: +Note 1003 select min(`test`.`t1`.`f10`) AS `field1` from `test`.`t1` join `test`.`t2` where ('7',(select 1 from `test`.`t3` where (('7') = `test`.`t3`.`f3`))) having (`field1` < 's') +drop table t1,t2,t3; +End of 5.2 tests diff --git a/mysql-test/t/having.test b/mysql-test/t/having.test index 2ed8b40b858..df3f217be85 100644 --- a/mysql-test/t/having.test +++ b/mysql-test/t/having.test @@ -589,5 +589,69 @@ ORDER BY t1.f1; DROP TABLE t1,t2; - --echo End of 5.1 tests + +--echo # +--echo # LP bug:938518 HAVING does not reject the result of aggregation +--echo # +CREATE TABLE t1 (pk INT PRIMARY KEY, a INT); +INSERT INTO t1 VALUES (2,7), (4,7), (6,2), (17,0); +SELECT MIN(t.pk) FROM t1, t1 as t WHERE t1.pk = 1; +SELECT MIN(t.pk) FROM t1, t1 as t WHERE t1.pk = 1 HAVING MIN(t.pk) < 10; +drop table t1; + +--echo # +--echo # LP bug #791761: MAX over an empty join + HAVING +--echo # + +CREATE TABLE t1 (a int, b int , KEY (b)) ; +INSERT INTO t1 VALUES (3,1); + +CREATE TABLE t2 (a int NOT NULL ) ; +INSERT INTO t2 VALUES (29); + +SELECT MAX(t1.b) FROM t1,t2 WHERE t2.a > 0 HAVING MAX(t1.b) <> 6; +SELECT MAX(t1.b) FROM t1,t2 WHERE t2.a > 0 HAVING MAX(t1.b) IS NULL; + +EXPLAIN +SELECT MAX(t1.b) FROM t1,t2 WHERE t2.a < 0 HAVING MAX(t1.b) <> 6; +SELECT MAX(t1.b) FROM t1,t2 WHERE t2.a < 0 HAVING MAX(t1.b) <> 6; + +CREATE TABLE t3 ( f3 int) ; +INSERT INTO t3 VALUES (NULL); + +SELECT MAX(t1.b) AS f FROM t1 JOIN t2 ON t2.a != 0 + WHERE (SELECT f3 FROM t3) <> 0 HAVING f <> 6 ; + +DROP TABLE t1,t2,t3; + +--echo # +--echo # LP bug:806955 HAVING not observed with aggregate +subquery +--echo # + +#in 5.3 here optimizer_switch should be saved, and semijoin switched off +CREATE TABLE t1 (f3 int, f10 varchar(1), f11 int, KEY (f10) ); +INSERT INTO t1 VALUES (NULL,'a',0),(8,'b',0); + +CREATE TABLE t2 (f2 int); +INSERT INTO t2 VALUES (7); + +CREATE TABLE t3 (f3 int); +INSERT INTO t3 VALUES (0),(8); + +SELECT MIN( t1.f10 ) AS field1 +FROM t1 , t2 +WHERE t2.f2 IN ( SELECT f3 FROM t3 ) +HAVING field1 < 's'; + +explain extended +SELECT MIN( t1.f10 ) AS field1 +FROM t1 , t2 +WHERE t2.f2 IN ( SELECT f3 FROM t3 ) +HAVING field1 < 's'; + +#in 5.3 here optimizer_switch should be restored +drop table t1,t2,t3; + + +--echo End of 5.2 tests diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 7a70c9bdf44..49f1c11c4d8 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -104,7 +104,7 @@ static ORDER *remove_const(JOIN *join,ORDER *first_order,COND *cond, static int return_zero_rows(JOIN *join, select_result *res,TABLE_LIST *tables, List &fields, bool send_row, ulonglong select_options, const char *info, - Item *having); + Item *having, List &all_fields); static COND *build_equal_items(THD *thd, COND *cond, COND_EQUAL *inherited, List *join_list, @@ -1854,7 +1854,7 @@ JOIN::exec() send_row_on_empty_set(), select_options, zero_result_cause, - having); + having, all_fields); DBUG_VOID_RETURN; } @@ -7447,7 +7447,7 @@ remove_const(JOIN *join,ORDER *first_order, COND *cond, static int return_zero_rows(JOIN *join, select_result *result,TABLE_LIST *tables, List &fields, bool send_row, ulonglong select_options, - const char *info, Item *having) + const char *info, Item *having, List &all_fields) { DBUG_ENTER("return_zero_rows"); @@ -7461,8 +7461,16 @@ return_zero_rows(JOIN *join, select_result *result,TABLE_LIST *tables, if (send_row) { + List_iterator_fast it(all_fields); + Item *item; for (TABLE_LIST *table= tables; table; table= table->next_leaf) mark_as_null_row(table->table); // All fields are NULL + /* + Inform all items (especially aggregating) to calculate HAVING correctly, + also we will need it for sending results. + */ + while ((item= it++)) + item->no_rows_in_result(); if (having && having->val_int() == 0) send_row=0; } @@ -7471,13 +7479,7 @@ return_zero_rows(JOIN *join, select_result *result,TABLE_LIST *tables, { bool send_error= FALSE; if (send_row) - { - List_iterator_fast it(fields); - Item *item; - while ((item= it++)) - item->no_rows_in_result(); send_error= result->send_data(fields) > 0; - } if (!send_error) result->send_eof(); // Should be safe } From 5db67c721afaa114b036b410096a6876f92371cf Mon Sep 17 00:00:00 2001 From: Igor Babaev Date: Sat, 25 Feb 2012 17:10:07 -0800 Subject: [PATCH 2/2] Fixed LP bug #939866. The field key_cache_mem_size of the KEY_CACHE structure must be initialized in the function init_key_cache() and updated in the function resize_key_cache(). --- mysys/mf_keycache.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/mysys/mf_keycache.c b/mysys/mf_keycache.c index a038061d9d0..e0d495ce8e0 100644 --- a/mysys/mf_keycache.c +++ b/mysys/mf_keycache.c @@ -5945,6 +5945,10 @@ int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size, ((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->partitions : 0; DBUG_ASSERT(partitions <= MAX_KEY_CACHE_PARTITIONS); + keycache->key_cache_mem_size= + keycache->partitions ? + ((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->key_cache_mem_size : + ((SIMPLE_KEY_CACHE_CB *) keycache_cb)->key_cache_mem_size; if (blocks > 0) keycache->can_be_used= 1; return blocks; @@ -6008,6 +6012,11 @@ int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size, ((PARTITIONED_KEY_CACHE_CB *)(keycache->keycache_cb))->partitions; } + keycache->key_cache_mem_size= + keycache->partitions ? + ((PARTITIONED_KEY_CACHE_CB *)(keycache->keycache_cb))->key_cache_mem_size : + ((SIMPLE_KEY_CACHE_CB *)(keycache->keycache_cb))->key_cache_mem_size; + keycache->can_be_used= (blocks >= 0); } return blocks;