From 71113c68c34a9144feb1ebb88889a86ae6b85400 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 13 Jun 2007 10:42:21 +0000 Subject: [PATCH 01/41] BUG#23354 Clear "no start" when nodes restart and add new prompting string when nodes restart ndb/src/common/debugger/EventLogger.cpp: Remove "no start" from output when nodes restart. ndb/src/mgmclient/CommandInterpreter.cpp: Add new prompting string when nodes restart. --- ndb/src/common/debugger/EventLogger.cpp | 2 -- ndb/src/mgmclient/CommandInterpreter.cpp | 12 ++++++++++-- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/ndb/src/common/debugger/EventLogger.cpp b/ndb/src/common/debugger/EventLogger.cpp index 6280d5bb9b3..c3bdb18dc06 100644 --- a/ndb/src/common/debugger/EventLogger.cpp +++ b/ndb/src/common/debugger/EventLogger.cpp @@ -91,8 +91,6 @@ void getRestartAction(Uint32 action, BaseString &str) if (action == 0) return; str.appfmt(", restarting"); - if (action & 2) - str.appfmt(", no start"); if (action & 4) str.appfmt(", initial"); } diff --git a/ndb/src/mgmclient/CommandInterpreter.cpp b/ndb/src/mgmclient/CommandInterpreter.cpp index 2265579ad1e..eb70601057d 100644 --- a/ndb/src/mgmclient/CommandInterpreter.cpp +++ b/ndb/src/mgmclient/CommandInterpreter.cpp @@ -2026,7 +2026,7 @@ CommandInterpreter::executeRestart(Vector &command_list, return -1; } - if (!nostart) + if (nostart) ndbout_c("Shutting down nodes with \"-n, no start\" option, to subsequently start the nodes."); result= ndb_mgm_restart3(m_mgmsrv, no_of_nodes, node_ids, @@ -2046,7 +2046,15 @@ CommandInterpreter::executeRestart(Vector &command_list, ndbout << "Node"; for (int i= 0; i < no_of_nodes; i++) ndbout << " " << node_ids[i]; - ndbout_c(" is being restarted"); + ndbout_c(": Is being restarted"); + + ndbout << "Node"; + for (int i= 0; i < no_of_nodes; i++) + ndbout << " " << node_ids[i]; + if (nostart) + ndbout_c(": No start"); + else + ndbout_c(": Is rejoining the cluster"); } if(need_disconnect) disconnect(); From 8df3331d8a3831577ab7bc20a1e41b62abbba991 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 25 Jul 2007 09:32:28 +0800 Subject: [PATCH 02/41] BUG#28423 cluster to storage engine error code mapping problem sql/ha_ndbcluster.cc: make HA_ERR_FOUND_DUPP_KEY error cases throw warning like the other ambiguous engine error codes that may be caused by multiple cluster error codes --- sql/ha_ndbcluster.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc index 47815f0fbf1..4d4edccd59c 100644 --- a/sql/ha_ndbcluster.cc +++ b/sql/ha_ndbcluster.cc @@ -181,8 +181,8 @@ struct err_code_mapping static const err_code_mapping err_map[]= { { 626, HA_ERR_KEY_NOT_FOUND, 0 }, - { 630, HA_ERR_FOUND_DUPP_KEY, 0 }, - { 893, HA_ERR_FOUND_DUPP_KEY, 0 }, + { 630, HA_ERR_FOUND_DUPP_KEY, 1 }, + { 893, HA_ERR_FOUND_DUPP_KEY, 1 }, { 721, HA_ERR_TABLE_EXIST, 1 }, { 4244, HA_ERR_TABLE_EXIST, 1 }, From 54077b746a078604d84b48bc2d4ef526e60ab701 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 25 Jul 2007 14:53:25 +0800 Subject: [PATCH 03/41] BUG#27683 Incorrect description for ndb_restore --print ndb/tools/restore/restore_main.cpp: modify --print explaination of ndb_restore --- ndb/tools/restore/restore_main.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ndb/tools/restore/restore_main.cpp b/ndb/tools/restore/restore_main.cpp index 9ec59b9b4a6..9887869a0b3 100644 --- a/ndb/tools/restore/restore_main.cpp +++ b/ndb/tools/restore/restore_main.cpp @@ -112,7 +112,7 @@ static struct my_option my_long_options[] = "(parallelism can be 1 to 1024)", (gptr*) &ga_nParallelism, (gptr*) &ga_nParallelism, 0, GET_INT, REQUIRED_ARG, 128, 1, 1024, 0, 1, 0 }, - { "print", OPT_PRINT, "Print data and log to stdout", + { "print", OPT_PRINT, "Print metadata, data and log to stdout", (gptr*) &_print, (gptr*) &_print, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 }, { "print_data", OPT_PRINT_DATA, "Print data to stdout", From b50015f280f2eca4676267c79e868c2a0b511016 Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 26 Jul 2007 20:24:54 +1000 Subject: [PATCH 04/41] [PATCH] BUG#26793 test: mysqld crashes in NDB on I_S query Reduce case and formalise into something we should be able to use in mysql-test-run. Index: ndb-work/mysql-test/t/ndb_bug26793.test =================================================================== mysql-test/r/ndb_bug26793.result: BUG#26793 test: mysqld crashes in NDB on I_S query mysql-test/t/ndb_bug26793.test: BUG#26793 test: mysqld crashes in NDB on I_S query --- mysql-test/r/ndb_bug26793.result | 9 +++++++++ mysql-test/t/ndb_bug26793.test | 33 ++++++++++++++++++++++++++++++++ 2 files changed, 42 insertions(+) create mode 100644 mysql-test/r/ndb_bug26793.result create mode 100644 mysql-test/t/ndb_bug26793.test diff --git a/mysql-test/r/ndb_bug26793.result b/mysql-test/r/ndb_bug26793.result new file mode 100644 index 00000000000..9a15841e670 --- /dev/null +++ b/mysql-test/r/ndb_bug26793.result @@ -0,0 +1,9 @@ +DROP TABLE IF EXISTS t1; +CREATE TABLE `test` ( +`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , +`t` VARCHAR( 10 ) NOT NULL +) ENGINE = ndbcluster; +delete from mysql.db where user=''; +flush privileges; +GRANT USAGE ON *.* TO user1@localhost IDENTIFIED BY 'pass'; +DROP TABLE `test`.`test`; diff --git a/mysql-test/t/ndb_bug26793.test b/mysql-test/t/ndb_bug26793.test new file mode 100644 index 00000000000..66595639c3e --- /dev/null +++ b/mysql-test/t/ndb_bug26793.test @@ -0,0 +1,33 @@ +-- source include/have_ndb.inc + +--disable_warnings +DROP TABLE IF EXISTS t1; +--enable_warnings + +CREATE TABLE `test` ( +`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , +`t` VARCHAR( 10 ) NOT NULL +) ENGINE = ndbcluster; + +delete from mysql.db where user=''; + +flush privileges; + +GRANT USAGE ON *.* TO user1@localhost IDENTIFIED BY 'pass'; + +connect (user1,localhost,user1,pass,*NO-ONE*); + +disable_query_log; +disable_result_log; +let $i= 100; +while ($i) +{ +select count(*) from information_schema.tables union all select count(*) from information_schema.tables union all select count(*) from information_schema.tables; +dec $i; +} +enable_query_log; +enable_result_log; + +connect (root,localhost,root,,test); +connection root; +DROP TABLE `test`.`test`; From ffa5fb613d6078ddaef0e9476e30da557fa4ad6b Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 26 Jul 2007 20:25:05 +1000 Subject: [PATCH 05/41] [PATCH] Bug#26793 I_S query crashes in NDB If ::exteral_lock hadn't been called, we'd have no NDB object, so need to check/get one here. It looks like sql_show.cc is the only place that does this.... or at least the other places will be well hidden. Index: ndb-work/sql/ha_ndbcluster.cc =================================================================== sql/ha_ndbcluster.cc: Bug#26793 I_S query crashes in NDB --- sql/ha_ndbcluster.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc index 357b797ec75..03b6bcf3242 100644 --- a/sql/ha_ndbcluster.cc +++ b/sql/ha_ndbcluster.cc @@ -3310,6 +3310,8 @@ int ha_ndbcluster::info(uint flag) DBUG_PRINT("info", ("HA_STATUS_AUTO")); if (m_table && table->found_next_number_field) { + if ((my_errno= check_ndb_connection())) + DBUG_RETURN(my_errno); Ndb *ndb= get_ndb(); Uint64 auto_increment_value64; From 180068ddceb0e400bb22f19c10df9187b301dedb Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 27 Jul 2007 17:12:53 +1000 Subject: [PATCH 06/41] save the data from mysql.db that we delete (side effect that made read_only fail) --- mysql-test/r/ndb_bug26793.result | 4 ++++ mysql-test/t/ndb_bug26793.test | 5 +++++ 2 files changed, 9 insertions(+) diff --git a/mysql-test/r/ndb_bug26793.result b/mysql-test/r/ndb_bug26793.result index 9a15841e670..31f9763dd6b 100644 --- a/mysql-test/r/ndb_bug26793.result +++ b/mysql-test/r/ndb_bug26793.result @@ -3,7 +3,11 @@ CREATE TABLE `test` ( `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , `t` VARCHAR( 10 ) NOT NULL ) ENGINE = ndbcluster; +create table test.db_temp as select * from mysql.db where user=''; delete from mysql.db where user=''; flush privileges; GRANT USAGE ON *.* TO user1@localhost IDENTIFIED BY 'pass'; DROP TABLE `test`.`test`; +insert into mysql.db select * from test.db_temp; +drop table db_temp; +flush privileges; diff --git a/mysql-test/t/ndb_bug26793.test b/mysql-test/t/ndb_bug26793.test index 66595639c3e..4f5a78fdca4 100644 --- a/mysql-test/t/ndb_bug26793.test +++ b/mysql-test/t/ndb_bug26793.test @@ -9,6 +9,7 @@ CREATE TABLE `test` ( `t` VARCHAR( 10 ) NOT NULL ) ENGINE = ndbcluster; +create table test.db_temp as select * from mysql.db where user=''; delete from mysql.db where user=''; flush privileges; @@ -31,3 +32,7 @@ enable_result_log; connect (root,localhost,root,,test); connection root; DROP TABLE `test`.`test`; +insert into mysql.db select * from test.db_temp; +drop table db_temp; +flush privileges; + From 4c23e5f37319e381f9a564707d6022fa6600239d Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 7 Aug 2007 18:07:57 +0000 Subject: [PATCH 07/41] BUG#29674 Restore/backup are endian compatible in 5.0 ndb/src/ndbapi/NdbDictionaryImpl.cpp: Twiddle the "replicaCount" and "fragCount" variable when restore data from different endian. ndb/src/ndbapi/NdbDictionaryImpl.hpp: Add byte order variable ndb/tools/restore/Restore.cpp: Twiddle blob, datatime,timestamp when do restore in different endian. mysql-test/r/ndb_restore_different_endian_data.result: Test case result for restore data from different endian mysql-test/std_data/ndb_backup50_data_be/BACKUP-1-0.1.Data: Test case data mysql-test/std_data/ndb_backup50_data_be/BACKUP-1-0.2.Data: Test case data mysql-test/std_data/ndb_backup50_data_be/BACKUP-1.1.ctl: Test case data mysql-test/std_data/ndb_backup50_data_be/BACKUP-1.1.log: Test case data mysql-test/std_data/ndb_backup50_data_be/BACKUP-1.2.ctl: Test case data mysql-test/std_data/ndb_backup50_data_be/BACKUP-1.2.log: Test case data mysql-test/std_data/ndb_backup50_data_le/BACKUP-1-0.1.Data: Test case data mysql-test/std_data/ndb_backup50_data_le/BACKUP-1-0.2.Data: Test case data mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.1.ctl: Test case data mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.1.log: Test case data mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.2.ctl: Test case data mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.2.log: Test case data mysql-test/t/ndb_restore_different_endian_data.test: Test case for restore data from different endian --- .../ndb_restore_different_endian_data.result | 200 ++++++++++++++++++ .../ndb_backup50_data_be/BACKUP-1-0.1.Data | Bin 0 -> 47900 bytes .../ndb_backup50_data_be/BACKUP-1-0.2.Data | Bin 0 -> 17608 bytes .../ndb_backup50_data_be/BACKUP-1.1.ctl | Bin 0 -> 24644 bytes .../ndb_backup50_data_be/BACKUP-1.1.log | Bin 0 -> 44 bytes .../ndb_backup50_data_be/BACKUP-1.2.ctl | Bin 0 -> 24644 bytes .../ndb_backup50_data_be/BACKUP-1.2.log | Bin 0 -> 44 bytes .../ndb_backup50_data_le/BACKUP-1-0.1.Data | Bin 0 -> 17656 bytes .../ndb_backup50_data_le/BACKUP-1-0.2.Data | Bin 0 -> 47852 bytes .../ndb_backup50_data_le/BACKUP-1.1.ctl | Bin 0 -> 24644 bytes .../ndb_backup50_data_le/BACKUP-1.1.log | Bin 0 -> 44 bytes .../ndb_backup50_data_le/BACKUP-1.2.ctl | Bin 0 -> 24644 bytes .../ndb_backup50_data_le/BACKUP-1.2.log | Bin 0 -> 44 bytes .../t/ndb_restore_different_endian_data.test | 185 ++++++++++++++++ ndb/src/ndbapi/NdbDictionaryImpl.cpp | 13 +- ndb/src/ndbapi/NdbDictionaryImpl.hpp | 3 +- ndb/tools/restore/Restore.cpp | 33 ++- 17 files changed, 429 insertions(+), 5 deletions(-) create mode 100644 mysql-test/r/ndb_restore_different_endian_data.result create mode 100644 mysql-test/std_data/ndb_backup50_data_be/BACKUP-1-0.1.Data create mode 100644 mysql-test/std_data/ndb_backup50_data_be/BACKUP-1-0.2.Data create mode 100644 mysql-test/std_data/ndb_backup50_data_be/BACKUP-1.1.ctl create mode 100644 mysql-test/std_data/ndb_backup50_data_be/BACKUP-1.1.log create mode 100644 mysql-test/std_data/ndb_backup50_data_be/BACKUP-1.2.ctl create mode 100644 mysql-test/std_data/ndb_backup50_data_be/BACKUP-1.2.log create mode 100644 mysql-test/std_data/ndb_backup50_data_le/BACKUP-1-0.1.Data create mode 100644 mysql-test/std_data/ndb_backup50_data_le/BACKUP-1-0.2.Data create mode 100644 mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.1.ctl create mode 100644 mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.1.log create mode 100644 mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.2.ctl create mode 100644 mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.2.log create mode 100644 mysql-test/t/ndb_restore_different_endian_data.test diff --git a/mysql-test/r/ndb_restore_different_endian_data.result b/mysql-test/r/ndb_restore_different_endian_data.result new file mode 100644 index 00000000000..e1efefb751a --- /dev/null +++ b/mysql-test/r/ndb_restore_different_endian_data.result @@ -0,0 +1,200 @@ +USE test; +DROP TABLE IF EXISTS t_num,t_datetime,t_string_1,t_string_2,t_gis; +SHOW TABLES; +Tables_in_test +t_gis +t_string_1 +t_num +t_string_2 +t_datetime +SHOW CREATE TABLE t_num; +Table Create Table +t_num CREATE TABLE `t_num` ( + `t_pk` int(11) NOT NULL, + `t_bit` bit(64) default NULL, + `t_tinyint` tinyint(4) default NULL, + `t_bool` tinyint(1) default NULL, + `t_smallint` smallint(6) default NULL, + `t_mediumint` mediumint(9) default NULL, + `t_int` int(11) default NULL, + `t_bigint` bigint(20) default NULL, + `t_float` float default NULL, + `t_double` double default NULL, + `t_decimal` decimal(37,16) default NULL, + PRIMARY KEY (`t_pk`) +) ENGINE=ndbcluster DEFAULT CHARSET=latin1 +SHOW CREATE TABLE t_datetime; +Table Create Table +t_datetime CREATE TABLE `t_datetime` ( + `t_pk` int(11) NOT NULL, + `t_date` date default NULL, + `t_datetime` datetime default NULL, + `t_timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP, + `t_time` time default NULL, + `t_year` year(4) default NULL, + PRIMARY KEY (`t_pk`) +) ENGINE=ndbcluster DEFAULT CHARSET=latin1 +SHOW CREATE TABLE t_string_1; +Table Create Table +t_string_1 CREATE TABLE `t_string_1` ( + `t_pk` int(11) NOT NULL, + `t_char` char(255) default NULL, + `t_varchar` varchar(655) default NULL, + `t_binary` binary(255) default NULL, + `t_varbinary` varbinary(6553) default NULL, + PRIMARY KEY (`t_pk`) +) ENGINE=ndbcluster DEFAULT CHARSET=latin1 +SHOW CREATE TABLE t_string_2; +Table Create Table +t_string_2 CREATE TABLE `t_string_2` ( + `t_pk` int(11) NOT NULL, + `t_tinyblob` tinyblob, + `t_tinytext` tinytext, + `t_blob` blob, + `t_text` text, + `t_mediumblob` mediumblob, + `t_mediumtext` mediumtext, + `t_longblob` longblob, + `t_longtext` longtext, + `t_enum` enum('001001','001004','001010','001018','001019','001020','001021','001027','001028','001029','001030','001031','001100','002003','002004','002005','002007') NOT NULL default '001001', + `t_set` set('a','B') default NULL, + PRIMARY KEY (`t_pk`) +) ENGINE=ndbcluster DEFAULT CHARSET=latin1 +SHOW CREATE TABLE t_gis; +Table Create Table +t_gis CREATE TABLE `t_gis` ( + `t_pk` int(11) NOT NULL, + `t_point` point default NULL, + `t_linestring` linestring default NULL, + `t_polygon` polygon default NULL, + `t_multipoint` multipoint default NULL, + `t_multilinestring` multilinestring default NULL, + `t_multipolygon` multipolygon default NULL, + `t_geometrycollection` geometrycollection default NULL, + `t_geometry` geometry default NULL, + PRIMARY KEY (`t_pk`) +) ENGINE=ndbcluster DEFAULT CHARSET=latin1 +SELECT * FROM t_datetime; +t_pk t_date t_datetime t_timestamp t_time t_year +1 1998-01-01 2006-08-10 10:11:12 2002-10-29 16:51:06 19:38:34 2155 +SELECT t_pk,hex(t_bit),t_tinyint,t_bool,t_smallint,t_mediumint,t_int,t_bigint,t_float,t_double,t_decimal FROM t_num; +t_pk hex(t_bit) t_tinyint t_bool t_smallint t_mediumint t_int t_bigint t_float t_double t_decimal +1 AAAAAAAAAAAAAAAA 125 1 32765 8388606 2147483647 9223372036854775807 1e+20 1e+150 331.0000000000000000 +SELECT t_pk,t_char,t_varchar,hex(t_binary),hex(t_varbinary) FROM t_string_1; +t_pk t_char t_varchar hex(t_binary) hex(t_varbinary) +1 abcdefghijklmn abcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmn 612020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 4100 +SELECT * FROM t_string_2; +t_pk t_tinyblob t_tinytext t_blob t_text t_mediumblob t_mediumtext t_longblob t_longtext t_enum t_set +1 abcdefghijklmnabcdefghijklmn abcdefghijklmnabcdefghijklmn a123456789b123456789c123456789d123456789e123456789f123456789g123456789 a123456789b123456789c123456789d123456789e123456789f123456789g123456789 a123456789b123456789c123456789d123456789e123456789f123456789g123456789 a123456789b123456789c123456789d123456789e123456789f123456789g123456789 a123456789b123456789c123456789d123456789e123456789f123456789g123456789 a123456789b123456789c123456789d123456789e123456789f123456789g123456789 001001 a +SELECT AsText(t_point), AsText(t_linestring),AsText(t_polygon) FROM t_gis ORDER by t_pk; +AsText(t_point) AsText(t_linestring) AsText(t_polygon) +POINT(10 10) LINESTRING(10 10,20 10,20 20,10 20,10 10) POLYGON((0 0,50 0,50 50,0 50,0 0),(10 10,20 10,20 20,10 20,10 10)) +POINT(10 20) LINESTRING(10 10,40 10) POLYGON((0 0,30 0,30 30,0 0)) +SELECT AsText(t_multipoint), AsText(t_multilinestring),AsText(t_multipolygon) FROM t_gis ORDER by t_pk; +AsText(t_multipoint) AsText(t_multilinestring) AsText(t_multipolygon) +MULTIPOINT(1 1,11 11,11 21,21 21) MULTILINESTRING((10 48,10 21,10 0)) MULTIPOLYGON(((28 26,28 0,84 0,84 42,28 26),(52 18,66 23,73 9,48 6,52 18)),((59 18,67 18,67 13,59 13,59 18))) +MULTIPOINT(3 6,4 10) MULTILINESTRING((1 2,3 5),(2 5,5 8,21 7)) MULTIPOLYGON(((0 3,3 3,3 0,0 3))) +SELECT AsText(t_geometrycollection), AsText(t_geometry) FROM t_gis ORDER by t_pk; +AsText(t_geometrycollection) AsText(t_geometry) +GEOMETRYCOLLECTION(POINT(0 0),LINESTRING(0 0,10 10)) MULTIPOLYGON(((28 26,28 0,84 0,84 42,28 26),(52 18,66 23,73 9,48 6,52 18)),((59 18,67 18,67 13,59 13,59 18))) +GEOMETRYCOLLECTION(POINT(44 6),LINESTRING(3 6,7 9)) GEOMETRYCOLLECTION(POINT(44 6),LINESTRING(3 6,7 9)) +DROP TABLE t_num,t_datetime,t_string_1,t_string_2,t_gis; +SHOW TABLES; +Tables_in_test +t_gis +t_string_1 +t_num +t_string_2 +t_datetime +SHOW CREATE TABLE t_num; +Table Create Table +t_num CREATE TABLE `t_num` ( + `t_pk` int(11) NOT NULL, + `t_bit` bit(64) default NULL, + `t_tinyint` tinyint(4) default NULL, + `t_bool` tinyint(1) default NULL, + `t_smallint` smallint(6) default NULL, + `t_mediumint` mediumint(9) default NULL, + `t_int` int(11) default NULL, + `t_bigint` bigint(20) default NULL, + `t_float` float default NULL, + `t_double` double default NULL, + `t_decimal` decimal(37,16) default NULL, + PRIMARY KEY (`t_pk`) +) ENGINE=ndbcluster DEFAULT CHARSET=latin1 +SHOW CREATE TABLE t_datetime; +Table Create Table +t_datetime CREATE TABLE `t_datetime` ( + `t_pk` int(11) NOT NULL, + `t_date` date default NULL, + `t_datetime` datetime default NULL, + `t_timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP, + `t_time` time default NULL, + `t_year` year(4) default NULL, + PRIMARY KEY (`t_pk`) +) ENGINE=ndbcluster DEFAULT CHARSET=latin1 +SHOW CREATE TABLE t_string_1; +Table Create Table +t_string_1 CREATE TABLE `t_string_1` ( + `t_pk` int(11) NOT NULL, + `t_char` char(255) default NULL, + `t_varchar` varchar(655) default NULL, + `t_binary` binary(255) default NULL, + `t_varbinary` varbinary(6553) default NULL, + PRIMARY KEY (`t_pk`) +) ENGINE=ndbcluster DEFAULT CHARSET=latin1 +SHOW CREATE TABLE t_string_2; +Table Create Table +t_string_2 CREATE TABLE `t_string_2` ( + `t_pk` int(11) NOT NULL, + `t_tinyblob` tinyblob, + `t_tinytext` tinytext, + `t_blob` blob, + `t_text` text, + `t_mediumblob` mediumblob, + `t_mediumtext` mediumtext, + `t_longblob` longblob, + `t_longtext` longtext, + `t_enum` enum('001001','001004','001010','001018','001019','001020','001021','001027','001028','001029','001030','001031','001100','002003','002004','002005','002007') NOT NULL default '001001', + `t_set` set('a','B') default NULL, + PRIMARY KEY (`t_pk`) +) ENGINE=ndbcluster DEFAULT CHARSET=latin1 +SHOW CREATE TABLE t_gis; +Table Create Table +t_gis CREATE TABLE `t_gis` ( + `t_pk` int(11) NOT NULL, + `t_point` point default NULL, + `t_linestring` linestring default NULL, + `t_polygon` polygon default NULL, + `t_multipoint` multipoint default NULL, + `t_multilinestring` multilinestring default NULL, + `t_multipolygon` multipolygon default NULL, + `t_geometrycollection` geometrycollection default NULL, + `t_geometry` geometry default NULL, + PRIMARY KEY (`t_pk`) +) ENGINE=ndbcluster DEFAULT CHARSET=latin1 +SELECT * FROM t_datetime; +t_pk t_date t_datetime t_timestamp t_time t_year +1 1998-01-01 2006-08-10 10:11:12 2002-10-29 16:51:06 19:38:34 2155 +SELECT t_pk,hex(t_bit),t_tinyint,t_bool,t_smallint,t_mediumint,t_int,t_bigint,t_float,t_double,t_decimal FROM t_num; +t_pk hex(t_bit) t_tinyint t_bool t_smallint t_mediumint t_int t_bigint t_float t_double t_decimal +1 AAAAAAAAAAAAAAAA 125 1 32765 8388606 2147483647 9223372036854775807 1e+20 1e+150 331.0000000000000000 +SELECT t_pk,t_char,t_varchar,hex(t_binary),hex(t_varbinary) FROM t_string_1; +t_pk t_char t_varchar hex(t_binary) hex(t_varbinary) +1 abcdefghijklmn abcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmn 612020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 4100 +SELECT * FROM t_string_2; +t_pk t_tinyblob t_tinytext t_blob t_text t_mediumblob t_mediumtext t_longblob t_longtext t_enum t_set +1 abcdefghijklmnabcdefghijklmn abcdefghijklmnabcdefghijklmn a123456789b123456789c123456789d123456789e123456789f123456789g123456789 a123456789b123456789c123456789d123456789e123456789f123456789g123456789 a123456789b123456789c123456789d123456789e123456789f123456789g123456789 a123456789b123456789c123456789d123456789e123456789f123456789g123456789 a123456789b123456789c123456789d123456789e123456789f123456789g123456789 a123456789b123456789c123456789d123456789e123456789f123456789g123456789 001001 a +SELECT AsText(t_point), AsText(t_linestring),AsText(t_polygon) FROM t_gis ORDER by t_pk; +AsText(t_point) AsText(t_linestring) AsText(t_polygon) +POINT(10 10) LINESTRING(10 10,20 10,20 20,10 20,10 10) POLYGON((0 0,50 0,50 50,0 50,0 0),(10 10,20 10,20 20,10 20,10 10)) +POINT(10 20) LINESTRING(10 10,40 10) POLYGON((0 0,30 0,30 30,0 0)) +SELECT AsText(t_multipoint), AsText(t_multilinestring),AsText(t_multipolygon) FROM t_gis ORDER by t_pk; +AsText(t_multipoint) AsText(t_multilinestring) AsText(t_multipolygon) +MULTIPOINT(1 1,11 11,11 21,21 21) MULTILINESTRING((10 48,10 21,10 0)) MULTIPOLYGON(((28 26,28 0,84 0,84 42,28 26),(52 18,66 23,73 9,48 6,52 18)),((59 18,67 18,67 13,59 13,59 18))) +MULTIPOINT(3 6,4 10) MULTILINESTRING((1 2,3 5),(2 5,5 8,21 7)) MULTIPOLYGON(((0 3,3 3,3 0,0 3))) +SELECT AsText(t_geometrycollection), AsText(t_geometry) FROM t_gis ORDER by t_pk; +AsText(t_geometrycollection) AsText(t_geometry) +GEOMETRYCOLLECTION(POINT(0 0),LINESTRING(0 0,10 10)) MULTIPOLYGON(((28 26,28 0,84 0,84 42,28 26),(52 18,66 23,73 9,48 6,52 18)),((59 18,67 18,67 13,59 13,59 18))) +GEOMETRYCOLLECTION(POINT(44 6),LINESTRING(3 6,7 9)) GEOMETRYCOLLECTION(POINT(44 6),LINESTRING(3 6,7 9)) +DROP TABLE t_num,t_datetime,t_string_1,t_string_2,t_gis; diff --git a/mysql-test/std_data/ndb_backup50_data_be/BACKUP-1-0.1.Data b/mysql-test/std_data/ndb_backup50_data_be/BACKUP-1-0.1.Data new file mode 100644 index 0000000000000000000000000000000000000000..90a8443cf45125b8a89d3e8a868b44aac83d9441 GIT binary patch literal 47900 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 t_9~+?oaGJj2H+;L32;3L_b=~9uT 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 XP|wG{kf>Ouv*nWzb?^U|_0P-0CeVPS` literal 0 HcmV?d00001 diff --git a/mysql-test/std_data/ndb_backup50_data_be/BACKUP-1.2.ctl b/mysql-test/std_data/ndb_backup50_data_be/BACKUP-1.2.ctl new file mode 100644 index 0000000000000000000000000000000000000000..8849978e2938a8bf477a5729e341f071abf92efc GIT binary patch literal 24644 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 XP|wG{kf>Ouv*nWzb?^U|_0P-0CeVPS` literal 0 HcmV?d00001 diff --git a/mysql-test/std_data/ndb_backup50_data_le/BACKUP-1-0.1.Data b/mysql-test/std_data/ndb_backup50_data_le/BACKUP-1-0.1.Data new file mode 100644 index 0000000000000000000000000000000000000000..157c28b67b309a82ada8e2a0f94a344020ff72a9 GIT binary patch literal 17656 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 Aod5s; literal 0 HcmV?d00001 diff --git a/mysql-test/std_data/ndb_backup50_data_le/BACKUP-1-0.2.Data b/mysql-test/std_data/ndb_backup50_data_le/BACKUP-1-0.2.Data new file mode 100644 index 0000000000000000000000000000000000000000..e7602c89db7143a9bde0e46fccbd283fee25eca2 GIT binary patch literal 47852 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 DX8Y3p literal 0 HcmV?d00001 diff --git a/mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.1.ctl b/mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.1.ctl new file mode 100644 index 0000000000000000000000000000000000000000..e2b8f4977ed13b1ae13ef7be312fd40e4aa8846d GIT binary patch literal 24644 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 literal 0 HcmV?d00001 diff --git a/mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.1.log b/mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.1.log new file mode 100644 index 0000000000000000000000000000000000000000..c8037dd453a93670e128e26b66dccdf41c05de08 GIT binary patch literal 44 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 literal 0 HcmV?d00001 diff --git a/mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.2.log b/mysql-test/std_data/ndb_backup50_data_le/BACKUP-1.2.log new file mode 100644 index 0000000000000000000000000000000000000000..c8037dd453a93670e128e26b66dccdf41c05de08 GIT binary patch literal 44 rcmeZsadL9@4h>*nWzb?^U|> $NDB_TOOLS_OUTPUT +--exec $NDB_TOOLS_DIR/ndb_restore --no-defaults -b 1 -n 2 -r $MYSQL_TEST_DIR/std_data/ndb_backup50_data_le >> $NDB_TOOLS_OUTPUT +SHOW TABLES; +SHOW CREATE TABLE t_num; +SHOW CREATE TABLE t_datetime; +SHOW CREATE TABLE t_string_1; +SHOW CREATE TABLE t_string_2; +SHOW CREATE TABLE t_gis; +SELECT * FROM t_datetime; +SELECT t_pk,hex(t_bit),t_tinyint,t_bool,t_smallint,t_mediumint,t_int,t_bigint,t_float,t_double,t_decimal FROM t_num; +SELECT t_pk,t_char,t_varchar,hex(t_binary),hex(t_varbinary) FROM t_string_1; +SELECT * FROM t_string_2; +SELECT AsText(t_point), AsText(t_linestring),AsText(t_polygon) FROM t_gis ORDER by t_pk; +SELECT AsText(t_multipoint), AsText(t_multilinestring),AsText(t_multipolygon) FROM t_gis ORDER by t_pk; +SELECT AsText(t_geometrycollection), AsText(t_geometry) FROM t_gis ORDER by t_pk; + +# +# Restore backup files (from big endian) +# + +DROP TABLE t_num,t_datetime,t_string_1,t_string_2,t_gis; +--exec $NDB_TOOLS_DIR/ndb_restore --no-defaults -b 1 -n 1 -m -r $MYSQL_TEST_DIR/std_data/ndb_backup50_data_be >> $NDB_TOOLS_OUTPUT +--exec $NDB_TOOLS_DIR/ndb_restore --no-defaults -b 1 -n 2 -r $MYSQL_TEST_DIR/std_data/ndb_backup50_data_be >> $NDB_TOOLS_OUTPUT +SHOW TABLES; +SHOW CREATE TABLE t_num; +SHOW CREATE TABLE t_datetime; +SHOW CREATE TABLE t_string_1; +SHOW CREATE TABLE t_string_2; +SHOW CREATE TABLE t_gis; +SELECT * FROM t_datetime; +SELECT t_pk,hex(t_bit),t_tinyint,t_bool,t_smallint,t_mediumint,t_int,t_bigint,t_float,t_double,t_decimal FROM t_num; +SELECT t_pk,t_char,t_varchar,hex(t_binary),hex(t_varbinary) FROM t_string_1; +SELECT * FROM t_string_2; +SELECT AsText(t_point), AsText(t_linestring),AsText(t_polygon) FROM t_gis ORDER by t_pk; +SELECT AsText(t_multipoint), AsText(t_multilinestring),AsText(t_multipolygon) FROM t_gis ORDER by t_pk; +SELECT AsText(t_geometrycollection), AsText(t_geometry) FROM t_gis ORDER by t_pk; + +DROP TABLE t_num,t_datetime,t_string_1,t_string_2,t_gis; diff --git a/ndb/src/ndbapi/NdbDictionaryImpl.cpp b/ndb/src/ndbapi/NdbDictionaryImpl.cpp index 3fed04de26d..392abffa160 100644 --- a/ndb/src/ndbapi/NdbDictionaryImpl.cpp +++ b/ndb/src/ndbapi/NdbDictionaryImpl.cpp @@ -1220,7 +1220,8 @@ indexTypeMapping[] = { int NdbDictInterface::parseTableInfo(NdbTableImpl ** ret, const Uint32 * data, Uint32 len, - bool fullyQualifiedNames) + bool fullyQualifiedNames, + bool hostByteOrder) { DBUG_ENTER("NdbDictInterface::parseTableInfo"); @@ -1379,8 +1380,14 @@ NdbDictInterface::parseTableInfo(NdbTableImpl ** ret, if(tableDesc.FragmentDataLen > 0) { - Uint32 replicaCount = tableDesc.FragmentData[0]; - Uint32 fragCount = tableDesc.FragmentData[1]; + Uint16 replicaCount = tableDesc.FragmentData[0]; + Uint16 fragCount = tableDesc.FragmentData[1]; + + if(hostByteOrder == false) + { + replicaCount = ((replicaCount & 0xFF00) >> 8) |((replicaCount & 0x00FF) << 8); + fragCount = ((fragCount & 0xFF00) >> 8) |((fragCount & 0x00FF) << 8); + } impl->m_replicaCount = replicaCount; impl->m_fragmentCount = fragCount; diff --git a/ndb/src/ndbapi/NdbDictionaryImpl.hpp b/ndb/src/ndbapi/NdbDictionaryImpl.hpp index 819de921235..a8757b69472 100644 --- a/ndb/src/ndbapi/NdbDictionaryImpl.hpp +++ b/ndb/src/ndbapi/NdbDictionaryImpl.hpp @@ -262,7 +262,8 @@ public: static int parseTableInfo(NdbTableImpl ** dst, const Uint32 * data, Uint32 len, - bool fullyQualifiedNames); + bool fullyQualifiedNames, + bool hostByteOrder = true); static int create_index_obj_from_table(NdbIndexImpl ** dst, NdbTableImpl* index_table, diff --git a/ndb/tools/restore/Restore.cpp b/ndb/tools/restore/Restore.cpp index c07bfbc2bd4..b89d3e239c2 100644 --- a/ndb/tools/restore/Restore.cpp +++ b/ndb/tools/restore/Restore.cpp @@ -324,7 +324,11 @@ bool RestoreMetaData::parseTableDescriptor(const Uint32 * data, Uint32 len) { NdbTableImpl* tableImpl = 0; - int ret = NdbDictInterface::parseTableInfo(&tableImpl, data, len, false); + int ret = 0; + if(!m_hostByteOrder) + ret = NdbDictInterface::parseTableInfo(&tableImpl, data, len, false, false); + else + ret = NdbDictInterface::parseTableInfo(&tableImpl, data, len, false); if (ret != 0) { err << "parseTableInfo " << " failed" << endl; @@ -478,6 +482,10 @@ RestoreDataIterator::getNextTuple(int & res) attr_data->void_value = ptr; attr_data->size = 4*sz; + if(!m_hostByteOrder + && attr_desc->m_column->getType() == NdbDictionary::Column::Timestamp) + attr_data->u_int32_value[0] = Twiddle32(attr_data->u_int32_value[0]); + if(!Twiddle(attr_desc, attr_data)) { res = -1; @@ -520,6 +528,29 @@ RestoreDataIterator::getNextTuple(int & res) */ const Uint32 arraySize = (4 * sz) / (attr_desc->size / 8); assert(arraySize >= attr_desc->arraySize); + + //convert the length of blob(v1) and text(v1) + if(!m_hostByteOrder + && (attr_desc->m_column->getType() == NdbDictionary::Column::Blob + || attr_desc->m_column->getType() == NdbDictionary::Column::Text)) + { + char* p = (char*)&attr_data->u_int64_value[0]; + Uint64 x; + memcpy(&x, p, sizeof(Uint64)); + x = Twiddle64(x); + memcpy(p, &x, sizeof(Uint64)); + } + + if(!m_hostByteOrder + && attr_desc->m_column->getType() == NdbDictionary::Column::Datetime) + { + char* p = (char*)&attr_data->u_int64_value[0]; + Uint64 x; + memcpy(&x, p, sizeof(Uint64)); + x = Twiddle64(x); + memcpy(p, &x, sizeof(Uint64)); + } + if(!Twiddle(attr_desc, attr_data, attr_desc->arraySize)) { res = -1; From 52a014c7c646f4b4fa5c3117675671c6668cd1ac Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 13 Aug 2007 09:22:42 +0200 Subject: [PATCH 08/41] ndb - bug#28804 Handle out of transaction buffer in TC for INDX lookups ndb/src/kernel/blocks/ERROR_codes.txt: Add new error codes for simulating out of transaction buffer memory ndb/src/kernel/blocks/dbtc/Dbtc.hpp: Change signature to handle out of buffer ndb/src/kernel/blocks/dbtc/DbtcMain.cpp: Handle otu of transaction buffers in index operations (TCINDXREQ++) ndb/src/ndbapi/NdbTransaction.cpp: Give more info on 4012 ndb/src/ndbapi/ndberror.c: Add new error code ndb/test/ndbapi/testIndex.cpp: add tests ndb/test/run-test/daily-basic-tests.txt: add tests sql/ha_ndbcluster.cc: Set correct status --- ndb/src/kernel/blocks/ERROR_codes.txt | 6 +- ndb/src/kernel/blocks/dbtc/Dbtc.hpp | 10 +- ndb/src/kernel/blocks/dbtc/DbtcMain.cpp | 163 ++++++++++++++++++------ ndb/src/ndbapi/NdbTransaction.cpp | 38 +++++- ndb/src/ndbapi/ndberror.c | 2 + ndb/test/ndbapi/testIndex.cpp | 117 +++++++++++++++++ ndb/test/run-test/daily-basic-tests.txt | 8 ++ sql/ha_ndbcluster.cc | 10 +- 8 files changed, 299 insertions(+), 55 deletions(-) diff --git a/ndb/src/kernel/blocks/ERROR_codes.txt b/ndb/src/kernel/blocks/ERROR_codes.txt index 17f2c35624a..e45c608b601 100644 --- a/ndb/src/kernel/blocks/ERROR_codes.txt +++ b/ndb/src/kernel/blocks/ERROR_codes.txt @@ -6,7 +6,7 @@ Next DBTUP 4014 Next DBLQH 5043 Next DBDICT 6007 Next DBDIH 7183 -Next DBTC 8039 +Next DBTC 8052 Next CMVMI 9000 Next BACKUP 10022 Next DBUTIL 11002 @@ -296,6 +296,10 @@ ABORT OF TCKEYREQ 8038 : Simulate API disconnect just after SCAN_TAB_REQ +8039 : Simulate failure of TransactionBufferMemory allocation for OI lookup + +8051 : Simulate failure of allocation for saveINDXKEYINFO + CMVMI ----- diff --git a/ndb/src/kernel/blocks/dbtc/Dbtc.hpp b/ndb/src/kernel/blocks/dbtc/Dbtc.hpp index 6934de76ad3..710d2fde182 100644 --- a/ndb/src/kernel/blocks/dbtc/Dbtc.hpp +++ b/ndb/src/kernel/blocks/dbtc/Dbtc.hpp @@ -1497,12 +1497,12 @@ private: void clearCommitAckMarker(ApiConnectRecord * const regApiPtr, TcConnectRecord * const regTcPtr); // Trigger and index handling - bool saveINDXKEYINFO(Signal* signal, - TcIndexOperation* indexOp, - const Uint32 *src, - Uint32 len); + int saveINDXKEYINFO(Signal* signal, + TcIndexOperation* indexOp, + const Uint32 *src, + Uint32 len); bool receivedAllINDXKEYINFO(TcIndexOperation* indexOp); - bool saveINDXATTRINFO(Signal* signal, + int saveINDXATTRINFO(Signal* signal, TcIndexOperation* indexOp, const Uint32 *src, Uint32 len); diff --git a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp index e2df1249661..60024e82978 100644 --- a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp +++ b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp @@ -1789,9 +1789,18 @@ start_failure: }//switch } +static +inline +bool +compare_transid(Uint32* val0, Uint32* val1) +{ + Uint32 tmp0 = val0[0] ^ val1[0]; + Uint32 tmp1 = val0[1] ^ val1[1]; + return (tmp0 | tmp1) == 0; +} + void Dbtc::execKEYINFO(Signal* signal) { - UintR compare_transid1, compare_transid2; jamEntry(); apiConnectptr.i = signal->theData[0]; tmaxData = 20; @@ -1801,10 +1810,8 @@ void Dbtc::execKEYINFO(Signal* signal) }//if ptrAss(apiConnectptr, apiConnectRecord); ttransid_ptr = 1; - compare_transid1 = apiConnectptr.p->transid[0] ^ signal->theData[1]; - compare_transid2 = apiConnectptr.p->transid[1] ^ signal->theData[2]; - compare_transid1 = compare_transid1 | compare_transid2; - if (compare_transid1 != 0) { + if (compare_transid(apiConnectptr.p->transid, signal->theData+1) == false) + { TCKEY_abort(signal, 19); return; }//if @@ -2105,7 +2112,6 @@ void Dbtc::saveAttrbuf(Signal* signal) void Dbtc::execATTRINFO(Signal* signal) { - UintR compare_transid1, compare_transid2; UintR Tdata1 = signal->theData[0]; UintR Tlength = signal->length(); UintR TapiConnectFilesize = capiConnectFilesize; @@ -2120,17 +2126,13 @@ void Dbtc::execATTRINFO(Signal* signal) return; }//if - UintR Tdata2 = signal->theData[1]; - UintR Tdata3 = signal->theData[2]; ApiConnectRecord * const regApiPtr = &localApiConnectRecord[Tdata1]; - compare_transid1 = regApiPtr->transid[0] ^ Tdata2; - compare_transid2 = regApiPtr->transid[1] ^ Tdata3; apiConnectptr.p = regApiPtr; - compare_transid1 = compare_transid1 | compare_transid2; - if (compare_transid1 != 0) { + if (compare_transid(regApiPtr->transid, signal->theData+1) == false) + { DEBUG("Drop ATTRINFO, wrong transid, lenght="<theData[1]<<", "<theData[2]); TCKEY_abort(signal, 19); return; }//if @@ -5456,11 +5458,32 @@ void Dbtc::execTC_COMMITREQ(Signal* signal) } }//Dbtc::execTC_COMMITREQ() +/** + * TCROLLBACKREQ + * + * Format is: + * + * thedata[0] = apiconnectptr + * thedata[1] = transid[0] + * thedata[2] = transid[1] + * OPTIONAL thedata[3] = flags + * + * Flags: + * 0x1 = potentiallyBad data from API (try not to assert) + */ void Dbtc::execTCROLLBACKREQ(Signal* signal) { + bool potentiallyBad= false; UintR compare_transid1, compare_transid2; jamEntry(); + + if(unlikely((signal->getLength() >= 4) && (signal->theData[3] & 0x1))) + { + ndbout_c("Trying to roll back potentially bad txn\n"); + potentiallyBad= true; + } + apiConnectptr.i = signal->theData[0]; if (apiConnectptr.i >= capiConnectFilesize) { goto TC_ROLL_warning; @@ -5547,12 +5570,14 @@ void Dbtc::execTCROLLBACKREQ(Signal* signal) TC_ROLL_warning: jam(); - warningHandlerLab(signal, __LINE__); + if(likely(potentiallyBad==false)) + warningHandlerLab(signal, __LINE__); return; TC_ROLL_system_error: jam(); - systemErrorLab(signal, __LINE__); + if(likely(potentiallyBad==false)) + systemErrorLab(signal, __LINE__); return; }//Dbtc::execTCROLLBACKREQ() @@ -11559,6 +11584,7 @@ void Dbtc::execTCINDXREQ(Signal* signal) // This is a newly started transaction, clean-up releaseAllSeizedIndexOperations(regApiPtr); + regApiPtr->apiConnectstate = CS_STARTED; regApiPtr->transid[0] = tcIndxReq->transId1; regApiPtr->transid[1] = tcIndxReq->transId2; }//if @@ -11599,20 +11625,29 @@ void Dbtc::execTCINDXREQ(Signal* signal) Uint32 includedIndexLength = MIN(indexLength, indexBufSize); indexOp->expectedAttrInfo = attrLength; Uint32 includedAttrLength = MIN(attrLength, attrBufSize); - if (saveINDXKEYINFO(signal, - indexOp, - dataPtr, - includedIndexLength)) { + + int ret; + if ((ret = saveINDXKEYINFO(signal, + indexOp, + dataPtr, + includedIndexLength)) == 0) + { jam(); // We have received all we need readIndexTable(signal, regApiPtr, indexOp); return; } + else if (ret == -1) + { + jam(); + return; + } + dataPtr += includedIndexLength; if (saveINDXATTRINFO(signal, indexOp, dataPtr, - includedAttrLength)) { + includedAttrLength) == 0) { jam(); // We have received all we need readIndexTable(signal, regApiPtr, indexOp); @@ -11715,13 +11750,25 @@ void Dbtc::execINDXKEYINFO(Signal* signal) TcIndexOperationPtr indexOpPtr; TcIndexOperation* indexOp; + if (compare_transid(regApiPtr->transid, indxKeyInfo->transId) == false) + { + TCKEY_abort(signal, 19); + return; + } + + if (regApiPtr->apiConnectstate == CS_ABORTING) + { + jam(); + return; + } + if((indexOpPtr.i = regApiPtr->accumulatingIndexOp) != RNIL) { indexOp = c_theIndexOperationPool.getPtr(indexOpPtr.i); if (saveINDXKEYINFO(signal, indexOp, src, - keyInfoLength)) { + keyInfoLength) == 0) { jam(); // We have received all we need readIndexTable(signal, regApiPtr, indexOp); @@ -11748,17 +11795,31 @@ void Dbtc::execINDXATTRINFO(Signal* signal) TcIndexOperationPtr indexOpPtr; TcIndexOperation* indexOp; + if (compare_transid(regApiPtr->transid, indxAttrInfo->transId) == false) + { + TCKEY_abort(signal, 19); + return; + } + + if (regApiPtr->apiConnectstate == CS_ABORTING) + { + jam(); + return; + } + if((indexOpPtr.i = regApiPtr->accumulatingIndexOp) != RNIL) { indexOp = c_theIndexOperationPool.getPtr(indexOpPtr.i); if (saveINDXATTRINFO(signal, indexOp, src, - attrInfoLength)) { + attrInfoLength) == 0) { jam(); // We have received all we need readIndexTable(signal, regApiPtr, indexOp); + return; } + return; } } @@ -11766,12 +11827,13 @@ void Dbtc::execINDXATTRINFO(Signal* signal) * Save signal INDXKEYINFO * Return true if we have received all needed data */ -bool Dbtc::saveINDXKEYINFO(Signal* signal, - TcIndexOperation* indexOp, - const Uint32 *src, - Uint32 len) +int +Dbtc::saveINDXKEYINFO(Signal* signal, + TcIndexOperation* indexOp, + const Uint32 *src, + Uint32 len) { - if (!indexOp->keyInfo.append(src, len)) { + if (ERROR_INSERTED(8039) || !indexOp->keyInfo.append(src, len)) { jam(); // Failed to seize keyInfo, abort transaction #ifdef VM_TRACE @@ -11781,15 +11843,17 @@ bool Dbtc::saveINDXKEYINFO(Signal* signal, apiConnectptr.i = indexOp->connectionIndex; ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); releaseIndexOperation(apiConnectptr.p, indexOp); - terrorCode = 4000; + terrorCode = 289; + if(TcKeyReq::getExecuteFlag(indexOp->tcIndxReq.requestInfo)) + apiConnectptr.p->m_exec_flag= 1; abortErrorLab(signal); - return false; + return -1; } if (receivedAllINDXKEYINFO(indexOp) && receivedAllINDXATTRINFO(indexOp)) { jam(); - return true; + return 0; } - return false; + return 1; } bool Dbtc::receivedAllINDXKEYINFO(TcIndexOperation* indexOp) @@ -11801,12 +11865,13 @@ bool Dbtc::receivedAllINDXKEYINFO(TcIndexOperation* indexOp) * Save signal INDXATTRINFO * Return true if we have received all needed data */ -bool Dbtc::saveINDXATTRINFO(Signal* signal, - TcIndexOperation* indexOp, - const Uint32 *src, - Uint32 len) +int +Dbtc::saveINDXATTRINFO(Signal* signal, + TcIndexOperation* indexOp, + const Uint32 *src, + Uint32 len) { - if (!indexOp->attrInfo.append(src, len)) { + if (ERROR_INSERTED(8051) || !indexOp->attrInfo.append(src, len)) { jam(); #ifdef VM_TRACE ndbout_c("Dbtc::saveINDXATTRINFO: Failed to seize attrInfo\n"); @@ -11814,15 +11879,17 @@ bool Dbtc::saveINDXATTRINFO(Signal* signal, apiConnectptr.i = indexOp->connectionIndex; ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord); releaseIndexOperation(apiConnectptr.p, indexOp); - terrorCode = 4000; + terrorCode = 289; + if(TcKeyReq::getExecuteFlag(indexOp->tcIndxReq.requestInfo)) + apiConnectptr.p->m_exec_flag= 1; abortErrorLab(signal); - return false; + return -1; } if (receivedAllINDXKEYINFO(indexOp) && receivedAllINDXATTRINFO(indexOp)) { jam(); - return true; + return 0; } - return false; + return 1; } bool Dbtc::receivedAllINDXATTRINFO(TcIndexOperation* indexOp) @@ -12006,6 +12073,9 @@ void Dbtc::execTCKEYREF(Signal* signal) tcIndxRef->transId[0] = tcKeyRef->transId[0]; tcIndxRef->transId[1] = tcKeyRef->transId[1]; tcIndxRef->errorCode = tcKeyRef->errorCode; + + releaseIndexOperation(regApiPtr, indexOp); + sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, TcKeyRef::SignalLength, JBB); return; @@ -12538,7 +12608,18 @@ void Dbtc::executeIndexOperation(Signal* signal, bool Dbtc::seizeIndexOperation(ApiConnectRecord* regApiPtr, TcIndexOperationPtr& indexOpPtr) { - return regApiPtr->theSeizedIndexOperations.seize(indexOpPtr); + if (regApiPtr->theSeizedIndexOperations.seize(indexOpPtr)) + { + ndbassert(indexOpPtr.p->expectedKeyInfo == 0); + ndbassert(indexOpPtr.p->keyInfo.getSize() == 0); + ndbassert(indexOpPtr.p->expectedAttrInfo == 0); + ndbassert(indexOpPtr.p->attrInfo.getSize() == 0); + ndbassert(indexOpPtr.p->expectedTransIdAI == 0); + ndbassert(indexOpPtr.p->transIdAI.getSize() == 0); + return true; + } + + return false; } void Dbtc::releaseIndexOperation(ApiConnectRecord* regApiPtr, diff --git a/ndb/src/ndbapi/NdbTransaction.cpp b/ndb/src/ndbapi/NdbTransaction.cpp index f5076ff2020..1ebc5b7ef24 100644 --- a/ndb/src/ndbapi/NdbTransaction.cpp +++ b/ndb/src/ndbapi/NdbTransaction.cpp @@ -481,12 +481,27 @@ NdbTransaction::executeNoBlobs(ExecType aTypeOfExec, while (1) { int noOfComp = tNdb->sendPollNdb(3 * timeout, 1, forceSend); if (noOfComp == 0) { - /** - * This timeout situation can occur if NDB crashes. + /* + * Just for fun, this is only one of two places where + * we could hit this error... It's quite possible we + * hit it in Ndbif.cpp in Ndb::check_send_timeout() + * + * We behave rather similarly in both places. + * Hitting this is certainly a bug though... */ - ndbout << "This timeout should never occur, execute(..)" << endl; - theError.code = 4012; - setOperationErrorCodeAbort(4012); // Error code for "Cluster Failure" + g_eventLogger.error("WARNING: Timeout in executeNoBlobs() waiting for " + "response from NDB data nodes. This should NEVER " + "occur. You have likely hit a NDB Bug. Please " + "file a bug."); + DBUG_PRINT("error",("This timeout should never occure, execute()")); + g_eventLogger.error("Forcibly trying to rollback txn (%p" + ") to try to clean up data node resources.", + this); + executeNoBlobs(NdbTransaction::Rollback); + theError.code = 4012; + theError.status= NdbError::PermanentError; + theError.classification= NdbError::TimeoutExpired; + setOperationErrorCodeAbort(4012); // ndbd timeout DBUG_RETURN(-1); }//if @@ -550,7 +565,12 @@ NdbTransaction::executeAsynchPrepare( ExecType aTypeOfExec, */ if (theError.code != 0) DBUG_PRINT("enter", ("Resetting error %d on execute", theError.code)); - theError.code = 0; + /** + * for timeout (4012) we want sendROLLBACK to behave differently. + * Else, normal behaviour of reset errcode + */ + if (theError.code != 4012) + theError.code = 0; NdbScanOperation* tcOp = m_theFirstScanOperation; if (tcOp != 0){ // Execute any cursor operations @@ -873,6 +893,12 @@ NdbTransaction::sendROLLBACK() // Send a TCROLLBACKREQ signal; tSignal.setData(theTCConPtr, 1); tSignal.setData(tTransId1, 2); tSignal.setData(tTransId2, 3); + if(theError.code == 4012) + { + g_eventLogger.error("Sending TCROLLBACKREQ with Bad flag"); + tSignal.setLength(tSignal.getLength() + 1); // + flags + tSignal.setData(0x1, 4); // potentially bad data + } tReturnCode = tp->sendSignal(&tSignal,theDBnode); if (tReturnCode != -1) { theSendStatus = sendTC_ROLLBACK; diff --git a/ndb/src/ndbapi/ndberror.c b/ndb/src/ndbapi/ndberror.c index 328b0688857..24ccb1d07c2 100644 --- a/ndb/src/ndbapi/ndberror.c +++ b/ndb/src/ndbapi/ndberror.c @@ -173,6 +173,8 @@ ErrorBundle ErrorCodes[] = { { 4022, TR, "Out of Send Buffer space in NDB API" }, { 4032, TR, "Out of Send Buffer space in NDB API" }, { 288, TR, "Out of index operations in transaction coordinator (increase MaxNoOfConcurrentIndexOperations)" }, + { 289, TR, "Out of transaction buffer memory in TC (increase TransactionBufferMemory)" }, + /** * InsufficientSpace */ diff --git a/ndb/test/ndbapi/testIndex.cpp b/ndb/test/ndbapi/testIndex.cpp index 78672cd519f..f715db1ef8c 100644 --- a/ndb/test/ndbapi/testIndex.cpp +++ b/ndb/test/ndbapi/testIndex.cpp @@ -1297,6 +1297,102 @@ runBug25059(NDBT_Context* ctx, NDBT_Step* step) return res; } +int tcSaveINDX_test(NDBT_Context* ctx, NDBT_Step* step, int inject_err) +{ + int result= NDBT_OK; + Ndb* pNdb = GETNDB(step); + NdbDictionary::Dictionary * dict = pNdb->getDictionary(); + const NdbDictionary::Index * idx = dict->getIndex(pkIdxName, *ctx->getTab()); + + HugoOperations ops(*ctx->getTab(), idx); + + g_err << "Using INDEX: " << pkIdxName << endl; + + NdbRestarter restarter; + + int loops = ctx->getNumLoops(); + const int rows = ctx->getNumRecords(); + const int batchsize = ctx->getProperty("BatchSize", 1); + + for(int bs=1; bs < loops; bs++) + { + int c= 0; + while (c++ < loops) + { + g_err << "BS " << bs << " LOOP #" << c << endl; + + g_err << "inserting error on op#" << c << endl; + + CHECK(ops.startTransaction(pNdb) == 0); + for(int i=1;i<=c;i++) + { + if(i==c) + { + if(restarter.insertErrorInAllNodes(inject_err)!=0) + { + g_err << "**** FAILED to insert error" << endl; + result= NDBT_FAILED; + break; + } + } + CHECK(ops.indexReadRecords(pNdb, pkIdxName, i,false,1) == 0); + if(i%bs==0 || i==c) + { + if(istatus= STATUS_NOT_FOUND; - DBUG_RETURN(ndb_err(trans)); + int err= ndb_err(trans); + if(err==HA_ERR_KEY_NOT_FOUND) + table->status= STATUS_NOT_FOUND; + else + table->status= STATUS_GARBAGE; + + DBUG_RETURN(err); } + // The value have now been fetched from NDB unpack_record(buf); table->status= 0; From c1b89b85ce24583d2bd9d48b3a951b956bb2a368 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 13 Aug 2007 11:36:30 +0200 Subject: [PATCH 09/41] bug#30337 DELETE ... WHERE PK IN (..) and AFTER DELETE trigger crashes API node: Disable multi_read_range if there are after delete/update triggers --- sql/ha_ndbcluster.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc index 03b6bcf3242..c7ad51596cf 100644 --- a/sql/ha_ndbcluster.cc +++ b/sql/ha_ndbcluster.cc @@ -6464,7 +6464,8 @@ ha_ndbcluster::read_multi_range_first(KEY_MULTI_RANGE **found_range_p, if (uses_blob_value(m_retrieve_all_fields) || (cur_index_type == UNIQUE_INDEX && has_null_in_unique_index(active_index) && - null_value_index_search(ranges, ranges+range_count, buffer))) + null_value_index_search(ranges, ranges+range_count, buffer)) + || m_delete_cannot_batch || m_update_cannot_batch) { m_disable_multi_read= TRUE; DBUG_RETURN(handler::read_multi_range_first(found_range_p, From a40202e6965d8c508defa223e6f1a13fd39051d4 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 13 Aug 2007 15:59:08 +0200 Subject: [PATCH 10/41] bug#30337 DELETE ... WHERE PK IN (..) and AFTER DELETE trigger crashes API node: Added testcase --- mysql-test/r/ndb_read_multi_range.result | 19 +++++++++++++++++++ mysql-test/t/ndb_read_multi_range.test | 22 ++++++++++++++++++++++ 2 files changed, 41 insertions(+) diff --git a/mysql-test/r/ndb_read_multi_range.result b/mysql-test/r/ndb_read_multi_range.result index 64a6749bed1..d18f4c1e65a 100644 --- a/mysql-test/r/ndb_read_multi_range.result +++ b/mysql-test/r/ndb_read_multi_range.result @@ -405,3 +405,22 @@ a b 1 1 10 10 drop table t2; +create table t1 (id int primary key) engine ndb; +insert into t1 values (1), (2), (3); +create table t2 (id int primary key) engine ndb; +insert into t2 select id from t1; +create trigger kaboom after delete on t1 +for each row begin +delete from t2 where id=old.id; +end| +select * from t1 order by id; +id +1 +2 +3 +delete from t1 where id in (1,2); +select * from t2 order by id; +id +3 +drop trigger kaboom; +drop table t1; diff --git a/mysql-test/t/ndb_read_multi_range.test b/mysql-test/t/ndb_read_multi_range.test index e1f1dfc1150..1d1d5f26552 100644 --- a/mysql-test/t/ndb_read_multi_range.test +++ b/mysql-test/t/ndb_read_multi_range.test @@ -291,3 +291,25 @@ insert into t2 values (1,1), (10,10); select * from t2 use index (ab) where a in(1,10) order by a; drop table t2; + +#bug#30337 + +create table t1 (id int primary key) engine ndb; +insert into t1 values (1), (2), (3); + +create table t2 (id int primary key) engine ndb; +insert into t2 select id from t1; + +delimiter |; +create trigger kaboom after delete on t1 +for each row begin + delete from t2 where id=old.id; +end| +delimiter ;| + +select * from t1 order by id; +delete from t1 where id in (1,2); +select * from t2 order by id; + +drop trigger kaboom; +drop table t1; From 6656d39c7216cc07b457f090d5432168e668582d Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 14 Aug 2007 15:07:17 +1000 Subject: [PATCH 11/41] Backport Magnus' fix from 5.1 ChangeSet@1.2575, 2007-08-07 19:16:06+02:00, msvensson@pilot.(none) +2 -0 Bug#26793 mysqld crashes when doing specific query on information_schema - Drop the newly created user user1@localhost - Cleanup testcase mysql-test/r/ndb_bug26793.result: mysql-test/r/ndb_bug26793.result@1.3, 2007-08-07 19:16:04+02:00, msvensson@pilot.(none) +1 -6 Update test result mysql-test/t/ndb_bug26793.test: mysql-test/t/ndb_bug26793.test@1.3, 2007-08-07 19:16:04+02:00, msvensson@pilot.(none) +8 -11 - Remove the drop/restore of anonymous users - there are no such users by default anymore(if there were, they would probably be in mysql.user) - Switch back to default connection before cleanup - Drop user1@localhost as part of cleanup --- mysql-test/r/ndb_bug26793.result | 7 +------ mysql-test/t/ndb_bug26793.test | 21 +++++++++------------ 2 files changed, 10 insertions(+), 18 deletions(-) diff --git a/mysql-test/r/ndb_bug26793.result b/mysql-test/r/ndb_bug26793.result index 31f9763dd6b..a9a8a798546 100644 --- a/mysql-test/r/ndb_bug26793.result +++ b/mysql-test/r/ndb_bug26793.result @@ -3,11 +3,6 @@ CREATE TABLE `test` ( `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , `t` VARCHAR( 10 ) NOT NULL ) ENGINE = ndbcluster; -create table test.db_temp as select * from mysql.db where user=''; -delete from mysql.db where user=''; -flush privileges; GRANT USAGE ON *.* TO user1@localhost IDENTIFIED BY 'pass'; DROP TABLE `test`.`test`; -insert into mysql.db select * from test.db_temp; -drop table db_temp; -flush privileges; +drop user user1@localhost; diff --git a/mysql-test/t/ndb_bug26793.test b/mysql-test/t/ndb_bug26793.test index 4f5a78fdca4..f35d8808c1a 100644 --- a/mysql-test/t/ndb_bug26793.test +++ b/mysql-test/t/ndb_bug26793.test @@ -9,15 +9,12 @@ CREATE TABLE `test` ( `t` VARCHAR( 10 ) NOT NULL ) ENGINE = ndbcluster; -create table test.db_temp as select * from mysql.db where user=''; -delete from mysql.db where user=''; - -flush privileges; - +# Add user1@localhost with a specific password +# and connect as that user GRANT USAGE ON *.* TO user1@localhost IDENTIFIED BY 'pass'; - connect (user1,localhost,user1,pass,*NO-ONE*); +# Run the query 100 times disable_query_log; disable_result_log; let $i= 100; @@ -29,10 +26,10 @@ dec $i; enable_query_log; enable_result_log; -connect (root,localhost,root,,test); -connection root; -DROP TABLE `test`.`test`; -insert into mysql.db select * from test.db_temp; -drop table db_temp; -flush privileges; +disconnect user1; + +# Switch back to the default connection and cleanup +connection default; +DROP TABLE `test`.`test`; +drop user user1@localhost; From bc6e536db372bb057aa758b2cc437b02f4004856 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 15 Aug 2007 18:10:16 -0600 Subject: [PATCH 12/41] Bug#23062 (GCOV build: helper scripts missing in the BUILD directory) This patch provides compile helper scripts only, no server logic is affected. Before this patch, GCOV and GPROF build scripts were only provided for pentium platforms. With this patch, pentium, pentium64 and amd64 platforms have associated helper build scripts. The GCOV and GPROF specific compilation flags are set once in SETUP.sh, to avoid code duplication. BUILD/SETUP.sh: Moved GCOV and GPROF flags to compile-pentium-{gcov,gprof) to SETUP.sh BUILD/compile-pentium-gcov: Moved GCOV and GPROF flags to compile-pentium-{gcov,gprof) to SETUP.sh BUILD/compile-pentium-gprof: Moved GCOV and GPROF flags to compile-pentium-{gcov,gprof) to SETUP.sh BUILD/compile-amd64-gcov: Added helper scripts for GCOV and GPROF builds. BUILD/compile-amd64-gprof: Added helper scripts for GCOV and GPROF builds. BUILD/compile-pentium64-gcov: Added helper scripts for GCOV and GPROF builds. BUILD/compile-pentium64-gprof: Added helper scripts for GCOV and GPROF builds. --- BUILD/SETUP.sh | 25 +++++++++++++++++++++++++ BUILD/compile-amd64-gcov | 17 +++++++++++++++++ BUILD/compile-amd64-gprof | 9 +++++++++ BUILD/compile-pentium-gcov | 13 +++---------- BUILD/compile-pentium-gprof | 4 ++-- BUILD/compile-pentium64-gcov | 17 +++++++++++++++++ BUILD/compile-pentium64-gprof | 9 +++++++++ 7 files changed, 82 insertions(+), 12 deletions(-) create mode 100755 BUILD/compile-amd64-gcov create mode 100755 BUILD/compile-amd64-gprof create mode 100755 BUILD/compile-pentium64-gcov create mode 100755 BUILD/compile-pentium64-gprof diff --git a/BUILD/SETUP.sh b/BUILD/SETUP.sh index 10324c22e56..a8efaf75db4 100755 --- a/BUILD/SETUP.sh +++ b/BUILD/SETUP.sh @@ -138,3 +138,28 @@ then echo "$CC" | grep "ccache" > /dev/null || CC="ccache $CC" echo "$CXX" | grep "ccache" > /dev/null || CXX="ccache $CXX" fi + +# gcov + +# The -fprofile-arcs and -ftest-coverage options cause GCC to instrument the +# code with profiling information used by gcov. +# The -DDISABLE_TAO_ASM is needed to avoid build failures in Yassl. +# The -DHAVE_gcov enables code to write out coverage info even when crashing. + +gcov_compile_flags="-fprofile-arcs -ftest-coverage" +gcov_compile_flags="$gcov_compile_flags -DDISABLE_TAO_ASM" +gcov_compile_flags="$gcov_compile_flags -DMYSQL_SERVER_SUFFIX=-gcov -DHAVE_gcov" + +# GCC4 needs -fprofile-arcs -ftest-coverage on the linker command line (as well +# as on the compiler command line), and this requires setting LDFLAGS for BDB. + +gcov_link_flags="-fprofile-arcs -ftest-coverage" + +gcov_configs="--disable-shared $static_link" + +# gprof + +gprof_compile_flags="-O2 -pg -g" + +gprof_link_flags="--disable-shared $static_link" + diff --git a/BUILD/compile-amd64-gcov b/BUILD/compile-amd64-gcov new file mode 100755 index 00000000000..239a4aed0fb --- /dev/null +++ b/BUILD/compile-amd64-gcov @@ -0,0 +1,17 @@ +#! /bin/sh + +path=`dirname $0` +. "$path/SETUP.sh" + +# Need to disable ccache, or we loose the gcov-needed compiler output files. +CCACHE_DISABLE=1 +export CCACHE_DISABLE + +export LDFLAGS="$gcov_link_flags" + +extra_flags="$amd64_cflags $debug_cflags $max_cflags $gcov_compile_flags" +c_warnings="$c_warnings $debug_extra_warnings" +cxx_warnings="$cxx_warnings $debug_extra_warnings" +extra_configs="$amd64_configs $debug_configs $gcov_configs $max_configs" + +. "$path/FINISH.sh" diff --git a/BUILD/compile-amd64-gprof b/BUILD/compile-amd64-gprof new file mode 100755 index 00000000000..6cfb8a4302c --- /dev/null +++ b/BUILD/compile-amd64-gprof @@ -0,0 +1,9 @@ +#! /bin/sh + +path=`dirname $0` +. "$path/SETUP.sh" + +extra_flags="$amd64_cflags $gprof_compile_flags" +extra_configs="$amd64_configs $debug_configs $gprof_link_flags" + +. "$path/FINISH.sh" diff --git a/BUILD/compile-pentium-gcov b/BUILD/compile-pentium-gcov index 0d561d5b147..d4878dc591e 100755 --- a/BUILD/compile-pentium-gcov +++ b/BUILD/compile-pentium-gcov @@ -7,18 +7,11 @@ path=`dirname $0` CCACHE_DISABLE=1 export CCACHE_DISABLE -# GCC4 needs -fprofile-arcs -ftest-coverage on the linker command line (as well -# as on the compiler command line), and this requires setting LDFLAGS for BDB. -export LDFLAGS="-fprofile-arcs -ftest-coverage" +export LDFLAGS="$gcov_link_flags" -# The -fprofile-arcs and -ftest-coverage options cause GCC to instrument the -# code with profiling information used by gcov. -# The -DDISABLE_TAO_ASM is needed to avoid build failures in Yassl. -# The -DHAVE_gcov enables code to write out coverage info even when crashing. -extra_flags="$pentium_cflags -fprofile-arcs -ftest-coverage -DDISABLE_TAO_ASM $debug_cflags $max_cflags -DMYSQL_SERVER_SUFFIX=-gcov -DHAVE_gcov" +extra_flags="$pentium_cflags $debug_cflags $max_cflags $gcov_compile_flags" c_warnings="$c_warnings $debug_extra_warnings" cxx_warnings="$cxx_warnings $debug_extra_warnings" -extra_configs="$pentium_configs $debug_configs --disable-shared $static_link" -extra_configs="$extra_configs $max_configs" +extra_configs="$pentium_configs $debug_configs $gcov_configs $max_configs" . "$path/FINISH.sh" diff --git a/BUILD/compile-pentium-gprof b/BUILD/compile-pentium-gprof index aa74de0b1b2..4aebc1d2e02 100755 --- a/BUILD/compile-pentium-gprof +++ b/BUILD/compile-pentium-gprof @@ -3,7 +3,7 @@ path=`dirname $0` . "$path/SETUP.sh" -extra_flags="$pentium_cflags -O2 -pg -g" -extra_configs="$pentium_configs $debug_configs --disable-shared $static_link" +extra_flags="$pentium_cflags $gprof_compile_flags" +extra_configs="$pentium_configs $debug_configs $gprof_link_flags" . "$path/FINISH.sh" diff --git a/BUILD/compile-pentium64-gcov b/BUILD/compile-pentium64-gcov new file mode 100755 index 00000000000..5a99b7f8796 --- /dev/null +++ b/BUILD/compile-pentium64-gcov @@ -0,0 +1,17 @@ +#! /bin/sh + +path=`dirname $0` +. "$path/SETUP.sh" + +# Need to disable ccache, or we loose the gcov-needed compiler output files. +CCACHE_DISABLE=1 +export CCACHE_DISABLE + +export LDFLAGS="$gcov_link_flags" + +extra_flags="$pentium64_cflags $debug_cflags $max_cflags $gcov_compile_flags" +c_warnings="$c_warnings $debug_extra_warnings" +cxx_warnings="$cxx_warnings $debug_extra_warnings" +extra_configs="$pentium64_configs $debug_configs $gcov_configs $max_configs" + +. "$path/FINISH.sh" diff --git a/BUILD/compile-pentium64-gprof b/BUILD/compile-pentium64-gprof new file mode 100755 index 00000000000..f64dee6d196 --- /dev/null +++ b/BUILD/compile-pentium64-gprof @@ -0,0 +1,9 @@ +#! /bin/sh + +path=`dirname $0` +. "$path/SETUP.sh" + +extra_flags="$pentium64_cflags $gprof_compile_flags" +extra_configs="$pentium64_configs $debug_configs $gprof_link_flags" + +. "$path/FINISH.sh" From d280a06e36b04d245ad26126c5f0466d21726146 Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 17 Aug 2007 18:30:41 +0400 Subject: [PATCH 13/41] Bug#30245: A wrong type of a BIT field is reported when grouped by it. HEAP tables can't index BIT fields. Due to this when grouping by such fields is needed they are converted to a fields of the LONG type when temporary table is being created. But a side effect of this is that a wrong type of BIT fields is returned to a client. Now the JOIN::prepare and the create_distinct_group functions are create additional hidden copy of BIT fields to preserve original fields untouched. New hidden fields are used for grouping instead. mysql-test/t/type_bit.test: Added a test case for the bug#30245: A wrong type of a BIT field is reported when grouped by it. mysql-test/r/type_bit.result: Added a test case for the bug#30245: A wrong type of a BIT field is reported when grouped by it. sql/sql_select.cc: Bug#30245: A wrong type of a BIT field is reported when grouped by it. Now the JOIN::prepare and the create_distinct_group functions are create additional hidden copy of BIT fields to preserve original fields untouched. New hidden fields are used for grouping instead. --- mysql-test/r/type_bit.result | 15 +++++++++ mysql-test/t/type_bit.test | 13 ++++++++ sql/sql_select.cc | 62 ++++++++++++++++++++++++++++++------ 3 files changed, 81 insertions(+), 9 deletions(-) diff --git a/mysql-test/r/type_bit.result b/mysql-test/r/type_bit.result index 7c765d6d50b..5356f7e0712 100644 --- a/mysql-test/r/type_bit.result +++ b/mysql-test/r/type_bit.result @@ -642,4 +642,19 @@ b+0 COUNT(DISTINCT a) 1 1 3 2 DROP TABLE t1; +CREATE TABLE t1 (b BIT); +INSERT INTO t1 (b) VALUES (1), (0); +SELECT DISTINCT b FROM t1; +Catalog Database Table Table_alias Column Column_alias Type Length Max length Is_null Flags Decimals Charsetnr +def test t1 t1 b b 16 1 1 Y 32 0 63 +b +# +# +SELECT b FROM t1 GROUP BY b; +Catalog Database Table Table_alias Column Column_alias Type Length Max length Is_null Flags Decimals Charsetnr +def test t1 t1 b b 16 1 1 Y 32 0 63 +b +# +# +DROP TABLE t1; End of 5.0 tests diff --git a/mysql-test/t/type_bit.test b/mysql-test/t/type_bit.test index 6423d017afb..66538f59c6f 100644 --- a/mysql-test/t/type_bit.test +++ b/mysql-test/t/type_bit.test @@ -291,4 +291,17 @@ INSERT INTO t1 (b, a) VALUES (1, 1), (3, 2), (0, 3), (3, 4); SELECT b+0, COUNT(DISTINCT a) FROM t1 GROUP BY b; DROP TABLE t1; +# +# Bug#30245: A wrong type of a BIT field is reported when grouped by it. +# +CREATE TABLE t1 (b BIT); +INSERT INTO t1 (b) VALUES (1), (0); +--enable_metadata +--replace_column 1 # +SELECT DISTINCT b FROM t1; +--replace_column 1 # +SELECT b FROM t1 GROUP BY b; +--disable_metadata +DROP TABLE t1; + --echo End of 5.0 tests diff --git a/sql/sql_select.cc b/sql/sql_select.cc index ac8dc84f118..84c09707fb6 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -189,6 +189,7 @@ static bool setup_new_fields(THD *thd, List &fields, List &all_fields, ORDER *new_order); static ORDER *create_distinct_group(THD *thd, Item **ref_pointer_array, ORDER *order, List &fields, + List &all_fields, bool *all_order_by_fields_used); static bool test_if_subpart(ORDER *a,ORDER *b); static TABLE *get_sort_by_table(ORDER *a,ORDER *b,TABLE_LIST *tables); @@ -537,6 +538,28 @@ JOIN::prepare(Item ***rref_pointer_array, fix_inner_refs(thd, all_fields, select_lex, ref_pointer_array)) DBUG_RETURN(-1); + if (group) + { + /* + Because HEAP tables can't index BIT fields we need to use an + additional hidden field for grouping because later it will be + converted to a LONG field. Original field will remain of the + BIT type and will be returned to a client. + */ + for (ORDER *ord= group_list; ord; ord= ord->next) + { + if ((*ord->item)->type() == Item::FIELD_ITEM && + (*ord->item)->field_type() == MYSQL_TYPE_BIT) + { + Item_field *field= new Item_field(thd, *(Item_field**)ord->item); + int el= all_fields.elements; + ref_pointer_array[el]= field; + all_fields.push_front(field); + ord->item= ref_pointer_array + el; + } + } + } + if (setup_ftfuncs(select_lex)) /* should be after having->fix_fields */ DBUG_RETURN(-1); @@ -1068,12 +1091,13 @@ JOIN::optimize() if (order) skip_sort_order= test_if_skip_sort_order(tab, order, select_limit, 1); if ((group_list=create_distinct_group(thd, select_lex->ref_pointer_array, - order, fields_list, + order, fields_list, all_fields, &all_order_fields_used))) { bool skip_group= (skip_sort_order && test_if_skip_sort_order(tab, group_list, select_limit, 1) != 0); + count_field_types(select_lex, &tmp_table_param, all_fields, 0); if ((skip_group && all_order_fields_used) || select_limit == HA_POS_ERROR || (order && !skip_sort_order)) @@ -13646,11 +13670,12 @@ setup_new_fields(THD *thd, List &fields, static ORDER * create_distinct_group(THD *thd, Item **ref_pointer_array, - ORDER *order_list, List &fields, + ORDER *order_list, List &fields, + List &all_fields, bool *all_order_by_fields_used) { List_iterator li(fields); - Item *item; + Item *item, **orig_ref_pointer_array= ref_pointer_array; ORDER *order,*group,**prev; *all_order_by_fields_used= 1; @@ -13690,12 +13715,31 @@ create_distinct_group(THD *thd, Item **ref_pointer_array, ORDER *ord=(ORDER*) thd->calloc(sizeof(ORDER)); if (!ord) return 0; - /* - We have here only field_list (not all_field_list), so we can use - simple indexing of ref_pointer_array (order in the array and in the - list are same) - */ - ord->item= ref_pointer_array; + + if (item->type() == Item::FIELD_ITEM && + item->field_type() == MYSQL_TYPE_BIT) + { + /* + Because HEAP tables can't index BIT fields we need to use an + additional hidden field for grouping because later it will be + converted to a LONG field. Original field will remain of the + BIT type and will be returned to a client. + */ + Item_field *new_item= new Item_field(thd, (Item_field*)item); + int el= all_fields.elements; + orig_ref_pointer_array[el]= new_item; + all_fields.push_front(new_item); + ord->item= orig_ref_pointer_array + el; + } + else + { + /* + We have here only field_list (not all_field_list), so we can use + simple indexing of ref_pointer_array (order in the array and in the + list are same) + */ + ord->item= ref_pointer_array; + } ord->asc=1; *prev=ord; prev= &ord->next; From 073f9508084542b48efc8f808a1d98f15ad4701b Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 20 Aug 2007 10:47:09 +0000 Subject: [PATCH 14/41] BUG#29674 add install data of the new test case in makefile.am mysql-test/Makefile.am: Add install info of new test case data in makefile.am --- mysql-test/Makefile.am | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/mysql-test/Makefile.am b/mysql-test/Makefile.am index 6c7207b0b2d..c9d4a5acead 100644 --- a/mysql-test/Makefile.am +++ b/mysql-test/Makefile.am @@ -48,7 +48,9 @@ INCLUDES = -I$(top_builddir)/include -I$(top_srcdir)/include -I.. dist-hook: mkdir -p $(distdir)/t $(distdir)/r $(distdir)/include \ - $(distdir)/std_data $(distdir)/lib + $(distdir)/std_data \ + $(distdir)/std_data/ndb_backup50_data_be $(distdir)/std_data/ndb_backup50_data_le \ + $(distdir)/lib -$(INSTALL_DATA) $(srcdir)/t/*.def $(distdir)/t $(INSTALL_DATA) $(srcdir)/t/*.test $(distdir)/t -$(INSTALL_DATA) $(srcdir)/t/*.imtest $(distdir)/t @@ -66,6 +68,8 @@ dist-hook: $(INSTALL_DATA) $(srcdir)/std_data/*.frm $(distdir)/std_data $(INSTALL_DATA) $(srcdir)/std_data/*.MY* $(distdir)/std_data $(INSTALL_DATA) $(srcdir)/std_data/*.cnf $(distdir)/std_data + $(INSTALL_DATA) $(srcdir)/std_data/ndb_backup50_data_be/BACKUP* $(distdir)/std_data/ndb_backup50_data_be + $(INSTALL_DATA) $(srcdir)/std_data/ndb_backup50_data_le/BACKUP* $(distdir)/std_data/ndb_backup50_data_le $(INSTALL_DATA) $(srcdir)/lib/*.pl $(distdir)/lib -rm -rf `find $(distdir)/suite -type d -name SCCS` @@ -75,6 +79,8 @@ install-data-local: $(DESTDIR)$(testdir)/r \ $(DESTDIR)$(testdir)/include \ $(DESTDIR)$(testdir)/std_data \ + $(DESTDIR)$(testdir)/std_data/ndb_backup50_data_be \ + $(DESTDIR)$(testdir)/std_data/ndb_backup50_data_le \ $(DESTDIR)$(testdir)/lib $(INSTALL_DATA) $(srcdir)/README $(DESTDIR)$(testdir) -$(INSTALL_DATA) $(srcdir)/t/*.def $(DESTDIR)$(testdir)/t @@ -98,6 +104,8 @@ install-data-local: $(INSTALL_DATA) $(srcdir)/std_data/*.frm $(DESTDIR)$(testdir)/std_data $(INSTALL_DATA) $(srcdir)/std_data/*.MY* $(DESTDIR)$(testdir)/std_data $(INSTALL_DATA) $(srcdir)/std_data/*.cnf $(DESTDIR)$(testdir)/std_data + $(INSTALL_DATA) $(srcdir)/std_data/ndb_backup50_data_be/BACKUP* $(DESTDIR)$(testdir)/std_data/ndb_backup50_data_be + $(INSTALL_DATA) $(srcdir)/std_data/ndb_backup50_data_le/BACKUP* $(DESTDIR)$(testdir)/std_data/ndb_backup50_data_le $(INSTALL_DATA) $(srcdir)/lib/*.pl $(DESTDIR)$(testdir)/lib for f in `(cd $(srcdir); find suite -type f | grep -v SCCS)`; \ do \ From 1cfa76569d7800f74def8beb7cba42b5607663a3 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 20 Aug 2007 14:57:04 +0000 Subject: [PATCH 15/41] BUG#29674 Remove warning in pushbuild in 5.0 ndb/src/ndbapi/NdbDictionaryImpl.cpp: Remove warning in pushbuild --- ndb/src/ndbapi/NdbDictionaryImpl.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ndb/src/ndbapi/NdbDictionaryImpl.cpp b/ndb/src/ndbapi/NdbDictionaryImpl.cpp index 3fed04de26d..e07b53a763e 100644 --- a/ndb/src/ndbapi/NdbDictionaryImpl.cpp +++ b/ndb/src/ndbapi/NdbDictionaryImpl.cpp @@ -1385,7 +1385,7 @@ NdbDictInterface::parseTableInfo(NdbTableImpl ** ret, impl->m_replicaCount = replicaCount; impl->m_fragmentCount = fragCount; - for(i = 0; i<(fragCount*replicaCount); i++) + for(i = 0; i<(Uint32) (fragCount*replicaCount); i++) { if (impl->m_fragments.push_back(tableDesc.FragmentData[i+2])) { From fb1be0f1e595ec9208cb508a65d60464710c9b4e Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 22 Aug 2007 11:05:35 -0600 Subject: [PATCH 16/41] Bug#30237 (Performance regression in boolean expressions) This is a performance bug, related to the parsing or 'OR' and 'AND' boolean expressions. Let N be the number of expressions involved in a OR (respectively AND). When N=1 For example, "select 1" involve only 1 term: there is no OR operator. In 4.0 and 4.1, parsing expressions not involving OR had no overhead. In 5.0, parsing adds some overhead, with Select->expr_list. With this patch, the overhead introduced in 5.0 has been removed, so that performances for N=1 should be identical to the 4.0 performances, which are optimal (there is no code executed at all) The overhead in 5.0 was in fact affecting significantly some operations. For example, loading 1 Million rows into a table with INSERTs, for a table that has 100 columns, leads to parsing 100 Millions of expressions, which means that the overhead related to Select->expr_list is executed 100 Million times ... Considering that N=1 is by far the most probable expression, this case should be optimal. When N=2 For example, "select a OR b" involves 2 terms in the OR operator. In 4.0 and 4.1, parsing expressions involving 2 terms created 1 Item_cond_or node, which is the expected result. In 5.0, parsing these expression also produced 1 node, but with some extra overhead related to Select->expr_list : creating 1 list in Select->expr_list and another in Item_cond::list is inefficient. With this patch, the overhead introduced in 5.0 has been removed so that performances for N=2 should be identical to the 4.0 performances. Note that the memory allocation uses the new (thd->mem_root) syntax directly. The cost of "is_cond_or" is estimated to be neglectable: the real problem of the performance degradation comes from unneeded memory allocations. When N>=3 For example, "select a OR b OR c ...", which involves 3 or more terms. In 4.0 and 4.1, the parser had no significant cost overhead, but produced an Item tree which is difficult to evaluate / optimize during runtime. In 5.0, the parser produces a better Item tree, using the Item_cond constructor that accepts a list of children directly, but at an extra cost related to Select->expr_list. With this patch, the code is implemented to take the best of the two implementations: - there is no overhead with Select->expr_list - the Item tree generated is optimized and flattened. This is achieved by adding children nodes into the Item tree directly, with Item_cond::add(), which avoids the need for temporary lists and memory allocation Note that this patch also provide an extra optimization, that the previous code in 5.0 did not provide: expressions are flattened in the Item tree, based on what the expression already parsed is, and not based on the order in which rules are reduced. For example : "(a OR b) OR c", "a OR (b OR c)" would both be represented with 2 Item_cond_or nodes before this patch, and with 1 node only with this patch. The logic used is based on the mathematical properties of the OR operator (it's associative), and produces a simpler tree. sql/item_cmpfunc.h: Improved performances for parsing boolean expressions sql/sql_yacc.yy: Improved performances for parsing boolean expressions mysql-test/r/parser_precedence.result: Added test cases to cover boolean operator precedence mysql-test/t/parser_precedence.test: Added test cases to cover boolean operator precedence --- mysql-test/r/parser_precedence.result | 356 ++++++++++++++++++++++++++ mysql-test/t/parser_precedence.test | 93 +++++++ sql/item_cmpfunc.h | 18 ++ sql/sql_yacc.yy | 144 +++++++---- 4 files changed, 566 insertions(+), 45 deletions(-) create mode 100644 mysql-test/r/parser_precedence.result create mode 100644 mysql-test/t/parser_precedence.test diff --git a/mysql-test/r/parser_precedence.result b/mysql-test/r/parser_precedence.result new file mode 100644 index 00000000000..e2d35521ca9 --- /dev/null +++ b/mysql-test/r/parser_precedence.result @@ -0,0 +1,356 @@ +drop table if exists t1_30237_bool; +create table t1_30237_bool(A boolean, B boolean, C boolean); +insert into t1_30237_bool values +(FALSE, FALSE, FALSE), +(FALSE, FALSE, NULL), +(FALSE, FALSE, TRUE), +(FALSE, NULL, FALSE), +(FALSE, NULL, NULL), +(FALSE, NULL, TRUE), +(FALSE, TRUE, FALSE), +(FALSE, TRUE, NULL), +(FALSE, TRUE, TRUE), +(NULL, FALSE, FALSE), +(NULL, FALSE, NULL), +(NULL, FALSE, TRUE), +(NULL, NULL, FALSE), +(NULL, NULL, NULL), +(NULL, NULL, TRUE), +(NULL, TRUE, FALSE), +(NULL, TRUE, NULL), +(NULL, TRUE, TRUE), +(TRUE, FALSE, FALSE), +(TRUE, FALSE, NULL), +(TRUE, FALSE, TRUE), +(TRUE, NULL, FALSE), +(TRUE, NULL, NULL), +(TRUE, NULL, TRUE), +(TRUE, TRUE, FALSE), +(TRUE, TRUE, NULL), +(TRUE, TRUE, TRUE) ; +Testing OR, XOR, AND +select A, B, A OR B, A XOR B, A AND B +from t1_30237_bool where C is null order by A, B; +A B A OR B A XOR B A AND B +NULL NULL NULL NULL NULL +NULL 0 NULL NULL 0 +NULL 1 1 NULL NULL +0 NULL NULL NULL 0 +0 0 0 0 0 +0 1 1 1 0 +1 NULL 1 NULL NULL +1 0 1 1 0 +1 1 1 0 1 +Testing that OR is associative +select A, B, C, (A OR B) OR C, A OR (B OR C), A OR B OR C +from t1_30237_bool order by A, B, C; +A B C (A OR B) OR C A OR (B OR C) A OR B OR C +NULL NULL NULL NULL NULL NULL +NULL NULL 0 NULL NULL NULL +NULL NULL 1 1 1 1 +NULL 0 NULL NULL NULL NULL +NULL 0 0 NULL NULL NULL +NULL 0 1 1 1 1 +NULL 1 NULL 1 1 1 +NULL 1 0 1 1 1 +NULL 1 1 1 1 1 +0 NULL NULL NULL NULL NULL +0 NULL 0 NULL NULL NULL +0 NULL 1 1 1 1 +0 0 NULL NULL NULL NULL +0 0 0 0 0 0 +0 0 1 1 1 1 +0 1 NULL 1 1 1 +0 1 0 1 1 1 +0 1 1 1 1 1 +1 NULL NULL 1 1 1 +1 NULL 0 1 1 1 +1 NULL 1 1 1 1 +1 0 NULL 1 1 1 +1 0 0 1 1 1 +1 0 1 1 1 1 +1 1 NULL 1 1 1 +1 1 0 1 1 1 +1 1 1 1 1 1 +select count(*) from t1_30237_bool +where ((A OR B) OR C) != (A OR (B OR C)); +count(*) +0 +Testing that XOR is associative +select A, B, C, (A XOR B) XOR C, A XOR (B XOR C), A XOR B XOR C +from t1_30237_bool order by A, B, C; +A B C (A XOR B) XOR C A XOR (B XOR C) A XOR B XOR C +NULL NULL NULL NULL NULL NULL +NULL NULL 0 NULL NULL NULL +NULL NULL 1 NULL NULL NULL +NULL 0 NULL NULL NULL NULL +NULL 0 0 NULL NULL NULL +NULL 0 1 NULL NULL NULL +NULL 1 NULL NULL NULL NULL +NULL 1 0 NULL NULL NULL +NULL 1 1 NULL NULL NULL +0 NULL NULL NULL NULL NULL +0 NULL 0 NULL NULL NULL +0 NULL 1 NULL NULL NULL +0 0 NULL NULL NULL NULL +0 0 0 0 0 0 +0 0 1 1 1 1 +0 1 NULL NULL NULL NULL +0 1 0 1 1 1 +0 1 1 0 0 0 +1 NULL NULL NULL NULL NULL +1 NULL 0 NULL NULL NULL +1 NULL 1 NULL NULL NULL +1 0 NULL NULL NULL NULL +1 0 0 1 1 1 +1 0 1 0 0 0 +1 1 NULL NULL NULL NULL +1 1 0 0 0 0 +1 1 1 1 1 1 +select count(*) from t1_30237_bool +where ((A XOR B) XOR C) != (A XOR (B XOR C)); +count(*) +0 +Testing that AND is associative +select A, B, C, (A AND B) AND C, A AND (B AND C), A AND B AND C +from t1_30237_bool order by A, B, C; +A B C (A AND B) AND C A AND (B AND C) A AND B AND C +NULL NULL NULL NULL NULL NULL +NULL NULL 0 0 0 0 +NULL NULL 1 NULL NULL NULL +NULL 0 NULL 0 0 0 +NULL 0 0 0 0 0 +NULL 0 1 0 0 0 +NULL 1 NULL NULL NULL NULL +NULL 1 0 0 0 0 +NULL 1 1 NULL NULL NULL +0 NULL NULL 0 0 0 +0 NULL 0 0 0 0 +0 NULL 1 0 0 0 +0 0 NULL 0 0 0 +0 0 0 0 0 0 +0 0 1 0 0 0 +0 1 NULL 0 0 0 +0 1 0 0 0 0 +0 1 1 0 0 0 +1 NULL NULL NULL NULL NULL +1 NULL 0 0 0 0 +1 NULL 1 NULL NULL NULL +1 0 NULL 0 0 0 +1 0 0 0 0 0 +1 0 1 0 0 0 +1 1 NULL NULL NULL NULL +1 1 0 0 0 0 +1 1 1 1 1 1 +select count(*) from t1_30237_bool +where ((A AND B) AND C) != (A AND (B AND C)); +count(*) +0 +Testing that AND has precedence over OR +select A, B, C, (A OR B) AND C, A OR (B AND C), A OR B AND C +from t1_30237_bool order by A, B, C; +A B C (A OR B) AND C A OR (B AND C) A OR B AND C +NULL NULL NULL NULL NULL NULL +NULL NULL 0 0 NULL NULL +NULL NULL 1 NULL NULL NULL +NULL 0 NULL NULL NULL NULL +NULL 0 0 0 NULL NULL +NULL 0 1 NULL NULL NULL +NULL 1 NULL NULL NULL NULL +NULL 1 0 0 NULL NULL +NULL 1 1 1 1 1 +0 NULL NULL NULL NULL NULL +0 NULL 0 0 0 0 +0 NULL 1 NULL NULL NULL +0 0 NULL 0 0 0 +0 0 0 0 0 0 +0 0 1 0 0 0 +0 1 NULL NULL NULL NULL +0 1 0 0 0 0 +0 1 1 1 1 1 +1 NULL NULL NULL 1 1 +1 NULL 0 0 1 1 +1 NULL 1 1 1 1 +1 0 NULL NULL 1 1 +1 0 0 0 1 1 +1 0 1 1 1 1 +1 1 NULL NULL 1 1 +1 1 0 0 1 1 +1 1 1 1 1 1 +select count(*) from t1_30237_bool +where (A OR (B AND C)) != (A OR B AND C); +count(*) +0 +select A, B, C, (A AND B) OR C, A AND (B OR C), A AND B OR C +from t1_30237_bool order by A, B, C; +A B C (A AND B) OR C A AND (B OR C) A AND B OR C +NULL NULL NULL NULL NULL NULL +NULL NULL 0 NULL NULL NULL +NULL NULL 1 1 NULL 1 +NULL 0 NULL NULL NULL NULL +NULL 0 0 0 0 0 +NULL 0 1 1 NULL 1 +NULL 1 NULL NULL NULL NULL +NULL 1 0 NULL NULL NULL +NULL 1 1 1 NULL 1 +0 NULL NULL NULL 0 NULL +0 NULL 0 0 0 0 +0 NULL 1 1 0 1 +0 0 NULL NULL 0 NULL +0 0 0 0 0 0 +0 0 1 1 0 1 +0 1 NULL NULL 0 NULL +0 1 0 0 0 0 +0 1 1 1 0 1 +1 NULL NULL NULL NULL NULL +1 NULL 0 NULL NULL NULL +1 NULL 1 1 1 1 +1 0 NULL NULL NULL NULL +1 0 0 0 0 0 +1 0 1 1 1 1 +1 1 NULL 1 1 1 +1 1 0 1 1 1 +1 1 1 1 1 1 +select count(*) from t1_30237_bool +where ((A AND B) OR C) != (A AND B OR C); +count(*) +0 +Testing that AND has precedence over XOR +select A, B, C, (A XOR B) AND C, A XOR (B AND C), A XOR B AND C +from t1_30237_bool order by A, B, C; +A B C (A XOR B) AND C A XOR (B AND C) A XOR B AND C +NULL NULL NULL NULL NULL NULL +NULL NULL 0 0 NULL NULL +NULL NULL 1 NULL NULL NULL +NULL 0 NULL NULL NULL NULL +NULL 0 0 0 NULL NULL +NULL 0 1 NULL NULL NULL +NULL 1 NULL NULL NULL NULL +NULL 1 0 0 NULL NULL +NULL 1 1 NULL NULL NULL +0 NULL NULL NULL NULL NULL +0 NULL 0 0 0 0 +0 NULL 1 NULL NULL NULL +0 0 NULL 0 0 0 +0 0 0 0 0 0 +0 0 1 0 0 0 +0 1 NULL NULL NULL NULL +0 1 0 0 0 0 +0 1 1 1 1 1 +1 NULL NULL NULL NULL NULL +1 NULL 0 0 1 1 +1 NULL 1 NULL NULL NULL +1 0 NULL NULL 1 1 +1 0 0 0 1 1 +1 0 1 1 1 1 +1 1 NULL 0 NULL NULL +1 1 0 0 1 1 +1 1 1 0 0 0 +select count(*) from t1_30237_bool +where (A XOR (B AND C)) != (A XOR B AND C); +count(*) +0 +select A, B, C, (A AND B) XOR C, A AND (B XOR C), A AND B XOR C +from t1_30237_bool order by A, B, C; +A B C (A AND B) XOR C A AND (B XOR C) A AND B XOR C +NULL NULL NULL NULL NULL NULL +NULL NULL 0 NULL NULL NULL +NULL NULL 1 NULL NULL NULL +NULL 0 NULL NULL NULL NULL +NULL 0 0 0 0 0 +NULL 0 1 1 NULL 1 +NULL 1 NULL NULL NULL NULL +NULL 1 0 NULL NULL NULL +NULL 1 1 NULL 0 NULL +0 NULL NULL NULL 0 NULL +0 NULL 0 0 0 0 +0 NULL 1 1 0 1 +0 0 NULL NULL 0 NULL +0 0 0 0 0 0 +0 0 1 1 0 1 +0 1 NULL NULL 0 NULL +0 1 0 0 0 0 +0 1 1 1 0 1 +1 NULL NULL NULL NULL NULL +1 NULL 0 NULL NULL NULL +1 NULL 1 NULL NULL NULL +1 0 NULL NULL NULL NULL +1 0 0 0 0 0 +1 0 1 1 1 1 +1 1 NULL NULL NULL NULL +1 1 0 1 1 1 +1 1 1 0 0 0 +select count(*) from t1_30237_bool +where ((A AND B) XOR C) != (A AND B XOR C); +count(*) +0 +Testing that XOR has precedence over OR +select A, B, C, (A XOR B) OR C, A XOR (B OR C), A XOR B OR C +from t1_30237_bool order by A, B, C; +A B C (A XOR B) OR C A XOR (B OR C) A XOR B OR C +NULL NULL NULL NULL NULL NULL +NULL NULL 0 NULL NULL NULL +NULL NULL 1 1 NULL 1 +NULL 0 NULL NULL NULL NULL +NULL 0 0 NULL NULL NULL +NULL 0 1 1 NULL 1 +NULL 1 NULL NULL NULL NULL +NULL 1 0 NULL NULL NULL +NULL 1 1 1 NULL 1 +0 NULL NULL NULL NULL NULL +0 NULL 0 NULL NULL NULL +0 NULL 1 1 1 1 +0 0 NULL NULL NULL NULL +0 0 0 0 0 0 +0 0 1 1 1 1 +0 1 NULL 1 1 1 +0 1 0 1 1 1 +0 1 1 1 1 1 +1 NULL NULL NULL NULL NULL +1 NULL 0 NULL NULL NULL +1 NULL 1 1 0 1 +1 0 NULL 1 NULL 1 +1 0 0 1 1 1 +1 0 1 1 0 1 +1 1 NULL NULL 0 NULL +1 1 0 0 0 0 +1 1 1 1 0 1 +select count(*) from t1_30237_bool +where ((A XOR B) OR C) != (A XOR B OR C); +count(*) +0 +select A, B, C, (A OR B) XOR C, A OR (B XOR C), A OR B XOR C +from t1_30237_bool order by A, B, C; +A B C (A OR B) XOR C A OR (B XOR C) A OR B XOR C +NULL NULL NULL NULL NULL NULL +NULL NULL 0 NULL NULL NULL +NULL NULL 1 NULL NULL NULL +NULL 0 NULL NULL NULL NULL +NULL 0 0 NULL NULL NULL +NULL 0 1 NULL 1 1 +NULL 1 NULL NULL NULL NULL +NULL 1 0 1 1 1 +NULL 1 1 0 NULL NULL +0 NULL NULL NULL NULL NULL +0 NULL 0 NULL NULL NULL +0 NULL 1 NULL NULL NULL +0 0 NULL NULL NULL NULL +0 0 0 0 0 0 +0 0 1 1 1 1 +0 1 NULL NULL NULL NULL +0 1 0 1 1 1 +0 1 1 0 0 0 +1 NULL NULL NULL 1 1 +1 NULL 0 1 1 1 +1 NULL 1 0 1 1 +1 0 NULL NULL 1 1 +1 0 0 1 1 1 +1 0 1 0 1 1 +1 1 NULL NULL 1 1 +1 1 0 1 1 1 +1 1 1 0 1 1 +select count(*) from t1_30237_bool +where (A OR (B XOR C)) != (A OR B XOR C); +count(*) +0 +drop table t1_30237_bool; diff --git a/mysql-test/t/parser_precedence.test b/mysql-test/t/parser_precedence.test new file mode 100644 index 00000000000..a3a80776fb1 --- /dev/null +++ b/mysql-test/t/parser_precedence.test @@ -0,0 +1,93 @@ + +--disable_warnings +drop table if exists t1_30237_bool; +--enable_warnings + +create table t1_30237_bool(A boolean, B boolean, C boolean); + +insert into t1_30237_bool values +(FALSE, FALSE, FALSE), +(FALSE, FALSE, NULL), +(FALSE, FALSE, TRUE), +(FALSE, NULL, FALSE), +(FALSE, NULL, NULL), +(FALSE, NULL, TRUE), +(FALSE, TRUE, FALSE), +(FALSE, TRUE, NULL), +(FALSE, TRUE, TRUE), +(NULL, FALSE, FALSE), +(NULL, FALSE, NULL), +(NULL, FALSE, TRUE), +(NULL, NULL, FALSE), +(NULL, NULL, NULL), +(NULL, NULL, TRUE), +(NULL, TRUE, FALSE), +(NULL, TRUE, NULL), +(NULL, TRUE, TRUE), +(TRUE, FALSE, FALSE), +(TRUE, FALSE, NULL), +(TRUE, FALSE, TRUE), +(TRUE, NULL, FALSE), +(TRUE, NULL, NULL), +(TRUE, NULL, TRUE), +(TRUE, TRUE, FALSE), +(TRUE, TRUE, NULL), +(TRUE, TRUE, TRUE) ; + +--echo Testing OR, XOR, AND +select A, B, A OR B, A XOR B, A AND B + from t1_30237_bool where C is null order by A, B; + +--echo Testing that OR is associative +select A, B, C, (A OR B) OR C, A OR (B OR C), A OR B OR C + from t1_30237_bool order by A, B, C; + +select count(*) from t1_30237_bool + where ((A OR B) OR C) != (A OR (B OR C)); + +--echo Testing that XOR is associative +select A, B, C, (A XOR B) XOR C, A XOR (B XOR C), A XOR B XOR C + from t1_30237_bool order by A, B, C; + +select count(*) from t1_30237_bool + where ((A XOR B) XOR C) != (A XOR (B XOR C)); + +--echo Testing that AND is associative +select A, B, C, (A AND B) AND C, A AND (B AND C), A AND B AND C + from t1_30237_bool order by A, B, C; + +select count(*) from t1_30237_bool + where ((A AND B) AND C) != (A AND (B AND C)); + +--echo Testing that AND has precedence over OR +select A, B, C, (A OR B) AND C, A OR (B AND C), A OR B AND C + from t1_30237_bool order by A, B, C; +select count(*) from t1_30237_bool + where (A OR (B AND C)) != (A OR B AND C); +select A, B, C, (A AND B) OR C, A AND (B OR C), A AND B OR C + from t1_30237_bool order by A, B, C; +select count(*) from t1_30237_bool + where ((A AND B) OR C) != (A AND B OR C); + +--echo Testing that AND has precedence over XOR +select A, B, C, (A XOR B) AND C, A XOR (B AND C), A XOR B AND C + from t1_30237_bool order by A, B, C; +select count(*) from t1_30237_bool + where (A XOR (B AND C)) != (A XOR B AND C); +select A, B, C, (A AND B) XOR C, A AND (B XOR C), A AND B XOR C + from t1_30237_bool order by A, B, C; +select count(*) from t1_30237_bool + where ((A AND B) XOR C) != (A AND B XOR C); + +--echo Testing that XOR has precedence over OR +select A, B, C, (A XOR B) OR C, A XOR (B OR C), A XOR B OR C + from t1_30237_bool order by A, B, C; +select count(*) from t1_30237_bool + where ((A XOR B) OR C) != (A XOR B OR C); +select A, B, C, (A OR B) XOR C, A OR (B XOR C), A OR B XOR C + from t1_30237_bool order by A, B, C; +select count(*) from t1_30237_bool + where (A OR (B XOR C)) != (A OR B XOR C); + +drop table t1_30237_bool; + diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h index 9afc0507817..da71b3ef512 100644 --- a/sql/item_cmpfunc.h +++ b/sql/item_cmpfunc.h @@ -1361,6 +1361,7 @@ public: Item_cond(List &nlist) :Item_bool_func(), list(nlist), abort_on_null(0) {} bool add(Item *item) { return list.push_back(item); } + bool add_at_head(Item *item) { return list.push_front(item); } void add_at_head(List *nlist) { list.prepand(nlist); } bool fix_fields(THD *, Item **ref); @@ -1554,6 +1555,15 @@ public: Item *neg_transformer(THD *thd); }; +inline bool is_cond_and(Item *item) +{ + if (item->type() != Item::COND_ITEM) + return FALSE; + + Item_cond *cond_item= (Item_cond*) item; + return (cond_item->functype() == Item_func::COND_AND_FUNC); +} + class Item_cond_or :public Item_cond { public: @@ -1575,6 +1585,14 @@ public: Item *neg_transformer(THD *thd); }; +inline bool is_cond_or(Item *item) +{ + if (item->type() != Item::COND_ITEM) + return FALSE; + + Item_cond *cond_item= (Item_cond*) item; + return (cond_item->functype() == Item_func::COND_OR_FUNC); +} /* XOR is Item_cond, not an Item_int_func because we could like to diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy index d71e756e91c..4230e6ee371 100644 --- a/sql/sql_yacc.yy +++ b/sql/sql_yacc.yy @@ -458,10 +458,10 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize); %pure_parser /* We have threads */ /* - Currently there is 251 shift/reduce conflict. We should not introduce - new conflicts any more. + Currently there are 245 shift/reduce conflicts. + We should not introduce new conflicts any more. */ -%expect 251 +%expect 245 %token END_OF_INPUT @@ -1011,7 +1011,8 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize); /* A dummy token to force the priority of table_ref production in a join. */ %left TABLE_REF_PRIORITY %left SET_VAR -%left OR_OR_SYM OR_SYM OR2_SYM XOR +%left OR_OR_SYM OR_SYM OR2_SYM +%left XOR %left AND_SYM AND_AND_SYM %left BETWEEN_SYM CASE_SYM WHEN_SYM THEN_SYM ELSE %left EQ EQUAL_SYM GE GT_SYM LE LT NE IS LIKE REGEXP IN_SYM @@ -1024,6 +1025,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize); %left NEG '~' %right NOT_SYM NOT2_SYM %right BINARY COLLATE_SYM +%left INTERVAL_SYM %type IDENT IDENT_QUOTED TEXT_STRING DECIMAL_NUM FLOAT_NUM NUM LONG_NUM HEX_NUM @@ -1066,7 +1068,8 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize); %type literal text_literal insert_ident order_ident simple_ident select_item2 expr opt_expr opt_else sum_expr in_sum_expr - variable variable_aux bool_term bool_factor bool_test bool_pri + variable variable_aux bool_factor + bool_test bool_pri predicate bit_expr bit_term bit_factor value_expr term factor table_wild simple_expr udf_expr expr_or_default set_expr_or_default interval_expr @@ -4464,53 +4467,103 @@ optional_braces: | '(' ')' {}; /* all possible expressions */ -expr: - bool_term { Select->expr_list.push_front(new List); } - bool_or_expr +expr: + bool_factor + | expr or expr %prec OR_SYM { - List *list= Select->expr_list.pop(); - if (list->elements) + /* + Design notes: + Do not use a manually maintained stack like thd->lex->xxx_list, + but use the internal bison stack ($$, $1 and $3) instead. + Using the bison stack is: + - more robust to changes in the grammar, + - guaranteed to be in sync with the parser state, + - better for performances (no memory allocation). + */ + Item_cond_or *item1; + Item_cond_or *item3; + if (is_cond_or($1)) { - list->push_front($1); - $$= new Item_cond_or(*list); - /* optimize construction of logical OR to reduce - amount of objects for complex expressions */ + item1= (Item_cond_or*) $1; + if (is_cond_or($3)) + { + item3= (Item_cond_or*) $3; + /* + (X1 OR X2) OR (Y1 OR Y2) ==> OR (X1, X2, Y1, Y2) + */ + item3->add_at_head(item1->argument_list()); + $$ = $3; + } + else + { + /* + (X1 OR X2) OR Y ==> OR (X1, X2, Y) + */ + item1->add($3); + $$ = $1; + } + } + else if (is_cond_or($3)) + { + item3= (Item_cond_or*) $3; + /* + X OR (Y1 OR Y2) ==> OR (X, Y1, Y2) + */ + item3->add_at_head($1); + $$ = $3; } else - $$= $1; - delete list; - } - ; - -bool_or_expr: - /* empty */ - | bool_or_expr or bool_term - { Select->expr_list.head()->push_back($3); } - ; - -bool_term: - bool_term XOR bool_term { $$= new Item_cond_xor($1,$3); } - | bool_factor { Select->expr_list.push_front(new List); } - bool_and_expr - { - List *list= Select->expr_list.pop(); - if (list->elements) { - list->push_front($1); - $$= new Item_cond_and(*list); - /* optimize construction of logical AND to reduce - amount of objects for complex expressions */ + /* X OR Y */ + $$ = new (YYTHD->mem_root) Item_cond_or($1, $3); + } + } + | expr XOR expr %prec XOR + { + /* XOR is a proprietary extension */ + $$ = new (YYTHD->mem_root) Item_cond_xor($1, $3); + } + | expr and expr %prec AND_SYM + { + /* See comments in rule expr: expr or expr */ + Item_cond_and *item1; + Item_cond_and *item3; + if (is_cond_and($1)) + { + item1= (Item_cond_and*) $1; + if (is_cond_and($3)) + { + item3= (Item_cond_and*) $3; + /* + (X1 AND X2) AND (Y1 AND Y2) ==> AND (X1, X2, Y1, Y2) + */ + item3->add_at_head(item1->argument_list()); + $$ = $3; + } + else + { + /* + (X1 AND X2) AND Y ==> AND (X1, X2, Y) + */ + item1->add($3); + $$ = $1; + } + } + else if (is_cond_and($3)) + { + item3= (Item_cond_and*) $3; + /* + X AND (Y1 AND Y2) ==> AND (X, Y1, Y2) + */ + item3->add_at_head($1); + $$ = $3; } else - $$= $1; - delete list; + { + /* X AND Y */ + $$ = new (YYTHD->mem_root) Item_cond_and($1, $3); + } } - ; - -bool_and_expr: - /* empty */ - | bool_and_expr and bool_factor - { Select->expr_list.head()->push_back($3); } ; bool_factor: @@ -4648,7 +4701,8 @@ all_or_any: ALL { $$ = 1; } ; interval_expr: - INTERVAL_SYM expr { $$=$2; } + INTERVAL_SYM expr %prec INTERVAL_SYM + { $$=$2; } ; simple_expr: From 33e123ead93b0122a67821e4b16ef70ef2b3d3af Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 22 Aug 2007 18:11:01 -0600 Subject: [PATCH 17/41] Do not use $static_link for GCOV builds, since this flag was explicitly removed in pushbuild for GCOV builds. BUILD_CMD => ['sh', '-c', 'perl -i.bak -pe "s/ \\\\\$static_link//" ' . 'BUILD/compile-pentium-gcov; BUILD/compile-pentium-gcov'], Moving $static_link to SETUP.sh broke this, and is now fixed. Should this flag be needed on some platforms, the proper location is compile--gcov Tested the amd64 and pentium64 build fine without it, and can run NDB tests. BUILD/SETUP.sh: Removed $static_link from GCOV builds. --- BUILD/SETUP.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/BUILD/SETUP.sh b/BUILD/SETUP.sh index a8efaf75db4..532ea4eb0f1 100755 --- a/BUILD/SETUP.sh +++ b/BUILD/SETUP.sh @@ -155,7 +155,7 @@ gcov_compile_flags="$gcov_compile_flags -DMYSQL_SERVER_SUFFIX=-gcov -DHAVE_gcov" gcov_link_flags="-fprofile-arcs -ftest-coverage" -gcov_configs="--disable-shared $static_link" +gcov_configs="--disable-shared" # gprof From 5b03876f2e5d0a456170874d660374762f7fc99e Mon Sep 17 00:00:00 2001 From: unknown Date: Sat, 25 Aug 2007 17:32:17 +0000 Subject: [PATCH 18/41] sql_select.cc: Additional fix for the bug#30245. sql/sql_select.cc: Additional fix for the bug#30245. --- sql/sql_select.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 9db0a2ee490..f685d3093d6 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -538,7 +538,7 @@ JOIN::prepare(Item ***rref_pointer_array, fix_inner_refs(thd, all_fields, select_lex, ref_pointer_array)) DBUG_RETURN(-1); - if (group) + if (group_list) { /* Because HEAP tables can't index BIT fields we need to use an From 369a5f1cdcd569a02de4a12d64faebc33e9128f0 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 27 Aug 2007 10:13:54 -0300 Subject: [PATCH 19/41] Bug#25164 create table `a` as select * from `A` hangs The problem from a user's perspective: user creates table A, and then tries to CREATE TABLE a SELECT from A - and this causes a deadlock error, a hang, or fails with a debug assert, but only if the storage engine is InnoDB. The origin of the problem: InnoDB uses case-insensitive collation (system_charset_info) when looking up the internal table share, thus returning the same share for 'a' and 'A'. Cause of the user-visible behavior: since the same share is returned to SQL locking subsystem, it assumes that the same table is first locked (within the same session) for WRITE, and then for READ, and returns a deadlock error. However, the code is wrong in not properly cleaning up upon an error, leaving external locks in place, which leads to assertion failures and hangs. Fix that has been implemented: the SQL layer should properly propagate the deadlock error, cleaning up and freeing all resources. Further work towards a more complete solution: InnoDB should not use case insensitive collation for table share hash if table names on disk honor the case. mysql-test/r/innodb-deadlock.result: Bug#25164 test case result mysql-test/t/innodb-deadlock.test: Bug#25164 test case. The CREATE TABLE may fail depending on the character set of the system and filesystem, but it should never hang. sql/lock.cc: Unlock the storage engine "external" table level locks, if the MySQL thr_lock locking subsystem detects a deadlock error. --- mysql-test/r/innodb-deadlock.result | 11 +++++++++++ mysql-test/t/innodb-deadlock.test | 27 ++++++++++++++++++++++++++- sql/lock.cc | 2 ++ 3 files changed, 39 insertions(+), 1 deletion(-) diff --git a/mysql-test/r/innodb-deadlock.result b/mysql-test/r/innodb-deadlock.result index 2ca82101fb4..b6a3373e8c6 100644 --- a/mysql-test/r/innodb-deadlock.result +++ b/mysql-test/r/innodb-deadlock.result @@ -94,3 +94,14 @@ id x 300 300 commit; drop table t1, t2; +End of 4.1 tests +set storage_engine=innodb; +drop table if exists a; +drop table if exists A; +create table A (c int); +insert into A (c) values (0); +create table a as select * from A; +drop table A; +drop table if exists a; +set storage_engine=default; +End of 5.0 tests. diff --git a/mysql-test/t/innodb-deadlock.test b/mysql-test/t/innodb-deadlock.test index 81acfba5c93..1a184f98771 100644 --- a/mysql-test/t/innodb-deadlock.test +++ b/mysql-test/t/innodb-deadlock.test @@ -112,4 +112,29 @@ commit; drop table t1, t2; -# End of 4.1 tests +--echo End of 4.1 tests + +# +# Bug#25164 create table `a` as select * from `A` hangs +# + +set storage_engine=innodb; + +--disable_warnings +drop table if exists a; +drop table if exists A; +--enable_warnings + +create table A (c int); +insert into A (c) values (0); +--error 0,ER_LOCK_DEADLOCK,ER_UPDATE_TABLE_USED +create table a as select * from A; +drop table A; + +--disable_warnings +drop table if exists a; +--enable_warnings + +set storage_engine=default; + +--echo End of 5.0 tests. diff --git a/sql/lock.cc b/sql/lock.cc index 0036d0aef77..cf06be5f95f 100644 --- a/sql/lock.cc +++ b/sql/lock.cc @@ -172,6 +172,8 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd, TABLE **tables, uint count, thd->lock_id)]; if (rc > 1) /* a timeout or a deadlock */ { + if (sql_lock->table_count) + VOID(unlock_external(thd, sql_lock->table, sql_lock->table_count)); my_error(rc, MYF(0)); my_free((gptr) sql_lock,MYF(0)); sql_lock= 0; From 34ded629086fa8e1ddd3b73ffb3531b10452d46f Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 27 Aug 2007 10:37:12 -0300 Subject: [PATCH 20/41] Bug#30632 HANDLER read failure causes hang If, after the tables are locked, one of the conditions to read from a HANDLER table is not met, the handler code wrongly jumps to a error path that won't unlock the tables. The user-visible effect is that after a error in a handler read command, all subsequent handler operations on the same table will hang. The fix is simply to correct the code to jump to the (same) error path that unlocks the tables. mysql-test/r/handler.result: Bug#30632 test case result mysql-test/t/handler.test: Bug#30632 test case sql/sql_handler.cc: Always unlock the internal and external table level locks if any of the conditions (including errors) to read from a HANDLER table are not met. --- mysql-test/r/handler.result | 13 +++++++++++++ mysql-test/t/handler.test | 19 +++++++++++++++++++ sql/sql_handler.cc | 6 +++--- 3 files changed, 35 insertions(+), 3 deletions(-) diff --git a/mysql-test/r/handler.result b/mysql-test/r/handler.result index 5e123df9103..dc3750e16ea 100644 --- a/mysql-test/r/handler.result +++ b/mysql-test/r/handler.result @@ -489,3 +489,16 @@ handler t1 open; ERROR HY000: Table storage engine for 't1' doesn't have this option --> client 1 drop table t1; +drop table if exists t1; +create table t1 (a int); +handler t1 open as t1_alias; +handler t1_alias read a next; +ERROR HY000: Key 'a' doesn't exist in table 't1_alias' +handler t1_alias READ a next where inexistent > 0; +ERROR 42S22: Unknown column 'inexistent' in 'field list' +handler t1_alias read a next; +ERROR HY000: Key 'a' doesn't exist in table 't1_alias' +handler t1_alias READ a next where inexistent > 0; +ERROR 42S22: Unknown column 'inexistent' in 'field list' +handler t1_alias close; +drop table t1; diff --git a/mysql-test/t/handler.test b/mysql-test/t/handler.test index 4edd5b5ec32..6ef216f6ed2 100644 --- a/mysql-test/t/handler.test +++ b/mysql-test/t/handler.test @@ -441,3 +441,22 @@ handler t1 open; --echo --> client 1 connection default; drop table t1; + +# +# Bug#30632 HANDLER read failure causes hang +# +--disable_warnings +drop table if exists t1; +--enable_warnings +create table t1 (a int); +handler t1 open as t1_alias; +--error 1176 +handler t1_alias read a next; +--error 1054 +handler t1_alias READ a next where inexistent > 0; +--error 1176 +handler t1_alias read a next; +--error 1054 +handler t1_alias READ a next where inexistent > 0; +handler t1_alias close; +drop table t1; diff --git a/sql/sql_handler.cc b/sql/sql_handler.cc index 83c141f099f..9aefa71647e 100644 --- a/sql/sql_handler.cc +++ b/sql/sql_handler.cc @@ -440,7 +440,7 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables, cond->cleanup(); // File was reopened if ((!cond->fixed && cond->fix_fields(thd, &cond)) || cond->check_cols(1)) - goto err0; + goto err; } if (keyname) @@ -448,13 +448,13 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables, if ((keyno=find_type(keyname, &table->s->keynames, 1+2)-1)<0) { my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), keyname, tables->alias); - goto err0; + goto err; } } if (insert_fields(thd, &thd->lex->select_lex.context, tables->db, tables->alias, &it, 0)) - goto err0; + goto err; protocol->send_fields(&list, Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF); From 236866468123d5f61713c627ba77aae73c916d28 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 27 Aug 2007 17:33:41 +0200 Subject: [PATCH 21/41] Bug #30596 GROUP BY optimization gives wrong result order The optimization that uses a unique index to remove GROUP BY, did not ensure that the index was actually used, thus violating the ORDER BY that is impled by GROUP BY. Fixed by replacing GROUP BY with ORDER BY if the GROUP BY clause contains a unique index. In case GROUP BY ... ORDER BY null is used, GROUP BY is simply removed. BitKeeper/etc/ignore: Added support-files/mysqld_multi.server tests/bug25714 cscope.in.out cscope.out cscope.po.out to the ignore list mysql-test/r/distinct.result: Bug#30596: Changed test case. Prior to Bug#16458, These queries use temp table and filesort. The bug was that they used a temp table. However, that patch removed filesort also, in which case we can no longer gurantee correct ordering. mysql-test/r/group_by.result: Bug#30596: Correct result mysql-test/r/innodb_mysql.result: Bug#30596: Test case for innodb. Here, as opposed to for MyISAM, row lookup is done using index whenever the index covers the group list. mysql-test/t/group_by.test: Bug#30596: Test case mysql-test/t/innodb_mysql.test: Bug#30596: Test case sql/sql_select.cc: Bug#30596: The fix, replacing GROUP BY with ORDER BY unless ORDER BY [NULL|] --- .bzrignore | 5 ++++ mysql-test/r/distinct.result | 6 ++-- mysql-test/r/group_by.result | 49 ++++++++++++++++++++++++++++++++ mysql-test/r/innodb_mysql.result | 49 ++++++++++++++++++++++++++++++++ mysql-test/t/group_by.test | 27 ++++++++++++++++++ mysql-test/t/innodb_mysql.test | 27 ++++++++++++++++++ sql/sql_select.cc | 8 ++++++ 7 files changed, 168 insertions(+), 3 deletions(-) diff --git a/.bzrignore b/.bzrignore index 759ca4a20bf..35f5199be3c 100644 --- a/.bzrignore +++ b/.bzrignore @@ -1345,3 +1345,8 @@ zlib/*.vcproj debian/control debian/defs.mk include/abi_check +support-files/mysqld_multi.server +tests/bug25714 +cscope.in.out +cscope.out +cscope.po.out diff --git a/mysql-test/r/distinct.result b/mysql-test/r/distinct.result index 8525e0f19e4..8cfe5aa78b5 100644 --- a/mysql-test/r/distinct.result +++ b/mysql-test/r/distinct.result @@ -526,10 +526,10 @@ id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 index NULL PRIMARY 4 NULL 3 Using index EXPLAIN SELECT a,b FROM t1 GROUP BY a,b; id select_type table type possible_keys key key_len ref rows Extra -1 SIMPLE t1 ALL NULL NULL NULL NULL 3 +1 SIMPLE t1 ALL NULL NULL NULL NULL 3 Using filesort EXPLAIN SELECT DISTINCT a,b FROM t1 GROUP BY a,b; id select_type table type possible_keys key key_len ref rows Extra -1 SIMPLE t1 ALL NULL NULL NULL NULL 3 +1 SIMPLE t1 ALL NULL NULL NULL NULL 3 Using filesort CREATE TABLE t2(a INT, b INT NOT NULL, c INT NOT NULL, d INT, PRIMARY KEY (a,b)); INSERT INTO t2 VALUES (1,1,1,50), (1,2,3,40), (2,1,3,4); @@ -554,7 +554,7 @@ id select_type table type possible_keys key key_len ref rows Extra CREATE UNIQUE INDEX c_b_unq ON t2 (c,b); EXPLAIN SELECT DISTINCT a,b,d FROM t2 GROUP BY c,b,d; id select_type table type possible_keys key key_len ref rows Extra -1 SIMPLE t2 ALL NULL NULL NULL NULL 3 +1 SIMPLE t2 ALL NULL NULL NULL NULL 3 Using filesort DROP TABLE t1,t2; create table t1 (id int, dsc varchar(50)); insert into t1 values (1, "line number one"), (2, "line number two"), (3, "line number three"); diff --git a/mysql-test/r/group_by.result b/mysql-test/r/group_by.result index d4ffbe43a91..053c2901509 100644 --- a/mysql-test/r/group_by.result +++ b/mysql-test/r/group_by.result @@ -1064,3 +1064,52 @@ select t1.f1,t.* from t1, t1 t group by 1; ERROR 42000: 'test.t.f1' isn't in GROUP BY drop table t1; SET SQL_MODE = ''; +CREATE TABLE t1( +a INT, +b INT NOT NULL, +c INT NOT NULL, +d INT, +UNIQUE KEY (c,b) +); +INSERT INTO t1 VALUES (1,1,1,50), (1,2,3,40), (2,1,3,4); +EXPLAIN SELECT c,b,d FROM t1 GROUP BY c,b,d; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 ALL NULL NULL NULL NULL 3 Using filesort +SELECT c,b,d FROM t1 GROUP BY c,b,d; +c b d +1 1 50 +3 1 4 +3 2 40 +EXPLAIN SELECT c,b,d FROM t1 GROUP BY c,b,d ORDER BY NULL; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 ALL NULL NULL NULL NULL 3 +SELECT c,b,d FROM t1 GROUP BY c,b,d ORDER BY NULL; +c b d +1 1 50 +3 2 40 +3 1 4 +EXPLAIN SELECT c,b,d FROM t1 ORDER BY c,b,d; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 ALL NULL NULL NULL NULL 3 Using filesort +SELECT c,b,d FROM t1 ORDER BY c,b,d; +c b d +1 1 50 +3 1 4 +3 2 40 +EXPLAIN SELECT c,b,d FROM t1 GROUP BY c,b; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 ALL NULL NULL NULL NULL 3 Using filesort +SELECT c,b,d FROM t1 GROUP BY c,b; +c b d +1 1 50 +3 1 4 +3 2 40 +EXPLAIN SELECT c,b FROM t1 GROUP BY c,b; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 index NULL c 8 NULL 3 Using index +SELECT c,b FROM t1 GROUP BY c,b; +c b +1 1 +3 1 +3 2 +DROP TABLE t1; diff --git a/mysql-test/r/innodb_mysql.result b/mysql-test/r/innodb_mysql.result index 63e25b7aa1e..82955af4c8a 100644 --- a/mysql-test/r/innodb_mysql.result +++ b/mysql-test/r/innodb_mysql.result @@ -1047,4 +1047,53 @@ t1 CREATE TABLE `t1` ( KEY `a` (`a`(255)) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 drop table t1; +CREATE TABLE t1( +a INT, +b INT NOT NULL, +c INT NOT NULL, +d INT, +UNIQUE KEY (c,b) +) engine=innodb; +INSERT INTO t1 VALUES (1,1,1,50), (1,2,3,40), (2,1,3,4); +EXPLAIN SELECT c,b,d FROM t1 GROUP BY c,b,d; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 ALL NULL NULL NULL NULL 3 Using filesort +SELECT c,b,d FROM t1 GROUP BY c,b,d; +c b d +1 1 50 +3 1 4 +3 2 40 +EXPLAIN SELECT c,b,d FROM t1 GROUP BY c,b,d ORDER BY NULL; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 ALL NULL NULL NULL NULL 3 +SELECT c,b,d FROM t1 GROUP BY c,b,d ORDER BY NULL; +c b d +1 1 50 +3 1 4 +3 2 40 +EXPLAIN SELECT c,b,d FROM t1 ORDER BY c,b,d; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 ALL NULL NULL NULL NULL 3 Using filesort +SELECT c,b,d FROM t1 ORDER BY c,b,d; +c b d +1 1 50 +3 1 4 +3 2 40 +EXPLAIN SELECT c,b,d FROM t1 GROUP BY c,b; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 index NULL c 8 NULL 3 +SELECT c,b,d FROM t1 GROUP BY c,b; +c b d +1 1 50 +3 1 4 +3 2 40 +EXPLAIN SELECT c,b FROM t1 GROUP BY c,b; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 index NULL c 8 NULL 3 Using index +SELECT c,b FROM t1 GROUP BY c,b; +c b +1 1 +3 1 +3 2 +DROP TABLE t1; End of 5.0 tests diff --git a/mysql-test/t/group_by.test b/mysql-test/t/group_by.test index 91e69f9db34..b7c28cada46 100644 --- a/mysql-test/t/group_by.test +++ b/mysql-test/t/group_by.test @@ -788,3 +788,30 @@ select * from t1 group by f1, f2; select t1.f1,t.* from t1, t1 t group by 1; drop table t1; SET SQL_MODE = ''; + +# +# Bug#30596: GROUP BY optimization gives wrong result order +# +CREATE TABLE t1( + a INT, + b INT NOT NULL, + c INT NOT NULL, + d INT, + UNIQUE KEY (c,b) +); + +INSERT INTO t1 VALUES (1,1,1,50), (1,2,3,40), (2,1,3,4); + +EXPLAIN SELECT c,b,d FROM t1 GROUP BY c,b,d; +SELECT c,b,d FROM t1 GROUP BY c,b,d; +EXPLAIN SELECT c,b,d FROM t1 GROUP BY c,b,d ORDER BY NULL; +SELECT c,b,d FROM t1 GROUP BY c,b,d ORDER BY NULL; +EXPLAIN SELECT c,b,d FROM t1 ORDER BY c,b,d; +SELECT c,b,d FROM t1 ORDER BY c,b,d; + +EXPLAIN SELECT c,b,d FROM t1 GROUP BY c,b; +SELECT c,b,d FROM t1 GROUP BY c,b; +EXPLAIN SELECT c,b FROM t1 GROUP BY c,b; +SELECT c,b FROM t1 GROUP BY c,b; + +DROP TABLE t1; diff --git a/mysql-test/t/innodb_mysql.test b/mysql-test/t/innodb_mysql.test index adcfec68d3e..949e602a299 100644 --- a/mysql-test/t/innodb_mysql.test +++ b/mysql-test/t/innodb_mysql.test @@ -882,4 +882,31 @@ alter table t1 add index(a(1024)); show create table t1; drop table t1; +# +# Bug#30596: GROUP BY optimization gives wrong result order +# +CREATE TABLE t1( + a INT, + b INT NOT NULL, + c INT NOT NULL, + d INT, + UNIQUE KEY (c,b) +) engine=innodb; + +INSERT INTO t1 VALUES (1,1,1,50), (1,2,3,40), (2,1,3,4); + +EXPLAIN SELECT c,b,d FROM t1 GROUP BY c,b,d; +SELECT c,b,d FROM t1 GROUP BY c,b,d; +EXPLAIN SELECT c,b,d FROM t1 GROUP BY c,b,d ORDER BY NULL; +SELECT c,b,d FROM t1 GROUP BY c,b,d ORDER BY NULL; +EXPLAIN SELECT c,b,d FROM t1 ORDER BY c,b,d; +SELECT c,b,d FROM t1 ORDER BY c,b,d; + +EXPLAIN SELECT c,b,d FROM t1 GROUP BY c,b; +SELECT c,b,d FROM t1 GROUP BY c,b; +EXPLAIN SELECT c,b FROM t1 GROUP BY c,b; +SELECT c,b FROM t1 GROUP BY c,b; + +DROP TABLE t1; + --echo End of 5.0 tests diff --git a/sql/sql_select.cc b/sql/sql_select.cc index ac8dc84f118..4be542975b5 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -1030,6 +1030,14 @@ JOIN::optimize() find_field_in_order_list, (void *) group_list)) { + /* + We have found that grouping can be removed since groups correspond to + only one row anyway, but we still have to guarantee correct result + order. The line below effectively rewrites the query from GROUP BY + to ORDER BY . One exception is if skip_sort_order is + set (see above), then we can simply skip GROUP BY. + */ + order= skip_sort_order ? 0 : group_list; group_list= 0; group= 0; } From 310afbd4a96baeedc7202a3b2cac7860c76d83e2 Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 28 Aug 2007 18:51:03 +0300 Subject: [PATCH 22/41] Bug #30377: EXPLAIN loses last_query_cost when used with UNION Currently the Last_query_cost session status variable shows only the cost of a single flat subselect. For complex queries (with subselects or unions etc) Last_query_cost is not valid as it was showing the cost for the last optimized subselect. Fixed by reseting to zero Last_query_cost when the complete cost of the query cannot be determined. Last_query_cost will be non-zero only for single flat queries. mysql-test/r/status.result: Bug #30377: test case mysql-test/t/status.test: Bug #30377: test case sql/sql_lex.h: Bug #30377: helper function sql/sql_select.cc: Bug #30377: don't assign cost if not on single level statement --- mysql-test/r/status.result | 48 ++++++++++++++++++++++++++++++++++++++ mysql-test/t/status.test | 32 +++++++++++++++++++++++++ sql/sql_lex.h | 22 +++++++++++++++++ sql/sql_select.cc | 8 +++++-- 4 files changed, 108 insertions(+), 2 deletions(-) diff --git a/mysql-test/r/status.result b/mysql-test/r/status.result index ca21b333a6a..36857e22aaf 100644 --- a/mysql-test/r/status.result +++ b/mysql-test/r/status.result @@ -43,3 +43,51 @@ SHOW STATUS LIKE 'max_used_connections'; Variable_name Value Max_used_connections 4 SET GLOBAL thread_cache_size=@save_thread_cache_size; +CREATE TABLE t1 ( a INT ); +INSERT INTO t1 VALUES (1), (2); +SELECT a FROM t1 LIMIT 1; +a +1 +SHOW SESSION STATUS LIKE 'Last_query_cost'; +Variable_name Value +Last_query_cost 2.402418 +EXPLAIN SELECT a FROM t1; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 ALL NULL NULL NULL NULL 2 +SHOW SESSION STATUS LIKE 'Last_query_cost'; +Variable_name Value +Last_query_cost 2.402418 +SELECT a FROM t1 UNION SELECT a FROM t1 ORDER BY a; +a +1 +2 +SHOW SESSION STATUS LIKE 'Last_query_cost'; +Variable_name Value +Last_query_cost 0.000000 +EXPLAIN SELECT a FROM t1 UNION SELECT a FROM t1 ORDER BY a; +id select_type table type possible_keys key key_len ref rows Extra +1 PRIMARY t1 ALL NULL NULL NULL NULL 2 +2 UNION t1 ALL NULL NULL NULL NULL 2 +NULL UNION RESULT ALL NULL NULL NULL NULL NULL Using filesort +SHOW SESSION STATUS LIKE 'Last_query_cost'; +Variable_name Value +Last_query_cost 0.000000 +SELECT a IN (SELECT a FROM t1) FROM t1 LIMIT 1; +a IN (SELECT a FROM t1) +1 +SHOW SESSION STATUS LIKE 'Last_query_cost'; +Variable_name Value +Last_query_cost 0.000000 +SELECT (SELECT a FROM t1 LIMIT 1) x FROM t1 LIMIT 1; +x +1 +SHOW SESSION STATUS LIKE 'Last_query_cost'; +Variable_name Value +Last_query_cost 0.000000 +SELECT * FROM t1 a, t1 b LIMIT 1; +a a +1 1 +SHOW SESSION STATUS LIKE 'Last_query_cost'; +Variable_name Value +Last_query_cost 4.805836 +DROP TABLE t1; diff --git a/mysql-test/t/status.test b/mysql-test/t/status.test index 6fcb82e160d..33bba3a626a 100644 --- a/mysql-test/t/status.test +++ b/mysql-test/t/status.test @@ -139,4 +139,36 @@ disconnect con3; disconnect con2; disconnect con1; + +# +# Bug #30377: EXPLAIN loses last_query_cost when used with UNION +# + +CREATE TABLE t1 ( a INT ); +INSERT INTO t1 VALUES (1), (2); + +SELECT a FROM t1 LIMIT 1; +SHOW SESSION STATUS LIKE 'Last_query_cost'; + +EXPLAIN SELECT a FROM t1; +SHOW SESSION STATUS LIKE 'Last_query_cost'; + +SELECT a FROM t1 UNION SELECT a FROM t1 ORDER BY a; +SHOW SESSION STATUS LIKE 'Last_query_cost'; + +EXPLAIN SELECT a FROM t1 UNION SELECT a FROM t1 ORDER BY a; +SHOW SESSION STATUS LIKE 'Last_query_cost'; + +SELECT a IN (SELECT a FROM t1) FROM t1 LIMIT 1; +SHOW SESSION STATUS LIKE 'Last_query_cost'; + +SELECT (SELECT a FROM t1 LIMIT 1) x FROM t1 LIMIT 1; +SHOW SESSION STATUS LIKE 'Last_query_cost'; + +SELECT * FROM t1 a, t1 b LIMIT 1; +SHOW SESSION STATUS LIKE 'Last_query_cost'; + +DROP TABLE t1; + + # End of 5.0 tests diff --git a/sql/sql_lex.h b/sql/sql_lex.h index 94015a9fe07..ce56be79744 100644 --- a/sql/sql_lex.h +++ b/sql/sql_lex.h @@ -1257,6 +1257,28 @@ typedef struct st_lex : public Query_tables_list void reset_n_backup_query_tables_list(Query_tables_list *backup); void restore_backup_query_tables_list(Query_tables_list *backup); + + /** + @brief check if the statement is a single-level join + @return result of the check + @retval TRUE The statement doesn't contain subqueries, unions and + stored procedure calls. + @retval FALSE There are subqueries, UNIONs or stored procedure calls. + */ + bool is_single_level_stmt() + { + /* + This check exploits the fact that the last added to all_select_list is + on its top. So select_lex (as the first added) will be at the tail + of the list. + */ + if (&select_lex == all_selects_list && !sroutines.records) + { + DBUG_ASSERT(!all_selects_list->next_select_in_list()); + return TRUE; + } + return FALSE; + } } LEX; struct st_lex_local: public st_lex diff --git a/sql/sql_select.cc b/sql/sql_select.cc index b7846a7433d..7e9cb4cfbec 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -4369,9 +4369,13 @@ choose_plan(JOIN *join, table_map join_tables) /* Store the cost of this query into a user variable - Don't update last_query_cost for 'show status' command + Don't update last_query_cost for 'show status' command. + Don't update last_query_cost for statements that are not "flat joins" : + i.e. they have subqueries, unions or call stored procedures. + TODO: calculate a correct cost for a query with subqueries and UNIONs. */ - if (join->thd->lex->orig_sql_command != SQLCOM_SHOW_STATUS) + if (join->thd->lex->orig_sql_command != SQLCOM_SHOW_STATUS && + join->thd->lex->is_single_level_stmt()) join->thd->status_var.last_query_cost= join->best_read; DBUG_RETURN(FALSE); } From e0e44ad66e81cbff0d885ecd271eb9e546a02190 Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 28 Aug 2007 11:16:03 -0600 Subject: [PATCH 23/41] Bug#30625 (Performance, reduce depth for expressions) This is a performance bug, affecting in particular the bison generated code for the parser. Prior to this fix, the grammar used a long chain of reduces to parse an expression, like: bit_expr -> bit_term bit_term -> bit_factor bit_factor -> value_expr value_expr -> term term -> factor etc This chain of reduces cause the internal state automaton in the generated parser to execute more state transitions and more reduces, so that the generated MySQLParse() function would spend a lot of time looping to execute all the grammar reductions. With this patch, the grammar has been reorganized so that rules are more "flat", limiting the depth of reduces needed to parse . Tests have been written to enforce that relative priorities and properties of operators have not changed while changing the grammar. See the bug report for performance data. mysql-test/r/parser_precedence.result: Improved test coverage for operator precedence mysql-test/t/parser_precedence.test: Improved test coverage for operator precedence sql/sql_yacc.yy: Simplified the grammar to improve performances --- mysql-test/r/parser_precedence.result | 391 ++++++++++++++++++++++++++ mysql-test/t/parser_precedence.test | 240 ++++++++++++++++ sql/sql_yacc.yy | 115 ++++---- 3 files changed, 686 insertions(+), 60 deletions(-) diff --git a/mysql-test/r/parser_precedence.result b/mysql-test/r/parser_precedence.result index e2d35521ca9..cf301ec677b 100644 --- a/mysql-test/r/parser_precedence.result +++ b/mysql-test/r/parser_precedence.result @@ -354,3 +354,394 @@ where (A OR (B XOR C)) != (A OR B XOR C); count(*) 0 drop table t1_30237_bool; +Testing that NOT has precedence over OR +select (NOT FALSE) OR TRUE, NOT (FALSE OR TRUE), NOT FALSE OR TRUE; +(NOT FALSE) OR TRUE NOT (FALSE OR TRUE) NOT FALSE OR TRUE +1 0 1 +Testing that NOT has precedence over XOR +select (NOT FALSE) XOR FALSE, NOT (FALSE XOR FALSE), NOT FALSE XOR FALSE; +(NOT FALSE) XOR FALSE NOT (FALSE XOR FALSE) NOT FALSE XOR FALSE +1 1 1 +Testing that NOT has precedence over AND +select (NOT FALSE) AND FALSE, NOT (FALSE AND FALSE), NOT FALSE AND FALSE; +(NOT FALSE) AND FALSE NOT (FALSE AND FALSE) NOT FALSE AND FALSE +0 1 0 +Testing that NOT is associative +select NOT NOT TRUE, NOT NOT NOT FALSE; +NOT NOT TRUE NOT NOT NOT FALSE +1 1 +Testing that IS has precedence over NOT +select (NOT NULL) IS TRUE, NOT (NULL IS TRUE), NOT NULL IS TRUE; +(NOT NULL) IS TRUE NOT (NULL IS TRUE) NOT NULL IS TRUE +0 1 1 +select (NOT NULL) IS NOT TRUE, NOT (NULL IS NOT TRUE), NOT NULL IS NOT TRUE; +(NOT NULL) IS NOT TRUE NOT (NULL IS NOT TRUE) NOT NULL IS NOT TRUE +1 0 0 +select (NOT NULL) IS FALSE, NOT (NULL IS FALSE), NOT NULL IS FALSE; +(NOT NULL) IS FALSE NOT (NULL IS FALSE) NOT NULL IS FALSE +0 1 1 +select (NOT NULL) IS NOT FALSE, NOT (NULL IS NOT FALSE), NOT NULL IS NOT FALSE; +(NOT NULL) IS NOT FALSE NOT (NULL IS NOT FALSE) NOT NULL IS NOT FALSE +1 0 0 +select (NOT TRUE) IS UNKNOWN, NOT (TRUE IS UNKNOWN), NOT TRUE IS UNKNOWN; +(NOT TRUE) IS UNKNOWN NOT (TRUE IS UNKNOWN) NOT TRUE IS UNKNOWN +0 1 1 +select (NOT TRUE) IS NOT UNKNOWN, NOT (TRUE IS NOT UNKNOWN), NOT TRUE IS NOT UNKNOWN; +(NOT TRUE) IS NOT UNKNOWN NOT (TRUE IS NOT UNKNOWN) NOT TRUE IS NOT UNKNOWN +1 0 0 +select (NOT TRUE) IS NULL, NOT (TRUE IS NULL), NOT TRUE IS NULL; +(NOT TRUE) IS NULL NOT (TRUE IS NULL) NOT TRUE IS NULL +0 1 1 +select (NOT TRUE) IS NOT NULL, NOT (TRUE IS NOT NULL), NOT TRUE IS NOT NULL; +(NOT TRUE) IS NOT NULL NOT (TRUE IS NOT NULL) NOT TRUE IS NOT NULL +1 0 0 +Testing that IS [NOT] TRUE/FALSE/UNKNOWN predicates are not associative +select TRUE IS TRUE IS TRUE IS TRUE; +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 'IS TRUE IS TRUE' at line 1 +select FALSE IS NOT TRUE IS NOT TRUE IS NOT TRUE; +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 'IS NOT TRUE IS NOT TRUE' at line 1 +select NULL IS FALSE IS FALSE IS FALSE; +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 'IS FALSE IS FALSE' at line 1 +select TRUE IS NOT FALSE IS NOT FALSE IS NOT FALSE; +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 'IS NOT FALSE IS NOT FALSE' at line 1 +select FALSE IS UNKNOWN IS UNKNOWN IS UNKNOWN; +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 'IS UNKNOWN IS UNKNOWN' at line 1 +select TRUE IS NOT UNKNOWN IS NOT UNKNOWN IS NOT UNKNOWN; +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 'IS NOT UNKNOWN IS NOT UNKNOWN' at line 1 +Testing that IS [NOT] NULL predicates are associative +select FALSE IS NULL IS NULL IS NULL; +FALSE IS NULL IS NULL IS NULL +0 +select TRUE IS NOT NULL IS NOT NULL IS NOT NULL; +TRUE IS NOT NULL IS NOT NULL IS NOT NULL +1 +Testing that comparison operators are left associative +select 1 <=> 2 <=> 2, (1 <=> 2) <=> 2, 1 <=> (2 <=> 2); +1 <=> 2 <=> 2 (1 <=> 2) <=> 2 1 <=> (2 <=> 2) +0 0 1 +select 1 = 2 = 2, (1 = 2) = 2, 1 = (2 = 2); +1 = 2 = 2 (1 = 2) = 2 1 = (2 = 2) +0 0 1 +select 1 != 2 != 3, (1 != 2) != 3, 1 != (2 != 3); +1 != 2 != 3 (1 != 2) != 3 1 != (2 != 3) +1 1 0 +select 1 <> 2 <> 3, (1 <> 2) <> 3, 1 <> (2 <> 3); +1 <> 2 <> 3 (1 <> 2) <> 3 1 <> (2 <> 3) +1 1 0 +select 1 < 2 < 3, (1 < 2) < 3, 1 < (2 < 3); +1 < 2 < 3 (1 < 2) < 3 1 < (2 < 3) +1 1 0 +select 3 <= 2 <= 1, (3 <= 2) <= 1, 3 <= (2 <= 1); +3 <= 2 <= 1 (3 <= 2) <= 1 3 <= (2 <= 1) +1 1 0 +select 1 > 2 > 3, (1 > 2) > 3, 1 > (2 > 3); +1 > 2 > 3 (1 > 2) > 3 1 > (2 > 3) +0 0 1 +select 1 >= 2 >= 3, (1 >= 2) >= 3, 1 >= (2 >= 3); +1 >= 2 >= 3 (1 >= 2) >= 3 1 >= (2 >= 3) +0 0 1 +Testing that | is associative +select 0xF0 | 0x0F | 0x55, (0xF0 | 0x0F) | 0x55, 0xF0 | (0x0F | 0x55); +0xF0 | 0x0F | 0x55 (0xF0 | 0x0F) | 0x55 0xF0 | (0x0F | 0x55) +255 255 255 +Testing that & is associative +select 0xF5 & 0x5F & 0x55, (0xF5 & 0x5F) & 0x55, 0xF5 & (0x5F & 0x55); +0xF5 & 0x5F & 0x55 (0xF5 & 0x5F) & 0x55 0xF5 & (0x5F & 0x55) +85 85 85 +Testing that << is left associative +select 4 << 3 << 2, (4 << 3) << 2, 4 << (3 << 2); +4 << 3 << 2 (4 << 3) << 2 4 << (3 << 2) +128 128 16384 +Testing that >> is left associative +select 256 >> 3 >> 2, (256 >> 3) >> 2, 256 >> (3 >> 2); +256 >> 3 >> 2 (256 >> 3) >> 2 256 >> (3 >> 2) +8 8 256 +Testing that & has precedence over | +select 0xF0 & 0x0F | 0x55, (0xF0 & 0x0F) | 0x55, 0xF0 & (0x0F | 0x55); +0xF0 & 0x0F | 0x55 (0xF0 & 0x0F) | 0x55 0xF0 & (0x0F | 0x55) +85 85 80 +select 0x55 | 0xF0 & 0x0F, (0x55 | 0xF0) & 0x0F, 0x55 | (0xF0 & 0x0F); +0x55 | 0xF0 & 0x0F (0x55 | 0xF0) & 0x0F 0x55 | (0xF0 & 0x0F) +85 5 85 +Testing that << has precedence over | +select 0x0F << 4 | 0x0F, (0x0F << 4) | 0x0F, 0x0F << (4 | 0x0F); +0x0F << 4 | 0x0F (0x0F << 4) | 0x0F 0x0F << (4 | 0x0F) +255 255 491520 +select 0x0F | 0x0F << 4, (0x0F | 0x0F) << 4, 0x0F | (0x0F << 4); +0x0F | 0x0F << 4 (0x0F | 0x0F) << 4 0x0F | (0x0F << 4) +255 240 255 +Testing that >> has precedence over | +select 0xF0 >> 4 | 0xFF, (0xF0 >> 4) | 0xFF, 0xF0 >> (4 | 0xFF); +0xF0 >> 4 | 0xFF (0xF0 >> 4) | 0xFF 0xF0 >> (4 | 0xFF) +255 255 0 +select 0xFF | 0xF0 >> 4, (0xFF | 0xF0) >> 4, 0xFF | (0xF0 >> 4); +0xFF | 0xF0 >> 4 (0xFF | 0xF0) >> 4 0xFF | (0xF0 >> 4) +255 15 255 +Testing that << has precedence over & +select 0x0F << 4 & 0xF0, (0x0F << 4) & 0xF0, 0x0F << (4 & 0xF0); +0x0F << 4 & 0xF0 (0x0F << 4) & 0xF0 0x0F << (4 & 0xF0) +240 240 15 +select 0xF0 & 0x0F << 4, (0xF0 & 0x0F) << 4, 0xF0 & (0x0F << 4); +0xF0 & 0x0F << 4 (0xF0 & 0x0F) << 4 0xF0 & (0x0F << 4) +240 0 240 +Testing that >> has precedence over & +select 0xF0 >> 4 & 0x55, (0xF0 >> 4) & 0x55, 0xF0 >> (4 & 0x55); +0xF0 >> 4 & 0x55 (0xF0 >> 4) & 0x55 0xF0 >> (4 & 0x55) +5 5 15 +select 0x0F & 0xF0 >> 4, (0x0F & 0xF0) >> 4, 0x0F & (0xF0 >> 4); +0x0F & 0xF0 >> 4 (0x0F & 0xF0) >> 4 0x0F & (0xF0 >> 4) +15 0 15 +Testing that >> and << have the same precedence +select 0xFF >> 4 << 2, (0xFF >> 4) << 2, 0xFF >> (4 << 2); +0xFF >> 4 << 2 (0xFF >> 4) << 2 0xFF >> (4 << 2) +60 60 0 +select 0x0F << 4 >> 2, (0x0F << 4) >> 2, 0x0F << (4 >> 2); +0x0F << 4 >> 2 (0x0F << 4) >> 2 0x0F << (4 >> 2) +60 60 30 +Testing that binary + is associative +select 1 + 2 + 3, (1 + 2) + 3, 1 + (2 + 3); +1 + 2 + 3 (1 + 2) + 3 1 + (2 + 3) +6 6 6 +Testing that binary - is left associative +select 1 - 2 - 3, (1 - 2) - 3, 1 - (2 - 3); +1 - 2 - 3 (1 - 2) - 3 1 - (2 - 3) +-4 -4 2 +Testing that binary + and binary - have the same precedence +select 1 + 2 - 3, (1 + 2) - 3, 1 + (2 - 3); +1 + 2 - 3 (1 + 2) - 3 1 + (2 - 3) +0 0 0 +select 1 - 2 + 3, (1 - 2) + 3, 1 - (2 + 3); +1 - 2 + 3 (1 - 2) + 3 1 - (2 + 3) +2 2 -4 +Testing that binary + has precedence over | +select 0xF0 + 0x0F | 0x55, (0xF0 + 0x0F) | 0x55, 0xF0 + (0x0F | 0x55); +0xF0 + 0x0F | 0x55 (0xF0 + 0x0F) | 0x55 0xF0 + (0x0F | 0x55) +255 255 335 +select 0x55 | 0xF0 + 0x0F, (0x55 | 0xF0) + 0x0F, 0x55 | (0xF0 + 0x0F); +0x55 | 0xF0 + 0x0F (0x55 | 0xF0) + 0x0F 0x55 | (0xF0 + 0x0F) +255 260 255 +Testing that binary + has precedence over & +select 0xF0 + 0x0F & 0x55, (0xF0 + 0x0F) & 0x55, 0xF0 + (0x0F & 0x55); +0xF0 + 0x0F & 0x55 (0xF0 + 0x0F) & 0x55 0xF0 + (0x0F & 0x55) +85 85 245 +select 0x55 & 0xF0 + 0x0F, (0x55 & 0xF0) + 0x0F, 0x55 & (0xF0 + 0x0F); +0x55 & 0xF0 + 0x0F (0x55 & 0xF0) + 0x0F 0x55 & (0xF0 + 0x0F) +85 95 85 +Testing that binary + has precedence over << +select 2 + 3 << 4, (2 + 3) << 4, 2 + (3 << 4); +2 + 3 << 4 (2 + 3) << 4 2 + (3 << 4) +80 80 50 +select 3 << 4 + 2, (3 << 4) + 2, 3 << (4 + 2); +3 << 4 + 2 (3 << 4) + 2 3 << (4 + 2) +192 50 192 +Testing that binary + has precedence over >> +select 4 + 3 >> 2, (4 + 3) >> 2, 4 + (3 >> 2); +4 + 3 >> 2 (4 + 3) >> 2 4 + (3 >> 2) +1 1 4 +select 3 >> 2 + 1, (3 >> 2) + 1, 3 >> (2 + 1); +3 >> 2 + 1 (3 >> 2) + 1 3 >> (2 + 1) +0 1 0 +Testing that binary - has precedence over | +select 0xFF - 0x0F | 0x55, (0xFF - 0x0F) | 0x55, 0xFF - (0x0F | 0x55); +0xFF - 0x0F | 0x55 (0xFF - 0x0F) | 0x55 0xFF - (0x0F | 0x55) +245 245 160 +select 0x55 | 0xFF - 0xF0, (0x55 | 0xFF) - 0xF0, 0x55 | (0xFF - 0xF0); +0x55 | 0xFF - 0xF0 (0x55 | 0xFF) - 0xF0 0x55 | (0xFF - 0xF0) +95 15 95 +Testing that binary - has precedence over & +select 0xFF - 0xF0 & 0x55, (0xFF - 0xF0) & 0x55, 0xFF - (0xF0 & 0x55); +0xFF - 0xF0 & 0x55 (0xFF - 0xF0) & 0x55 0xFF - (0xF0 & 0x55) +5 5 175 +select 0x55 & 0xFF - 0xF0, (0x55 & 0xFF) - 0xF0, 0x55 & (0xFF - 0xF0); +0x55 & 0xFF - 0xF0 (0x55 & 0xFF) - 0xF0 0x55 & (0xFF - 0xF0) +5 -155 5 +Testing that binary - has precedence over << +select 16 - 3 << 2, (16 - 3) << 2, 16 - (3 << 2); +16 - 3 << 2 (16 - 3) << 2 16 - (3 << 2) +52 52 4 +select 4 << 3 - 2, (4 << 3) - 2, 4 << (3 - 2); +4 << 3 - 2 (4 << 3) - 2 4 << (3 - 2) +8 30 8 +Testing that binary - has precedence over >> +select 16 - 3 >> 2, (16 - 3) >> 2, 16 - (3 >> 2); +16 - 3 >> 2 (16 - 3) >> 2 16 - (3 >> 2) +3 3 16 +select 16 >> 3 - 2, (16 >> 3) - 2, 16 >> (3 - 2); +16 >> 3 - 2 (16 >> 3) - 2 16 >> (3 - 2) +8 0 8 +Testing that * is associative +select 2 * 3 * 4, (2 * 3) * 4, 2 * (3 * 4); +2 * 3 * 4 (2 * 3) * 4 2 * (3 * 4) +24 24 24 +Testing that * has precedence over | +select 2 * 0x40 | 0x0F, (2 * 0x40) | 0x0F, 2 * (0x40 | 0x0F); +2 * 0x40 | 0x0F (2 * 0x40) | 0x0F 2 * (0x40 | 0x0F) +143 143 158 +select 0x0F | 2 * 0x40, (0x0F | 2) * 0x40, 0x0F | (2 * 0x40); +0x0F | 2 * 0x40 (0x0F | 2) * 0x40 0x0F | (2 * 0x40) +143 960 143 +Testing that * has precedence over & +select 2 * 0x40 & 0x55, (2 * 0x40) & 0x55, 2 * (0x40 & 0x55); +2 * 0x40 & 0x55 (2 * 0x40) & 0x55 2 * (0x40 & 0x55) +0 0 128 +select 0xF0 & 2 * 0x40, (0xF0 & 2) * 0x40, 0xF0 & (2 * 0x40); +0xF0 & 2 * 0x40 (0xF0 & 2) * 0x40 0xF0 & (2 * 0x40) +128 0 128 +Testing that * has precedence over << +select 5 * 3 << 4, (5 * 3) << 4, 5 * (3 << 4); +5 * 3 << 4 (5 * 3) << 4 5 * (3 << 4) +240 240 240 +select 2 << 3 * 4, (2 << 3) * 4, 2 << (3 * 4); +2 << 3 * 4 (2 << 3) * 4 2 << (3 * 4) +8192 64 8192 +Testing that * has precedence over >> +select 3 * 4 >> 2, (3 * 4) >> 2, 3 * (4 >> 2); +3 * 4 >> 2 (3 * 4) >> 2 3 * (4 >> 2) +3 3 3 +select 4 >> 2 * 3, (4 >> 2) * 3, 4 >> (2 * 3); +4 >> 2 * 3 (4 >> 2) * 3 4 >> (2 * 3) +0 3 0 +Testing that * has precedence over binary + +select 2 * 3 + 4, (2 * 3) + 4, 2 * (3 + 4); +2 * 3 + 4 (2 * 3) + 4 2 * (3 + 4) +10 10 14 +select 2 + 3 * 4, (2 + 3) * 4, 2 + (3 * 4); +2 + 3 * 4 (2 + 3) * 4 2 + (3 * 4) +14 20 14 +Testing that * has precedence over binary - +select 4 * 3 - 2, (4 * 3) - 2, 4 * (3 - 2); +4 * 3 - 2 (4 * 3) - 2 4 * (3 - 2) +10 10 4 +select 4 - 3 * 2, (4 - 3) * 2, 4 - (3 * 2); +4 - 3 * 2 (4 - 3) * 2 4 - (3 * 2) +-2 2 -2 +Testing that / is left associative +select 15 / 5 / 3, (15 / 5) / 3, 15 / (5 / 3); +15 / 5 / 3 (15 / 5) / 3 15 / (5 / 3) +1.00000000 1.00000000 9.0000 +Testing that / has precedence over | +select 105 / 5 | 2, (105 / 5) | 2, 105 / (5 | 2); +105 / 5 | 2 (105 / 5) | 2 105 / (5 | 2) +23 23 15.0000 +select 105 | 2 / 5, (105 | 2) / 5, 105 | (2 / 5); +105 | 2 / 5 (105 | 2) / 5 105 | (2 / 5) +105 21.4000 105 +Testing that / has precedence over & +select 105 / 5 & 0x0F, (105 / 5) & 0x0F, 105 / (5 & 0x0F); +105 / 5 & 0x0F (105 / 5) & 0x0F 105 / (5 & 0x0F) +5 5 21.0000 +select 0x0F & 105 / 5, (0x0F & 105) / 5, 0x0F & (105 / 5); +0x0F & 105 / 5 (0x0F & 105) / 5 0x0F & (105 / 5) +5 1.8000 5 +Testing that / has precedence over << +select 0x80 / 4 << 2, (0x80 / 4) << 2, 0x80 / (4 << 2); +0x80 / 4 << 2 (0x80 / 4) << 2 0x80 / (4 << 2) +128 128 8.0000 +select 0x80 << 4 / 2, (0x80 << 4) / 2, 0x80 << (4 / 2); +0x80 << 4 / 2 (0x80 << 4) / 2 0x80 << (4 / 2) +512 1024.0000 512 +Testing that / has precedence over >> +select 0x80 / 4 >> 2, (0x80 / 4) >> 2, 0x80 / (4 >> 2); +0x80 / 4 >> 2 (0x80 / 4) >> 2 0x80 / (4 >> 2) +8 8 128.0000 +select 0x80 >> 4 / 2, (0x80 >> 4) / 2, 0x80 >> (4 / 2); +0x80 >> 4 / 2 (0x80 >> 4) / 2 0x80 >> (4 / 2) +32 4.0000 32 +Testing that / has precedence over binary + +select 0x80 / 2 + 2, (0x80 / 2) + 2, 0x80 / (2 + 2); +0x80 / 2 + 2 (0x80 / 2) + 2 0x80 / (2 + 2) +66.0000 66.0000 32.0000 +select 0x80 + 2 / 2, (0x80 + 2) / 2, 0x80 + (2 / 2); +0x80 + 2 / 2 (0x80 + 2) / 2 0x80 + (2 / 2) +129.0000 65.0000 129.0000 +Testing that / has precedence over binary - +select 0x80 / 4 - 2, (0x80 / 4) - 2, 0x80 / (4 - 2); +0x80 / 4 - 2 (0x80 / 4) - 2 0x80 / (4 - 2) +30.0000 30.0000 64.0000 +select 0x80 - 4 / 2, (0x80 - 4) / 2, 0x80 - (4 / 2); +0x80 - 4 / 2 (0x80 - 4) / 2 0x80 - (4 / 2) +126.0000 62.0000 126.0000 +Testing that ^ is associative +select 0xFF ^ 0xF0 ^ 0x0F, (0xFF ^ 0xF0) ^ 0x0F, 0xFF ^ (0xF0 ^ 0x0F); +0xFF ^ 0xF0 ^ 0x0F (0xFF ^ 0xF0) ^ 0x0F 0xFF ^ (0xF0 ^ 0x0F) +0 0 0 +select 0xFF ^ 0xF0 ^ 0x55, (0xFF ^ 0xF0) ^ 0x55, 0xFF ^ (0xF0 ^ 0x55); +0xFF ^ 0xF0 ^ 0x55 (0xFF ^ 0xF0) ^ 0x55 0xFF ^ (0xF0 ^ 0x55) +90 90 90 +Testing that ^ has precedence over | +select 0xFF ^ 0xF0 | 0x0F, (0xFF ^ 0xF0) | 0x0F, 0xFF ^ (0xF0 | 0x0F); +0xFF ^ 0xF0 | 0x0F (0xFF ^ 0xF0) | 0x0F 0xFF ^ (0xF0 | 0x0F) +15 15 0 +select 0xF0 | 0xFF ^ 0xF0, (0xF0 | 0xFF) ^ 0xF0, 0xF0 | (0xFF ^ 0xF0); +0xF0 | 0xFF ^ 0xF0 (0xF0 | 0xFF) ^ 0xF0 0xF0 | (0xFF ^ 0xF0) +255 15 255 +Testing that ^ has precedence over & +select 0xFF ^ 0xF0 & 0x0F, (0xFF ^ 0xF0) & 0x0F, 0xFF ^ (0xF0 & 0x0F); +0xFF ^ 0xF0 & 0x0F (0xFF ^ 0xF0) & 0x0F 0xFF ^ (0xF0 & 0x0F) +15 15 255 +select 0x0F & 0xFF ^ 0xF0, (0x0F & 0xFF) ^ 0xF0, 0x0F & (0xFF ^ 0xF0); +0x0F & 0xFF ^ 0xF0 (0x0F & 0xFF) ^ 0xF0 0x0F & (0xFF ^ 0xF0) +15 255 15 +Testing that ^ has precedence over << +select 0xFF ^ 0xF0 << 2, (0xFF ^ 0xF0) << 2, 0xFF ^ (0xF0 << 2); +0xFF ^ 0xF0 << 2 (0xFF ^ 0xF0) << 2 0xFF ^ (0xF0 << 2) +60 60 831 +select 0x0F << 2 ^ 0xFF, (0x0F << 2) ^ 0xFF, 0x0F << (2 ^ 0xFF); +0x0F << 2 ^ 0xFF (0x0F << 2) ^ 0xFF 0x0F << (2 ^ 0xFF) +0 195 0 +Testing that ^ has precedence over >> +select 0xFF ^ 0xF0 >> 2, (0xFF ^ 0xF0) >> 2, 0xFF ^ (0xF0 >> 2); +0xFF ^ 0xF0 >> 2 (0xFF ^ 0xF0) >> 2 0xFF ^ (0xF0 >> 2) +3 3 195 +select 0xFF >> 2 ^ 0xF0, (0xFF >> 2) ^ 0xF0, 0xFF >> (2 ^ 0xF0); +0xFF >> 2 ^ 0xF0 (0xFF >> 2) ^ 0xF0 0xFF >> (2 ^ 0xF0) +0 207 0 +Testing that ^ has precedence over binary + +select 0xFF ^ 0xF0 + 0x0F, (0xFF ^ 0xF0) + 0x0F, 0xFF ^ (0xF0 + 0x0F); +0xFF ^ 0xF0 + 0x0F (0xFF ^ 0xF0) + 0x0F 0xFF ^ (0xF0 + 0x0F) +30 30 0 +select 0x0F + 0xFF ^ 0xF0, (0x0F + 0xFF) ^ 0xF0, 0x0F + (0xFF ^ 0xF0); +0x0F + 0xFF ^ 0xF0 (0x0F + 0xFF) ^ 0xF0 0x0F + (0xFF ^ 0xF0) +30 510 30 +Testing that ^ has precedence over binary - +select 0xFF ^ 0xF0 - 1, (0xFF ^ 0xF0) - 1, 0xFF ^ (0xF0 - 1); +0xFF ^ 0xF0 - 1 (0xFF ^ 0xF0) - 1 0xFF ^ (0xF0 - 1) +14 14 16 +select 0x55 - 0x0F ^ 0x55, (0x55 - 0x0F) ^ 0x55, 0x55 - (0x0F ^ 0x55); +0x55 - 0x0F ^ 0x55 (0x55 - 0x0F) ^ 0x55 0x55 - (0x0F ^ 0x55) +-5 19 -5 +Testing that ^ has precedence over * +select 0xFF ^ 0xF0 * 2, (0xFF ^ 0xF0) * 2, 0xFF ^ (0xF0 * 2); +0xFF ^ 0xF0 * 2 (0xFF ^ 0xF0) * 2 0xFF ^ (0xF0 * 2) +30 30 287 +select 2 * 0xFF ^ 0xF0, (2 * 0xFF) ^ 0xF0, 2 * (0xFF ^ 0xF0); +2 * 0xFF ^ 0xF0 (2 * 0xFF) ^ 0xF0 2 * (0xFF ^ 0xF0) +30 270 30 +Testing that ^ has precedence over / +select 0xFF ^ 0xF0 / 2, (0xFF ^ 0xF0) / 2, 0xFF ^ (0xF0 / 2); +0xFF ^ 0xF0 / 2 (0xFF ^ 0xF0) / 2 0xFF ^ (0xF0 / 2) +7.5000 7.5000 135 +select 0xF2 / 2 ^ 0xF0, (0xF2 / 2) ^ 0xF0, 0xF2 / (2 ^ 0xF0); +0xF2 / 2 ^ 0xF0 (0xF2 / 2) ^ 0xF0 0xF2 / (2 ^ 0xF0) +1.0000 137 1.0000 +Testing that ^ has precedence over % +select 0xFF ^ 0xF0 % 0x20, (0xFF ^ 0xF0) % 0x20, 0xFF ^ (0xF0 % 0x20); +0xFF ^ 0xF0 % 0x20 (0xFF ^ 0xF0) % 0x20 0xFF ^ (0xF0 % 0x20) +15 15 239 +select 0xFF % 0x20 ^ 0xF0, (0xFF % 0x20) ^ 0xF0, 0xFF % (0x20 ^ 0xF0); +0xFF % 0x20 ^ 0xF0 (0xFF % 0x20) ^ 0xF0 0xFF % (0x20 ^ 0xF0) +47 239 47 +Testing that ^ has precedence over DIV +select 0xFF ^ 0xF0 DIV 2, (0xFF ^ 0xF0) DIV 2, 0xFF ^ (0xF0 DIV 2); +0xFF ^ 0xF0 DIV 2 (0xFF ^ 0xF0) DIV 2 0xFF ^ (0xF0 DIV 2) +7 7 135 +select 0xF2 DIV 2 ^ 0xF0, (0xF2 DIV 2) ^ 0xF0, 0xF2 DIV (2 ^ 0xF0); +0xF2 DIV 2 ^ 0xF0 (0xF2 DIV 2) ^ 0xF0 0xF2 DIV (2 ^ 0xF0) +1 137 1 +Testing that ^ has precedence over MOD +select 0xFF ^ 0xF0 MOD 0x20, (0xFF ^ 0xF0) MOD 0x20, 0xFF ^ (0xF0 MOD 0x20); +0xFF ^ 0xF0 MOD 0x20 (0xFF ^ 0xF0) MOD 0x20 0xFF ^ (0xF0 MOD 0x20) +15 15 239 +select 0xFF MOD 0x20 ^ 0xF0, (0xFF MOD 0x20) ^ 0xF0, 0xFF MOD (0x20 ^ 0xF0); +0xFF MOD 0x20 ^ 0xF0 (0xFF MOD 0x20) ^ 0xF0 0xFF MOD (0x20 ^ 0xF0) +47 239 47 diff --git a/mysql-test/t/parser_precedence.test b/mysql-test/t/parser_precedence.test index a3a80776fb1..484c8759779 100644 --- a/mysql-test/t/parser_precedence.test +++ b/mysql-test/t/parser_precedence.test @@ -91,3 +91,243 @@ select count(*) from t1_30237_bool drop table t1_30237_bool; +--echo Testing that NOT has precedence over OR +select (NOT FALSE) OR TRUE, NOT (FALSE OR TRUE), NOT FALSE OR TRUE; + +--echo Testing that NOT has precedence over XOR +select (NOT FALSE) XOR FALSE, NOT (FALSE XOR FALSE), NOT FALSE XOR FALSE; + +--echo Testing that NOT has precedence over AND +select (NOT FALSE) AND FALSE, NOT (FALSE AND FALSE), NOT FALSE AND FALSE; + +--echo Testing that NOT is associative +select NOT NOT TRUE, NOT NOT NOT FALSE; + +--echo Testing that IS has precedence over NOT +select (NOT NULL) IS TRUE, NOT (NULL IS TRUE), NOT NULL IS TRUE; +select (NOT NULL) IS NOT TRUE, NOT (NULL IS NOT TRUE), NOT NULL IS NOT TRUE; +select (NOT NULL) IS FALSE, NOT (NULL IS FALSE), NOT NULL IS FALSE; +select (NOT NULL) IS NOT FALSE, NOT (NULL IS NOT FALSE), NOT NULL IS NOT FALSE; +select (NOT TRUE) IS UNKNOWN, NOT (TRUE IS UNKNOWN), NOT TRUE IS UNKNOWN; +select (NOT TRUE) IS NOT UNKNOWN, NOT (TRUE IS NOT UNKNOWN), NOT TRUE IS NOT UNKNOWN; +select (NOT TRUE) IS NULL, NOT (TRUE IS NULL), NOT TRUE IS NULL; +select (NOT TRUE) IS NOT NULL, NOT (TRUE IS NOT NULL), NOT TRUE IS NOT NULL; + +--echo Testing that IS [NOT] TRUE/FALSE/UNKNOWN predicates are not associative +# Documenting existing behavior in 5.0.48 +-- error ER_PARSE_ERROR +select TRUE IS TRUE IS TRUE IS TRUE; +-- error ER_PARSE_ERROR +select FALSE IS NOT TRUE IS NOT TRUE IS NOT TRUE; +-- error ER_PARSE_ERROR +select NULL IS FALSE IS FALSE IS FALSE; +-- error ER_PARSE_ERROR +select TRUE IS NOT FALSE IS NOT FALSE IS NOT FALSE; +-- error ER_PARSE_ERROR +select FALSE IS UNKNOWN IS UNKNOWN IS UNKNOWN; +-- error ER_PARSE_ERROR +select TRUE IS NOT UNKNOWN IS NOT UNKNOWN IS NOT UNKNOWN; + +--echo Testing that IS [NOT] NULL predicates are associative +# Documenting existing behavior in 5.0.48 +select FALSE IS NULL IS NULL IS NULL; +select TRUE IS NOT NULL IS NOT NULL IS NOT NULL; + +--echo Testing that comparison operators are left associative +select 1 <=> 2 <=> 2, (1 <=> 2) <=> 2, 1 <=> (2 <=> 2); +select 1 = 2 = 2, (1 = 2) = 2, 1 = (2 = 2); +select 1 != 2 != 3, (1 != 2) != 3, 1 != (2 != 3); +select 1 <> 2 <> 3, (1 <> 2) <> 3, 1 <> (2 <> 3); +select 1 < 2 < 3, (1 < 2) < 3, 1 < (2 < 3); +select 3 <= 2 <= 1, (3 <= 2) <= 1, 3 <= (2 <= 1); +select 1 > 2 > 3, (1 > 2) > 3, 1 > (2 > 3); +select 1 >= 2 >= 3, (1 >= 2) >= 3, 1 >= (2 >= 3); + +-- echo Testing that | is associative +select 0xF0 | 0x0F | 0x55, (0xF0 | 0x0F) | 0x55, 0xF0 | (0x0F | 0x55); + +-- echo Testing that & is associative +select 0xF5 & 0x5F & 0x55, (0xF5 & 0x5F) & 0x55, 0xF5 & (0x5F & 0x55); + +-- echo Testing that << is left associative +select 4 << 3 << 2, (4 << 3) << 2, 4 << (3 << 2); + +-- echo Testing that >> is left associative +select 256 >> 3 >> 2, (256 >> 3) >> 2, 256 >> (3 >> 2); + +--echo Testing that & has precedence over | +select 0xF0 & 0x0F | 0x55, (0xF0 & 0x0F) | 0x55, 0xF0 & (0x0F | 0x55); +select 0x55 | 0xF0 & 0x0F, (0x55 | 0xF0) & 0x0F, 0x55 | (0xF0 & 0x0F); + +--echo Testing that << has precedence over | +select 0x0F << 4 | 0x0F, (0x0F << 4) | 0x0F, 0x0F << (4 | 0x0F); +select 0x0F | 0x0F << 4, (0x0F | 0x0F) << 4, 0x0F | (0x0F << 4); + +--echo Testing that >> has precedence over | +select 0xF0 >> 4 | 0xFF, (0xF0 >> 4) | 0xFF, 0xF0 >> (4 | 0xFF); +select 0xFF | 0xF0 >> 4, (0xFF | 0xF0) >> 4, 0xFF | (0xF0 >> 4); + +--echo Testing that << has precedence over & +select 0x0F << 4 & 0xF0, (0x0F << 4) & 0xF0, 0x0F << (4 & 0xF0); +select 0xF0 & 0x0F << 4, (0xF0 & 0x0F) << 4, 0xF0 & (0x0F << 4); + +--echo Testing that >> has precedence over & +select 0xF0 >> 4 & 0x55, (0xF0 >> 4) & 0x55, 0xF0 >> (4 & 0x55); +select 0x0F & 0xF0 >> 4, (0x0F & 0xF0) >> 4, 0x0F & (0xF0 >> 4); + +--echo Testing that >> and << have the same precedence +select 0xFF >> 4 << 2, (0xFF >> 4) << 2, 0xFF >> (4 << 2); +select 0x0F << 4 >> 2, (0x0F << 4) >> 2, 0x0F << (4 >> 2); + +--echo Testing that binary + is associative +select 1 + 2 + 3, (1 + 2) + 3, 1 + (2 + 3); + +--echo Testing that binary - is left associative +select 1 - 2 - 3, (1 - 2) - 3, 1 - (2 - 3); + +--echo Testing that binary + and binary - have the same precedence +# evaluated left to right +select 1 + 2 - 3, (1 + 2) - 3, 1 + (2 - 3); +select 1 - 2 + 3, (1 - 2) + 3, 1 - (2 + 3); + +--echo Testing that binary + has precedence over | +select 0xF0 + 0x0F | 0x55, (0xF0 + 0x0F) | 0x55, 0xF0 + (0x0F | 0x55); +select 0x55 | 0xF0 + 0x0F, (0x55 | 0xF0) + 0x0F, 0x55 | (0xF0 + 0x0F); + +--echo Testing that binary + has precedence over & +select 0xF0 + 0x0F & 0x55, (0xF0 + 0x0F) & 0x55, 0xF0 + (0x0F & 0x55); +select 0x55 & 0xF0 + 0x0F, (0x55 & 0xF0) + 0x0F, 0x55 & (0xF0 + 0x0F); + +--echo Testing that binary + has precedence over << +select 2 + 3 << 4, (2 + 3) << 4, 2 + (3 << 4); +select 3 << 4 + 2, (3 << 4) + 2, 3 << (4 + 2); + +--echo Testing that binary + has precedence over >> +select 4 + 3 >> 2, (4 + 3) >> 2, 4 + (3 >> 2); +select 3 >> 2 + 1, (3 >> 2) + 1, 3 >> (2 + 1); + +--echo Testing that binary - has precedence over | +select 0xFF - 0x0F | 0x55, (0xFF - 0x0F) | 0x55, 0xFF - (0x0F | 0x55); +select 0x55 | 0xFF - 0xF0, (0x55 | 0xFF) - 0xF0, 0x55 | (0xFF - 0xF0); + +--echo Testing that binary - has precedence over & +select 0xFF - 0xF0 & 0x55, (0xFF - 0xF0) & 0x55, 0xFF - (0xF0 & 0x55); +select 0x55 & 0xFF - 0xF0, (0x55 & 0xFF) - 0xF0, 0x55 & (0xFF - 0xF0); + +--echo Testing that binary - has precedence over << +select 16 - 3 << 2, (16 - 3) << 2, 16 - (3 << 2); +select 4 << 3 - 2, (4 << 3) - 2, 4 << (3 - 2); + +--echo Testing that binary - has precedence over >> +select 16 - 3 >> 2, (16 - 3) >> 2, 16 - (3 >> 2); +select 16 >> 3 - 2, (16 >> 3) - 2, 16 >> (3 - 2); + +--echo Testing that * is associative +select 2 * 3 * 4, (2 * 3) * 4, 2 * (3 * 4); + +--echo Testing that * has precedence over | +select 2 * 0x40 | 0x0F, (2 * 0x40) | 0x0F, 2 * (0x40 | 0x0F); +select 0x0F | 2 * 0x40, (0x0F | 2) * 0x40, 0x0F | (2 * 0x40); + +--echo Testing that * has precedence over & +select 2 * 0x40 & 0x55, (2 * 0x40) & 0x55, 2 * (0x40 & 0x55); +select 0xF0 & 2 * 0x40, (0xF0 & 2) * 0x40, 0xF0 & (2 * 0x40); + +--echo Testing that * has precedence over << +# Actually, can't prove it for the first case, +# since << is a multiplication by a power of 2, +# and * is associative +select 5 * 3 << 4, (5 * 3) << 4, 5 * (3 << 4); +select 2 << 3 * 4, (2 << 3) * 4, 2 << (3 * 4); + +--echo Testing that * has precedence over >> +# >> is a multiplication by a (negative) power of 2, +# see above. +select 3 * 4 >> 2, (3 * 4) >> 2, 3 * (4 >> 2); +select 4 >> 2 * 3, (4 >> 2) * 3, 4 >> (2 * 3); + +--echo Testing that * has precedence over binary + +select 2 * 3 + 4, (2 * 3) + 4, 2 * (3 + 4); +select 2 + 3 * 4, (2 + 3) * 4, 2 + (3 * 4); + +--echo Testing that * has precedence over binary - +select 4 * 3 - 2, (4 * 3) - 2, 4 * (3 - 2); +select 4 - 3 * 2, (4 - 3) * 2, 4 - (3 * 2); + +--echo Testing that / is left associative +select 15 / 5 / 3, (15 / 5) / 3, 15 / (5 / 3); + +--echo Testing that / has precedence over | +select 105 / 5 | 2, (105 / 5) | 2, 105 / (5 | 2); +select 105 | 2 / 5, (105 | 2) / 5, 105 | (2 / 5); + +--echo Testing that / has precedence over & +select 105 / 5 & 0x0F, (105 / 5) & 0x0F, 105 / (5 & 0x0F); +select 0x0F & 105 / 5, (0x0F & 105) / 5, 0x0F & (105 / 5); + +--echo Testing that / has precedence over << +select 0x80 / 4 << 2, (0x80 / 4) << 2, 0x80 / (4 << 2); +select 0x80 << 4 / 2, (0x80 << 4) / 2, 0x80 << (4 / 2); + +--echo Testing that / has precedence over >> +select 0x80 / 4 >> 2, (0x80 / 4) >> 2, 0x80 / (4 >> 2); +select 0x80 >> 4 / 2, (0x80 >> 4) / 2, 0x80 >> (4 / 2); + +--echo Testing that / has precedence over binary + +select 0x80 / 2 + 2, (0x80 / 2) + 2, 0x80 / (2 + 2); +select 0x80 + 2 / 2, (0x80 + 2) / 2, 0x80 + (2 / 2); + +--echo Testing that / has precedence over binary - +select 0x80 / 4 - 2, (0x80 / 4) - 2, 0x80 / (4 - 2); +select 0x80 - 4 / 2, (0x80 - 4) / 2, 0x80 - (4 / 2); + +# TODO: %, DIV, MOD + +--echo Testing that ^ is associative +select 0xFF ^ 0xF0 ^ 0x0F, (0xFF ^ 0xF0) ^ 0x0F, 0xFF ^ (0xF0 ^ 0x0F); +select 0xFF ^ 0xF0 ^ 0x55, (0xFF ^ 0xF0) ^ 0x55, 0xFF ^ (0xF0 ^ 0x55); + +--echo Testing that ^ has precedence over | +select 0xFF ^ 0xF0 | 0x0F, (0xFF ^ 0xF0) | 0x0F, 0xFF ^ (0xF0 | 0x0F); +select 0xF0 | 0xFF ^ 0xF0, (0xF0 | 0xFF) ^ 0xF0, 0xF0 | (0xFF ^ 0xF0); + +--echo Testing that ^ has precedence over & +select 0xFF ^ 0xF0 & 0x0F, (0xFF ^ 0xF0) & 0x0F, 0xFF ^ (0xF0 & 0x0F); +select 0x0F & 0xFF ^ 0xF0, (0x0F & 0xFF) ^ 0xF0, 0x0F & (0xFF ^ 0xF0); + +--echo Testing that ^ has precedence over << +select 0xFF ^ 0xF0 << 2, (0xFF ^ 0xF0) << 2, 0xFF ^ (0xF0 << 2); +select 0x0F << 2 ^ 0xFF, (0x0F << 2) ^ 0xFF, 0x0F << (2 ^ 0xFF); + +--echo Testing that ^ has precedence over >> +select 0xFF ^ 0xF0 >> 2, (0xFF ^ 0xF0) >> 2, 0xFF ^ (0xF0 >> 2); +select 0xFF >> 2 ^ 0xF0, (0xFF >> 2) ^ 0xF0, 0xFF >> (2 ^ 0xF0); + +--echo Testing that ^ has precedence over binary + +select 0xFF ^ 0xF0 + 0x0F, (0xFF ^ 0xF0) + 0x0F, 0xFF ^ (0xF0 + 0x0F); +select 0x0F + 0xFF ^ 0xF0, (0x0F + 0xFF) ^ 0xF0, 0x0F + (0xFF ^ 0xF0); + +--echo Testing that ^ has precedence over binary - +select 0xFF ^ 0xF0 - 1, (0xFF ^ 0xF0) - 1, 0xFF ^ (0xF0 - 1); +select 0x55 - 0x0F ^ 0x55, (0x55 - 0x0F) ^ 0x55, 0x55 - (0x0F ^ 0x55); + +--echo Testing that ^ has precedence over * +select 0xFF ^ 0xF0 * 2, (0xFF ^ 0xF0) * 2, 0xFF ^ (0xF0 * 2); +select 2 * 0xFF ^ 0xF0, (2 * 0xFF) ^ 0xF0, 2 * (0xFF ^ 0xF0); + +--echo Testing that ^ has precedence over / +select 0xFF ^ 0xF0 / 2, (0xFF ^ 0xF0) / 2, 0xFF ^ (0xF0 / 2); +select 0xF2 / 2 ^ 0xF0, (0xF2 / 2) ^ 0xF0, 0xF2 / (2 ^ 0xF0); + +--echo Testing that ^ has precedence over % +select 0xFF ^ 0xF0 % 0x20, (0xFF ^ 0xF0) % 0x20, 0xFF ^ (0xF0 % 0x20); +select 0xFF % 0x20 ^ 0xF0, (0xFF % 0x20) ^ 0xF0, 0xFF % (0x20 ^ 0xF0); + +--echo Testing that ^ has precedence over DIV +select 0xFF ^ 0xF0 DIV 2, (0xFF ^ 0xF0) DIV 2, 0xFF ^ (0xF0 DIV 2); +select 0xF2 DIV 2 ^ 0xF0, (0xF2 DIV 2) ^ 0xF0, 0xF2 DIV (2 ^ 0xF0); + +--echo Testing that ^ has precedence over MOD +select 0xFF ^ 0xF0 MOD 0x20, (0xFF ^ 0xF0) MOD 0x20, 0xFF ^ (0xF0 MOD 0x20); +select 0xFF MOD 0x20 ^ 0xF0, (0xFF MOD 0x20) ^ 0xF0, 0xFF MOD (0x20 ^ 0xF0); + diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy index bfce73716c7..e0b9ab28594 100644 --- a/sql/sql_yacc.yy +++ b/sql/sql_yacc.yy @@ -1068,9 +1068,9 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize); %type literal text_literal insert_ident order_ident simple_ident select_item2 expr opt_expr opt_else sum_expr in_sum_expr - variable variable_aux bool_factor - bool_test bool_pri - predicate bit_expr bit_term bit_factor value_expr term factor + variable variable_aux + bool_pri + predicate bit_expr table_wild simple_expr udf_expr expr_or_default set_expr_or_default interval_expr param_marker geometry_function @@ -4468,8 +4468,7 @@ optional_braces: /* all possible expressions */ expr: - bool_factor - | expr or expr %prec OR_SYM + expr or expr %prec OR_SYM { /* Design notes: @@ -4564,30 +4563,30 @@ expr: $$ = new (YYTHD->mem_root) Item_cond_and($1, $3); } } - ; - -bool_factor: - NOT_SYM bool_factor { $$= negate_expression(YYTHD, $2); } - | bool_test ; - -bool_test: - bool_pri IS TRUE_SYM + | NOT_SYM expr %prec NOT_SYM + { $$= negate_expression(YYTHD, $2); } + | bool_pri IS TRUE_SYM %prec IS { $$= new (YYTHD->mem_root) Item_func_istrue($1); } - | bool_pri IS not TRUE_SYM + | bool_pri IS not TRUE_SYM %prec IS { $$= new (YYTHD->mem_root) Item_func_isnottrue($1); } - | bool_pri IS FALSE_SYM + | bool_pri IS FALSE_SYM %prec IS { $$= new (YYTHD->mem_root) Item_func_isfalse($1); } - | bool_pri IS not FALSE_SYM + | bool_pri IS not FALSE_SYM %prec IS { $$= new (YYTHD->mem_root) Item_func_isnotfalse($1); } - | bool_pri IS UNKNOWN_SYM { $$= new Item_func_isnull($1); } - | bool_pri IS not UNKNOWN_SYM { $$= new Item_func_isnotnull($1); } + | bool_pri IS UNKNOWN_SYM %prec IS + { $$= new Item_func_isnull($1); } + | bool_pri IS not UNKNOWN_SYM %prec IS + { $$= new Item_func_isnotnull($1); } | bool_pri ; bool_pri: - bool_pri IS NULL_SYM { $$= new Item_func_isnull($1); } - | bool_pri IS not NULL_SYM { $$= new Item_func_isnotnull($1); } - | bool_pri EQUAL_SYM predicate { $$= new Item_func_equal($1,$3); } + bool_pri IS NULL_SYM %prec IS + { $$= new Item_func_isnull($1); } + | bool_pri IS not NULL_SYM %prec IS + { $$= new Item_func_isnotnull($1); } + | bool_pri EQUAL_SYM predicate %prec EQUAL_SYM + { $$= new Item_func_equal($1,$3); } | bool_pri comp_op predicate %prec EQ { $$= (*$2)(0)->create($1,$3); } | bool_pri comp_op all_or_any '(' subselect ')' %prec EQ @@ -4630,11 +4629,11 @@ predicate: | bit_expr BETWEEN_SYM bit_expr AND_SYM predicate { $$= new Item_func_between($1,$3,$5); } | bit_expr not BETWEEN_SYM bit_expr AND_SYM predicate - { - Item_func_between *item= new Item_func_between($1,$4,$6); - item->negate(); - $$= item; - } + { + Item_func_between *item= new Item_func_between($1,$4,$6); + item->negate(); + $$= item; + } | bit_expr SOUNDS_SYM LIKE bit_expr { $$= new Item_func_eq(new Item_func_soundex($1), new Item_func_soundex($4)); } @@ -4648,40 +4647,36 @@ predicate: | bit_expr ; bit_expr: - bit_expr '|' bit_term { $$= new Item_func_bit_or($1,$3); } - | bit_term ; - -bit_term: - bit_term '&' bit_factor { $$= new Item_func_bit_and($1,$3); } - | bit_factor ; - -bit_factor: - bit_factor SHIFT_LEFT value_expr - { $$= new Item_func_shift_left($1,$3); } - | bit_factor SHIFT_RIGHT value_expr - { $$= new Item_func_shift_right($1,$3); } - | value_expr ; - -value_expr: - value_expr '+' term { $$= new Item_func_plus($1,$3); } - | value_expr '-' term { $$= new Item_func_minus($1,$3); } - | value_expr '+' interval_expr interval - { $$= new Item_date_add_interval($1,$3,$4,0); } - | value_expr '-' interval_expr interval - { $$= new Item_date_add_interval($1,$3,$4,1); } - | term ; - -term: - term '*' factor { $$= new Item_func_mul($1,$3); } - | term '/' factor { $$= new Item_func_div($1,$3); } - | term '%' factor { $$= new Item_func_mod($1,$3); } - | term DIV_SYM factor { $$= new Item_func_int_div($1,$3); } - | term MOD_SYM factor { $$= new Item_func_mod($1,$3); } - | factor ; - -factor: - factor '^' simple_expr { $$= new Item_func_bit_xor($1,$3); } - | simple_expr ; + bit_expr '|' bit_expr %prec '|' + { $$= new Item_func_bit_or($1,$3); } + | bit_expr '&' bit_expr %prec '&' + { $$= new Item_func_bit_and($1,$3); } + | bit_expr SHIFT_LEFT bit_expr %prec SHIFT_LEFT + { $$= new Item_func_shift_left($1,$3); } + | bit_expr SHIFT_RIGHT bit_expr %prec SHIFT_RIGHT + { $$= new Item_func_shift_right($1,$3); } + | bit_expr '+' bit_expr %prec '+' + { $$= new Item_func_plus($1,$3); } + | bit_expr '-' bit_expr %prec '-' + { $$= new Item_func_minus($1,$3); } + | bit_expr '+' interval_expr interval %prec '+' + { $$= new Item_date_add_interval($1,$3,$4,0); } + | bit_expr '-' interval_expr interval %prec '-' + { $$= new Item_date_add_interval($1,$3,$4,1); } + | bit_expr '*' bit_expr %prec '*' + { $$= new Item_func_mul($1,$3); } + | bit_expr '/' bit_expr %prec '/' + { $$= new Item_func_div($1,$3); } + | bit_expr '%' bit_expr %prec '%' + { $$= new Item_func_mod($1,$3); } + | bit_expr DIV_SYM bit_expr %prec DIV_SYM + { $$= new Item_func_int_div($1,$3); } + | bit_expr MOD_SYM bit_expr %prec MOD_SYM + { $$= new Item_func_mod($1,$3); } + | bit_expr '^' bit_expr + { $$= new Item_func_bit_xor($1,$3); } + | simple_expr + ; or: OR_SYM | OR2_SYM; and: AND_SYM | AND_AND_SYM; From 3d5440505cf530404b7b4d9ef544718ffb8c637f Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 29 Aug 2007 14:57:59 +0400 Subject: [PATCH 24/41] Test case for Bug#13675: DATETIME/DATE type in store proc param seems to be converted as varbinary. The bug has been already fixed. This CS just adds a test case for it. mysql-test/r/sp.result: Update result file. mysql-test/t/sp.test: Test case for BUG#13675. --- mysql-test/r/sp.result | 52 ++++++++++++++++++++++++++++++++++++++++ mysql-test/t/sp.test | 54 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 106 insertions(+) diff --git a/mysql-test/r/sp.result b/mysql-test/r/sp.result index 4a278cd4aec..7e80d9c3ad9 100644 --- a/mysql-test/r/sp.result +++ b/mysql-test/r/sp.result @@ -6314,4 +6314,56 @@ CALL p1(); NULL SET NAMES default; DROP PROCEDURE p1; + +# Bug#13675. + +DROP PROCEDURE IF EXISTS p1; +DROP PROCEDURE IF EXISTS p2; +DROP TABLE IF EXISTS t1; + +CREATE PROCEDURE p1(v DATETIME) CREATE TABLE t1 SELECT v; +CREATE PROCEDURE p2(v INT) CREATE TABLE t1 SELECT v; + +CALL p1(NOW()); +SHOW CREATE TABLE t1; +Table Create Table +t1 CREATE TABLE `t1` ( + `v` datetime default NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 + +DROP TABLE t1; + +CALL p1('text'); +Warnings: +Warning 1264 Out of range value adjusted for column 'v' at row 1 +SHOW CREATE TABLE t1; +Table Create Table +t1 CREATE TABLE `t1` ( + `v` datetime default NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 + +DROP TABLE t1; + +CALL p2(10); +SHOW CREATE TABLE t1; +Table Create Table +t1 CREATE TABLE `t1` ( + `v` bigint(11) default NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 + +DROP TABLE t1; + +CALL p2('text'); +Warnings: +Warning 1366 Incorrect integer value: 'text' for column 'v' at row 1 +SHOW CREATE TABLE t1; +Table Create Table +t1 CREATE TABLE `t1` ( + `v` bigint(11) default NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 + +DROP TABLE t1; + +DROP PROCEDURE p1; +DROP PROCEDURE p2; End of 5.0 tests diff --git a/mysql-test/t/sp.test b/mysql-test/t/sp.test index 46a1b1dc740..189273aeb06 100644 --- a/mysql-test/t/sp.test +++ b/mysql-test/t/sp.test @@ -7299,4 +7299,58 @@ CALL p1(); SET NAMES default; DROP PROCEDURE p1; +# +# Bug#13675: DATETIME/DATE type in store proc param seems to be converted as +# varbinary +# + +--echo +--echo # Bug#13675. +--echo + +--disable_warnings +DROP PROCEDURE IF EXISTS p1; +DROP PROCEDURE IF EXISTS p2; + +DROP TABLE IF EXISTS t1; +--enable_warnings + +--echo + +CREATE PROCEDURE p1(v DATETIME) CREATE TABLE t1 SELECT v; + +CREATE PROCEDURE p2(v INT) CREATE TABLE t1 SELECT v; + +--echo +CALL p1(NOW()); +SHOW CREATE TABLE t1; + +--echo +DROP TABLE t1; + +--echo +CALL p1('text'); +SHOW CREATE TABLE t1; + +--echo +DROP TABLE t1; + +--echo +CALL p2(10); +SHOW CREATE TABLE t1; + +--echo +DROP TABLE t1; + +--echo +CALL p2('text'); +SHOW CREATE TABLE t1; + +--echo +DROP TABLE t1; + +--echo +DROP PROCEDURE p1; +DROP PROCEDURE p2; + --echo End of 5.0 tests From cc0750aceeb29fae7fd6544a5e46ed5b9c61d1d2 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 29 Aug 2007 21:45:53 +0300 Subject: [PATCH 25/41] ndb - bug#29102 : use locked read even for blob parts ndb/src/ndbapi/NdbBlob.cpp: race condition : s/committedRead/readTuple/ when reading parts since TUP commits tuples separately --- ndb/src/ndbapi/NdbBlob.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/ndb/src/ndbapi/NdbBlob.cpp b/ndb/src/ndbapi/NdbBlob.cpp index 7ab9c2132d8..611d0396f96 100644 --- a/ndb/src/ndbapi/NdbBlob.cpp +++ b/ndb/src/ndbapi/NdbBlob.cpp @@ -892,7 +892,12 @@ NdbBlob::readParts(char* buf, Uint32 part, Uint32 count) while (n < count) { NdbOperation* tOp = theNdbCon->getNdbOperation(theBlobTable); if (tOp == NULL || - tOp->committedRead() == -1 || + /* + * This was committedRead() before. However lock on main + * table tuple does not fully protect blob parts since DBTUP + * commits each tuple separately. + */ + tOp->readTuple() == -1 || setPartKeyValue(tOp, part + n) == -1 || tOp->getValue((Uint32)3, buf) == NULL) { setErrorCode(tOp); From b0f899e9779764aee7b08021a179599e27a209e8 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 29 Aug 2007 14:50:32 -0600 Subject: [PATCH 26/41] Bug#28779 (mysql_query() allows execution of statements with unbalanced comments) Before this fix, the server would accept queries that contained comments, even when the comments were not properly closed with a '*' '/' marker. For example, select 1 /* + 2 would be accepted as select 1 /* + 2 */ and executed as select 1 With this fix, the server now rejects queries with unclosed comments as syntax errors. Both regular comments ('/' '*') and special comments ('/' '*' '!') must be closed with '*' '/' to be parsed correctly. mysql-test/r/comments.result: Unbalanced comments are a syntax error. mysql-test/t/comments.test: Unbalanced comments are a syntax error. sql/sql_lex.cc: Unbalanced comments are a syntax error. --- mysql-test/r/comments.result | 15 +++++++++++++++ mysql-test/t/comments.test | 33 ++++++++++++++++++++++++++++++++ sql/sql_lex.cc | 37 +++++++++++++++++++++++++++++------- 3 files changed, 78 insertions(+), 7 deletions(-) diff --git a/mysql-test/r/comments.result b/mysql-test/r/comments.result index a9106ce0538..1040c3fc8e9 100644 --- a/mysql-test/r/comments.result +++ b/mysql-test/r/comments.result @@ -26,3 +26,18 @@ select 1 # The rest of the row will be ignored 1 1 /* line with only comment */; +drop table if exists table_28779; +create table table_28779 (a int); +prepare bar from "DELETE FROM table_28779 WHERE a = 7 OR 1=1/*' AND b = 'bar';"; +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 '/*' AND b = 'bar'' at line 1 +prepare bar from "DELETE FROM table_28779 WHERE a = 7 OR 1=1/*' AND b = 'bar';*"; +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 '/*' AND b = 'bar';*' at line 1 +prepare bar from "DELETE FROM table_28779 WHERE a = 7 OR 1=1/*! AND 2=2;"; +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 '' at line 1 +prepare bar from "DELETE FROM table_28779 WHERE a = 7 OR 1=1/*! AND 2=2;*"; +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 ';*' at line 1 +prepare bar from "DELETE FROM table_28779 WHERE a = 7 OR 1=1/*!98765' AND b = 'bar';"; +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 '/*!98765' AND b = 'bar'' at line 1 +prepare bar from "DELETE FROM table_28779 WHERE a = 7 OR 1=1/*!98765' AND b = 'bar';*"; +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 '/*!98765' AND b = 'bar';*' at line 1 +drop table table_28779; diff --git a/mysql-test/t/comments.test b/mysql-test/t/comments.test index 52273ec9523..0c6853cf298 100644 --- a/mysql-test/t/comments.test +++ b/mysql-test/t/comments.test @@ -19,3 +19,36 @@ select 1 # The rest of the row will be ignored /* line with only comment */; # End of 4.1 tests + + +# +# Bug#28779 (mysql_query() allows execution of statements with unbalanced +# comments) +# + +--disable_warnings +drop table if exists table_28779; +--enable_warnings + +create table table_28779 (a int); + +--error 1064 +prepare bar from "DELETE FROM table_28779 WHERE a = 7 OR 1=1/*' AND b = 'bar';"; + +--error 1064 +prepare bar from "DELETE FROM table_28779 WHERE a = 7 OR 1=1/*' AND b = 'bar';*"; + +--error 1064 +prepare bar from "DELETE FROM table_28779 WHERE a = 7 OR 1=1/*! AND 2=2;"; + +--error 1064 +prepare bar from "DELETE FROM table_28779 WHERE a = 7 OR 1=1/*! AND 2=2;*"; + +--error 1064 +prepare bar from "DELETE FROM table_28779 WHERE a = 7 OR 1=1/*!98765' AND b = 'bar';"; + +--error 1064 +prepare bar from "DELETE FROM table_28779 WHERE a = 7 OR 1=1/*!98765' AND b = 'bar';*"; + +drop table table_28779; + diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc index 7911da69862..1770ff358a2 100644 --- a/sql/sql_lex.cc +++ b/sql/sql_lex.cc @@ -526,6 +526,7 @@ static inline uint int_token(const char *str,uint length) int MYSQLlex(void *arg, void *yythd) { reg1 uchar c; + bool comment_closed; int tokval, result_state; uint length; enum my_lex_states state; @@ -961,15 +962,34 @@ int MYSQLlex(void *arg, void *yythd) break; } } - while (lip->ptr != lip->end_of_query && - ((c=yyGet()) != '*' || yyPeek() != '/')) + /* + Discard: + - regular '/' '*' comments, + - special comments '/' '*' '!' for a future version, + by scanning until we find a closing '*' '/' marker. + Note: There is no such thing as nesting comments, + the first '*' '/' sequence seen will mark the end. + */ + comment_closed= FALSE; + while (lip->ptr != lip->end_of_query) { - if (c == '\n') - lip->yylineno++; + c= yyGet(); + if (c == '*') + { + if (yyPeek() == '/') + { + yySkip(); + comment_closed= TRUE; + state = MY_LEX_START; + break; + } + } + else if (c == '\n') + lip->yylineno++; } - if (lip->ptr != lip->end_of_query) - yySkip(); // remove last '/' - state = MY_LEX_START; // Try again + /* Unbalanced comments with a missing '*' '/' are a syntax error */ + if (! comment_closed) + return (ABORT_SYM); break; case MY_LEX_END_LONG_COMMENT: if (lex->in_comment && yyPeek() == '/') @@ -1009,6 +1029,9 @@ int MYSQLlex(void *arg, void *yythd) if (lip->ptr >= lip->end_of_query) { lip->next_state=MY_LEX_END; // Mark for next loop + /* Unbalanced comments with a missing '*' '/' are a syntax error */ + if (lex->in_comment) + return (ABORT_SYM); return(END_OF_INPUT); } state=MY_LEX_CHAR; From bb986a24e7d3436ea186278e9d82c896f22ddaaf Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 30 Aug 2007 12:53:24 +0400 Subject: [PATCH 27/41] Bug #30164: Using client side macro inside server side comments generates broken queries Problem: In cases when a client-side macro appears inside a server-side comment, the add_line() function in mysql.cc discarded all characters until the next delimiter to remove macro arguments from the query string. This resulted in broken queries being sent to the server when the next delimiter character appeared past the comment's boundaries, because the comment closing sequence ('*/') was discarded. Fix: If a client-side macro appears inside a server-side comment, discard all characters in the comment after the macro (that is, until the end of the comment rather than the next delimiter). This is a minimal fix to allow only simple cases used by the mysqlbinlog utility. Limitations that are worth documenting: - Nested server-side and/or client-side comments are not supported by mysql.cc - Using client-side macros in multi-line server-side comments is not supported - All characters after a client-side macro in a server-side comment will be omitted from the query string (and thus, will not be sent to server). client/mysql.cc: If a client-side macro appears inside a server-side comment, discard all characters in the comment after the macro. mysql-test/r/mysql.result: Added a test case for bug #30164. mysql-test/t/mysql.test: Added a test case for bug #30164. --- client/mysql.cc | 54 +++++++++++++++++++++++++++------------ mysql-test/r/mysql.result | 2 ++ mysql-test/t/mysql.test | 5 ++++ 3 files changed, 44 insertions(+), 17 deletions(-) diff --git a/client/mysql.cc b/client/mysql.cc index 277b56328a6..8e1b6c2a9b4 100644 --- a/client/mysql.cc +++ b/client/mysql.cc @@ -1245,6 +1245,7 @@ static bool add_line(String &buffer,char *line,char *in_string, char buff[80], *pos, *out; COMMANDS *com; bool need_space= 0; + bool ss_comment= 0; DBUG_ENTER("add_line"); if (!line[0] && buffer.is_empty()) @@ -1293,22 +1294,36 @@ static bool add_line(String &buffer,char *line,char *in_string, } if ((com=find_command(NullS,(char) inchar))) { - const String tmp(line,(uint) (out-line), charset_info); - buffer.append(tmp); - if ((*com->func)(&buffer,pos-1) > 0) - DBUG_RETURN(1); // Quit - if (com->takes_params) - { - for (pos++ ; - *pos && (*pos != *delimiter || - !is_prefix(pos + 1, delimiter + 1)) ; pos++) - ; // Remove parameters - if (!*pos) - pos--; - else - pos+= delimiter_length - 1; // Point at last delim char - } - out=line; + const String tmp(line,(uint) (out-line), charset_info); + buffer.append(tmp); + if ((*com->func)(&buffer,pos-1) > 0) + DBUG_RETURN(1); // Quit + if (com->takes_params) + { + if (ss_comment) + { + /* + If a client-side macro appears inside a server-side comment, + discard all characters in the comment after the macro (that is, + until the end of the comment rather than the next delimiter) + */ + for (pos++; *pos && (*pos != '*' || *(pos + 1) != '/'); pos++) + ; + pos--; + } + else + { + for (pos++ ; + *pos && (*pos != *delimiter || + !is_prefix(pos + 1, delimiter + 1)) ; pos++) + ; // Remove parameters + if (!*pos) + pos--; + else + pos+= delimiter_length - 1; // Point at last delim char + } + } + out=line; } else { @@ -1368,7 +1383,7 @@ static bool add_line(String &buffer,char *line,char *in_string, out=line; } } - else if (*ml_comment && inchar == '*' && *(pos + 1) == '/') + else if (*ml_comment && !ss_comment && inchar == '*' && *(pos + 1) == '/') { pos++; *ml_comment= 0; @@ -1376,6 +1391,11 @@ static bool add_line(String &buffer,char *line,char *in_string, } else { // Add found char to buffer + if (!*in_string && inchar == '/' && *(pos + 1) == '*' && + *(pos + 2) == '!') + ss_comment= 1; + else if (!*in_string && ss_comment && inchar == '*' && *(pos + 1) == '/') + ss_comment= 0; if (inchar == *in_string) *in_string= 0; else if (!*ml_comment && !*in_string && diff --git a/mysql-test/r/mysql.result b/mysql-test/r/mysql.result index 843f2c7285a..74b5c42e59b 100644 --- a/mysql-test/r/mysql.result +++ b/mysql-test/r/mysql.result @@ -176,4 +176,6 @@ ERROR at line 1: DELIMITER cannot contain a backslash character ERROR at line 1: DELIMITER cannot contain a backslash character 1 1 +1 +1 End of 5.0 tests diff --git a/mysql-test/t/mysql.test b/mysql-test/t/mysql.test index 37bbca77d9f..fad1d1fe746 100644 --- a/mysql-test/t/mysql.test +++ b/mysql-test/t/mysql.test @@ -273,4 +273,9 @@ EOF --exec $MYSQL --pager="540bytelengthstringxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" -e "select 1" > /dev/null 2>&1 --exec $MYSQL --character-sets-dir="540bytelengthstringxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" -e "select 1" 2>&1 +# +# bug #30164: Using client side macro inside server side comments generates broken queries +# +--exec $MYSQL test -e '/*! \C latin1 */ select 1;' + --echo End of 5.0 tests From aef135da6633e4ac88591b1b3603bc8c84008cff Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 30 Aug 2007 17:21:43 +0400 Subject: [PATCH 28/41] Use double quotes instead of single ones which make the test fail on Windows. This is for bug #30164. mysql-test/t/mysql.test: Use double quotes instead of single ones which make the test fail on Windows. --- mysql-test/t/mysql.test | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mysql-test/t/mysql.test b/mysql-test/t/mysql.test index fad1d1fe746..9f8841ec1f4 100644 --- a/mysql-test/t/mysql.test +++ b/mysql-test/t/mysql.test @@ -276,6 +276,6 @@ EOF # # bug #30164: Using client side macro inside server side comments generates broken queries # ---exec $MYSQL test -e '/*! \C latin1 */ select 1;' +--exec $MYSQL test -e "/*! \C latin1 */ select 1;" --echo End of 5.0 tests From bccbd5c493a5350a7dd36e0349f2ad6d05863e89 Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 30 Aug 2007 16:11:53 -0300 Subject: [PATCH 29/41] Bug#28587 SELECT is blocked by INSERT waiting on read lock, even with low_priority_updates The problem is that a SELECT on one thread is blocked by INSERT ... ON DUPLICATE KEY UPDATE on another thread even when low_priority_updates is activated. The solution is to possibly downgrade the lock type to the setting of low_priority_updates if the INSERT cannot be concurrent. sql/sql_insert.cc: Possibly downgrade lock type to the the setting of low_priority_updates if if the INSERT cannot be concurrent. --- sql/sql_insert.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc index bd21d929291..f07af393070 100644 --- a/sql/sql_insert.cc +++ b/sql/sql_insert.cc @@ -417,7 +417,7 @@ void upgrade_lock_type(THD *thd, thr_lock_type *lock_type, if (duplic == DUP_UPDATE || duplic == DUP_REPLACE && *lock_type == TL_WRITE_CONCURRENT_INSERT) { - *lock_type= TL_WRITE; + *lock_type= TL_WRITE_DEFAULT; return; } From ff149b713cc8fef67a6b25945efa8e4f4f65bcdb Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 31 Aug 2007 16:59:07 +0500 Subject: [PATCH 30/41] Fixed bug #30126. When dumping database from a 4.x server, the mysqldump client inserted a delimiter sign inside special commentaries of the form: /*!... CREATE DATABASE IF NOT EXISTS ... ;*/ During restoration that dump file was splitten by delimiter signs on the client side, and the rest of some commentary strings was prepended to following statements. The 4x_server_emul test case option has been added for use with the DBUG_EXECUTE_IF debugging macro. This option affects debug server builds only to emulate particular behavior of a 4.x server for the mysqldump client testing. Non-debugging builds are not affected. mysql-test/r/mysqldump-compat.result: Added test case for bug #30126. mysql-test/t/mysqldump-compat.opt: Added test case for bug #30126. mysql-test/t/mysqldump-compat.test: Added test case for bug #30126. sql/sql_parse.cc: Fixed bug #30126. The mysqldump client uses the "SHOW CREATE DATABASE" query to obtain the "CREATE DATABASE" statement from that database. The 4.x server doesn't recognise that query, and mysqldump forms the "CREATE DATABASE" statement from scratch. That statement was formed incorrectly. To enforce the mysqldump client to create that statement from scratch, debugging code has been added to the mysql_execute_command function: in tcase of the --loose-debug=d,4x_server_emul option, the server returns parse error to client to emulate old behaviour. The 4x_server_emul test case option has been added for use with the DBUG_EXECUTE_IF debugging macro. This option affects debug server builds only to emulate particular behavior of a 4.x server for the mysqldump client testing. Non-debugging builds are not affected. client/mysqldump.c: Fixed bug #30126. The init_dumping_tables function has been modified to output semicolon outside of commentaries. --- client/mysqldump.c | 2 +- mysql-test/r/mysqldump-compat.result | 4 ++++ mysql-test/t/mysqldump-compat.opt | 1 + mysql-test/t/mysqldump-compat.test | 13 +++++++++++++ sql/sql_parse.cc | 2 ++ 5 files changed, 21 insertions(+), 1 deletion(-) create mode 100644 mysql-test/r/mysqldump-compat.result create mode 100644 mysql-test/t/mysqldump-compat.opt create mode 100644 mysql-test/t/mysqldump-compat.test diff --git a/client/mysqldump.c b/client/mysqldump.c index 577e439d6a7..cc8458c7a8e 100644 --- a/client/mysqldump.c +++ b/client/mysqldump.c @@ -2898,7 +2898,7 @@ int init_dumping_tables(char *qdatabase) /* Old server version, dump generic CREATE DATABASE */ if (opt_drop_database) fprintf(md_result_file, - "\n/*!40000 DROP DATABASE IF EXISTS %s;*/\n", + "\n/*!40000 DROP DATABASE IF EXISTS %s*/;\n", qdatabase); fprintf(md_result_file, "\nCREATE DATABASE /*!32312 IF NOT EXISTS*/ %s;\n", diff --git a/mysql-test/r/mysqldump-compat.result b/mysql-test/r/mysqldump-compat.result new file mode 100644 index 00000000000..f15cc7a1d7a --- /dev/null +++ b/mysql-test/r/mysqldump-compat.result @@ -0,0 +1,4 @@ +CREATE DATABASE mysqldump_30126; +USE mysqldump_30126; +CREATE TABLE t1 (c1 int); +DROP DATABASE mysqldump_30126; diff --git a/mysql-test/t/mysqldump-compat.opt b/mysql-test/t/mysqldump-compat.opt new file mode 100644 index 00000000000..40d4ac738a6 --- /dev/null +++ b/mysql-test/t/mysqldump-compat.opt @@ -0,0 +1 @@ +--loose-debug=d,4x_server_emul diff --git a/mysql-test/t/mysqldump-compat.test b/mysql-test/t/mysqldump-compat.test new file mode 100644 index 00000000000..848d66cc728 --- /dev/null +++ b/mysql-test/t/mysqldump-compat.test @@ -0,0 +1,13 @@ +# Embedded server doesn't support external clients +--source include/not_embedded.inc + +# +# Bug #30126: semicolon before closing */ in /*!... CREATE DATABASE ;*/ +# + +CREATE DATABASE mysqldump_30126; +USE mysqldump_30126; +CREATE TABLE t1 (c1 int); +--exec $MYSQL_DUMP --add-drop-database mysqldump_30126 > $MYSQLTEST_VARDIR/tmp/bug30126.sql +--exec $MYSQL mysqldump_30126 < $MYSQLTEST_VARDIR/tmp/bug30126.sql +DROP DATABASE mysqldump_30126; diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index 58f5ffc5235..bb3ab9a67fe 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -3990,6 +3990,8 @@ end_with_restore_list: } case SQLCOM_SHOW_CREATE_DB: { + DBUG_EXECUTE_IF("4x_server_emul", + my_error(ER_UNKNOWN_ERROR, MYF(0)); goto error;); if (!strip_sp(lex->name) || check_db_name(lex->name)) { my_error(ER_WRONG_DB_NAME, MYF(0), lex->name); From ee0b7d895d42b0e3c93bdbffa7c4d3f51c1f60c2 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 3 Sep 2007 12:22:56 +0500 Subject: [PATCH 31/41] Bug#29408 Cannot find view in columns table if the selection contains a function Use view db name as thread default database, in order to ensure that the view is parsed and prepared correctly. mysql-test/r/sp.result: test result mysql-test/t/sp.test: test case sql/sql_parse.cc: copy thd->db_length to table_list->db_length sql/sql_view.cc: Use view db name as thread default database, in order to ensure that the view is parsed and prepared correctly. --- mysql-test/r/sp.result | 22 ++++++++++++++++++++++ mysql-test/t/sp.test | 33 +++++++++++++++++++++++++++++++++ sql/sql_parse.cc | 2 +- sql/sql_view.cc | 14 ++++++++++++++ 4 files changed, 70 insertions(+), 1 deletion(-) diff --git a/mysql-test/r/sp.result b/mysql-test/r/sp.result index 4a278cd4aec..917ade02e0a 100644 --- a/mysql-test/r/sp.result +++ b/mysql-test/r/sp.result @@ -6314,4 +6314,26 @@ CALL p1(); NULL SET NAMES default; DROP PROCEDURE p1; +create function f1() +returns int(11) +not deterministic +contains sql +sql security definer +comment '' +begin +declare x int(11); +set x=-1; +return x; +end| +create view v1 as select 1 as one, f1() as days; +show create view test.v1; +View Create View +v1 CREATE ALGORITHM=UNDEFINED DEFINER=`root`@`localhost` SQL SECURITY DEFINER VIEW `test`.`v1` AS select 1 AS `one`,`f1`() AS `days` +select column_name from information_schema.columns +where table_name='v1' and table_schema='test'; +column_name +one +days +drop view v1; +drop function f1; End of 5.0 tests diff --git a/mysql-test/t/sp.test b/mysql-test/t/sp.test index 46a1b1dc740..f1c7c6969db 100644 --- a/mysql-test/t/sp.test +++ b/mysql-test/t/sp.test @@ -7299,4 +7299,37 @@ CALL p1(); SET NAMES default; DROP PROCEDURE p1; +# +# Bug#29408 Cannot find view in columns table if the selection contains a function +# +delimiter |; + +create function f1() + returns int(11) +not deterministic +contains sql +sql security definer +comment '' +begin + declare x int(11); + set x=-1; + return x; +end| + +delimiter ;| + +create view v1 as select 1 as one, f1() as days; + +connect (bug29408, localhost, root,,*NO-ONE*); +connection bug29408; + +show create view test.v1; +select column_name from information_schema.columns +where table_name='v1' and table_schema='test'; + +connection default; +disconnect bug29408; +drop view v1; +drop function f1; + --echo End of 5.0 tests diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index bb3ab9a67fe..084bcfc3c76 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -1864,7 +1864,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd, statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS], &LOCK_status); bzero((char*) &table_list,sizeof(table_list)); - if (thd->copy_db_to(&table_list.db, 0)) + if (thd->copy_db_to(&table_list.db, &table_list.db_length)) break; pend= strend(packet); thd->convert_string(&conv_name, system_charset_info, diff --git a/sql/sql_view.cc b/sql/sql_view.cc index 56d7a3f8a9d..35a97411511 100644 --- a/sql/sql_view.cc +++ b/sql/sql_view.cc @@ -1008,8 +1008,19 @@ bool mysql_make_view(THD *thd, File_parser *parser, TABLE_LIST *table, table->view= lex= thd->lex= (LEX*) new(thd->mem_root) st_lex_local; { + char old_db_buf[NAME_LEN+1]; + LEX_STRING old_db= { old_db_buf, sizeof(old_db_buf) }; + bool dbchanged; Lex_input_stream lip(thd, table->query.str, table->query.length); thd->m_lip= &lip; + + /* + Use view db name as thread default database, in order to ensure + that the view is parsed and prepared correctly. + */ + if ((result= sp_use_new_db(thd, table->view_db, &old_db, 1, &dbchanged))) + goto end; + lex_start(thd); view_select= &lex->select_lex; view_select->select_number= ++thd->select_number; @@ -1051,6 +1062,9 @@ bool mysql_make_view(THD *thd, File_parser *parser, TABLE_LIST *table, thd->variables.character_set_client= save_cs; thd->variables.sql_mode= save_mode; + + if (dbchanged && mysql_change_db(thd, &old_db, TRUE)) + goto err; } if (!res && !thd->is_fatal_error) { From 733bd4fe81dc36cc1dc7be4b9562fd3b5727614c Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 3 Sep 2007 10:47:24 +0200 Subject: [PATCH 32/41] Bug #21074 Large query_cache freezes mysql server sporadically under heavy load Invaldating a subset of a sufficiently large query cache can take a long time. During this time the server is efficiently frozen and no other operation can be executed. This patch addresses this problem by setting a time limit on how long time a dictionary access request can take before giving up on the attempt. This patch does not work for query cache invalidations issued by DROP, ALTER or RENAME TABLE operations. sql/sql_cache.cc: Changed mutex locking to a timed spinn lock. If access to query cache dictionary takes "a long time" (currently more than 0.1 seconds) the system fall backs on ordinary statement execution. --- sql/sql_cache.cc | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc index 33d658ce6a1..cb00b98ccf8 100644 --- a/sql/sql_cache.cc +++ b/sql/sql_cache.cc @@ -1023,6 +1023,13 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length) Query_cache_block_table *block_table, *block_table_end; ulong tot_length; Query_cache_query_flags flags; + const uint spin_treshold= 50000; + const double lock_time_treshold= 0.1; /* Time in seconds */ + uint spin_count= 0; + int lock_status= 0; + ulong new_time= 0; + ulong stop_time= 0; + DBUG_ENTER("Query_cache::send_result_to_client"); /* @@ -1069,7 +1076,29 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length) } } - STRUCT_LOCK(&structure_guard_mutex); + stop_time= my_clock()+(ulong)lock_time_treshold*CLOCKS_PER_SEC; + while ((lock_status= pthread_mutex_trylock(&structure_guard_mutex)) == EBUSY + && spin_count < spin_treshold + && new_time < stop_time) + { + spin_count++; + if (spin_count%5) + new_time= my_clock(); + pthread_yield(); + } + + if (lock_status != 0) + { + /* + Query cache is too busy doing something else. + Fall back on ordinary statement execution. We also mark this + query as unsafe to cache because otherwise this thread will + still be halted when the result set is stored to the cache. + */ + thd->lex->safe_to_cache_query= FALSE; + goto err; + } + if (query_cache_size == 0 || flush_in_progress) { DBUG_PRINT("qcache", ("query cache disabled")); From f0d4beee7925035658a9ed4e48b826f699c31b7a Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 3 Sep 2007 11:55:35 +0200 Subject: [PATCH 33/41] Bug #30234: Unexpected behavior using DELETE with AS and USING DELETE FROM ... USING ... statements with the following type of ambiguous aliasing gave unexpected results: DELETE FROM t1 AS alias USING t1, t2 AS alias WHERE t1.a = alias.a; This query would leave table t1 intact but delete rows from t2. Fixed by changing DELETE FROM ... USING syntax so that only alias references (as opposed to alias declarations) may be used in FROM. mysql-test/r/delete.result: Bug#30234: Test Result mysql-test/t/delete.test: Bug#30234: Test Case sql/sql_yacc.yy: Bug#30234: - Added parser rule table_alias_ref_list that contains a list of table aliases only. - Added parser rule table_alias_ref that sets the TL_OPTION_ALIAS in order to turn off semantic checking that applies only for table names. --- mysql-test/r/delete.result | 37 ++++++++++++++++++++++++++++++++ mysql-test/t/delete.test | 44 ++++++++++++++++++++++++++++++++++++++ sql/sql_yacc.yy | 19 ++++++++++++++-- 3 files changed, 98 insertions(+), 2 deletions(-) diff --git a/mysql-test/r/delete.result b/mysql-test/r/delete.result index 4bdf1c770d3..d333425f23a 100644 --- a/mysql-test/r/delete.result +++ b/mysql-test/r/delete.result @@ -223,3 +223,40 @@ ERROR 42S22: Unknown column 't2.x' in 'order clause' DELETE FROM t1 ORDER BY (SELECT x); ERROR 42S22: Unknown column 'x' in 'field list' DROP TABLE t1; +CREATE TABLE t1 ( +a INT +); +CREATE TABLE t2 ( +a INT +); +CREATE DATABASE db1; +CREATE TABLE db1.t1 ( +a INT +); +INSERT INTO db1.t1 (a) SELECT * FROM t1; +CREATE DATABASE db2; +CREATE TABLE db2.t1 ( +a INT +); +INSERT INTO db2.t1 (a) SELECT * FROM t2; +DELETE FROM t1 alias USING t1, t2 alias WHERE t1.a = alias.a; +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 'alias USING t1, t2 alias WHERE t1.a = alias.a' at line 1 +DELETE FROM alias USING t1, t2 alias WHERE t1.a = alias.a; +DELETE FROM t1, alias USING t1, t2 alias WHERE t1.a = alias.a; +DELETE FROM t1, t2 USING t1, t2 alias WHERE t1.a = alias.a; +ERROR 42S02: Unknown table 't2' in MULTI DELETE +DELETE FROM db1.t1 alias USING db1.t1, db2.t1 alias WHERE db1.t1.a = alias.a; +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 'alias USING db1.t1, db2.t1 alias WHERE db1.t1.a = alias.a' at line 1 +DELETE FROM alias USING db1.t1, db2.t1 alias WHERE db1.t1.a = alias.a; +ERROR 42S02: Unknown table 'alias' in MULTI DELETE +DELETE FROM db2.alias USING db1.t1, db2.t1 alias WHERE db1.t1.a = alias.a; +DELETE FROM t1 USING t1 WHERE a = 1; +SELECT * FROM t1; +a +DELETE FROM t1 alias USING t1 alias WHERE a = 2; +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 'alias USING t1 alias WHERE a = 2' at line 1 +SELECT * FROM t1; +a +DROP TABLE t1, t2; +DROP DATABASE db1; +DROP DATABASE db2; diff --git a/mysql-test/t/delete.test b/mysql-test/t/delete.test index 36d627209db..e3713d248c4 100644 --- a/mysql-test/t/delete.test +++ b/mysql-test/t/delete.test @@ -221,3 +221,47 @@ DELETE FROM t1 ORDER BY t2.x; DELETE FROM t1 ORDER BY (SELECT x); DROP TABLE t1; + +# +# Bug #30234: Unexpected behavior using DELETE with AS and USING +# ' +CREATE TABLE t1 ( + a INT +); + +CREATE TABLE t2 ( + a INT +); + +CREATE DATABASE db1; +CREATE TABLE db1.t1 ( + a INT +); +INSERT INTO db1.t1 (a) SELECT * FROM t1; + +CREATE DATABASE db2; +CREATE TABLE db2.t1 ( + a INT +); +INSERT INTO db2.t1 (a) SELECT * FROM t2; + +--error ER_PARSE_ERROR +DELETE FROM t1 alias USING t1, t2 alias WHERE t1.a = alias.a; +DELETE FROM alias USING t1, t2 alias WHERE t1.a = alias.a; +DELETE FROM t1, alias USING t1, t2 alias WHERE t1.a = alias.a; +--error ER_UNKNOWN_TABLE +DELETE FROM t1, t2 USING t1, t2 alias WHERE t1.a = alias.a; +--error ER_PARSE_ERROR +DELETE FROM db1.t1 alias USING db1.t1, db2.t1 alias WHERE db1.t1.a = alias.a; +--error ER_UNKNOWN_TABLE +DELETE FROM alias USING db1.t1, db2.t1 alias WHERE db1.t1.a = alias.a; +DELETE FROM db2.alias USING db1.t1, db2.t1 alias WHERE db1.t1.a = alias.a; +DELETE FROM t1 USING t1 WHERE a = 1; +SELECT * FROM t1; +--error ER_PARSE_ERROR +DELETE FROM t1 alias USING t1 alias WHERE a = 2; +SELECT * FROM t1; + +DROP TABLE t1, t2; +DROP DATABASE db1; +DROP DATABASE db2; diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy index 6fbd521e302..de64e7664b1 100644 --- a/sql/sql_yacc.yy +++ b/sql/sql_yacc.yy @@ -1159,7 +1159,8 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize); field_opt_list opt_binary table_lock_list table_lock ref_list opt_on_delete opt_on_delete_list opt_on_delete_item use opt_delete_options opt_delete_option varchar nchar nvarchar - opt_outer table_list table_name opt_option opt_place + opt_outer table_list table_name table_alias_ref_list table_alias_ref + opt_option opt_place opt_attribute opt_attribute_list attribute column_list column_list_id opt_column_list grant_privileges grant_ident grant_list grant_option object_privilege object_privilege_list user_list rename_list @@ -6504,6 +6505,20 @@ table_name: } ; +table_alias_ref_list: + table_alias_ref + | table_alias_ref_list ',' table_alias_ref; + +table_alias_ref: + table_ident + { + if (!Select->add_table_to_list(YYTHD, $1, NULL, + TL_OPTION_UPDATING | TL_OPTION_ALIAS, + Lex->lock_option )) + MYSQL_YYABORT; + } + ; + if_exists: /* empty */ { $$= 0; } | IF EXISTS { $$= 1; } @@ -6774,7 +6789,7 @@ single_multi: if (multi_delete_set_locks_and_link_aux_tables(Lex)) MYSQL_YYABORT; } - | FROM table_wild_list + | FROM table_alias_ref_list { mysql_init_multi_delete(Lex); } USING join_table_list where_clause { From d2a0a4d53a217c906d7c7c5bf867477fc4f5936e Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 3 Sep 2007 13:42:32 +0200 Subject: [PATCH 34/41] - Fix cross compatibility issues by exchanging pthread_yield with my_sleep(0) --- sql/sql_cache.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc index cb00b98ccf8..97e37c870e2 100644 --- a/sql/sql_cache.cc +++ b/sql/sql_cache.cc @@ -1084,7 +1084,7 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length) spin_count++; if (spin_count%5) new_time= my_clock(); - pthread_yield(); + my_sleep(0); } if (lock_status != 0) From 5c836d24f64eb99aba3cb94da3ee90bcca209500 Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 4 Sep 2007 16:40:27 -0600 Subject: [PATCH 35/41] Fixed whitespace --- sql/sql_trigger.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/sql_trigger.cc b/sql/sql_trigger.cc index 6e4b5defb97..1737bb0d9f8 100644 --- a/sql/sql_trigger.cc +++ b/sql/sql_trigger.cc @@ -971,7 +971,7 @@ bool Table_triggers_list::check_n_load(THD *thd, const char *db, Lex_input_stream lip(thd, trg_create_str->str, trg_create_str->length); thd->m_lip= &lip; lex_start(thd); - thd->spcont= NULL; + thd->spcont= NULL; int err= MYSQLparse((void *)thd); if (err || thd->is_fatal_error) From 732f05a642279a569c6ed2b67fafff05b9de76c3 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 10 Sep 2007 16:26:51 +0400 Subject: [PATCH 36/41] BUG#30385: Server crash when deleting with ORDER BY and LIMIT in get_index_for_order(), don't walk over the end of the index key parts when matching index description and needed ordering. mysql-test/r/delete.result: BUG#30385: Testcase mysql-test/t/delete.test: BUG#30385: Testcase --- mysql-test/r/delete.result | 11 +++++++++++ mysql-test/t/delete.test | 13 +++++++++++++ sql/opt_range.cc | 3 ++- 3 files changed, 26 insertions(+), 1 deletion(-) diff --git a/mysql-test/r/delete.result b/mysql-test/r/delete.result index a5c22e66569..5dd37e6b98d 100644 --- a/mysql-test/r/delete.result +++ b/mysql-test/r/delete.result @@ -193,4 +193,15 @@ select @a; @a 1 drop table t1; +CREATE TABLE t1 ( +`date` date , +`time` time , +`seq` int(10) unsigned NOT NULL auto_increment, +PRIMARY KEY (`seq`), +KEY `seq` (`seq`), +KEY `time` (`time`), +KEY `date` (`date`) +); +DELETE FROM t1 ORDER BY date ASC, time ASC LIMIT 1; +drop table t1; End of 4.1 tests diff --git a/mysql-test/t/delete.test b/mysql-test/t/delete.test index 301b2cdbb99..fdbb96e0c2f 100644 --- a/mysql-test/t/delete.test +++ b/mysql-test/t/delete.test @@ -184,4 +184,17 @@ delete from t1 where (@a:= f1) order by f1 limit 1; select @a; drop table t1; +# BUG#30385 "Server crash when deleting with order by and limit" +CREATE TABLE t1 ( + `date` date , + `time` time , + `seq` int(10) unsigned NOT NULL auto_increment, + PRIMARY KEY (`seq`), + KEY `seq` (`seq`), + KEY `time` (`time`), + KEY `date` (`date`) +); +DELETE FROM t1 ORDER BY date ASC, time ASC LIMIT 1; +drop table t1; + --echo End of 4.1 tests diff --git a/sql/opt_range.cc b/sql/opt_range.cc index 01b366077b0..a8ba609f9dc 100644 --- a/sql/opt_range.cc +++ b/sql/opt_range.cc @@ -825,6 +825,7 @@ uint get_index_for_order(TABLE *table, ORDER *order, ha_rows limit) if (!(table->keys_in_use_for_query.is_set(idx))) continue; KEY_PART_INFO *keyinfo= table->key_info[idx].key_part; + uint n_parts= table->key_info[idx].key_parts; uint partno= 0; /* @@ -834,7 +835,7 @@ uint get_index_for_order(TABLE *table, ORDER *order, ha_rows limit) */ if (!(table->file->index_flags(idx, 0, 1) & HA_READ_ORDER)) continue; - for (ord= order; ord; ord= ord->next, partno++) + for (ord= order; ord && partno < n_parts; ord= ord->next, partno++) { Item *item= order->item[0]; if (!(item->type() == Item::FIELD_ITEM && From 4e5c03961a60eb056e0dd43427cdec2f57de1144 Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 11 Sep 2007 02:41:42 +0400 Subject: [PATCH 37/41] Post-merge fixes --- mysql-test/t/delete.test | 1 - 1 file changed, 1 deletion(-) diff --git a/mysql-test/t/delete.test b/mysql-test/t/delete.test index df8c529407e..8a03cb6c715 100644 --- a/mysql-test/t/delete.test +++ b/mysql-test/t/delete.test @@ -187,7 +187,6 @@ DELETE FROM t1 ORDER BY date ASC, time ASC LIMIT 1; drop table t1; --echo End of 4.1 tests -# End of 4.1 tests # # Test of multi-delete where we are not scanning the first table From ba39449e01c88f84a3a1b0cbc55fadb77ef20e82 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 12 Sep 2007 01:52:27 +0400 Subject: [PATCH 38/41] Post-merge fixes --- mysql-test/r/delete.result | 1 - 1 file changed, 1 deletion(-) diff --git a/mysql-test/r/delete.result b/mysql-test/r/delete.result index a3ba61c9046..5084498c01c 100644 --- a/mysql-test/r/delete.result +++ b/mysql-test/r/delete.result @@ -195,7 +195,6 @@ KEY `date` (`date`) DELETE FROM t1 ORDER BY date ASC, time ASC LIMIT 1; drop table t1; End of 4.1 tests -End of 4.1 tests CREATE TABLE t1 (a int not null,b int not null); CREATE TABLE t2 (a int not null, b int not null, primary key (a,b)); CREATE TABLE t3 (a int not null, b int not null, primary key (a,b)); From 2ef5838c90dda27a8b403a29f47e22dbcc4ec064 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 12 Sep 2007 13:53:32 +0200 Subject: [PATCH 39/41] BUG#23354 revert --- ndb/src/common/debugger/EventLogger.cpp | 2 ++ ndb/src/mgmclient/CommandInterpreter.cpp | 10 +--------- 2 files changed, 3 insertions(+), 9 deletions(-) diff --git a/ndb/src/common/debugger/EventLogger.cpp b/ndb/src/common/debugger/EventLogger.cpp index c3bdb18dc06..6280d5bb9b3 100644 --- a/ndb/src/common/debugger/EventLogger.cpp +++ b/ndb/src/common/debugger/EventLogger.cpp @@ -91,6 +91,8 @@ void getRestartAction(Uint32 action, BaseString &str) if (action == 0) return; str.appfmt(", restarting"); + if (action & 2) + str.appfmt(", no start"); if (action & 4) str.appfmt(", initial"); } diff --git a/ndb/src/mgmclient/CommandInterpreter.cpp b/ndb/src/mgmclient/CommandInterpreter.cpp index 8d3e046c9ad..1036461d404 100644 --- a/ndb/src/mgmclient/CommandInterpreter.cpp +++ b/ndb/src/mgmclient/CommandInterpreter.cpp @@ -2168,15 +2168,7 @@ CommandInterpreter::executeRestart(Vector &command_list, ndbout << "Node"; for (int i= 0; i < no_of_nodes; i++) ndbout << " " << node_ids[i]; - ndbout_c(": Is being restarted"); - - ndbout << "Node"; - for (int i= 0; i < no_of_nodes; i++) - ndbout << " " << node_ids[i]; - if (nostart) - ndbout_c(": No start"); - else - ndbout_c(": Is rejoining the cluster"); + ndbout_c(" is being restarted"); } if(need_disconnect) disconnect(); From 0068c1893054a81ce981ede96e97dbb790cf04ba Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 12 Sep 2007 18:13:19 +0400 Subject: [PATCH 40/41] Better wording in comments --- sql/opt_range.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sql/opt_range.cc b/sql/opt_range.cc index f57cb03ca53..04e2816d553 100644 --- a/sql/opt_range.cc +++ b/sql/opt_range.cc @@ -1597,10 +1597,10 @@ SEL_ARG *SEL_ARG::clone_tree(PARAM *param) the UPDATE/DELETE code will work: * index can only be scanned in forward direction * HA_EXTRA_KEYREAD will not be used - Perhaps these assumptions could be relaxed + Perhaps these assumptions could be relaxed. RETURN - index number + Number of the index that produces the required ordering in the cheapest way MAX_KEY if no such index was found. */ From eacd5ec43ce3671e14f00558dbbba2df8539a7bf Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 13 Sep 2007 09:47:21 +0200 Subject: [PATCH 41/41] bug#27494 An invalid subselect crashes mysql server: Added check for missing arguments --- sql/ha_ndbcluster_cond.cc | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/sql/ha_ndbcluster_cond.cc b/sql/ha_ndbcluster_cond.cc index a0eaccb68d8..ea3f8a7683a 100644 --- a/sql/ha_ndbcluster_cond.cc +++ b/sql/ha_ndbcluster_cond.cc @@ -46,6 +46,14 @@ void ndb_serialize_cond(const Item *item, void *arg) // Check if we are skipping arguments to a function to be evaluated if (context->skip) { + if (!item) + { + DBUG_PRINT("info", ("Unexpected mismatch of found and expected number of function arguments %u", context->skip)); + sql_print_error("ndb_serialize_cond: Unexpected mismatch of found and " + "expected number of function arguments %u", context->skip); + context->skip= 0; + DBUG_VOID_RETURN; + } DBUG_PRINT("info", ("Skiping argument %d", context->skip)); context->skip--; switch (item->type()) {