From: He Zhenxing Date: December 8 2010 6:43am Subject: bzr commit into mysql-5.1-bugteam branch (zhenxing.he:3418) Bug#42415 List-Archive: http://lists.mysql.com/commits/126287 X-Bug: 42415 Message-Id: <201012080643.oB86hlcx026511@hezx-dev.localdomain> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============0265357091658476207==" --===============0265357091658476207== 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-12-08 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. - UNIONs with global LIMIT are marked unsafe no matter this is ORDER BY or not - UNIONs without global LIMIT are unsafe if any of sub-selects is unsafe, and safe if all sub-selects are safe. 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-12-08 06:43:40 +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-12-08 06:43:40 +0000 @@ -0,0 +1,1200 @@ +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 t SET nokey = nokey + 10 [LIMIT_1]'), +('UPDATE t SET nokey = nokey + 10 WHERE nokey=1 [LIMIT_1]'), +('UPDATE t SET nokey = nokey + 10 WHERE nuk=1 [LIMIT_1]'), +('UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 [LIMIT_1]'), +('UPDATE t SET nokey = nokey + 10 WHERE pk=1 [LIMIT_1]'), +('DELETE FROM t [LIMIT_1]'), +('DELETE FROM t WHERE nokey=1 [LIMIT_1]'), +('DELETE FROM t WHERE nuk=1 [LIMIT_1]'), +('DELETE FROM t WHERE nnuk=1 [LIMIT_1]'), +('DELETE FROM t 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 t2.* 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 t SET nokey = nokey + 10 LIMIT 0; +ROWS in table t: 2 +UPDATE t 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 t 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 t 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 t 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 t SET nokey = nokey + 10 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nokey=1 LIMIT 0; +ROWS in table t: 2 +UPDATE t 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 t 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 t 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 t 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 t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nuk=1 LIMIT 0; +ROWS in table t: 2 +UPDATE t 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 t 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 t 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 t 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 t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 LIMIT 0; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nuk LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk1 LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE pk=1 LIMIT 0; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE pk=1 LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nuk LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk1 LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 2 +UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 2 +DELETE FROM t LIMIT 0; +ROWS in table t: 2 +DELETE FROM t LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 1 +DELETE FROM t ORDER BY nokey LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 1 +DELETE FROM t ORDER BY nuk LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 1 +DELETE FROM t ORDER BY nnuk1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 1 +DELETE FROM t ORDER BY nnuk LIMIT 1; +ROWS in table t: 1 +DELETE FROM t ORDER BY pk LIMIT 1; +ROWS in table t: 1 +DELETE FROM t ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 1 +DELETE FROM t ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 1 +DELETE FROM t ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nokey=1 LIMIT 0; +ROWS in table t: 2 +DELETE FROM t WHERE nokey=1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 1 +DELETE FROM t 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: 1 +DELETE FROM t 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: 1 +DELETE FROM t 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: 1 +DELETE FROM t WHERE nokey=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nokey=1 ORDER BY pk LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nokey=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nokey=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nokey=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nuk=1 LIMIT 0; +ROWS in table t: 2 +DELETE FROM t WHERE nuk=1 LIMIT 1; +Warnings: +Note 1592 Statement may not be safe to log in statement format. +ROWS in table t: 1 +DELETE FROM t 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: 1 +DELETE FROM t 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: 1 +DELETE FROM t 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: 1 +DELETE FROM t WHERE nuk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nuk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nnuk=1 LIMIT 0; +ROWS in table t: 2 +DELETE FROM t WHERE nnuk=1 LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nnuk=1 ORDER BY nokey LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nnuk=1 ORDER BY nuk LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nnuk=1 ORDER BY nnuk1 LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nnuk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nnuk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nnuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nnuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE nnuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE pk=1 LIMIT 0; +ROWS in table t: 2 +DELETE FROM t WHERE pk=1 LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE pk=1 ORDER BY nokey LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE pk=1 ORDER BY nuk LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE pk=1 ORDER BY nnuk1 LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE pk=1 ORDER BY nnuk LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE pk=1 ORDER BY pk LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE pk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE pk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 1 +DELETE FROM t WHERE pk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +ROWS in table t: 1 +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 t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk LIMIT 0; +ROWS in table t: 2 +INSERT INTO t SELECT t2.* FROM t1 RIGHT 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 t2.* FROM t1 RIGHT 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 t2.* FROM t1 RIGHT 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 t2.* FROM t1 RIGHT 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 t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY pk LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nnuk2 LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nnuk2, nokey LIMIT 1; +ROWS in table t: 3 +INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; +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-12-08 06:43:40 +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 t SET nokey = nokey + 10 [LIMIT_1]'), + ('UPDATE t SET nokey = nokey + 10 WHERE nokey=1 [LIMIT_1]'), + ('UPDATE t SET nokey = nokey + 10 WHERE nuk=1 [LIMIT_1]'), + ('UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 [LIMIT_1]'), + ('UPDATE t SET nokey = nokey + 10 WHERE pk=1 [LIMIT_1]'), + + ('DELETE FROM t [LIMIT_1]'), + ('DELETE FROM t WHERE nokey=1 [LIMIT_1]'), + ('DELETE FROM t WHERE nuk=1 [LIMIT_1]'), + ('DELETE FROM t WHERE nnuk=1 [LIMIT_1]'), + ('DELETE FROM t 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 t2.* 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-12-08 06:43:40 +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-12-08 06:43:40 +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-12-08 06:43:40 +0000 @@ -910,6 +910,22 @@ 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. + */ + 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 +17178,418 @@ 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; +} + +class Node :public Sql_alloc { +public: + Node() :todo(0) {} + virtual ~Node() {} + virtual void add_successor(Node* node) + { + node->predecessors.push_back(this); + } + + uint todo; + List predecessors; +}; + +class OrNode :public Node { +public: + OrNode() :Node() {} + void add_successor(Node* node) + { + Node::add_successor(node); + todo= 1; + } +}; + +class AndNode :public Node { +public: + AndNode() :Node() {} + + void add_successor(Node* node) + { + Node::add_successor(node); + todo++; + } +}; + +typedef OrNode ColumnNode; +typedef AndNode KeyNode; +typedef AndNode AllColumnsNode; + +class TableNode :public OrNode { +public: + TableNode(TABLE* table_arg); + ~TableNode(); + ColumnNode* getColumnNode(Field* field); + ColumnNode* createColumnNode(Field* field); + AndNode* createAllColumnsNode(); + KeyNode* createKeyNode(KEY* key_info); +private: + TABLE* table; + ColumnNode** columns; +}; + +TableNode::TableNode(TABLE* table_arg) + :table(table_arg) +{ + columns= new ColumnNode*[table->s->fields]; + memset(columns, 0, sizeof(ColumnNode*) * table->s->fields); + + if (table->s->primary_key == MAX_KEY && !table->s->uniques) + { + add_successor(createAllColumnsNode()); + return; + } + uint key; + for (key=0; key < table->s->keys; key++) + { + if ((table->s->key_info[key].flags & + (HA_NOSAME | HA_NULL_PART_KEY)) == HA_NOSAME) + add_successor(createKeyNode(&table->s->key_info[key])); + } +} + +TableNode::~TableNode() +{ + delete [] columns; +} + +inline ColumnNode* TableNode::getColumnNode(Field* field) +{ + return columns[field->field_index]; +} + +inline ColumnNode* TableNode::createColumnNode(Field* field) +{ + if (!getColumnNode(field)) + { + ColumnNode* column= new ColumnNode; + columns[field->field_index]= column; + /* + If the table is ORDERED or CONST, then all the columns are + ORDERED or CONST, so add the table as an successor of the column + node (OrNode). + */ + column->add_successor(this); + } + return getColumnNode(field); +} + +AllColumnsNode* TableNode::createAllColumnsNode() +{ + AllColumnsNode* node= new AllColumnsNode; + uint i= 0; + for (i=0; is->fields; i++) + { + ColumnNode* column= createColumnNode(table->field[i]); + node->add_successor(column); + } + return node; +} + +KeyNode* TableNode::createKeyNode(KEY *key_info) +{ + KeyNode* node= new KeyNode; + uint key_parts= key_info->key_parts; + uint i; + for (i=0; ikey_part[i]; + Field *field= table->field[key_part->fieldnr - 1]; + node->add_successor(createColumnNode(field)); + } + return node; +} + +class ConstOrderedTableNode :public OrNode { +public: + ConstOrderedTableNode(TABLE* table_arg); + TABLE* get_table() { return table; } + ColumnNode* getOrderedColumnNode(Field* field); + ColumnNode* getConstColumnNode(Field* field); + +private: + TABLE* table; + TableNode* orderedTableNode; + TableNode* constTableNode; +}; + +ConstOrderedTableNode::ConstOrderedTableNode(TABLE* table_arg) + :table(table_arg) +{ + orderedTableNode= new TableNode(table); + constTableNode= new TableNode(table); + add_successor(orderedTableNode); + add_successor(constTableNode); +} + +inline ColumnNode* ConstOrderedTableNode::getOrderedColumnNode(Field* field) +{ + return orderedTableNode->createColumnNode(field); +} + +inline ColumnNode* ConstOrderedTableNode::getConstColumnNode(Field* field) +{ + return constTableNode->createColumnNode(field); +} + +class JoinNode :public AndNode { +public: + JoinNode(List* join_list, COND* cond, ORDER* order); + JoinNode(TABLE_LIST* table, COND* cond, ORDER* order); + bool is_ordered(); +private: + void add_join_list(List* join_list); + void add_table(TABLE* table); + ConstOrderedTableNode* getConstOrderedTableNode(TABLE* table); + ColumnNode* getOrderedColumnNode(Field* field); + ColumnNode* getConstColumnNode(Field* field); + void add_ordered_columns(ORDER* order); + void add_const_equi_columns(COND* cond); + void add_const_column(Field* field); + void add_equi_column(Field* left, Field* right); +private: + List tables; + List init_nodes; +}; + +inline void JoinNode::add_join_list(List* join_list) +{ + List_iterator it(*join_list); + TABLE_LIST *table= join_list->head(); + COND* on_expr= table->on_expr; + while((table= it++)) + if (table->nested_join) + add_join_list(&table->nested_join->join_list); + else + add_table(table->table); + add_const_equi_columns(on_expr); +} + +inline void JoinNode::add_table(TABLE* table) +{ + ConstOrderedTableNode* tableNode= new ConstOrderedTableNode(table); + add_successor(tableNode); + tables.push_back(tableNode); +} + +inline JoinNode::JoinNode(List* join_list, COND* cond, ORDER* order) +{ + DBUG_ASSERT(!join_list->is_empty()); + add_join_list(join_list); + add_ordered_columns(order); + add_const_equi_columns(cond); +} + +inline JoinNode::JoinNode(TABLE_LIST* table, COND* cond, ORDER* order) +{ + add_table(table->table); + add_ordered_columns(order); + add_const_equi_columns(cond); +} + +inline ConstOrderedTableNode* JoinNode::getConstOrderedTableNode(TABLE* table) +{ + List_iterator it(tables); + ConstOrderedTableNode* node; + while ((node= it++)) + { + if (node->get_table() == table) + return node; + } + DBUG_ASSERT(0); + return NULL; +} + +inline ColumnNode* JoinNode::getOrderedColumnNode(Field* field) +{ + return getConstOrderedTableNode(field->table)->getOrderedColumnNode(field); +} + +inline ColumnNode* JoinNode::getConstColumnNode(Field* field) +{ + return getConstOrderedTableNode(field->table)->getConstColumnNode(field); +} + +inline void JoinNode::add_const_column(Field* field) +{ + ColumnNode* column= getConstColumnNode(field); + init_nodes.push_back(column); +} + +void JoinNode::add_equi_column(Field* left, Field* right) +{ + ColumnNode* left_column= getConstColumnNode(left); + ColumnNode* right_column= getConstColumnNode(right); + left_column->add_successor(right_column); + right_column->add_successor(left_column); + + left_column= getOrderedColumnNode(left); + right_column= getOrderedColumnNode(right); + left_column->add_successor(right_column); + right_column->add_successor(left_column); +} + +void JoinNode::add_const_equi_columns(COND* cond) +{ + if (!cond) + return; + if (is_cond_or(cond)) + return; + if (is_cond_and(cond)) + { + List *args= ((Item_cond*) cond)->argument_list(); + List_iterator it(*args); + COND *c; + while ((c= it++)) + add_const_equi_columns(c); + return; + } + if (is_cond_equal(cond)) + { + uint i; + Field *first_field= NULL; + Field *second_field= NULL; + Item **args= ((Item_func*)cond)->arguments(); + uint arg_count= ((Item_func*)cond)->argument_count(); + bool const_value= FALSE; + + DBUG_ASSERT(arg_count == 2); + + for (i=0; ireal_item()->type() == Item::FIELD_ITEM) + { + if (!first_field) + first_field= ((Item_field*)args[i]->real_item())->field; + else + second_field= ((Item_field*)args[i]->real_item())->field; + } + else if (args[i]->real_item()->basic_const_item()) + { + const_value = TRUE; + } + } + if (first_field && const_value) + add_const_column(first_field); + else if (second_field) + add_equi_column(first_field, second_field); + return; + } + if (is_cond_mult_equal(cond)) + { + bool has_const= ((Item_equal*)cond)->get_const(); + Item_equal_iterator it(*((Item_equal*)cond)); + Item_field *item; + if (has_const) + { + while ((item= it++)) + add_const_column(item->field); + } + else + { + Item_field *first_item= it++; + while ((item= it++)) + add_equi_column(first_item->field, item->field); + } + } + return; +} + +void JoinNode::add_ordered_columns(ORDER* order) +{ + for (; order; order=order->next) + { + if ((*order->item)->real_item()->type() == Item::FIELD_ITEM) + { + Field *field=((Item_field*) (*order->item)->real_item())->field; + ColumnNode* column= getOrderedColumnNode(field); + init_nodes.push_back(column); + } + } +} + +bool JoinNode::is_ordered() +{ + if (todo == 0) + return false; + + List nodes(init_nodes); + List_iterator it(nodes); + Node *node; + + while ((node= it++)) + { + node->todo--; + if (node->todo == 0) + { + if (node == this) + return true; + List_iterator pit(node->predecessors); + Node *pnode; + while ((pnode= pit++)) + { + if (pnode->todo) + nodes.push_back(pnode); + } + } + } + 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) +{ + /* + join_list->is_empty() means this is a UNION with a global LIMIT, + always mark such statements as non-deterministic. + */ + if (join_list->is_empty()) + return FALSE; + + JoinNode root(join_list, cond, order); + return root.is_ordered(); +} + +/* + 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, + COND *cond, ORDER *order) +{ + if (order == NULL && cond == NULL) + return FALSE; + + JoinNode root(table, cond, order); + return root.is_ordered(); +} + /** @} (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-12-08 06:43:40 +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-12-08 06:43:40 +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); --===============0265357091658476207== 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: 9547a837e18ceb36b83c985362a35f2a413aabad # timestamp: 2010-12-08 14:43:47 +0800 # base_revision_id: ramil@stripped # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWUf2brcAOIJ/gH8wAEB9//// f///+v////9gM55MubPvqDn3dR63D2ebxzfANsp7r3Dw6UHvM4c9fePOfHeh3b05W3M05xu63vHu 9ZuXO3riQgKrzmt7CfdjqqrLLZj267GYNlNoH3Zbe6nHTutvee4iu93vcbnW959ePWmhnjnERX19 2Qnltsq+trdGV8rzeXnmOuly1ey3duwkiRpMIMTTQTIwmQBE2k0aRk0yNGmEzU2keoBtQJEQICCZ TJkxTIap+pgm1TzUQ2oxDQaeoeoAABoJU9pQlUeUNNAGm1AAAAZNDQAADQAAAJPVSKTSYqfpqe0k GSe0o9IyYTQADQAaABkGmgAIkiCATTTJNMjJqNoQyaGpgaiHig9NQ0NA0DTEBUUggQCYTE0AU8TK n6TQ9SeiGnpNB6QaGmTTTTRoHgakEDRBRI6UR/MUQgeQUQ8Xh9dBeMIGUAqD74jUCsApI/yCGPlK WxGZRZ0yzQf3vJBpSlzfUbuk7p2TMDFFGBMfn+nWdn4f37fvYxkaBFDQexoJhxvewxidA4zFz9g0 L3fvjDLzQpSH89/9SSh/wVSlSNNx3sIu2z7PoCAtpGcwYnCIxUrnn998y3pdyiamn8f3UqWhkVGa ZD9VFufC1EYHt/hs+Gklwe2E0Hg7mxvdUuYsrNB7SGqxOwdCMLBK91DG5ghpNL5EskuYwhiQ6JDB mSQhlcQJwTmvCd9chsgzENkIRIYm5ghYczBD0QDlobTY2tDY/5Zf5YwvtY8GhLnf/MPzkk55PedN ngLSx9vuetiT+vTJCl/d6H3b44eM4kpmEDXHejfpch8H0ueUdsZPpgbVBkzK6dwINyZNrbC2FsLY WjNkbtmIn1Yxa+ebgwAARV57qrrnKkqWjWrUVFtFRbEltGzwSIbd+3fs2CtGtvlu8m0mSTJtRrJk yZNtJkyZMmTJkyZMmTSZITJNRUkyWyZMmSsmTWTJkyVhamSTItEyJkyZKTJjGmO3vgyB1QCiECQd Ylz7iZSyaMhht9sL7GgP1UOhg9j6dhJeJimlZmIBX6byxv5x01brorfGvh8QjQ/GQEkJ8iAL9kUB cVkElcIsHKLFBSiwk/eS62lZbXLiiiiiiiihisViVilrCR5aNFgfiuPJcRgqeHRAprlrnCBTQQBB BDTSlgg4776tnVx2IAguWiSKk1SWRLQyZgZDMAL1dPr83nh6G4N42n4kB27/N5pKcvaLvRA3yW54 e3wvogfn/F+T35/y/Z7IiIiIiVVJPiEzdBeP9FThM3DKMrNi6BLouQIkHpVFd3/nM+M+X7h5JXi9 u/7mYanzgrz6VtnPmK91tW/a/0geYfWMGSQkSSSTAxPKQOzyWLSQgIf9r3op6/Jp8ukckU0xQgX/ WCtJ7vm1PzzV7c8NVVLSadsFQT9We4UAJfWke3Cb+xxYACqKQkZyibWVRA/hVG0wjEcLLZlHKxiK sVnXredPGx6PP6NE57qv81PHdSSfW7t4y9W+Zavjh7Dgb+UnkIUnv1J5EZ/088e03xLhISRKPyzi ew6ioxY2aQsximEYx8cIQdfKSugnMnx4aRSx+A1dQSFoFBSCqYWjNaCSlAkCjYx1qacKfScdOlOb R39lKyM+B2mCA5Xsrqu69t56aqvhAAAAAAAAAAAAAAAAAAJAattfY4nPXPJybgm4hps5bv++1EyE wMTqqMNhPUQ/k9Guy1ZfJyHS6k7Z39PgVVKqanjflryBfMM5HI6Sp9mcv0xDbp4UiYmSnhNZb+Rx JTWhsLRSo2y2RWsrVay3GLFQq1FWo3MtkVkVyjRcFRuZSqyK5RotRtlsisisisisisipIoqyK1G5 lKrIrlGiKtRuZbIrIrlGiyKyKyKKteM2xjq6zmWObbm2ivFtzbYxzbc2W6zaZuFqNGxWMc23i2xj m6zkbuWgZZYjbRsi1Kseee0c7k5cOXrHR7DGObkE7ni8O9jyXi6EzjbZLUZYenf4epjqE2iUJgCj 41Xplz3ic4OTOS006a0Y26eisTEUJfa4c0Tud7uJoYcLJd6crneXhdO9xB41YSS501clm4yaJxvd xON2Eku9NXJZxGSo72tKaRW8wNzatHJFBsvEVhu17wgvRPYwqyXenK53l4XTvcQcjDhZLnTlc8Ze F073HMxeLYSS501clm4yaJxvfZHh5EPiy1wrsMOwzBmDYe0+eAZ+OHKCajofOC5hMBJOfTBEj7ik k8GXPynKpVGR3vM15WaLm3DG8GOhhtYAurPyOWw0jhM2uLQ7OBr3cgVfXrevogAAD4eV8fzd+Hm/ Mr/q/gvC+n4p4XQ5eU5lFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRYj BUVGSKjwAKvE4esXYS25teOTgePdSjkh8a1dBmkQXiLuB3tSjkh3rV0GXiJIFU+YwODPzTNHXZbo 8WHHWtqTnelPXHtqWTG2NNN+Hh1xdry8vhxbmx2QbkR8KQZ55vWOmuJjlZS/d3U0e7jn8pEiQgiH 6J68XqdrpL53GabBioUv55zusPXa+CQ0qrV1BLLVhOWuN0ufu+6vrYvI7L8O/PhZM4aUvlGnCTi/ Qq+EG5uamlJbtx7KzjAugMZPlnDfLr2LmcBKwG9IVro/FMuX9Bk74O2Dm4twuEhBGqKdrC8Yy0ZK 2L0zjDpujoq0XV9o0/QrDT16HW0ANoZDoRjhPHibvmJCCqx++gECgr36ZKyj3/JW9vi2xSnlG/cV bB9AzdnldTmXWunRLfyc9mnEPSlN9sz0ory07aqWbTHY2y95zpy7T/APbDagIhumDMbVwofaEAwg Z7Qkt4CQg5aT0KbUYkIPR2a29Cv6r99/uA00fRLd7JEert5M2aIzqEMIiclJHSE25dVeOXx+itt5 VtvP8AAIwYLRiMU1g2Mb0cttvRVb6HpXk5evx8N5OvgJCCFkPiy2hgQjWwArILXvKlk9aJ0JP/im tLRG7NueUmW3f9I+C+aka07vo30GjTUMhhhucnfHFm4u9eoCumTTpqKxCL7wBZI69M8yaJgOcHOg L3G4aoE0RzaQ55xysmsZZdUsjInJ6CcfMJfQ16CbQQGZzSXLat7S1quYEkFWN+yXSYDLLy5lm1U1 DIjkEhA02N89PCiTkCwcdAAtJpEwJIYJJcITDrxCGyiZKiGdRE49MERyOgRHkCewJtCYIXsYbu1Y AYYqqquMCqqqwxjr0CYtuRJXRrtJoJtJSbZSbdjKZELVY1ICDSGitkYw5TKyAg+brGE/ywou0cZ6 X5ezlXx8gCpnTauR0Z3PuxjYy7LX9VpZ3stlFJ3zmWOmhnR2pSlXVI2zlFbO9OzC5Y8vdiokIOSr OM67Idd5aVlq6tu5BFqcoMYLJpYfia8JVW1FJjhXOnqMXd9UO6fVsLKnGnnalAUqdjgiadm8H9sw djIWZvYvt+weDfR6vm8/yfEnWrhq+z59azhv+gp4u7FX0w5sY5cvRze4mlSH9aRP7OuMqfMWlidj 1R6Lahx7xhGVktttIyyGEVYe/Sq15laWXu5vmc+f7/rAAAAAAAAAAAAAAAAPrXvvNfdexX9fpubf B9eXxerQC3YPvCIhVonSrCIU8Bl8fVST3CbBgeBmev49SkkP79KljLv1ksehvoIcSIo3AwGQg2ZX H5MPKOO5YuUDJIjZMVGiMjBpQsXPzEwOrsRBhsp5oFIAtXbcILGRclCEQsOLOCKXkzLWVKx5H6Ge b4/k/XSmWkW5cKUw1wt2/QddbN4LxpSKMPl7Dk9L2ppEzpb9M3BzSUQHmOb6PzOj2Q9jV+bJXjL7 vulyIbyFmdWxERE8LedtvPKy5zV4VvX855vGMz+sy29P2kLV0wxvtn7Tn0pRqUyes+vcAVlLHgnP YACtPBv3ef0Wzqi9OuYbtJCFJVvul4ZZ9xJSxdJ2e2K7Fpb0xFHRtkYdPPz3iPj2ysezKhlq5al6 ScaGxNa0ZORkWwZcuQSb70p28WHBkIYaMICnJx+rScs5qtacrzo/RJo9sh/SCVFJRFJUBSSUJiRn 9kmDakqev8keyhRKv40okdg+YyglhvWYIX0+KHit/1jRF42sjFkqwHtkfxz4dY683lCc2/T4ejQJ /EGSc1I1o1o60bkdaN6OtHFHYjEsbNkc5gOk8uJZ+xxYO2/Xp7PlxWvtDtGUPkDcoZjbbYDZABpA AAJBBAAEwGoVtfStaW23d4/d8b4CsoIkhJoloWTIUiSVRoLJZp6Z4NigYWnb5V1dCN6GXR064uz8 RfGMQO5BYDAiKNpl+i4xI2A59RhSpO09PgvKoq0C9DFjmPAFyrU4+pNyBkZIJiCJRyMov4rXvMnP icgHSppGlz0LPMdes8xtij4RFxhpBE5Vbrdss+SDlMYP5XbeNAkIJpl1P8GC2d7fTJi8W7uJE1JS SZuBUetG3iW1lVpY7+liJ27OW2KeJ6lpYjLzcuk6Ii6V8Nb56srfaqyt9CqytzWAAABytsrUrKys rcREREREQbqsrdVqVlby14+a8UrVyPWOBcg3LIMjFjgB35Lue+gEMxzs7WMVZZlWighjEC6a1nFU vrlxCHSzBEdTSuxFa1MzPfglRSMkmdIzl0p3steFACDRRC2P4fv4GtrLCyBGp6zMim1sjGQIgUE5 ERjFIwNKsaQj5AlJSk4ltI05S9FeyfSavkdy6IKnNzACGNn6gQ9BQ2sWChQbxdc5c3AW4sRbGNxS q5uLmm4uabi5puLmlxuabi5puLmm4ubbWHHGOOJbi8PHenx2t3U0FgsKonbhqRCpJPTSSIziRaGR K1IhGhggJhHtkfeX2VZ7dGOM05njEhQCJGtt48HfWc4y7fDGU4N768dh97vwhamxg+r8YjFvwxRo tDHj+YSEFlatJZe8Yrl2jCjbmI6q8amKC02VOzwRXXb5fLqu624yyIJjLCIMto8gTN/CSI03udq6 Ol3uJ3jmdry5I1cm9Ih1n407Dg2JAA31tSmvPW2WVswF0GMLpAoHLaNqoqhqsmTJk1kyZMm1Ukli qXpuWle/q1qVqNCEi99fQkBiQR7CL6bcDrw77V0GKmR6CyaoqMVYVGyTTnjMmU5rjZe6smMRe6Rm cZMNeAJjSkVHiYsBbtoLS4wDk3O9xw0oeQ4FZ+0r85HqgOadmWkhM478O6kNdOjZXf4I8HNs0di2 GuuWOPMzBGQ71a8fQRqzk9zQ9XGhyRggx8RBFn0An8czvXVrB3UcNJsVDZtTKQOVwVrnY0BG4jBM VqGOapPX+WpqCJ293kFH1M2QUU9L3jmMnMJZkoQVrMWGgiYiOIwlhswl5IetETDN2FpdblSCYd40 5TxJEaJSOY3QJ8plKAvMRcQzwzZCjqlMV6LcRO5s1TFVAWEukzxMQiYSEGpuJoVLngaGi9pofEeB 1Ow4b69PCacHWlgLj1Uth4dp31Aywp5mRykrFdc9pMFCXIId9ZIPRvRmApYZgtBFOZr8wiYpLxww mU6cZApwmnUYKbS64zqBRKOXmBEpjDdbc7I0QB8IK/QQhIsOYrGokkNyJOz9IkDZmJrSs0EA5m1z 3mLIQloHfPK0LOjObKBGtZynPlJTEYjWpJucmu6zTv6chTMb811mSTNNmR5xNIUcwQ5wQcZ0dOkF bA79TmdxOxGXBsyKm+hPC1Haxit57fmNzBUuHaX0HJwBHxGhz8/WdMtWV5I67CMq878VNzHgW5GQ kIODm2XHiRJrqaFGQIg1z1O0zMHPdiH21GcORlmVDSx1MzjnyNy54+ORvu37pPMxmCJhNjG/l+Rw xIQetAIF6N+MHVlsGAghgjpwS3a7h3YDMPtlTah2xQUzpL6SgpAh4FCvWjQbJGLGURbKzvmXw1tB uDk3VIV2Offc7ewJWgzv3zvOW+XH1EqlGwMd/ui7Fuw9WfQ/tyqfnjeb+h7TRpVZzTzfz+qBU+iA 0T09GikomSPjL8NmcxRULqyCUlA6G1OnmHTNjyvdNcmDFhRo4OwnXHPjsUo6Vpg62SAohttlRo0a jUaNGjRo0FJSFIVGjRUaNRpEkQtFCIGFVMrUIgWR3x5cxe3K1E3Sqj1cOay8MbPPDaE9W/DyoUYs khInK3ufpQmQbk++uT4jihUsz1TGcJFxk3v3ceCWOnkQSYyXoMwVmjTurjrwqLHCoQppGkyAp9e/ I/RqtSIsRYooiixVpa0Z/Y+W9xIVWri2k4E7iUlJmNgRLANgGgfj/BcJv9+Og5Djo5+b8M6GJL5+ dXTBFOO/+XzO04SRNnjw1omxRO0UD8QfhX96H7z/E1Ir+0kEuJkL/ofmBgD974vUIQFfzWD+sHYY mWp5n03EqkkgEkTb/0qPnvmqRJHFXAfqaxBS9JOlGqT7eH23db0s/k/bmwxiPZU1Q426AkyTC8/k nwViQVEUkjTHJOsoHLA7/GOAGHbKTF6V6p6dV6prVfJtVdXoeYABlR+hUVUVUU9+SzJ4kgTYzTJN p0M543U2KSTzPAkliYQyMNUxDRVVhQTCkJWBmSSmQTGFq0n+0izyRyGsMFLl2LYtizKQjRYQ5dgz OAkybDJlJPtfvbICTOIO3l4G55nEcMPJy6LJvMxQOrzTWGuCipzHFtJYkA5BJJXLEEdMKgegmyQO tE2YHju6Ai9J0cOBfootajeb7IirkrztzHOHkA1NkE56icJJuZTiJoqNcOR/AgP0q6785s3WOSvO ByBoClEQMz4BVHg8pENkbTdYjwKiqiqiqRVQlpLSlpLSWktJaS0lpLSWkrSWktJaUtGUf+1+6+aX bZCE53ZAcZPJJBJoUQcHVHqgd3JteUBdEF4yRHynWBWjChqqFx7nnsGs84MXzRXSKB2C/wO02Diq 1MQEm1JxellIGhM4eNRyWLSdn+fNdKNdtiq1xbYqtG2xayXgXgiH+EMjxiA8Ae9BubhwOdbsQ8kO GJrjzDVHTMzJRFYc4FsyxZREDd2as81wExJEYLi4YIjCIUhYiWrTUmgwrXNNGSpkSTKFmHcaEhpA U42wjuyQI2qTYrVUjQgBVAVnn+77vy+orMuhMzEfD32rSvH9jtZ4BzIWGKQgRmVBTJeXiWzq0bR4 NYXq5mRrynNMO+c53ddV80Z81tavZfLPo71AB6jwD+Iqj2UoisOlAeICs58pDDNOfi/ddl9qcQ9u YetYbLLYeqzFRr6y7muhBbdd82u5V2xq6bijXa7lXTGrtuKNdruWrqm121u1bua7EFt13za7muxB ZvegbkAvGRC0agSJeF44R2Qh2V5jeMBNJzFzcgIPOUOfrQeI9p3KAUOD0JBYniYdcSpJJGaVKLPU ijUmEZJAlZFZGMJQJSyE4kKrrI8SoqoqopuOJZwsTF9xOaREk7ky2BCcE3kEcF5kYGHRZPhBCZE5 W3pYKqx+XJD3cswsqyrEyZMmTJltWW2rnOp6vqu++4RSh3kdYCocWCdfrzMhV3qIdQ0bnxJmRbGQ ohn45fqAVdTDRYd5FBTfBdy9t4ba2r6W+4AEgJi7t2IQMAhMU5DEgK1UUVMrkK0F6uWqWq6Fl2In EIRJHzLmjzQFYoJFWxZtjnXLVviBM2EZEzQTk3z2ae65fYXSD3uI4vo9Vy46m63Qvt3qmttjdD4m cJxPhn1zWK6m6Aq7yPSqKqKqKYYs85PQeNMpENXBiRA8/fjbKmkEJhIhhpyuy1ZxiiQYqIsqSLIZ nbtxB66TD2XBbaWjGWBlU5SkpT6HXTs++y/Z+Pir6fxsJFqQtClS22/T+SLct/7Xcgn35fP5Xcy8 3g2HvkyAta90+CWX1XeQvwR9bhpLhmGQmJRgYifs4jhC4n453hi/auLjgTJgUP2ssWolNVCbMhvm YsaaO5NyaVKtjJMo0kZIqaYqMWW2mTGbMu2RTNMo0KqtG1jruZjEC7enNAjaFBAodDg2cnGiRYaL 8OhMDAky+4/IpEfkMB+BtP3+b8T2GM6T7D8jnfpe5waLs4v1tjneL9n+/I7JEJPQFtshaNB6vTCX fhmO5G9PQ/z/lmZahxLmRsX4P7IoyhSiSqtMdM4VrAFPgJ8Cm2/mP7XcwwP3AU6RrT26EL9XTzJw l2U4JgZ6LfyWDRD/NSs8RpBt8iyrLp+zfSdUihkPo++/1P7S52PE2n9fxh+QohrBuOlN5t6OsZOw cXAIAodAdEPO7QsDbkoJB3xoCmUUNMSkIjBDU5UVTIEgr+bdGtv9LEdR3nYdJA4GG4sJhjvQxmGO 48cntDgj5V7BbsJkMeKB4mE+C8ECNo9hDEZQc6y247y0PuzDu7NNYAdVk7SeN8fkqcWll0d1J8u/ 7zVyHs3JIdBVeDpd0qIAQA1HOcesgazQazWe4EPetpIbSioWIPFskNpaZUoBzvr1VFhaOeALmEG3 j9B1VMHQtZ94g3XC9PEniHz2iDAqUWZzFZBmMXvQ4wkkDzWaJCBBJaDbeK3Oi7/4+4uH1ktDgtRS lJK1BqVmxHvckDdZUpHoccP0KZZHZ+0d4P6igAKGTLuNX9heIIYNJifAcu168jTF6qCAQIhlaWYw qhpdUOFjfmvkbq8MJoUbNoslaFhauK8grJ6BnPk2PL7MZvZhXD1OZo5flzZuNHw+L63Ij3OrnbOt xuZw5yOmclioW6C4mhEkQHMRAwYSSSEpoFTQufBeMaHI3ni+iKJwKOhD1QJroqAK1RrsCOk3D2h3 vaDzwE1xDSRENOhcgMlh44mZwJYo4IXC685OGw6NJjBguFow2X1n6BRDxODPnxj4UP86U68MnIuV 4IAsK0QGkVcib9ZaAmTW8KjKjy/DaKK37cfuTOxR9+S0snrYCie9yJur7lVlqTfNLjkZoGUpDxFc tK0A2rCFQqlEMLNSrU5CCDugUSbPn0a5ONOjWKIXqToZrRUisi0ZdrtSkgJYxgEMbQJ163MpSjNt TdPZ5+66jJaY66pFLISgcCBrqN2yuXLMOTG433QwU9DZrmwnI4hgPI8DA0aTh4FznOju3cg7M0Hx TxzCSDaNWlEg+A8o6mUmnliN07uysVKmLN0E8MTA8JCooVGQuBa49xY1vKFoVLwvjwuAXADzZj0l rKzDLMFimN8D54BGC1FASIAkGVK5ENmjT6L9d5eHOtG00rKiJE9PXRxJlaQNCRacDpNXO14I4Y5W t7nJuwARsEBjD0nn9b5DiYnZJCEMx4LV7U49cYqY9ycnZhu2EiGVLVFq6SzCGIp6JSaFzgluM3E1 nipsJNN7IFRNHqL2QuVlCQe3JDBUMzgZouKpT4eGWApySw+SkizHMBRlJkvNESqUlQ5YcZXK6EaT 7mJba4iGIaH9U6EGMLBqVNmIAd5nxnRuaSNrSSk2tZ6+uackHrJEOOgfrJtXs+5vdbb47l/auLqB V0jXJxzcmfrEWmM7jtJDAjqGNfiOiBlORR29vkQJykzpIEMT0EiCRBh7OkkWKUsBV8EakWJekZzs IQCQmC4s+MpcUOoIHUA9UDgDn4zx68P865miLHMeW/OjQcEpheLISEZNbo8loqSOBLECNi9p6D3H dsA5xRCBXxDSp7rF27BdhRk49oOoDZOqUR2QqMI1CEyzPB+c8ymGlI9XyHFLNcfZuy1xUQg7cTVn d+tPT9Z4HI7RPdCQ7F6JlPDodT6ozqHIx6sbeqvyNe1kI+dJasXWidfTqbuhi//etEvZX7pgJook G/ymstviOFqRIbu1JSIsTdPrct0HpIivXiLoEdHInDcMEIO6B9WHw/p0mavmt8aBso0hf0/sYSIs EII6UXZl757GHvhREqirSor0A4qdLqnRJvFod40Tg6UkbulZ4qEgs+7BQrwIPlU5GQOzW9lxw+Lp 2bN0jgVgiTBNxQohpFOrltNYO9Gtj41jj6/d6c94G1SJtNon6PP9PFDxnMoeMkiRisc91pIfG0Hz u6usv5OvSp2APvAN4pwNHWxeECRKUbgwaEaEqjJGHwwHgMLCC4lr5EqELISB149F6imIILfT11Aj wPi9RXWMwNly5YDsONyfm5shu6Cs01vq1lskwiCIxARARAAAEBBAQAVGxFRghbbrm4+n1rqshLBF gkmKE+dkiSfY8WgTIEpKJSFEom3Z445XvJJaSTxUgNEiVKFWmg5rArR7DhX8JxL3o9F4QrsPZtN2 tTg5Qw+tEyfsORweaJSQqiAQWgPKdqna9szT1EDKwaGlxQzEiF+Y7NpJtetzEcTZJ0LCHwccm/Aw LnWVghPXGeBFG5nkkTIWPz7EG/f3qqmxrc8Se6fFo2HM7Z2lj5One3k4GpNyH+oQSGsGypbLnPtm 9LEY0Bu/JbdYXri9WgUQ0upGwcExcgTg3rxLddGkQWvP4Gh06K58ayZ7eykLIsfDSdz4FroYRA+R twwIciVkiQqJDhNlGLdkEh0LL79j8LWZqlhU0Z/IbU7DW6hBdqYhpvrQp022602rqQRnQO4zD58G R+wXuUHPbSxTVFP0wVLHvqEhfGDa2RCXq7jdSEkpuKIYREQaljQfPKZjsBmMamBSc4DEW6MQCgZw kpZBSVgxIaSY2ccNdNgrXGjJKSsYgdsC0sCyBdS40Jex9tlwvSt1hCEDz0UzR5dBXgVS1gImcRUO b6DYKQ4IzRLLCb78ybglJJVsJbBUWRHvURMCFVZIirBSLEihKEpCvw5YlenzMLcY+rGZmrF7sq+y 72YkmbdiQLYKiySJSRfnIqCaZ9fans5k7Tr1EOMFogPAE4Ng/nIoNreIUQiRUQkjVJGAzHkDdV21 nsrfUtvhwICMGC0YjGlsGxiFq2qVWVs0DAGkMfmMHwMhS7Xwf67zvt8WigjBRDhpcTJ0zNtVXnI8 UfHN16PjMX4cP1C2NsptuYyrSSzbRGSRhGxdYGPd0AvDYaRQTHI5K+sP3KEULIijuRyn0kPwQSkW SuSVJOqx5Xec26GDDDCPT7s8msRMOwlVsxytDQnCDBD2idZsX1G7REhCSMCE2x/UToub7FNmD22J mG/Too+hT6KtyUx+ev+Mm6RphoO3v1oqHj2PbtesreiCUSHcKIb3WFspcTZhUGckmbA8y+vnCqCX pNZ15ahBuO04VS+TgQSd08f2EKjpcULrpjy2JMj5AYRgoSS2ySXwMEsQYCYEOpx5bpvXI8ew522Q yx7sDOLKuRSDMvD1A+aj5sCgKUVaM+FYAxjujfkk+Tqdzxdsj6bB+JZ7G6O0emHB5VWd9DRCFUUT 7ZQcxCH2P3xli5lmJ3bygmvLnL3yU1uGFKmU963Mnhy0UAbYmZiNQSQI8innO0rGOGSWr7Bi2Uh2 PDXfbgpmVZFMgCQJGEIGBhUWjCVCdw/L6Qee6oa0hihuIJdHykXpnyWVVp6qn9GUY7TxenKG6Htc WEXx2JM3kWqcqfFq+915mTx5fiqJDdJHljDtJNYih9KWz0+11htudxYDzGnF1FGrS/Fbchd2sFU0 ycbfpJnpgwqMRX0MNTXN7cGDL7iTZEBZihlnpYdJbAeb6zScmpl/iTrEYYFMsl52ipbPI/ueVVHv GruiTaZR922kqhWrl2qwr1i8mdwa8z1Pcz3yRCuFt5sMWbmJ0pncvN9WgoFpFxGJVbMKLHYmNtsS EDIZkFrhTdG3zJiiuBAoZSNA1z+vxiopl2ApTYA3E46BeB0mVUUYFsmTkiIkzJUAZ5SUwPfQzyjo kZOvaM9r4zbO2xmrYwdVdsR9x9o++APk9uvlt7rvqIiLreVeGSreUj1S8uKPJauTaatcsXNdbrPi 9ekQ6aym1qkZydUjRksGUFs0Q94OH3Hl4QzxCOYg6NVGMTvEgiIxyvcpUQ44lJUuKIbo4FYVMzdg ZwUQtbT6NJnI1b1zpWmgQQyMnKY4UFXeRuO/KFkyCIigEIkYbGkBqVWa5Ome4kIKha7GNW0ZvwNx JBhRKVEhKtbdmXpCWETNRJVEfhJJRKSSiYWtNPhqQ0g1IURSSWfe29rnZokJxb5r0OXr57vLmAyt Na8Fe3yiYd+PuvCTAo8SMdBnDDiDhsmyV4zE2Na45IoPEekp6yEOL8NiiT8KP0/ha95+MKCYwphW MMFr6/f2cokPrSIWyzleZIh0um91jEsOuw0nuxsnXEfl0JSlQzkJC56S94uapufq62gCe7BTaz4s DoOXr+ktV1VvcfB60AhosVPrJPejbF+QkdvmdM17LhDaiy0YaJJINfiyfF0h5CskZpjkyzBzQ0go RAjDqsJla5XMIGeHQ6g0vQ/lpNSeQE6j7l7+vHO4iUH1XNPBfFrDGK9rKQmFva8+SHScU4Gl4oig 55mnpLoasUPAiE5nMQZuzE92o4dmDiy99h22HuLYZpx4n0N/BCzpgiZ0Je6CgWIKE2hG0hlUv3EZ oXIxn1ftNsrbQ4PB2D3B7CZbEozNTen2mHSZl1O86TrBL9ZJBMDM6aXS9x9B6DeZs7QpOniVn76H v9RRMbyDA7KUN7oTzYB0pzZA3mc0FglKMtP3yBe1SPQ18xHncbKcHbMdiwcbXDoqJJaATBnk2+c8 ++kuokIGburrWrrSykizSAKq9i2T7zy2bxIgMIKxYPwlj0Y9pgaSOZji4sOSHUy6Hoa73I9zYPRX e+t9cKPj8+h1MryzSfUaK7DuOc3oDkLkuIhQSPu9//R4JSMH/qQcjJuJdsFBcZ0T/8XckU4UJBH9 m63A --===============0265357091658476207==--