From: He Zhenxing Date: October 15 2010 10:31am Subject: bzr commit into mysql-5.1-bugteam branch (zhenxing.he:3418) Bug#42415 List-Archive: http://lists.mysql.com/commits/120821 X-Bug: 42415 Message-Id: <201010151031.o9FAVg2q014223@hezx-dev.localdomain> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============4964619236702267240==" --===============4964619236702267240== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline #At file:///media/sdb2/hezx/work/mysql/bzr/b42415/5.1-bugteam/ based on revid:ramil@stripped 3418 He Zhenxing 2010-10-15 BUG#42415 UPDATE/DELETE with LIMIT clause unsafe for SBL even with ORDER BY PK clause UPDATE/DELETE/INSERT..SELECT with LIMIT clause were considered unsafe unconditionally, even if there is an ORDER BY PK or WHERE condition that can guarantee the result to be deterministic. The problem is fixed by implementing a algorithm to do more elaborate analyzed on the nature of the query to determine whether the query will cause uncertainty for replication or not. The statement will not be considered unsafe for following cases: - single table UPDATE/DELETE/INSERT..SELECT with ORDER BY - single table UPDATE/DELETE/INSERT..SELECT with WHERE clause that include = , if it is a multi-part key, then it must be = AND = ..., and this condition is ANDed with other conditions if there is any. - single table INSERT..SELECT with WHERE clause that include some parts of the non null unique key compare to const values, and the ORDER BY clause includes all the other key pars of the same non null unique key. for example (a,b) is a non null unique key, then WHERE a= ORDER b will make the query result deterministic. - for INSERT..SELECT ... JOIN ..., the join condition (ON, USING, or WHERE) must include equations between columns of non null unique key of tables from both side of the join. For example t1 JOIN t2 USING (a,b), if (a,b) is not a non null unique key for both t1 and t2, then the result will be non- deterministic. otherwise the result can be deterministic with appropirate WHERE/ORDER clauses, and in this case, the same rule for single table above applys. But there is a difference for INNER JOIN with OUTER JOIN, for OUTER JOIN, only one table of the two JOIN tables will be used when checking the WHERE/ORDER conditions, it's the left table for LEFT JOIN and the right one for RIGHT JOIN when checking the keys. On the other hand, for INNER JOIN, keys from both tables can be used when checking the conditions. For example: INSERT..SELECT * FROM t1 INNER JOIN t2 USING(pk) ORDER BY nnuk LIMIT 1; This can be safe if nnuk is a non null unique key of either t1 or t2. But if we change the INNER JOIN to LEFT JOIN or RIGHT JOIN, then nnuk must be a non null unique key key of t1 (LEFT JOIN) or t2 (RIGHT JOIN) respectively. - If JOIN are nested, the will be handled recursively from inner outside. ****** BUG#42415 UPDATE/DELETE with LIMIT clause unsafe for SBL even with ORDER BY PK clause UPDATE/DELETE/INSERT..SELECT with LIMIT clause were considered unsafe unconditionally, even if there is an ORDER BY PK or WHERE condition that can guarantee the result to be deterministic. The problem is fixed by implementing a algorithm to do more elaborate analyzed on the nature of the query to determine whether the query will cause uncertainty for replication or not. The statement will not be considered unsafe for following cases: - single table UPDATE/DELETE/INSERT..SELECT with ORDER BY - single table UPDATE/DELETE/INSERT..SELECT with WHERE clause that include = , if it is a multi-part key, then it must be = AND = ..., and this condition is ANDed with other conditions if there is any. - single table INSERT..SELECT with WHERE clause that include some parts of the non null unique key compare to const values, and the ORDER BY clause includes all the other key pars of the same non null unique key. for example (a,b) is a non null unique key, then WHERE a= ORDER b will make the query result deterministic. - for INSERT..SELECT ... JOIN ..., the join condition (ON, USING, or WHERE) must include equations between columns of non null unique key of tables from both side of the join. For example t1 JOIN t2 USING (a,b), if (a,b) is not a non null unique key for both t1 and t2, then the result will be non- deterministic. otherwise the result can be deterministic with appropirate WHERE/ORDER clauses, and in this case, the same rule for single table above applys. But there is a difference for INNER JOIN with OUTER JOIN, for OUTER JOIN, only one table of the two JOIN tables will be used when checking the WHERE/ORDER conditions, it's the left table for LEFT JOIN and the right one for RIGHT JOIN when checking the keys. On the other hand, for INNER JOIN, keys from both tables can be used when checking the conditions. For example: INSERT..SELECT * FROM t1 INNER JOIN t2 USING(pk) ORDER BY nnuk LIMIT 1; This can be safe if nnuk is a non null unique key of either t1 or t2. But if we change the INNER JOIN to LEFT JOIN or RIGHT JOIN, then nnuk must be a non null unique key key of t1 (LEFT JOIN) or t2 (RIGHT JOIN) respectively. - If JOIN are nested, the will be handled recursively from inner outside. added: mysql-test/suite/binlog/r/binlog_unsafe_limit.result mysql-test/suite/binlog/t/binlog_unsafe_limit.test modified: mysql-test/suite/binlog/r/binlog_stm_unsafe_warning.result sql/sql_delete.cc sql/sql_insert.cc sql/sql_select.cc sql/sql_select.h sql/sql_update.cc === modified file 'mysql-test/suite/binlog/r/binlog_stm_unsafe_warning.result' --- a/mysql-test/suite/binlog/r/binlog_stm_unsafe_warning.result 2009-07-31 13:00:35 +0000 +++ b/mysql-test/suite/binlog/r/binlog_stm_unsafe_warning.result 2010-10-15 10:31:35 +0000 @@ -3,11 +3,7 @@ DROP TABLE IF EXISTS t1; CREATE TABLE t1 (a int, b int, primary key (a)); INSERT INTO t1 VALUES (1,2), (2,3); UPDATE t1 SET b='4' WHERE a=1 LIMIT 1; -Warnings: -Note 1592 Statement may not be safe to log in statement format. UPDATE t1 SET b='5' WHERE a=2 ORDER BY a LIMIT 1; -Warnings: -Note 1592 Statement may not be safe to log in statement format. DROP TABLE t1; ### NOT filtered database => assertion: binlog disabled and warnings ARE NOT shown SET SQL_LOG_BIN= 0; === added file 'mysql-test/suite/binlog/r/binlog_unsafe_limit.result' --- a/mysql-test/suite/binlog/r/binlog_unsafe_limit.result 1970-01-01 00:00:00 +0000 +++ b/mysql-test/suite/binlog/r/binlog_unsafe_limit.result 2010-10-15 10:31:35 +0000 @@ -0,0 +1,1246 @@ +CREATE TABLE t (nokey INT, pk INT PRIMARY KEY, nnuk INT NOT NULL UNIQUE KEY, nuk INT UNIQUE KEY, nnuk1 INT NOT NULL, nnuk2 INT NOT NULL, UNIQUE KEY(nnuk1, nnuk2)); +CREATE TABLE t1 LIKE t; +CREATE TABLE t2 LIKE t; +CREATE TABLE t3 LIKE t; +CREATE TABLE t4 LIKE t; +CREATE TABLE queries (query VARCHAR(1024) NOT NULL); +CREATE TABLE result_queries (id INT AUTO_INCREMENT PRIMARY KEY, query VARCHAR(1024) NOT NULL); +CREATE TABLE limits (`limit` VARCHAR(256) NOT NULL); +INSERT INTO queries(query) VALUES +('UPDATE t1 SET nokey = nokey + 10 [LIMIT_1]'), +('UPDATE t1 SET nokey = nokey + 10 WHERE nokey=1 [LIMIT_1]'), +('UPDATE t1 SET nokey = nokey + 10 WHERE nuk=1 [LIMIT_1]'), +('UPDATE t1 SET nokey = nokey + 10 WHERE nnuk=1 [LIMIT_1]'), +('UPDATE t1 SET nokey = nokey + 10 WHERE pk=1 [LIMIT_1]'), +('DELETE FROM t1 [LIMIT_1]'), +('DELETE FROM t1 WHERE nokey=1 [LIMIT_1]'), +('DELETE FROM t1 WHERE nuk=1 [LIMIT_1]'), +('DELETE FROM t1 WHERE nnuk=1 [LIMIT_1]'), +('DELETE FROM t1 WHERE pk=1 [LIMIT_1]'), +('REPLACE INTO t SELECT * FROM t1 [LIMIT_1]'), +('REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 [LIMIT_1]'), +('REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 [LIMIT_1]'), +('REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 [LIMIT_1]'), +('REPLACE INTO t SELECT * FROM t1 WHERE pk=1 [LIMIT_1]'), +('INSERT INTO t SELECT * FROM t1 [LIMIT_1]'), +('INSERT INTO t SELECT * FROM t1 WHERE nokey=1 [LIMIT_1]'), +('INSERT INTO t SELECT * FROM t1 WHERE nuk=1 [LIMIT_1]'), +('INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 [LIMIT_1]'), +('INSERT INTO t SELECT * FROM t1 WHERE pk=1 [LIMIT_1]'), +('INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) [LIMIT_1]'), +('INSERT INTO t (SELECT * FROM t1 [LIMIT_1]) UNION (SELECT * FROM t2)'), +('INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 [LIMIT_1])'), +('INSERT INTO t (SELECT * FROM t1 [LIMIT_1]) UNION (SELECT * FROM t2 [LIMIT_2])'), +('INSERT INTO t SELECT * FROM (SELECT * FROM t1 [LIMIT_1]) AS subselect [LIMIT_2]'), +('INSERT INTO t SELECT t1.* FROM t1, t2 [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.pk=t3.pk) ON t1.pk=t4.pk [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 AND t2.pk=1 [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk [LIMIT_1]'), +('INSERT INTO t SELECT t1.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk [LIMIT_1]'); +INSERT INTO limits (`limit`) VALUES +('LIMIT 0'), +('LIMIT 1'), +('ORDER BY nokey LIMIT 1'), +('ORDER BY nuk LIMIT 1'), +('ORDER BY nnuk1 LIMIT 1'), +('ORDER BY nnuk LIMIT 1'), +('ORDER BY pk LIMIT 1'), +('ORDER BY nnuk1, nnuk2 LIMIT 1'), +('ORDER BY nnuk1, nnuk2, nokey LIMIT 1'), +('ORDER BY nnuk1, nokey, nnuk2 LIMIT 1'); +CREATE PROCEDURE gen_queries() +BEGIN +DECLARE done INT DEFAULT 0; +DECLARE q VARCHAR(1024); +DECLARE limit1, limit2 VARCHAR(256); +DECLARE qcur CURSOR FOR SELECT * FROM queries; +DECLARE lcur1 CURSOR FOR SELECT * FROM limits; +DECLARE lcur2 CURSOR FOR SELECT * FROM limits; +DECLARE CONTINUE HANDLER FOR NOT FOUND SET done=1; +OPEN qcur; +FETCH qcur INTO q; +WHILE done <> 1 DO +OPEN lcur1; +FETCH lcur1 INTO limit1; +WHILE done <> 1 DO +IF LOCATE('[LIMIT_2]', q) > 0 THEN +OPEN lcur2; +FETCH lcur2 INTO limit2; +WHILE done <> 1 DO +SELECT REPLACE(REPLACE(q, '[LIMIT_1]', limit1), '[LIMIT_2]', limit2) INTO @query; +FETCH lcur2 INTO limit2; +END WHILE; +CLOSE lcur2; +SET done = 0; +ELSE +SELECT REPLACE(q, '[LIMIT_1]', limit1) INTO @query; +END IF; +INSERT INTO result_queries set query=@query; +FETCH lcur1 INTO limit1; +END WHILE; +CLOSE lcur1; +SET done = 0; +FETCH qcur INTO q; +END WHILE; +CLOSE qcur; +END| +call gen_queries(); +UPDATE t1 SET nokey = nokey + 10 LIMIT 0; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nokey=1 LIMIT 0; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nokey=1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nokey=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nuk=1 LIMIT 0; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nuk=1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nuk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nnuk=1 LIMIT 0; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nnuk=1 LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nuk LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk1 LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE pk=1 LIMIT 0; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE pk=1 LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE pk=1 ORDER BY nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE pk=1 ORDER BY nuk LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk1 LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE pk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t1 SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 LIMIT 0; +ROWS in table t: 2 +DELETE FROM t1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +DELETE FROM t1 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +DELETE FROM t1 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +DELETE FROM t1 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +DELETE FROM t1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nokey=1 LIMIT 0; +ROWS in table t: 2 +DELETE FROM t1 WHERE nokey=1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +DELETE FROM t1 WHERE nokey=1 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +DELETE FROM t1 WHERE nokey=1 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +DELETE FROM t1 WHERE nokey=1 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +DELETE FROM t1 WHERE nokey=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nokey=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nokey=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nokey=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nokey=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nuk=1 LIMIT 0; +ROWS in table t: 2 +DELETE FROM t1 WHERE nuk=1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +DELETE FROM t1 WHERE nuk=1 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +DELETE FROM t1 WHERE nuk=1 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +DELETE FROM t1 WHERE nuk=1 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +DELETE FROM t1 WHERE nuk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nuk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nnuk=1 LIMIT 0; +ROWS in table t: 2 +DELETE FROM t1 WHERE nnuk=1 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nnuk=1 ORDER BY nokey LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nnuk=1 ORDER BY nuk LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nnuk=1 ORDER BY nnuk1 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nnuk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nnuk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE pk=1 LIMIT 0; +ROWS in table t: 2 +DELETE FROM t1 WHERE pk=1 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE pk=1 ORDER BY nokey LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE pk=1 ORDER BY nuk LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE pk=1 ORDER BY nnuk1 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE pk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE pk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE pk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE pk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +DELETE FROM t1 WHERE pk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 LIMIT 0; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +REPLACE INTO t SELECT * FROM t1 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +REPLACE INTO t SELECT * FROM t1 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 3 +REPLACE INTO t SELECT * FROM t1 ORDER BY pk LIMIT 1; +ROWS in table t: 3 +REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 3 +REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 3 +REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 3 +REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 LIMIT 0; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 LIMIT 0; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 LIMIT 0; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nokey LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nuk LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1 LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE pk=1 LIMIT 0; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE pk=1 LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nokey LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nuk LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1 LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT * FROM t1 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT * FROM t1 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT * FROM t1 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT * FROM t1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT * FROM t1 ORDER BY pk LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT * FROM t1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT * FROM t1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT * FROM t1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT * FROM t1 WHERE nokey=1 LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nokey=1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nuk=1 LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nuk=1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE pk=1 LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE pk=1 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) LIMIT 0; +ROWS in table t: 2 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY pk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk1, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t (SELECT * FROM t1 LIMIT 0) UNION (SELECT * FROM t2); +ROWS in table t: 4 +INSERT INTO t (SELECT * FROM t1 LIMIT 1) UNION (SELECT * FROM t2); +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1 ORDER BY nokey LIMIT 1) UNION (SELECT * FROM t2); +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1 ORDER BY nuk LIMIT 1) UNION (SELECT * FROM t2); +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1 LIMIT 1) UNION (SELECT * FROM t2); +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk LIMIT 1) UNION (SELECT * FROM t2); +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1 ORDER BY pk LIMIT 1) UNION (SELECT * FROM t2); +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1, nnuk2 LIMIT 1) UNION (SELECT * FROM t2); +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1) UNION (SELECT * FROM t2); +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1) UNION (SELECT * FROM t2); +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 LIMIT 0); +ROWS in table t: 4 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 LIMIT 1); +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nokey LIMIT 1); +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nuk LIMIT 1); +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk1 LIMIT 1); +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk LIMIT 1); +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY pk LIMIT 1); +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nnuk2 LIMIT 1); +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nnuk2, nokey LIMIT 1); +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); +ROWS in table t: 5 +INSERT INTO t (SELECT * FROM t1 LIMIT 0) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); +ROWS in table t: 3 +INSERT INTO t (SELECT * FROM t1 LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 4 +INSERT INTO t (SELECT * FROM t1 ORDER BY nokey LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 4 +INSERT INTO t (SELECT * FROM t1 ORDER BY nuk LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 4 +INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1 LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 4 +INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); +ROWS in table t: 4 +INSERT INTO t (SELECT * FROM t1 ORDER BY pk LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); +ROWS in table t: 4 +INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1, nnuk2 LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); +ROWS in table t: 4 +INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); +ROWS in table t: 4 +INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); +ROWS in table t: 4 +INSERT INTO t SELECT * FROM (SELECT * FROM t1 LIMIT 0) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT * FROM (SELECT * FROM t1 LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nokey LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nuk LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk1 LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY pk LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk1, nnuk2 LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1, t2 LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY pk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk1, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY pk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk1, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nnuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY pk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nnuk1, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.pk=t3.pk) ON t1.pk=t4.pk LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.pk=t3.pk) ON t1.pk=t4.pk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.pk=t3.pk) ON t1.pk=t4.pk ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.pk=t3.pk) ON t1.pk=t4.pk ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.pk=t3.pk) ON t1.pk=t4.pk ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.pk=t3.pk) ON t1.pk=t4.pk ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.pk=t3.pk) ON t1.pk=t4.pk ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.pk=t3.pk) ON t1.pk=t4.pk ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.pk=t3.pk) ON t1.pk=t4.pk ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.pk=t3.pk) ON t1.pk=t4.pk ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 AND t2.pk=1 LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 AND t2.pk=1 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 AND t2.pk=1 ORDER BY nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 AND t2.pk=1 ORDER BY nuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 AND t2.pk=1 ORDER BY nnuk1 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 AND t2.pk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 AND t2.pk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 AND t2.pk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 AND t2.pk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 AND t2.pk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY pk LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t1.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk LIMIT 1; +Warnings: +Warning 1048 Column 'pk' cannot be null +Warning 1048 Column 'nnuk' cannot be null +Warning 1048 Column 'nnuk1' cannot be null +Warning 1048 Column 'nnuk2' cannot be null +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nokey LIMIT 1; +Warnings: +Warning 1048 Column 'pk' cannot be null +Warning 1048 Column 'nnuk' cannot be null +Warning 1048 Column 'nnuk1' cannot be null +Warning 1048 Column 'nnuk2' cannot be null +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nuk LIMIT 1; +Warnings: +Warning 1048 Column 'pk' cannot be null +Warning 1048 Column 'nnuk' cannot be null +Warning 1048 Column 'nnuk1' cannot be null +Warning 1048 Column 'nnuk2' cannot be null +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1 LIMIT 1; +Warnings: +Warning 1048 Column 'pk' cannot be null +Warning 1048 Column 'nnuk' cannot be null +Warning 1048 Column 'nnuk1' cannot be null +Warning 1048 Column 'nnuk2' cannot be null +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk LIMIT 1; +Warnings: +Warning 1048 Column 'pk' cannot be null +Warning 1048 Column 'nnuk' cannot be null +Warning 1048 Column 'nnuk1' cannot be null +Warning 1048 Column 'nnuk2' cannot be null +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY pk LIMIT 1; +Warnings: +Warning 1048 Column 'pk' cannot be null +Warning 1048 Column 'nnuk' cannot be null +Warning 1048 Column 'nnuk1' cannot be null +Warning 1048 Column 'nnuk2' cannot be null +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nnuk2 LIMIT 1; +Warnings: +Warning 1048 Column 'pk' cannot be null +Warning 1048 Column 'nnuk' cannot be null +Warning 1048 Column 'nnuk1' cannot be null +Warning 1048 Column 'nnuk2' cannot be null +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +Warnings: +Warning 1048 Column 'pk' cannot be null +Warning 1048 Column 'nnuk' cannot be null +Warning 1048 Column 'nnuk1' cannot be null +Warning 1048 Column 'nnuk2' cannot be null +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +INSERT INTO t SELECT t1.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +Warnings: +Warning 1048 Column 'pk' cannot be null +Warning 1048 Column 'nnuk' cannot be null +Warning 1048 Column 'nnuk1' cannot be null +Warning 1048 Column 'nnuk2' cannot be null +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 3 +DROP TABLE t, t1, t2, t3, t4; +DROP TABLE queries, result_queries, limits; +DROP PROCEDURE gen_queries; === added file 'mysql-test/suite/binlog/t/binlog_unsafe_limit.test' --- a/mysql-test/suite/binlog/t/binlog_unsafe_limit.test 1970-01-01 00:00:00 +0000 +++ b/mysql-test/suite/binlog/t/binlog_unsafe_limit.test 2010-10-15 10:31:35 +0000 @@ -0,0 +1,206 @@ +# ==== Purpose ==== +# +# Test under what circumstances there is a warning for unsafe +# statements on the following form: +# +# [INSERT...SELECT | REPLACE...SELECT | DELETE | UPDATE] ... ORDER BY ... LIMIT +# +# INSERT...SELECT...LIMIT should give a warning because the order of +# rows may differ between master and slave, so the LIMIT may select a +# different set of rows on master and slave. However, if there is an +# 'ORDER BY primary_key', then the order is known and there should not +# be any warning. The same is true for REPLACE...SELECT, DELETE, and +# UPDATE. In REPLACE...SELECT and INSERT...SELECT, the select may be +# compound using UNION or JOIN or subqueries in the FROM clause. So +# we test LIMIT in various places in the subqueries. +# +# We also test various forms of ORDER BY ... LIMIT. If there is one +# ORDER BY column and it is a PRIMARY KEY or NOT NULL UNIQUE KEY, then +# the order is deterministic. If there is one ORDER BY column and it +# is neither a PRIMARY KEY nor a NOT NULL UNIQUE KEY, then the order +# is not deterministic. If the ORDER BY consists of several columns, +# and a prefix of the ORDER BY columns is a PRIMARY KEY or NOT NULL +# UNIQUE KEY, then the order is deterministic. If the ORDER BY +# consists of several columns, and no prefix of the ORDER BY COLUMNS +# is a PRIMARY KEY or NOT NULL UNIQUE KEY, then the order is not +# deterministic. + +source include/have_log_bin.inc; +source include/have_binlog_format_statement.inc; + +# +# Create the tables for test +# Where: +# - nokey is a column not part of key +# - pk is column of the primary key +# - nuk is a column of UNIQUE KEY, which can be NULL. +# - nnuk is a column of NOT NULL UNIQUE KEY +# - nnuk1 and nnuk2 are NOT NULL columns, and togather forms a UNIQUE KEY. +# +CREATE TABLE t (nokey INT, pk INT PRIMARY KEY, nnuk INT NOT NULL UNIQUE KEY, nuk INT UNIQUE KEY, nnuk1 INT NOT NULL, nnuk2 INT NOT NULL, UNIQUE KEY(nnuk1, nnuk2)); +CREATE TABLE t1 LIKE t; +CREATE TABLE t2 LIKE t; +CREATE TABLE t3 LIKE t; +CREATE TABLE t4 LIKE t; + + +CREATE TABLE queries (query VARCHAR(1024) NOT NULL); +CREATE TABLE result_queries (id INT AUTO_INCREMENT PRIMARY KEY, query VARCHAR(1024) NOT NULL); +CREATE TABLE limits (`limit` VARCHAR(256) NOT NULL); + +# +# Iterate through the following queries +# +# [LIMIT_1] and [LIMIT_2] will iterate over the strings in table `limits` +# +INSERT INTO queries(query) VALUES + ('UPDATE t1 SET nokey = nokey + 10 [LIMIT_1]'), + ('UPDATE t1 SET nokey = nokey + 10 WHERE nokey=1 [LIMIT_1]'), + ('UPDATE t1 SET nokey = nokey + 10 WHERE nuk=1 [LIMIT_1]'), + ('UPDATE t1 SET nokey = nokey + 10 WHERE nnuk=1 [LIMIT_1]'), + ('UPDATE t1 SET nokey = nokey + 10 WHERE pk=1 [LIMIT_1]'), + + ('DELETE FROM t1 [LIMIT_1]'), + ('DELETE FROM t1 WHERE nokey=1 [LIMIT_1]'), + ('DELETE FROM t1 WHERE nuk=1 [LIMIT_1]'), + ('DELETE FROM t1 WHERE nnuk=1 [LIMIT_1]'), + ('DELETE FROM t1 WHERE pk=1 [LIMIT_1]'), + + ('REPLACE INTO t SELECT * FROM t1 [LIMIT_1]'), + ('REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 [LIMIT_1]'), + ('REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 [LIMIT_1]'), + ('REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 [LIMIT_1]'), + ('REPLACE INTO t SELECT * FROM t1 WHERE pk=1 [LIMIT_1]'), + + ('INSERT INTO t SELECT * FROM t1 [LIMIT_1]'), + ('INSERT INTO t SELECT * FROM t1 WHERE nokey=1 [LIMIT_1]'), + ('INSERT INTO t SELECT * FROM t1 WHERE nuk=1 [LIMIT_1]'), + ('INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 [LIMIT_1]'), + ('INSERT INTO t SELECT * FROM t1 WHERE pk=1 [LIMIT_1]'), + + ('INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) [LIMIT_1]'), + ('INSERT INTO t (SELECT * FROM t1 [LIMIT_1]) UNION (SELECT * FROM t2)'), + ('INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 [LIMIT_1])'), + ('INSERT INTO t (SELECT * FROM t1 [LIMIT_1]) UNION (SELECT * FROM t2 [LIMIT_2])'), + + ('INSERT INTO t SELECT * FROM (SELECT * FROM t1 [LIMIT_1]) AS subselect [LIMIT_2]'), + ('INSERT INTO t SELECT t1.* FROM t1, t2 [LIMIT_1]'), + ('INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey [LIMIT_1]'), + ('INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk [LIMIT_1]'), + ('INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk [LIMIT_1]'), + ('INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk [LIMIT_1]'), + + ('INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 [LIMIT_1]'), + ('INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) [LIMIT_1]'), + ('INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 [LIMIT_1]'), + ('INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 [LIMIT_1]'), + ('INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) [LIMIT_1]'), + ('INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.pk=t3.pk) ON t1.pk=t4.pk [LIMIT_1]'), + ('INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 [LIMIT_1]'), + ('INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING (pk)) ON t2.nnuk=t3.nnuk) ON t1.nnuk1=t4.nnuk1 AND t1.nnuk2=t4.nnuk2 AND t2.pk=1 [LIMIT_1]'), + ('INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk [LIMIT_1]'), + ('INSERT INTO t SELECT t1.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk [LIMIT_1]'); + + +# +# Let the LIMIT cluase ([LIMIT_1] and [LIMIT_2]) iterate through the following strings: +# +INSERT INTO limits (`limit`) VALUES + ('LIMIT 0'), + ('LIMIT 1'), + ('ORDER BY nokey LIMIT 1'), + ('ORDER BY nuk LIMIT 1'), + ('ORDER BY nnuk1 LIMIT 1'), + ('ORDER BY nnuk LIMIT 1'), + ('ORDER BY pk LIMIT 1'), + ('ORDER BY nnuk1, nnuk2 LIMIT 1'), + ('ORDER BY nnuk1, nnuk2, nokey LIMIT 1'), + ('ORDER BY nnuk1, nokey, nnuk2 LIMIT 1'); + + +DELIMITER |; + +# +# This function is used to generate the queries by replace [LIMIT_1] +# and [LIMIT_2] with values in table `limits` for values in table +# `queries`. And the result will be save in table `result_queries`. +# + +CREATE PROCEDURE gen_queries() +BEGIN + DECLARE done INT DEFAULT 0; + DECLARE q VARCHAR(1024); + DECLARE limit1, limit2 VARCHAR(256); + DECLARE qcur CURSOR FOR SELECT * FROM queries; + DECLARE lcur1 CURSOR FOR SELECT * FROM limits; + DECLARE lcur2 CURSOR FOR SELECT * FROM limits; + DECLARE CONTINUE HANDLER FOR NOT FOUND SET done=1; + + OPEN qcur; + + FETCH qcur INTO q; + WHILE done <> 1 DO + OPEN lcur1; + FETCH lcur1 INTO limit1; + WHILE done <> 1 DO + + IF LOCATE('[LIMIT_2]', q) > 0 THEN + OPEN lcur2; + FETCH lcur2 INTO limit2; + WHILE done <> 1 DO + SELECT REPLACE(REPLACE(q, '[LIMIT_1]', limit1), '[LIMIT_2]', limit2) INTO @query; + FETCH lcur2 INTO limit2; + END WHILE; + CLOSE lcur2; + SET done = 0; + ELSE + SELECT REPLACE(q, '[LIMIT_1]', limit1) INTO @query; + END IF; + INSERT INTO result_queries set query=@query; + FETCH lcur1 INTO limit1; + END WHILE; + CLOSE lcur1; + SET done = 0; + FETCH qcur INTO q; + END WHILE; + CLOSE qcur; +END| + +DELIMITER ;| + +call gen_queries(); + +# +# Execute the generated queries +# +let $count= `SELECT COUNT(*) FROM result_queries`; +let $id=1; +while (`SELECT $id <= $count`) +{ + disable_query_log; + TRUNCATE t; + TRUNCATE t1; + TRUNCATE t2; + TRUNCATE t3; + TRUNCATE t4; + INSERT INTO t VALUES (1, 1, 1, 1, 1, 1), (2, 2, 2, 2, 2, 2); + INSERT INTO t1 VALUES (3, 3, 3, 3, 3, 3), (4, 4, 4, 4, 4, 4); + INSERT INTO t2 VALUES (5, 5, 5, 5, 5, 5), (6, 6, 6, 6, 6, 6); + INSERT INTO t3 VALUES (7, 7, 7, 7, 7, 7), (8, 8, 8, 8, 8, 8); + INSERT INTO t4 VALUES (9, 9, 9, 9, 9, 9), (10, 10, 10, 10, 10, 10); + + let $query= `SELECT query FROM result_queries WHERE id=$id`; + enable_query_log; + + eval $query; + let $rows= `SELECT COUNT(*) FROM t`; + echo ROWS in table t: $rows; + inc $id; +} + +# +# Cleanup +# +DROP TABLE t, t1, t2, t3, t4; +DROP TABLE queries, result_queries, limits; +DROP PROCEDURE gen_queries; === modified file 'sql/sql_delete.cc' --- a/sql/sql_delete.cc 2010-05-14 11:36:27 +0000 +++ b/sql/sql_delete.cc 2010-10-15 10:31:35 +0000 @@ -92,6 +92,18 @@ bool mysql_delete(THD *thd, TABLE_LIST * } } + /* + Statement-based replication of DELETE ... LIMIT is not safe as + order of rows is not defined unless ORDER BY primary_key, so in + mixed mode we go to row-based. + */ + if (thd->lex->current_select->select_limit && + select_lex->select_limit->val_int() && + !is_order_deterministic(table_list, conds, (ORDER*)order->first)) + { + thd->lex->set_stmt_unsafe(); + } + const_cond= (!conds || conds->const_item()); safe_update=test(thd->options & OPTION_SAFE_UPDATES); if (safe_update && const_cond) @@ -475,19 +487,6 @@ int mysql_prepare_delete(THD *thd, TABLE DBUG_ENTER("mysql_prepare_delete"); List all_fields; - /* - Statement-based replication of DELETE ... LIMIT is not safe as order of - rows is not defined, so in mixed mode we go to row-based. - - Note that we may consider a statement as safe if ORDER BY primary_key - is present. However it may confuse users to see very similiar statements - replicated differently. - */ - if (thd->lex->current_select->select_limit) - { - thd->lex->set_stmt_unsafe(); - thd->set_current_stmt_binlog_row_based_if_mixed(); - } thd->lex->allow_sum_func= 0; if (setup_tables_and_check_access(thd, &thd->lex->select_lex.context, &thd->lex->select_lex.top_join_list, === modified file 'sql/sql_insert.cc' --- a/sql/sql_insert.cc 2010-03-29 02:32:30 +0000 +++ b/sql/sql_insert.cc 2010-10-15 10:31:35 +0000 @@ -2881,19 +2881,6 @@ bool mysql_insert_select_prepare(THD *th DBUG_ENTER("mysql_insert_select_prepare"); /* - Statement-based replication of INSERT ... SELECT ... LIMIT is not safe - as order of rows is not defined, so in mixed mode we go to row-based. - - Note that we may consider a statement as safe if ORDER BY primary_key - is present or we SELECT a constant. However it may confuse users to - see very similiar statements replicated differently. - */ - if (lex->current_select->select_limit) - { - lex->set_stmt_unsafe(); - thd->set_current_stmt_binlog_row_based_if_mixed(); - } - /* SELECT_LEX do not belong to INSERT statement, so we can't add WHERE clause if table is VIEW */ === modified file 'sql/sql_select.cc' --- a/sql/sql_select.cc 2010-05-27 15:13:53 +0000 +++ b/sql/sql_select.cc 2010-10-15 10:31:35 +0000 @@ -910,6 +910,27 @@ JOIN::optimize() } } + if (thd->lex->sql_command == SQLCOM_INSERT_SELECT || + thd->lex->sql_command == SQLCOM_REPLACE_SELECT) + { + /* + Statement-based replication of INSERT ... SELECT ... LIMIT is + not safe as order of rows is not defined unless ORDER BY + primary_key, so in mixed mode we go to row-based. + + NOTE: When more than one tables are joined in the SELECT part, + it will very hard to figure out whether the result order will be + deterministic or not, so they are always considered unsafe to + simplify the logic. + */ + if (!thd->lex->is_stmt_unsafe() && select_lex->select_limit && + select_lex->select_limit->val_int() && + !is_order_deterministic(join_list, conds, order)) + { + thd->lex->set_stmt_unsafe(); + } + } + #ifdef WITH_PARTITION_STORAGE_ENGINE { TABLE_LIST *tbl; @@ -17162,6 +17183,505 @@ bool JOIN::change_result(select_result * DBUG_RETURN(FALSE); } +bool is_cond_equal(COND *cond) +{ + if (cond->type() == Item::FUNC_ITEM && + (((Item_func*)cond)->functype() == Item_func::EQ_FUNC || + ((Item_func*)cond)->functype() == Item_func::EQUAL_FUNC)) + return TRUE; + return FALSE; +} + +bool is_cond_mult_equal(COND *cond) +{ + if (cond->type() == Item::FUNC_ITEM && + (((Item_func*)cond)->functype() == Item_func::MULT_EQUAL_FUNC)) + return TRUE; + return FALSE; +} + +static bool covers_unique_key(MY_BITMAP *bitmap, TABLE *table) +{ + uint key; + MY_BITMAP key_set; + + if (table->s->primary_key == MAX_KEY && !table->s->uniques) + return FALSE; + + bitmap_init(&key_set, NULL, table->s->fields, FALSE); + for (key=0; key < table->s->keys; key++) + { + if ((table->s->key_info[key].flags & (HA_NOSAME | HA_NULL_PART_KEY)) == HA_NOSAME) + { + table->mark_columns_used_by_index_no_reset(key, &key_set); + if (bitmap_is_subset(&key_set, bitmap)) + { + bitmap_free(&key_set); + return TRUE; + } + bitmap_clear_all(&key_set); + } + } + bitmap_free(&key_set); + return FALSE; +} + +/* + This class is used to calculate the equation bitmaps for JOIN table + lists. + + When there is an equation 't1.a=t2.b' in the WHERE condition or ON + expression, both the bit of the bitmap for field 'a' in table 't1' + and the bit for field 'b' in table 't2' will be set. The bit will be + first set in the 'tmp_bitmap' when iterating over each item, and + after iterated over all the items of the condition, the value of + 'tmp_bitmap' will be merged if the fields of the equation are from + tables of both side of the JOIN. + + Please check calc_equation_bitmap_* functions for more detail. + */ +class TABLE_BITMAP_LIST { +public: + TABLE_BITMAP_LIST(TABLE_LIST *t) + :table(t->table) + { + bitmap_init(&bitmap, NULL, table->s->fields, FALSE); + bitmap_init(&tmp_bitmap, NULL, table->s->fields, FALSE); + } + + TABLE* get_table() { return table; } + + void set_tmp_bit(uint16 field_index) + { + bitmap_set_bit(&tmp_bitmap, field_index); + } + + void clear_all() + { + bitmap_clear_all(&bitmap); + } + + void clear_tmp_all() + { + bitmap_clear_all(&tmp_bitmap); + } + + void merge_tmp() + { + bitmap_union(&bitmap, &tmp_bitmap); + } + + bool is_owner_of(Field *field) + { + return field->table == table; + } + + bool covers_unique_key() + { + return ::covers_unique_key(&bitmap, table); + } + +private: + TABLE *table; + MY_BITMAP bitmap; + + /* + tmp_bitmap is used to temporary save the result when tranversing + all items of the condition. it will be throw away or merged to + bitmap at the end + */ + MY_BITMAP tmp_bitmap; +}; + +static TABLE_BITMAP_LIST* find_field_owner(List *tbls, + Field *field) +{ + List_iterator it(*tbls); + TABLE_BITMAP_LIST *tbl; + while ((tbl= it++)) + { + if (tbl->is_owner_of(field)) + return tbl; + } + return NULL; +} + +static bool list_covers_unique_key(List *tbls) +{ + List_iterator it(*tbls); + TABLE_BITMAP_LIST *tbl; + while ((tbl= it++)) + { + if(tbl->covers_unique_key()) + return TRUE; + } + return FALSE; +} + +static void list_clear_all(List *tbls) +{ + List_iterator it(*tbls); + TABLE_BITMAP_LIST *tbl; + while ((tbl= it++)) + tbl->clear_all(); +} + +static void list_clear_tmp_all(List *tbls) +{ + List_iterator it(*tbls); + TABLE_BITMAP_LIST *tbl; + while ((tbl= it++)) + tbl->clear_tmp_all(); +} + +static void list_merge_tmp(List *tbls) +{ + List_iterator it(*tbls); + TABLE_BITMAP_LIST *tbl; + while ((tbl= it++)) + tbl->merge_tmp(); +} + +static bool calc_equation_bitmap_for_single_equal(List *first_list, + List *second_list, + COND *cond) +{ + if (is_cond_equal(cond)) + { + uint i; + Item **args= ((Item_func*)cond)->arguments(); + uint arg_count= ((Item_func*)cond)->argument_count(); + bool from_first= FALSE, from_second= FALSE; + + list_clear_tmp_all(first_list); + list_clear_tmp_all(second_list); + + for (i=0; ireal_item()->type() == Item::FIELD_ITEM) + { + TABLE_BITMAP_LIST *tbl= NULL; + Field *field= ((Item_field*)args[i]->real_item())->field; + if ((tbl= find_field_owner(first_list, field))) + { + from_first= TRUE; + tbl->set_tmp_bit(field->field_index); + } + else if ((tbl= find_field_owner(second_list, field))) + { + from_second= TRUE; + tbl->set_tmp_bit(field->field_index); + } + } + } + if (from_first && from_second) + { + list_merge_tmp(first_list); + list_merge_tmp(second_list); + return TRUE; + } + } + return FALSE; +} + +static bool calc_equation_bitmap_for_mult_equal(List *first_list, + List *second_list, + Item_equal *item_equal) +{ + Item_equal_iterator it(*item_equal); + Item_field *item= NULL; + + list_clear_tmp_all(first_list); + list_clear_tmp_all(second_list); + + bool from_first= FALSE, from_second= FALSE; + + while ((item= it++)) + { + Field *field= item->field; + TABLE_BITMAP_LIST *tbl= NULL; + if ((tbl= find_field_owner(first_list, field))) + { + tbl->set_tmp_bit(field->field_index); + from_first= TRUE; + } + else if ((tbl= find_field_owner(second_list, field))) + { + tbl->set_tmp_bit(field->field_index); + from_second= TRUE; + } + } + if(from_first && from_second) + { + list_merge_tmp(first_list); + list_merge_tmp(second_list); + return TRUE; + } + return FALSE; +} + +static bool calc_equation_bitmap_for_cond_equal(List *first_list, + List *second_list, + COND_EQUAL *cond_equal) +{ + if (!cond_equal || cond_equal->current_level.is_empty()) + return FALSE; + + bool ret= FALSE; + while (cond_equal) + { + Item_equal *item_equal; + List_iterator equal_it(cond_equal->current_level); + while ((item_equal= equal_it++)) + { + ret|= calc_equation_bitmap_for_mult_equal(first_list, second_list, item_equal); + } + cond_equal= cond_equal->upper_levels; + } + return ret; +} + +static bool calc_equation_bitmap_for_cond(List *first_list, + List *second_list, + COND *cond); + +static bool calc_equation_bitmap_for_and(List *first_list, + List *second_list, + Item_cond_and *cond_and) +{ + bool ret= calc_equation_bitmap_for_cond_equal(first_list, second_list, + &cond_and->cond_equal); + List *args= cond_and->argument_list(); + List_iterator it(*args); + COND *cond; + while ((cond= it++)) + { + ret|= calc_equation_bitmap_for_cond(first_list, second_list, cond); + } + return ret; +} + +static bool calc_equation_bitmap_for_cond(List *first_list, + List *second_list, + COND *cond) +{ + if (!cond) + return FALSE; + + if (is_cond_equal(cond)) + return calc_equation_bitmap_for_single_equal(first_list, + second_list, + cond); + + if (is_cond_mult_equal(cond)) + return calc_equation_bitmap_for_mult_equal(first_list, + second_list, + (Item_equal*)cond); + + if (is_cond_and(cond)) + return calc_equation_bitmap_for_and(first_list, second_list, + (Item_cond_and*)cond); + return FALSE; +} + + +/* + Mark all the fields in the condition that is an equality comparison + between a field and a const value (i.e. col1=const1 [and col2=const2]). + */ +static void mark_cond_field_const_equations(TABLE *table, + COND *cond, MY_BITMAP *cond_set) +{ + if (is_cond_and(cond)) + { + List *args= ((Item_cond*) cond)->argument_list(); + + List_iterator it(*args); + COND *c; + while ((c= it++)) + { + mark_cond_field_const_equations(table, c, cond_set); + } + } + + if (is_cond_equal(cond)) + { + uint i; + Field *field= NULL; + Item **args= ((Item_func*)cond)->arguments(); + uint arg_count= ((Item_func*)cond)->argument_count(); + bool const_value= FALSE; + + for (i=0; ireal_item()->type() == Item::FIELD_ITEM) + { + field= ((Item_field*)args[i]->real_item())->field; + } + else if (args[i]->real_item()->basic_const_item()) + { + const_value = TRUE; + } + } + if (field && const_value && field->table == table) + bitmap_set_bit(cond_set, field->field_index); + } + else if (is_cond_mult_equal(cond) && + ((Item_equal*)cond)->get_const()) + { + Item_equal_iterator it(*((Item_equal*)cond)); + Item_field *item; + while ((item= it++)) + { + if (item->field->table == table) + bitmap_set_bit(cond_set, item->field->field_index); + } + } + return; +} + +/* + Mark all the columns used by the order clause. + */ +static void mark_order_fields(TABLE *table, ORDER *order, MY_BITMAP *order_set) +{ + for (; order; order=order->next) + { + if ((*order->item)->real_item()->type() == Item::FIELD_ITEM) + { + Field *field=((Item_field*) (*order->item)->real_item())->field; + if (field->table == table) + bitmap_set_bit(order_set, field->field_index); + } + } + return; +} + +inline bool is_nested_join_table(TABLE_LIST *table) +{ + return table->nested_join ? TRUE : FALSE; +} + +static List* join_on_unique_key(TABLE_LIST *table, COND *cond); + +static List* join_on_unique_key(List *join_list, COND *cond) +{ + if (join_list->is_empty()) + return NULL; + + List_iterator it(*join_list); + TABLE_LIST *table= it++; + COND* on_expr= table->on_expr; + uint outer_join= table->outer_join; + + List *first_list, *second_list; + first_list= join_on_unique_key(table, cond); + + if (!first_list) + return NULL; + + if (join_list->elements == 1) + return first_list; + + while ((table= it++)) + { + second_list= join_on_unique_key(table, cond); + if (!second_list) + return NULL; + + list_clear_all(first_list); + list_clear_all(second_list); + + if (!calc_equation_bitmap_for_cond(first_list, second_list, on_expr) && + !calc_equation_bitmap_for_cond(first_list, second_list, cond)) + return NULL; + + if (!list_covers_unique_key(first_list) || + !list_covers_unique_key(second_list)) + return NULL; + if (!outer_join) + first_list->concat(second_list); + } + + if (outer_join) + return second_list; + return first_list; +} + +static List* join_on_unique_key(TABLE_LIST *table, COND *cond) +{ + if (!is_nested_join_table(table)) + { + TABLE_BITMAP_LIST *tbl= new TABLE_BITMAP_LIST(table); + List *tbls= new List; + tbls->push_back(tbl); + return tbls; + } + + return join_on_unique_key(&table->nested_join->join_list, cond); +} + +/* + Helper function to check if the result order is deterministic. + */ +static bool is_order_deterministic(List *tbls, COND *cond, ORDER *order) +{ + if (!tbls || tbls->is_empty()) + return FALSE; + + List_iterator tbls_it(*tbls); + TABLE_BITMAP_LIST *tbl; + while ((tbl= tbls_it++)) + { + MY_BITMAP check_set; + TABLE *table= tbl->get_table(); + bitmap_init(&check_set, NULL, table->s->fields, FALSE); + + if (order) + mark_order_fields(table, order, &check_set); + if (cond) + mark_cond_field_const_equations(table, cond, &check_set); + + bool ret= covers_unique_key(&check_set, table); + + bitmap_free(&check_set); + if (ret) + return ret; + } + return FALSE; +} + +/* + Test if the result order is deterministic for a JOIN table list. + + @retval FALSE not deterministic + @retval TRUE deterministic + */ +bool is_order_deterministic(List* join_list, + COND* cond, ORDER* order) +{ + List *tbls= join_on_unique_key(join_list, cond); + + return is_order_deterministic(tbls, cond, order); +} + +/* + Test if the result order is deterministic for a single table. + + @retval FALSE not deterministic + @retval TRUE deterministic + */ +bool is_order_deterministic(TABLE_LIST *table_list, COND *cond, ORDER *order) +{ + if (order == NULL && cond == NULL) + return FALSE; + + List *tbls= join_on_unique_key(table_list, cond); + + return is_order_deterministic(tbls, cond, order); +} + + /** @} (end of group Query_Optimizer) */ === modified file 'sql/sql_select.h' --- a/sql/sql_select.h 2010-02-26 13:16:46 +0000 +++ b/sql/sql_select.h 2010-10-15 10:31:35 +0000 @@ -794,3 +794,5 @@ inline bool optimizer_flag(THD *thd, uin return (thd->variables.optimizer_switch & flag); } +bool is_order_deterministic(TABLE_LIST *table_list, COND *cond, ORDER *order); +bool is_order_deterministic(List *join_list, COND *cond, ORDER *order); === modified file 'sql/sql_update.cc' --- a/sql/sql_update.cc 2010-05-27 20:07:40 +0000 +++ b/sql/sql_update.cc 2010-10-15 10:31:35 +0000 @@ -248,6 +248,18 @@ int mysql_update(THD *thd, if (mysql_prepare_update(thd, table_list, &conds, order_num, order)) DBUG_RETURN(1); + /* + Statement-based replication of UPDATE ... LIMIT is not safe as + order of rows is not defined unless ORDER BY primary_key, so in + mixed mode we go to row-based. + */ + if (thd->lex->current_select->select_limit && + select_lex->select_limit->val_int() && + !is_order_deterministic(table_list, conds, order)) + { + thd->lex->set_stmt_unsafe(); + } + old_covering_keys= table->covering_keys; // Keys used in WHERE /* Check the fields we are going to modify */ #ifndef NO_EMBEDDED_ACCESS_CHECKS @@ -875,19 +887,6 @@ bool mysql_prepare_update(THD *thd, TABL SELECT_LEX *select_lex= &thd->lex->select_lex; DBUG_ENTER("mysql_prepare_update"); - /* - Statement-based replication of UPDATE ... LIMIT is not safe as order of - rows is not defined, so in mixed mode we go to row-based. - - Note that we may consider a statement as safe if ORDER BY primary_key - is present. However it may confuse users to see very similiar statements - replicated differently. - */ - if (thd->lex->current_select->select_limit) - { - thd->lex->set_stmt_unsafe(); - thd->set_current_stmt_binlog_row_based_if_mixed(); - } #ifndef NO_EMBEDDED_ACCESS_CHECKS table_list->grant.want_privilege= table->grant.want_privilege= (SELECT_ACL & ~table->grant.privilege); --===============4964619236702267240== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/zhenxing.he@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: zhenxing.he@stripped # target_branch: file:///media/sdb2/hezx/work/mysql/bzr/b42415/5.1-\ # bugteam/ # testament_sha1: a11aac6716ab0e299437843b3fa01ce0317bf28c # timestamp: 2010-10-15 18:31:42 +0800 # base_revision_id: ramil@stripped # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWTZOaLoAPWxfgH2wf/////// //r////+YDje++7vHuxd56FuzujK3tq9q8SR8A7fcp318PGUklfa6dzUfW4F9z5vdUu8649nm17P Hl72e8b3Fbl7hQUIetV43u97sSldenTxja0KwhrWayqzr3vdx3o9ts+7ure5fe9eeJZ0XdrMu7c7 Y0aFvGcI6wN7l2BeQ1ezWsgjyy6ac9Y6lSts8rW7t1wkiJoJiZGQBGmjKbUZGkmwVD9T1NMo2o9T T1G09UfqmmgP1IJEIQTQInqnkaaaTU9TaNCGhoDQDIDQAAAaDU/JKaqgGmQ00DQGjRiGgAAA0aGg GjQAAk9VIpEmjEDINGCNANAB6gAAAAAAAIkkJkTBGIAmmRNoCTyaap+gUabUbU2oeUPU9QA0ep6B UUgQE0TCJhMRpkaAFT/UTyhpqGnqe1I2powQbUMmmSfIQVTPERM8F3QAGmyI/gCH96pDHsIWemRI Xy+788GVlU30YqfssbiueFddaf+6JleL1OJZ05yaCmmGZRZx2Tq/VH+jSCwn5WHd07/EKWBir6fX 8yfR/PwjDi9fs2XTj30QgkAr9fVYahCSbJXNXYQtNW2x4OhjI0GZOT6FiCx5IkvDcP+x/knZBTUM iCFEG6CBqUhmQ0vpj98GrZw8Xx3xFi4x+DhyafLCpqtDjAd1BbNk3HHx/FiXgeHJiiGSsuMR/O4v G9Bq0dR/i/R1v5HiNz/FhqyYQHHDaMf8EfpYcTWvoXBqYUNjo0MQdndDjnVRJ3OhQxSnOn2e/uo9 9mhinOvKbNlMG2N3gg3HoyvTu8OmMbHSgwz+8VQNjS8yBOzBsTbY2DOJzEcj3CML9TPS5t3x/if6 VXs18x08/2CwY/Pa//jEf5d8YZH/n7n590rOlIkp2EDX4i4I5bHPh8bz44ePC732K7mRkeHPSHmi YiDeUGWFI+/nC8nd5dwAAirx3VXXOVJUtGtWVLQ1FS0a29LbbXyGJRUTdw3aNRUWxJh2LKsSrKuT JrGsmTJk20mTJkyZMmTJkyZNJkwmSaipJktkyZMlZMmsmTJk2kWpkkyStMrKsqlWVVWVdPxw5F0g mGJvkTehSihyn777eozWXjgcRA1/Gn4ZqUyvN5kbpowIE7weuLzDvPjbA8KoQBVsDG4vI8jWJDpJ 9iQh/NYRDdKkIVOMVJ0FSgslFIT/4SokpLJIziKMmSiiiiiiiii5ZcUVCJYSdlUxCMSK/XKJ10Ul BC+0hAprlq5wgU0EAQQQ00poIOLvvrVOriTsQBBXJKllpTbSaVLFS0VVA/LD5v5/u+/L1X1XU+zx P7mbC36vt+3yaNNx7zwqavKQ2tafVI7JMoxaVN2ezxgex17n0Ly7xete286IiIiIiSSfSE5O0rqf 2LJiy82bjmjLZiahNGMwIkTmAVfnNb0D7D8/sV5ee1DcsOoo+xKgXi1PojGNtIlB6QSW5G4Qyjvd yPqTg5NY/cPkT60qW2rYttt0ap6PWwqkP/F9fTj14jgIZoo8cUIF/9oK0nv9uh93Fdmv0Yxfut4B EbvfISF4RXt1lv4XdqBrGdKWslrnC8Qr33pv03WTKtMZGyaiqSERiLGvDfu6/MLQMWAx+tg1DSBJ c/BA/SlTI8Zjl+o4nB1k85Ck5NieZ9vYiSRTd7O+TBgSKama8ykkpj0e2mcU0uhENKzoZMG9gkXA 4v2E8Knk7sRCeKxbBbFsWxbFsGjRbERERERERERERERERERERERERERERSREtVVpIMbO5m49eb6n Y4O1m7bHxd2bRkr8Xg3MHW6GRmdjcWA6W2222220AAAAAAAAAAAAAAAEi22EkftcnZXZFWdW8JvI aNnRXD7GomQmBg7lRhsT1ENfz/Ns3KpUrt6/OVVKqbNXEnuVxcXVlMr2W9uMW3Ll41tDOXwh44hx OOI0lsWVjaWgrUrValutUVkq1iCtY3C0FQVxjYuqxuFlVBXGNi1jaWgqCoKgqCoKwFiqCsrG4WVU FcY2MVaxuFoKgrjGxiqCoK1KIjlzMKOW3LbFd23LaI5bcpbxlsy6WsbGiojlt3bRHLxmRuy2SYlG NtjQWpa2NQ/YGX0VJ2/gacgeK+rgbOI6LQWox26x9jW4CiippLUcDP1zO21de8TYSiUJy2j2dzf1 bRJoQubOK11I1bG3PiqJiKJfsOG7P2L3qlHESEAbji5xjteHe1NJgQBuNXJTgQ4N73maTgIA3Grk psQ4N73madItAxuJqnJFDZeIdn7GMQgxayi5DGNtvDi5vHsl4d7U05EhAG44ubx2vDvamkwIA3Gr kpwIcG97zkTyZyeROVOVObJiGIbz9Rd+yIaO6rOCYkcHNALaJgElbNqgCFPIYgr1F/JNgbCBCAUu +dfZXUfj4Gc3SQYJkuu9wfqAF5+VxrHCZuO5oeBqDdxOYIOZbzOjAAAHm3K996Pfh4vXr/d9u8Lz 7169a830vZ73zGMYxjGMYxjGMYxjGMYxjGMYxjGMYxjGMYyWMYI3jAFYsHDzi6vdmKbcYHzcDy9V U5ImONihmsQMd3A7XqnJExexQy8RYgVj1nWOCe9amrvvXAPKNZs57i5goktiq9BBbyG8vcsNHed/ w2tkeJYXPSOOV+0mgsmQYmM2Eppy8nX7efecimRSxlYc6EyIAggMkJA6cY022F9gXdJijoJ27RDZ 8/7BkMy6Gjjt21Z3NuIiOPn5GYM/ECCDMTl6nzUion+h1h6TrDP8dhgR8XkcVU9ZluPHet/69nNk vtY2+lnxKy0exYnAckmCa6y+RbfWxqVOwcsNSg0iht5nPUtORkLoDGcK8DUgfwb+ZIVzOhkKWbUL nj7E5G9gdNQ0wPmal1kUH1S1FDRGO4wNpz0zFEw4/Z6W5SSEglZKdggbTAtIyzbCQxhTHrdYE45k /aWDFOCJiwZ0mZA45TI4VobyjGhsZPikJBf0jNfvIBAs5xaCDv0sLAeoqT0GxlPn38TMYwpqOpGg 7vMyU6GFOnZoAca3sGgbMSvsGYXUkd8Xauoyz0xDa7KcIYWeSRSMOhMHQY2Hq2IOruP4h64bUBEN 0ZlzJ+RgphXvMmnjau7GPVIkM82btdXOyCQbIyxlBPQQ5k51Go+QFJkY1GU6AkebYVkTNEZ1CGER OlJHeExsSTsJJnoACMGC0YjGawbLLVuuEkmoTo4KdqsGu/lO15ZEhibl513Ti3IjlqE1cCFDZuZb s5nVzdVJySW+YqlIy8EG8Zsbu7BRmZWO1b1PvFFukSWk8i0yJkZHrqR1kxlGOI0oF3fHPtAvJ9cx kMBCNOkAV2/ZPJMTE51g5wDS4118CeQ5wIOrewdGzrs8TyNGao3t/BvY+KeieAfurxwpMVwXNpi9 TJAItrFkeHnmNZDPSYQ5LaLQbZyxNXORIV0vk2x7yeMJ5FhJCu15EQ0UTJSIpJM8EkOpowRHF0Ik eUJ8Am4JgheKtctcYxQmLjGMYVV1qKqqqSSdoySaQLJrRO5m5kibEpNpSbaspkQyxk4wQmIbsNOk cTJjAhBAIFyU47jh+koRfKNiXUEpeTeeG2/OO4AjMMKDTfeDqGWOhO+u+0GZlGdotcquRYzPIeXI ocPxsyyILTwNxJI1MKjZalh2q1FAGxrKswxvkgwvciF1mRNt57pJdISDJQW0o2GZbyRiV1vZYauE BF4ZXKFljI9SGd5txNFzZruDie9tYfVqIxNFoTfE+p+YlcDU8p4B1G8gMtkCj0u7f04/lXTfgF62 hfp/eh/KRDJZ8nu/D9X3fE+MFu57f8v7t63hy/cV97uxZSBlug93m7M3oBUYuJD+Ao/eWG0A+Ckg xE5ghHwlRJHnyh+xDEOXF/Q09sfJbUPFsMIyslttpGWQwirD6+ARxpFSqkPKsk+X6OvD4/Od9XV1 1y/L54AAAAAAAAAAAAAEkkkkkknoPKZH8/+PNYf8NRSBoN2n0Gp1iWDulpOqggiGRa5XujDLOBQe 8JsGBYf0nb91fwqMnya1Th1fX78VdZ4KkidHTr0atA43TVjZBL4p8ICMWNhrYyhjdsMSyWM5M398 pi/MiUJ0K6LtxnNtzdWpEXpu3K56Wdj0cLWEUQtD5PPm+bpo8PNC+30Iuzra5XrnnZN5MdyDm+th xK+OMbrGlOBeuTLXgrt/JnFnZksji2YuV9XDA/R7e2Htavdkryl+v+ouRDgRK7RERETwt5TbeVKy 5zV4Urt7NKcZirzhTsPeGXPGhhmgveZlqFaYQok/Y8xJ4voYJ54nbcAJwnTVnwABYHrb8vt9uJQi m5OHrJXXqRwsvGyfTzkt1s8NZx2svcXhIxweyWZAMUcOGl340lMhUUtU0SG6GRyt5X3BlLbYx1XM GZjEU6qYKeJwuc9Mk/sR7iP0BKikoikqApJKE/4e7/Pw/3mf3cOVWeX65KxnzfDk/6WG5c1IYtsl WBUqB88X6j1eJG13UANlOyIdvqJcAOrmy8fsC9cMelN6N6OiOKOiO1HRHNHnRnyNW64uGfPmmGgE mfkdO2hHIajypdmGYaB2wWsYVWQ2FRrORlqKCR316Mu72K9vd3mQFRoAMgAAEhIIAgYDVIRFOkRI Ktxjie4xNRt3nEYl5iOhwpziSWQ3EM1oYk5XjaWVhcOZWsG618BUDhyQw+HZfUroH6yFjqQ2hATB O0U4dTxxuOW1PrJwrKyXjDukMTeMWOVjAHZdlmUZe+myQMylKcGKAhJOTzRF+9b+wxu5MQDuU9zT aa1pnO82mTqkj2CNBZQRrx68NxEYvJGMNFFhAY+2nr4yyJCRdp7cf0bu5vPZ6xhd+3J18XnIkamp Ynjib+a2sqWix5/PdMrUNvL1c+CxTk7lpYjTP09NZ4oi67biesSk+gSk4hKtzWAAABytsrUrKysr cREREREQbqsrZEKSk22fWjqnzfYmB3IfjOtY6umQ+rX278gSQ7ZU2Q5YYQviXCQgg8nkrG5KkRe0 51YQ8OzF16eBCxrAAMRYQEp5MCcPMz62vHUMUiq2I5zBDKdTk3cdNJuc2zGTYVVmrRHKM7F2nUiP ymjRo69lg9FZ0MkY5bDbk1Gv/BZLL0q2e8AQTkF7QQcx7dXV1XKtbsuucubgLca44i2MbjCq5uLm hcXLNxcs3Fyy43NC4uaFxcs3FyttYccQuLirJimm6YyhqSYFi0sFhVA+6iwIhBV7YgilyK/viXzO In4QBQEwjQCNB8gQS4m8w2Y5YzSKNBPCcyKxy2Em379Nb7tG+GeqvdcTZfpcXg7Ail55zNAdrSk8 oZRFD2n2U1l2cBV6UhIM1+tqjQSzrNTLQMKJsutVxxnXMi6uKdQnKb5OvbkTOQq1lVSrUqgQnAx2 gCmD4JIRYerEnMTYOby02gTkdR1RRz4SJDyL2vFaRIeGfVny7HHX0acBO9VXi2rckto1VFUZqsmT Jk1kyZMmtUklns/HzV1qjjhFPTkiMjksiI5eOQa+t2sNd/C6OXE8XHPLGoxUZGXLEGpyzOIanmt5 L4TWZ32rxQsElVj1mLpGDjJhtmgAThsSG8iVWsqILMXlfXCc7tSHidxcfeW/YSwQAZFhvjJIFMjY 5rYEE8163CM5c/EvHBE2JF9wy0UuSy55ikmMjIRJluYqIjrgXZoGorLDDPOhysnM1Q4yG+sx2IuC GY03AtoOWvieySDejDYdJBJRa29I0HeBoGKCxd00dP7iigoI3mXhxJrzSQKyZWggsmLosqSRnvkg zLWaTMOTFBpIHwRYUX9DKZ7kgkO81Vy8iKNcxJCLTz0RKc2cxJisMC03EARBtEYzFXfMW69KNeUq oIE44bwR1FG410lgjKkJAwzmU05iesYms2k5aaTmWHA2msrNem6/NlaUYywblTYeTtLZ5LB38bD0 z3YJIau3Ju6NXFTOonKMNOvQIpC1ioznK4uJGsoozGhayeYcxJ0TFYS434OyNMAesFqBGIQiXGL0 6jJCB+KI/WYfdkxODlGBmNJBGyrdqy4EptcWwhdtoEYrKaJiJkNyvlvOhq7YAjh1FgIM9puvjbCb Mje+EXTz0KOc07JGpi+HFGAeXI7CNix5Dhp240hs47to6HQtsdl3Hb7hwOZXINPRRW92M7GpTPN4 F+fLNzjkjs5iOd7a8VJgrrOBkkJBxyN2OJEGupyKxuJKEZFq4X8p0N5sW38BDosWsZFBtp4iCtDt 7dDRaN8z1UeYxpned8tFFDxICDy+vhs5eEc5nSZt21dkwceOZnrhdkRGplCCYENq1S0G5Iv9DOL9 XC6+Hk17I8OfjAjS555x2oZO+MD8tTs3zYpGU7s9Jn80zROFtfZigu20viZt5YNWmNa9Z++VoyxG fiilRqOPlenqbw2ul2WOlfVXw00/1Ep66XVpHZdoFGZWsUMieJaalQqYMUqOLg4k6ceO/YqnVqyO q5TQ2iNGjUBUaNGo1GjRo0aNBTKQ0FRo0VGjUaNFXTbNV4c48fXLaq6BMgbLjCFlz7IOw+V2GINi zm2JWr+l2HagckWpFSpb5mT4J+uGIYfw39bZhoaVkzb4oF5a8ZJU3cGO3wlziWBl0cGNB3uMrMEl ndW+sb81cIsDKoQppGkwAp2Gr3ACECLEWKKIosUUXhd+pX1uLnIVWrh5urXgTMmZKSk0JkRFgGwD QPq+1bycZ9YDgZzgOBkcZyfaYqcZLzI94Boiqmjhs/XQ3HJJE0/C/SiaRBPGKB/H+sH5BH/1Cx+R oFX8yH3gjQl4mIv9uY0J4/oQpJP+UlR+8nJo14THujrWi2x/SROp/FCPzz1RJI504j+9rEFE3A7h MBfox+6ZSbi78rfKfdRa1J4TzH5UGQhschCTJMLyIXEiR5ZIMaW222222Uj+Coqoqop72Spk65IE 1ZjYcQtsYG8pOM7MSgVo6wViNCFkYZpiGiqrCgmFISsEzJJkATgbGx/ybSZ3NYFFi4XtA7JiVA6o XaS1isTEM0PN8aTMQk2MMIfvf9KcBAlFAg+eXIio4GAppsd2EEXlAkBw4NeUnKokkdbvTJVZFrqA OghHdCoHrJtJB4SRtgSd/TuKieN3dvaz3UWtRtaFFXAQ42x1/d/piZ8Q3iDyEBdKHF1E0VHDDrf5 kgf3IdWbunLsyeRDuHjJgYkRBufMEk73kSQ2huN9lr06WktJaStJaS0lpS0lpLSWktJaS0lpLSWk rSWktJaV1r/y/tL1bDGKCDtOAq6QF7FQFvSHaCMEBwXoInecv8ZLqbVdJYSAivcHUBWUGQXOeCMX QQRwFA6hf0OxvTIYiQaCEm4OD2MpINBJnDvUc7FsTu/88rpRrtsWrXFbGq0bbGtZnTOySHvuzxoJ 2CT5CGbomjxImciHVDkw4psGbz0Hn1XjeYQKaqRdBnBRWTykTvGfJmykRBz+XfrN9b1bbZXGAmES MFYuGCIwSFIVJJVhkTYYVuZyTRkqZEkyKtYeYaJIaJJKOxsR8fnzIiNlaq3rECayAzdiih0DrUAH ceMP0AFeWgUVhjlBKJJ4mSRmni4e2635E+YfKzSPSqNrjV6TcUV6bdzXQgtuu+bXcq7Y1dNxRXbd yrpjV23FFdt3LbpSbXbja7a3c10ILbrvm13NdiC2775tdyrtjV03FFdpnTReXkdaWI3upodUEJ2M PinelO/wkgyTM8aQUmkSK8TKd8SxAmiUlFjRFakwjKSBKyhWRjCUCUqROBHcR2Kiqiqim82EdEFo h3A6wUV5htmAEHQOdUBcb0kMDDssntghMidG52sFVRP6erV6V525MmTJkyZMmTLaSpIYYyXl5bnl nSJGEdizkIR8X0bMBV2Cocw0coCy9RQw7JdzIKvOARzWHYQEUdBcQ2l6oocqeEkkkkkgCUld27tS vCk8WvQs0rbcqgKplG4oqSiWmKtwIadxOKKM3Sg9wMzFYOETwpJLIRZVsKnLiniLns5siJZATNlI ZkzQTr5sztWEDzNsSkaRvQ8xcCGJ3XbnBIcRkKsXgR8aoqoqopiYWPOT0HgmSSBgGgpQQN++sWDe gINKqlBfreSSzmKSQYqIssSLB0k0O/fhD1Xa5eq5QUVcdNulva0rKV8/Xy/J5a8k20W1G2UsC+xr 6n3fdWq389vHhI1Q3bTUYbCS+s9CXQEMMkmYTMGxU0TTfILAIvt8RX6/yeSvrbxUavvbbxc3VX3f tXstfhO4bhp0oVsL44NQayWBF1kYLD1ghOIh2kJGMkDFWzobJcBmKHQLnjQmLmBY22h8TU4peOF2 xCo04LVatwWWa7u1rlm7KYeVznG5JCBc6JcQ4bmW00pHAx2KlE2YzB/aDAEiNiyILooGMZg3Hfbh vFc2FrpqnsEMmSZe8LgWGg1WkJtQzY2SslKL3LNNsbbVgwHQ6G+5xaokYTRXk7WBFAv8dh/E/M/I vzCPmVfiQA/Q+ZN8ygkfj93oKPzN54DlHWStLzA+O78S4/30dAii9nTSHUZyHPn5dOi7NCazJEUh lXiUz3vY/3f7EC8pVphksMgDIr22Pdcn7ldpWKko0pAMs7xc44OdYQ7fiX4XmjWUP3xTJNlU3ENX C6TYJS+rOSdjbRPCI+Q5/IX6HmX8BYk/kWC4fiCDzgyQkEwKN7IrdezjPEMJ1mDyAZr7IqGKXzND xOujmRVH1bYQy5TfFIwTzs3AaSjL0MObjz4REgvZvj0pKJDOg8cfyFAD5nf0PQOeo1ETwMD/VGs8 JERz1Zqw5+b+Iu7YeQxaNqBJC4nrfyDS4P5TtpPq5MVDXGrqT0F0H1hDzhrM+kZrR8uMD5ZfcVd5 1XeCovxIh6rKnWXjhCT3kIFMasCtXmsT4eb9TU6dx4cRxqTKSPSUiKUoAQBcTV3Hp8jkTDDHUdRO YpzmUVWBvbdl9Mk9zk5uyP9LaO1YJv3Rtk5tz6SezZ6PvYG/zExM1bvvIVh3IZL15XcedmmcF3l8 kB1pulNVSVoEitbRWHfYL5ZN+XNOcaC+PztQTfKChyzDlDViLhFKXXLKRWtnFz2bLJIlmueio5rB +pWn9+RawZfRcJ/F15OWeK9xH8rmDjKs9D1/H/3TBFOBrPY8vyT4tnCWNgd0AxojCkmZUBIoUEwg mUKDRkOot8Lmt4SsZTWhK3UubenUhztAivThwo5tMc3GM/cXl0O71maY9ZcI9WwryiOh68NGw2G8 LtNFEjKEJKW6zQpEKChU6GCHjaN71jtNRttvPdix4hWmMU45RYcVxXWKdlg76G6NzWH4VsiyNpHn ed3QzjNDtV3eNmGXjLSuXZ9xHU/CRIep5PO3N59csH2y9WccMhmdHzmCyYTgWDmQE0FrqCiF0xAS 1QNZn69qVzfB9rOqNlmGncbpFgwNgyFvGaANM35hBaslgyC5puJMJHHJEcEMHC76zVoySGnGaNJF 6ashNYkhYtuejI2kITmsLjnp8G9xtd7qynHpsqQkGZgKCNyk1JM1f2ANiExI1wQJPKX9lYoqYDrJ z3qw2QJTEx3mZ+3sq7Gvz4+gqCnkd5AnORuM/Csx2ut7LmB1AXkTqQivWlSw++CpEYAG5TAbJfCy 2eQ78qNK5ZkCuk5TgceWQrqQBQAHWUnuUbdGeKxMpSTqdlJUIcPwJDq0qHgHMYktm028c5oW3gHJ G8mPDu3Kw3mkvOw7TV1DcCuzBu3xcnO9IA2ABG5d9Xs9fhTmJg6hxgRUjD1MPM6oMLymopR5Bzcx KMesUUzsWyoqq0lMI1kipvgbKpUkxqTxDOA8anbVFP2mSlZhCqC6GCho+TzmFhYGbAsYF1oyI9pi jemTpQ4GdFwAGaCV6TXMulZiDsS0OUNEkYmCIIFO5WIwo7JnOOOL9ssZdEzhNDY/21lSKlO6yrHL SUHVNIJ6CvSRv8NpTu3mClxeZIUDMB9PK1frQPIKo6YgjqgImz1DyKpD8CLRIRCoSBUWMCJhWFfQ j5/pfgemPtV6fiwe53Pc+n6fxbnBqSEMVkEEEHIcK4GVC2cke7abhveQcILweAMREQHuWCyqhNwi BkBH1gPhAhC6KxFoH5b03Ftqj69ZsqvO/D5fCPO9jYfasDmLBVCdNFMXiIcX6UFV8z0azn8pnziZ O59p5jq9ZtBDywHlUUItRU8dFn0hBdZRipGUFBBWBWzPI5LyLCqelI2+BgiKcw9Ns9gxJCw79XLc zTl/JHt/W9zvetD8VHjXtmU8/IcD23QQw1hYlG+J9hfzllH3wRIRUkYQDQicMhbOIwn0UBK/X2Il 96DfC9kVxKJCQu+JoNeBem0uO31K3JtId/m+ixycx8CcJH3o6+RQAi1gOOVke+Xd/ZUUoOuHnQFj lQl3g/iMEXOi6fZiEZA99J8raiVKWo1JJFCbkduYx5T1cHcLcA9IJgOkxFTQbN5TuYCqBE/ZESvK QTsU0JyiZajNc9enAhx3PoxzZ9FuK0MtIi6SOjEiQ4pHEMtaOos+sYzp5D3+GOwQ0aakiEVkF0ll A+c8vx3AhrQeZJCLIgZtRUZD288t8IkY0cnVznUpl1CgfUqxGCRNoryFZ+h6KSE8UMAtQnEUBSVJ EvVelLAai52X9bC4rGEzJ0kPdOjsQ4wTjE6uxp7exsNITpiAE/s6ek9/vL8wyYYwdjDFlACI3ZYd vC8295W9WstkmEQRFEBEBEAAAQEEBAFRsRUYMi23n3e6rqrCwxgwJUIqJJMUJ8KAfxdmgTIEpKJS FEomqapub04jwBWQFdUEBoJBKQJrsKtmy2sCtB7Nv7Rt4BAtzns1GvQpqHNC/45n6DeqG1YDrGFF JREISBGClRYkIkYEY9vdQ9Z2Jc2IszWG8OyYmSeggZ7hu3wqyLvm8YSWGbsefo8VDg+VuDxEdG8m yyROSconFcSSis1yWCE+SFSGY4M2SZsxiT+rlJP03g5uTenGIxgg8y8SRMtSzGtODI9JnKirIKQK kQfMqK5ZQGVS/etq37Fx9duODwfy1Id5bMSJQBVK8fUl1jBRQzuhGulN2wQkSBhmVdzfRwUuU5tA g15vAyDiMijeYGaxBh7TspSyLHwznc+Ba5S+IkGCQfW25C8sgPZbnJOYaMFVCCqGlMSIZAqhuCBC 7HlSj05HwMXOAFhU04dRtToNTpEHamC7V0QEvdKFh0Oy6/SlnmKKKohcKoDwoKT+guichXU5mBAy jWzJBMfc4rq58GLpOysBgolMkpSQm4qFeQQxu0TQ0QkFMYizQ/rVlayxisYUtq9BMYxjRcpEsGaV gYrVzRpqRrUGWuSXKEQBMqmJH6GKnI00mwQNphCEL1IKxIIFqE+qwhcXUoXRj58MF3+pzk4Mnmdr LJlsEcFER2fB0kCcyGaCypOStSH6yb5CfpDBJMLYS2CouIVEfBREyEKqxEVZCkXKFJGAlCUheezA kmjPCBahUWSRKSpPxLDrIUhHrs/Lzx1R5nCPiLLKXriOuZL/SREo3qKEYooSMbikqkoAnHc10tl5 1bzbbzMCAxgwWjEYpbBsYkbbVqVWUrQMAaFG/3F7XcZhSmvEH59BR5oJixRQ9pooLPI7U9O7Rmo8 L2vRtETpO09KiJpmR4kPSK0iInOA+o1J8wIULpWCsB4yl6yugTXkIUtMCiCNeSVsAhmVgyngSlbs OpoTQk+oTyOR8zo3KLGBFgTTE+wIG4uqMCJGhILFOGTP5qj7FxfzVVl/Sv0ydxMtPOelyQR5uXOb R7hAhfxSEguAsAmzmBPiBtNJPd7d0FRkKcQM4fw8Sa+C3L852Hn8yc6wScYh3npLm4Egr59dj30B BKo7yH0hDO3IWAzmzn6NaV9RN6yxC2WrJJfuh5jIlSDIDQCHOa7cQ6SFkmc8dVvq/jJCh3OJJ0x+ X3OaKij5UqVGqtUheG1FUBL1GJ1AjaZ9gJfAZeUyTlRXvEDQdpCTuoaIQqiifTKTYQV+U/3WXJm2 +PsOElL8bBSxGLSqVFkVbFPNhGCqzsOdibNUxUWiPAp2nYVhG/ES1ZAWQpAjAhSxSjrdtx4XukwU MSr7lUhcU1SkbmrWK6V9uwsnoeIpwQ1hBLx2QvgvcReE4QfYMA76IVP3WaiWCoVCqo5wq2/uvQ4g 8DWJSBNURbjUPAvPdN5dQHLb4xVQxADyJR8USNSCfCMtzh5JDnlPjnUPS4aziwcXIfPcnQhmZSll c+fBnDK51aYVGIr52GsZPZsYLk9hlia0YWS8Vwqp3WLjVbmWLUTmzrc+0tLwxEmltSDEHmMRg23Z HtjrRqD1tYHWkEERQbDSqoYUSxyMgkr5TOy3XLo1V2Poe5o4EkK2t6cGMrN2k0l7xUkBogt8NgGi xi3WdzAhIooRHkpcOGHGPJsmgLOcg2Ic4+zvXR+wP+6r1Si4jF9m7fLJZfeTNwF+Z7vMnteE3N7Y 39vCDKioSdSoStYmA1TExS61GRFmmUyCg1YpE5IiOD6Zwnx2N6tmJ5Kb/c/Qfvttttvc7Y9Kd7PJ atWrWUzncs7F7SqxjnFXimVFaGKBQQoikCCUCxLNmd+lFTtvUhmm9skmknhI1ZSpMjSE94mn5vH6 m7UsybkJvx7EZQkhZq5szEBO8uoRA8WQkgscTPBIyyfEvm0hIKJvHtmgW0sNZz6CtNTBdJxnCeBw VCLspSMcGrp4nqd3formhKZEd63tOVbrKxMDXeTK3nnwtV1O2RuSEgyuGWjGNYk+A1SITfT3ZsCU qEkxSJGmTFZtmTkEsiJmok1wwknwiSUSkkomFrVqv1bENINSFEUkln38PO7G4EvEEHXnlUVS1RqK VYQqFUUbIX5GBc2J3JZgWRXYisQMoYbgzYN7F6Qp2mEM69gRVQd70Sm3KclpKCk77fbBtJ56vhag jSHzebX0GtFQ+pRQhJSOjd7133HN+jkmlaQt54JhlrcpXpkRDePPE1MeXifRY1Dyn7S8WJAixjCC M4kkOGTR8nv4me1knEG0+HomAv36IdBc/oWO13eHeyxmSJs2ldlcpmTCxm+5h9qaTNhyBSMYkVOj tOBdnJCEO6moSoYklVjDEphrMQT1yHX871nV02MBIzBQkaKYIjMIk3EKJFLOwoRFzkhCwTccHuTW 4H34GSfEUOw30qZalfbcJ2kdmAjBQ9SpEwteR7PGdrz+JyndIRE3ZbnF3tEictg9qWFdib0JvzE9 3YRsjmcBxWQ797iBgDY6Q6FEC110JslYhdEwTnMuZCR98RRM6ArAyObO0jiL94T8ARPTAXKOx+79 rbS9DxTpzttHr+5+ZGNzqTfMinKZp0wDz+slqJJHcaiSCBI0OUhxPtPMXFCavsCw8NwUZcdI+SSS L2yxAaINyd5ShQEicdKg3QOw0GkzCRMMLV+cUdxISOBLrKxxweSY8Fg5NcOxUSS0EpZ312Ywwy5D 7CoZZISBioiCqU6TJtZGEwUjMDRAqi4s2xfpOqzdEiAwiBjKWL3lx8+3oaHEcnPJzWdUO5k8T0te D9xHR7m4eo20+B8EDAer8M55mWsz7S0135j0HUcUC5JHrD+s5pGb+v/T/3MZGF9axosSi0m43G5m TJKv/i7kinChIGyc0XQ= --===============4964619236702267240==--