From: He Zhenxing Date: December 9 2010 4:15am Subject: bzr commit into mysql-5.1-bugteam branch (zhenxing.he:3418) Bug#42415 List-Archive: http://lists.mysql.com/commits/126381 X-Bug: 42415 Message-Id: <201012090415.oB94Fwve006559@hezx-dev.localdomain> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============8533767047012690673==" --===============8533767047012690673== 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-09 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 without global LIMIT are unsafe if any of sub-selects is unsafe, and safe if all sub-selects are safe. UNIONs with global LIMIT are marked unsafe no matter this is ORDER BY or not. If the key field length is longer than MAX_SORT_LENGTH, then it will be ignore and not treated as a key field. 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-09 04:15:47 +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-09 04:15:47 +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-09 04:15:47 +0000 @@ -0,0 +1,221 @@ +# ==== 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 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), + nnuk_str_long VARCHAR(512) NOT NULL UNIQUE KEY, + nnuk_str_short VARCHAR(50) NOT NULL UNIQUE KEY); +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 nnuk_str_short LIMIT 1'), + ('ORDER BY nnuk_str_long 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; +SET MAX_SORT_LENGTH=50; +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); + + INSERT INTO t VALUES (1, 1, 1, 1, 1, 1, "a", "a"), (2, 2, 2, 2, 2, 2, "b", "b"); + INSERT INTO t1 VALUES (3, 3, 3, 3, 3, 3, "c", "c"), (4, 4, 4, 4, 4, 4, "d", "d"); + INSERT INTO t2 VALUES (5, 5, 5, 5, 5, 5, "e", "e"), (6, 6, 6, 6, 6, 6, "f", "f"); + INSERT INTO t3 VALUES (7, 7, 7, 7, 7, 7, "g", "g"), (8, 8, 8, 8, 8, 8, "h", "h"); + INSERT INTO t4 VALUES (9, 9, 9, 9, 9, 9, "i", "i"), (10, 10, 10, 10, 10, 10, "j", "j"); + + 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; +} +SET MAX_SORT_LENGTH=DEFAULT; + +# +# 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-09 04:15:47 +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-09 04:15:47 +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-09 04:15:47 +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,457 @@ 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; +} + +/* + And-or graph truth propogation algorithm is used to calculate if the + statement is ordered or not. + + Nodes: + JoinNode - And node, this is the root, successors are a list of + ConstOrderedTableNode. + ConstOrderedTableNode - Or node, have two TableNode as successors, + one for ordered table, and the other for constant table. + TableNode - Or node, have a list of KeyNode and one AllColumnsNode + as successors. + KeyNode - And node, successors are a list of ColumnNode that corresponding + to the fields of the key. + AllColumnsNode - And node, successors are a list of ColumnNode of all + fields of the table. + ColumnNode - Or node, represent a field of the table, it will take a + TableNode as a successor, which means if a table is true + (const or ordered), the all its columns are const or ordered. + Successors to other column nodes will be added mutually if + there is an equation to that field in the condition. The + column nodes for fields that are in the ORDER BY or are + equal to constants are added to the init_nodes of the JoinNode, + which is used as the initial true values of the propogation. + */ + +/* + Abstract base class for and-or node. +*/ +class Node :public Sql_alloc { +public: + Node() :todo(0) {} + virtual ~Node() {} + virtual void add_successor(Node* node)=0; + /* Number of successors need to be true to make this node true. */ + uint todo; + /* List of nodes that this node is a successor */ + List predecessors; +}; + +/* + Or node will be true if any of its successors is true. + */ +class OrNode :public Node { +public: + OrNode() :Node() {} + void add_successor(Node* node) + { + todo= 1; + node->predecessors.push_back(this); + } +}; + +/* + And node can only be true if all its successors are true. + */ +class AndNode :public Node { +public: + AndNode() :Node() {} + void add_successor(Node* node) + { + todo++; + node->predecessors.push_back(this); + } +}; + +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); + AllColumnsNode* 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; + ulong max_sort_length; +}; + +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()); + max_sort_length= current_thd->variables.max_sort_length; + add_join_list(join_list); + add_ordered_columns(order); + add_const_equi_columns(cond); +} + +inline JoinNode::JoinNode(TABLE_LIST* table, COND* cond, ORDER* order) +{ + max_sort_length= current_thd->variables.max_sort_length; + 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; + /* + If the field length is larger than the max_sort_length, then + ORDER BY the field will not be guaranteed to be deterministic. + */ + if (field->field_length > max_sort_length) + continue; + ColumnNode* column= getOrderedColumnNode(field); + init_nodes.push_back(column); + } + } +} + +bool JoinNode::is_ordered() +{ + 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, although it + might be deterministic for some cases (for example, UNION DISTINCT + with ORDER BY a unique key of both side of the UNION). + */ + 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-09 04:15:47 +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-09 04:15:47 +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); --===============8533767047012690673== 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: 42ba6c5d11fb9bf068aecd964dd2a8d855e1953b # timestamp: 2010-12-09 12:15:58 +0800 # base_revision_id: ramil@stripped # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWZfzp0QAOqB/gH80AEB9//// f///+v////9gN373dK9dz7fQbu3A64HcLifAO991LvX3h4OSlT73294OfTg698Pbhdt7Xc1Zs6t5 57PW493FXdw8gUKXm3c8ve3Xgfbuy+1s4hQfPs5UPWs2fbuIqn19fPbJM7vnenN8dXua6Y3m97ds 221laTjudskje4OvWmm1hXttt0rF981zeWnMZSNaPsrrOEkSNAAmjQBTaZNAgBDE1RmBTaj1M00J 5I00HlAlNBBBAmlU/yMo9VPwBJ5QaCeRANAAA2oGmEZBKntJQpRtQGgGRoNPUAA0NAAAAAAAAJPV SRKZU9oyU/QhPRhT0NNA1GEPQQ0ZBieghiYmTTARKEAiJtDQ0p4jUzRMno0TTKH6qaeoN6aSepp+ qDZRtIxB6giSIIAmENU8I0NCJ6p5PUxJptqg09QABoMgDag8pqVQMoCpHNBf8RRCB0iiFTmfL8PK 7slegq4t9ttuK53rmm/hS8HtSEmCyJSP3U7d8v+x7VKc3c9fA9Xv93y0TJAjXBV+f6UlH4/28fwY lLqRFLWvg0Ezjfq7jONdBB65JGhkviS897v3vlGYkmXXxx+n85IV+ksNDQCS/rjxQRlJHH7YOxfd 9ocxGGHxW6ttt/hjUt4q5LJo51t/lT+yacoZ3HmGLT8qf6QX9speDh9OHbR1Fsc5/X9/Z89xJLPa pl3h3OC4+Gwbt6Ttg6lH/BE+c+eCEHzp0QhyvRhrggQ2TZXvIyXDhsIakEgayQhLuyBXFaO5z+GQ sIpJMiwhCcdNxTOrOTeNyXg8lU6UYjen6Ut4e/z0N7i+B130v/eH9ZJOEn6nPw9AsWP4f8P4MSf7 9JIVP3ex+XONnbVSJKdhA3VmyFgjlsch7Psc9UeMZPsgcVBkzBOwFUH7WROZoSISISISAXLBo3Uj 8aqQ/Jc1lSAARV4rqrrnKkqWjWrIIJJAIJIiyQDA6RRDHPHPDACDGtvNdsm0mSTJtRrJkyZNtJky ZMmTJkyZMmTSZITJNRUkyWyZMmSsmTWTJkyVhamSTItEyJkyZKTIQjCY/GvbDaagrJAapBQ7L20y /uMbLeJUMF3tdeyZxhqGSGPtiZFJ5Wy0ECd4PJZLCDuDht366UKT6R0pXouKldka18PZziNR2kEJ AmAqL+59NKKucQQCGxIKdQEYADSptbfsrKrKzbVy4ooooooooouZcUXNbe3LXeUbbfC57LmuUt36 IFNc2ucIFNBAEEENNKaCDk7durZ1cdhAEFy0SRUyqSpiWoRSxba/t92tdYv+Hq9cPY3RvToP5EB2 8/q9UlWi0XnRAW4Ty3koZDDCSXwet7Pbxe75vNERERERJWe0AbGwJr+UGs0aGlUrHBlwAy4mAIkT kVFd/+e7Lgeeod3ePIlOb17O9l2t7AV1Wc4xLYz2FPrrps30+0DrH0jBkkJEkkkuLzqgdHTUrJCA h/JfnRT09OfVmOCqZxQiFvvBWgnu9mj9U09eN2lKSsm9oqgn9eO+KAEtqE8tcWk9s0wAAvEtRTSo lcL24QnvuE2WoTRW6MjYTcVQkIJC8PM8B7SvL0+WA5miN/gwamiCS9+ykCHKlQieZz/HoFYVXgtg IGBeMwLeRpYb9H4LwebynOGlISSJR+7YJ853lhdezSGesvFOIvHuhCDr5CLoKSb57PCsUZvYcPAJ DOBUVgrGFu1ZwSUECQJ7SfKUqvk85fVokx4VJJJJ4VfCxD8r2ubQ9TvCwXDgZhEAPKAAAAAAAAAA AAAAAAAASAtttex5L1F6m3p+Oq3jrV3y3TT9hiA2AaAp5wSjIHzBD5evHKQjPDaHJ5j0e7l4hBjE hB6sjxz4bOAPwIcDgcrN6fW2dyskzoY1tM6F2snNGSm23Febam2ClRtlsitZWq1lutWKhVqKtRu8 tkVkVxGi6KjclKrIriNFqNstkVkVkVkVkVkVJFFWRWo3JSqyK4jRFWo3JbIrIriNFkVkVkUVa75b GO12zJY5bctoryW3LbGOW3LLdstMulqNGxWMctvJbYxy7Zg3eWgYyxG2jWZ3g5B3Z8ToX01p5H/E 36bEuHLcWAt5p14kqhwa6w2XKCSA1oZZ9PkKGvaA5AMAYANfG1u3Ts4vGqc6I6Nrr27ShJT3U8O8 kLvTpULvtaNTYYcLJd9nFzfHhdnfeIPG1hJLmzVkhWTpUK9rQyvaEJKLU8O8kK6dKhXtaGmtG3FS S77ZKOEhwuzJvxw6DjNTcYVZLvs4ub48Ls77xBwYcLJc2cXOMeF2e1k/DLtObwhJRa7w7yQsJ0qF m1snt5MPv286uSlzZyTiag1I4n5H0QDX226ATU8n1guAmASWbCgRT3EBX0FurcG4iQgFg7zyMdxd Oe1+wY4gxxucfgALdy19c2/timNqZFDcJ2h40G/r7S1e9W8vRAAAHm5Xyb27td7wvmV/R7Rscdr3 XMdPo7cp0lFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRYjBUVGSO7j4A GrmcvUN1ISUWu/ROLHvmVA651SkRq7l3e6cV7TKgdXqlIi7vA41H0GBOaehkaorduDHNBHJ6DaXi NLwd/vtHrf1XMMhJCZMlB2+OYRGI8nBeX4eaUWOr3FxIc+NOToW0Wzz2ux030geLnFEof4T5luvd ycjsHlocZhgelMvpptuv+aDWS0aq4DXO1NT1qV/z1GvE+Gd4yF+xWbe8IwjZadu+bTLq1/GXiwuB nmstwqeKYuqeSah6rqNemJmZh1NI5wOBq2ymErcuy0YwN1BCI8dH5O/Tt5BXC2+78hmh7IDi7tnR j4RChfIte/2oolVHj7V6+AzDBfMU7YmkY0VX5mNKZxh03VhXnmVk7u1WJ+1TDJrLqSruAkHFwhFh 9JibcTdcxmGCzV/AwDAzvTrza5agf7z+uq8t82U/M/DuKSGXUNF6y76YaNScpkcayeivQlC6HB3z luAa0oT3sT2GtEcZNUprYkTcpfohIxiNZ6HmPsD2ukzg7pTg0EuwRgKPaDgwOMdAgXBPvEhBXmd4 ZENEN9ZhMwkINmvVLTgqrJ900vxAsrG0pYLsSEct1shIIRIwghRRHKIpyADUxsZHRzMaspkwmc2+ Stt61bbyeiACMGC0YjSBEZJFkZHZQq7AB4bYcpRuy3Udh4CiFHEm9C7gzmjkImrEAcUOPLPGpYkt DamkplREJ/2FSoLJ1stkP2ZiFm+/jw+Q7t9EviNBHV5bZBkV2BSMMNxIXqmS+bc7na7x3AY1ybdt qxEI1agBXxt2UTJuDTFBxBzrDU43HZAmiOdZDqoHMxNiy0S7oysigopIj6RL6m1IJthAZnW0yXWu xpcFhMCSCu5/CXaTmeXUblltqrGRCN4kILXnufVXznk7QVdLVK4nY6awBbFsEOAkgcFYUING+kEN UAbEEQuQRHfhQImg4gIneAPmAOYA0CE3wxtjVVADTFVVV1oVVVWGtdYIBpklBYcscwcAHMGA5sBz MizYELFWNSAg0horfGMOudWd0BB8u4duNi3+FjOxjE5z1z09Pd1t83zgEHfM3IztT72c5Ipeftfa dI9OJ5GsbZu2kXIR4ovrtFE8N4hCmjGlK9VLWVMNwvDFWV5ta/VN0i7a+XvizMwwZ5NtOEpKbCdV zc4jK1oXchsNxVklkHHvOJgzkhkzYWTblTc1pqcY5mW4RuJ/j/TOF8ajx8jps4s21ANWyj2MXyl9 t/ymXgyFk381/r948G+r5vq9Xz+490Fu7N33/TwWsOfT6yxmYssA4cof8vu9W+I28uf/vTHu54nF Yti+c/Qw3LzA7MhIEiQCKPxUaJFH7pRKwP0ASBEfmPKnYLV6/yrXLXTYCtddVctJq+j3tWvBWll8 nm+Y55/9/SAAAAAAAAAAAAYAAAB86928L6jzK+L0bm3j+hP6HkyHbAnrCqpwuy+ECqbbiGWf472D 4DCBBhEPOYnT6dFJIfLNSph4tRKnnbZEOMiKNgKEOwborH14WX5cCxc7qDRghC4Mmakw+hk2ksXP vtBSsO7YSK8mBoAG3VuIOWMlyGGGHbCeycebwaFrNVHzn8qbl9X9vonOr258ZnCb28r+b3HdvdKy 2hw0F8up0Wt7TrUTrH5bXBEuxIeIjnAP2HD2IdheeapDlCXT1ewJYEMwQbsiIiInhbwbbxSsuc1d 63p+xK1xI0+Rnfz/iHNkThCXdH4jp1mU0MiO2PTwAG9rCY5H4SIA8J9X6qT7Z7p7pxZhpytHoJ6S xXbYW5dlU3TKrkSWMaZNHc8srs1Mz3WdXVzlnZmI1tPNNcFuKPViTA6Z1mDfnRwJtaURkzbA5np0 CfFceNVszMF7DoYK2BwYLrecqvWDDMS4EOIj+AJ739q+9VWWlZVpWWqpW2VTRqQC39q0DEWD5PsT bYst3sWlSXh6DOhWBvXVoUe7pSY3YH3ntoB7JbKm/FKRYRAD0JHwXn1JamkOozsgFj11yNHpJEAX Pe3BvFubeLdjeM80+mdncGoHWaxLCaxNYmsTWJrE1iaxLBFyvZsznUBDuXHrwJGbo7zBsn0yGjs7 oTxj3hqF2vY15d2vRgKigA0gAAEgggACYDURFOURIKtnD6sDI2OZeaXF26/Ru8EIaCpVmwwzRnp9 dlUn2vhIXtXQ+PxXm5iO9DLn49UXZ94sBiB6UGcGBEUdZp+y8tRqBz9xOoKBrW3es8oqkLyYsdBY AuUgjH0slAGTLBchihy1Jxl/muHMv6rXIB0U0jS6qFqmHPHeUAj2nGVHwEdpWDbsR8yXXGaOqqed nHksqf6r+j3W0GYYFdvg/umOzI83WtJrv157gUcQYCt5qCCeMTPWSQtCQInd3c7I9NmgiQNp6yQI ic/R1YPJEmEOJwB9YDAfgAwHkAMBpGSSAAAcrbK1KysrK3EREREREG6rK3ValYCkFNE9QloXafH2 CgI1IKVmGRbdAD0X6dOqkEkPRKnGGEMYYRLiQgg8vZWdwzh9d5VKTPKturDMSGEG4X1UDBICWECz MID/MKtpG9QhiD7UgxwaLo4nEvDWNj6f77k1cDaCUwyEm8bwJod5+7EEtQYmBgbDA8TliNU0cTMd VO43+dYYJVMhItaGAAgmgsPgCDvurdut1XLat3LrnLm4C3FiLYxuKVXNxc03FzTcXNNxc0uNzTcX NNxc03Fyq2HHGOOJbgvyb0WoESQIgRCERdxQuREIKvsgKiXRXpBMCaxE6QLDBLew7OZjsMM9uU09 Bq2GULAR+dI6vwfW2/dba9dmFFOMhG220a5o3uqyY9OAiaW7+M9OzELYAj9okIMKr1mI5K/CXqGF cS7cLFLI2VZwpN4jSsmbhwiNQMPCAIBlWsIgZgd4A2PwVEvlpPA1mZyO3vMjvAmHiSm/hER6Cg4X 2AiwSEGg2jtoMGZJAB2YaL7+W/HPDUA8yMDFQaIQUkUAkqhqsmTJk1kyZMlaiEIQZjchULoDZzKC RDwlREq6ERCRECM2pIBwRebsKqL8oX4mObdPLlcOKWwt0mVECszaAsLMJdsZZk7sUFvCbHhsgq6T YyRrcZMNsAExuSNBaek0BOYGklUTbJoOedDyHMuPrLvWRpxQAbVpkiCFII2jmxgQRlzLMIoM18nY LwZNNy/LoZtKLLw8jxaJEc1boai8Odzoxc56jiIIN4Yn/7B6GbTcGu5pk1AY12C6EwdpICSfRGwR MO8AmuSRCGf7rCBXMS5WynbxLZ9AQLgRZFXE88J9JAs3lZQXVWIMy0lpPfeUuQKiBpLT4ozFUe8x NcuKQMO8tOJ6CQRrJSOc7IFEuRiUhoLDucljLtjorvJK+5y7JETZeVAiqBp4YtuqLApMxLsNeAiw SEErZhrCkmJbCoqG6FR1Gw4Feja99zXSSxKyDDINRqNdE6xJy+U74EZHQG+m2TqVR5V59hyYT8cG 5385TbBhBv3+fYY5XNS0cznS0sLzA4FWMlZpUCEg5kRRKWBZyzYu7iNQ6uBDNCUFpHkCzE3FJJIZ vmRH7cCYhvrNBREwMiFbBRoITkMoNfTqmEYrAkMbyUqKzgnm2gig4FB4H6gjT2du87wRbOVaMrLp I6BG8fTI63w0mlRoIfVRHcC8CTPUXpFwPTEfQDD6bJG5y8DXpCWghK+7ykmJmLgjSM5vJSJx6zKe 9tF4jSeQRRLmuSREmhmJhIQaoS02lbwKqSeklYgIeqmFxsOZnh0GE0naabcDYoKMHaI1O/20bmmi XgpPQZ+dqZCElecqCiHrQEHj27aeUMczMKKghfauqPYRci83WbcbnXVxtbVac7IXoSZidTSyMgsS J4lDvGjDzzL3YNBqejwJ/GBh8mMD8P5mmE5ZQl7NH0Ov73u+spqFlHh8HvX8kBxQerGvcf6xRem9 XDlmdQ7c6XxcIcLLTtg1gbsc/FzZGOD1xJD7js18O024tpz3lLfUSkrvorIpkDBj1RIOLWiUeBbT w4b9Ze8vhfM68VAukkkkAkSRjUajRo0aNGgpKQpCo0aKjRqNGjV02CIEwlTK1CIFkd8ezcZW22ol Sg+bq3WXDTCLZ8XKQbwzR6kDkUzMwzIyh7F7kEIAzQP31lbCeaLI8YfR2YuIi9/Nz5chDZ6+Q4ld KXDQCs06t9dmzCoyBDCoQppGkyAp5b3d9dVqRFiLFFEUWKKkMTD9H3n1azagQhkYbdAOwHvBgMBw BsCJUBqA0B7fit04fNfmcw35cXB8caGECiS7Hyq5wVTk2e/1uZxSRNfRdqRNYKeIUD4g9i/0F/of 6miK85IDYHAX8D9yFwP9zy+dQgK/uWD94OtvMA0aHx4H0VVpRJIBGR3/+gU9+jeoqmuGoD95eiBA nGDxg3i6tPumUnEW7j8rFClE8kG9D7ohvOaAC2NJOSHZ93rxyMSCoikkaayfGoHLA740ZAXtRzqi JqIbCakDWREDvUAsZzGAAXuOVr4paS0lpXz+pur1siA1xINRyDiLO45DAgK+I6gVghRQsFGI0hgQ hCiAA0QEGFIXBWBYAaokJCfqkWeiOQ1hgpcuxbFr2YSEaFVDk6RbIALUwCrVX9p/IwQASkQgNl1Q UHEyFLL5NOeCLFgUCQHLaWBYyiqYnNtJYkA2gKsNwiCchYCByBTJAGQATOC0XZwZLSs+OJJnchBz AwgiKuCuxsX4w6QC8MEB4II6K5FGrrB2uJQOVFj9gIAfpV134GzdY61eAHWDSFIogZnmKo8TXOtR DNNAaYieALSWktJWktJaS0paS0lpLSWktJaS0lpK0lpLSWlLS6tfwX6ntZ4lttDoOYCGwHu70EFx CAg4v69eyz3QPV2trygLiAtR7JIL6DwArVjS1KghiTydNBtPeDBPVEDSKB4i/geRsHEAINIALmLr 2PEuoBiDgh0IBuiSA9v6qSyjbs2KrXFtiq0bbFra7IvBEP0wyO4QHSD6xW5uHA4LcIL4w44uuO8a o7JmZKIrDghYMyxZFEDR2Yl7koAaREkKCVKKBEoRCAhERkIQMQcAKYY3HAsQbArZCNHcGAKFOACF BsMkHusqAmZADEjWE0CGGAamGa33X1f8P7/iI+P1wXiFUlBVU71a1TX7eZaywDYEQMmYQgTK7g7J SpTFrZqzXP05jkgQISGpompJVaWh3pIzR6RRDcV4j7/WAgPQ9wf+CqPfSiKw6xBzAVhvsoUXHv1+ cynuHWB7roHsGr0GNXutxRr5a7TXQgtuu3NrtKuzGrpuKNdl2lXTGrs3FCXhcghYIpeI3gNwiXkh JILa9bXaa7CC27dua3aVdmNXTcUYvC8NExhsjDvrS+R1DEHWbzA3ICDwKE0fSo8x9B6VAKHA8hQI LsKOsQigA3GDAI+sGAYg0DZRAYWCFgqhgADAig61CEOwE5EEhBIQSBkGojpEaTzI+BRFdw1wAEHQ dKCCajW1vEshRwgP4kBBsDgZ8igSa/z6tXzvLuTJkyZMmTJlGCgwVCqsTX0l73BFKHqI60VQ42CX nP20MBV4FEOYcmpvvKmRAKmIohlumfNfAFXUw0qPAREUcyxDYXArq+NvpABICYvXu+rvtprwppkl xiQFaqKKmVyFaC9XbVLVdDRddopzCESR8l0I9UBWAiQhIkdCYjQ8ymJ6xCAUSAiUFEQCpqFh3kcz d5A99dIPbcRxu/VcuOpuq6F9K9KWrxpmL2hYV1v025W9IchkAhCZgnzkEhBIQSBRUfIH1B8w2UQx NRQggeXKs2DggINCiFGAbjpIR2IRRQKiiRiqRBuHdnSB5wGj2ygkkCQClaAVg74QGBA9Btgcn1lf 9+/VDu7ygpIKEgBAgySTu+xJK5/wNwgPkZ4ek3FeroOk/+sHgB6H8ssbrr39HH7R+A/4UDccZIRG FxAhifo5jhC4n8md4Yv51xccCZMCh/OyxaiU0pCYVAzbARLrjcOQ3QYSJUapcpSqBQ4VBKjJIFyt BgYJNCkDAbJiEIQvMi/VYyGAZEA5ll7fR/YGitG0KBBoOpxaubhQkYS+nk8TAiofh8Cr/mfifv+R f0GNvsHA/2PaGfzH2aHv5yOf5kG3eZMlHiaFyTs/4/LkAEXrBJJASQIh081E8JDnxhjtHq7jtjf0 p7PVts0xstJDX1TqOQsJMbNcc/rjt+xAFNpNangu6yT5PAwuPy4oBV1DTPWXShE+Fst8hOBnkuTA U1K3eE/FrAZhn+MsZMBhIui7FBGIzyBBj+N44LawyQTi6fXJl7l/IlN6yC8/d4B/QKIbAbjqA5Tk b+/rgwm9cnACAKHEVhxw6XfCqNeQEUO3CZhpSXDbdeZhgQIVbWgMVzAAjN+3rjg3nP7q48oeJyM5 gSDHoRoHOhTZ+QchfsV/9Bccj1jHqPOWEwJCOo9b+sNznpN4PlsKUpI9qiAHBEOcHadnqIOd0CXH JAe/u5faYG+HlzVKCa+MN8qvpvSlgIB1PWcO7xJDcbiO41KfjA5lNQrA9LXQ6jmaNAyCQOx9G6wz jHoBb0hWcPMaSToSyttQKxhlaoycCFweWL0Zre73nAcRMxjUT2IdcJJA9dmiQiQSWg26hW5yu/hO hkHxLRJRjdstizrCaoc6GjJ5swSS3V1o6iEiH+HO2xj5AteqZo8MUNIx9J3fN/AaAkDQyMDxnJ1P PiaRd3KVKavQ3R1lyuW4c4soryLmixdP6v6bnlbvd8JoU5zbm0WSkkIhISo+AELFHqaIlwvkePnV z2UQ+AIr5nQzGE5mgZmMDoYCPLWUl4iU7yNRcWmZbIkEJLgYJFSxVBvEogQLFiwVZpUvfM2nV9r4 dp1nUcfsiiQ5AHzwCQ2EKggBSUIIOhrDeI87nOt6gdkBNUU0IgmmgOCGC7qAYmPJSxqNiF7aQDgJ s3zRXFhMJSwBkxdJafIJCDcYMQs3yeNNPsnPfNLLt57KBtcOOM1hrO4bPUOhksFnHRDm13aUFCz/ ju8tthvpypeMfU+s24EXdzj48dAzlIFaGwAmXLJyictgyXukcJ214l8mk7JmfeTVIZJkWvRNVYac nC6GrChbkwVEMKalWpyEEG3QOyRvP052S7X5o03GYYOG7RnXloTRbg12qsrD5k3Q0x7VsUFoQgBU JEGBnKISUZq0rpcj0V42uozLTI7jkkkJaxSkQPWSG07LTN1xJDmT6IdOXGXVl3HQJgR7CwwwOheM OcDHjbkG/SAtQ0jMwtbJ4M4zD7gPSByLLh6ETQ7+uFQYNR0Cj4U0BvSJROpGHWyYtFNWRgJVF7Bz mV4RADyMTfg0p+qbPZa17tHMct2NJ6ZP44YxDo8D0m5LMBRscLl3Enkl9sLNByWnmZlR1mKM5Odn fMsDeakjMdhUX7252eRqvK5HwSEjeICUPkPV8HuOw2uwCQhofS93tXZjRUGvcO3so0Kbc0UQvAkI BIExY0JkKe2UP1al0kEvznUTadKSwnfuLbMcEComv5y9kLlaISD6chMEU0m8zRazAzt7PZehmO8p MYXV0SReYgeFMA6JiC6tksWZLVa1onC1eLBVzO9iV3m8QvDJ+ybEGMKhog671XhMeN2ZFymJcsBx Lw+rrcNqB7EBQ2QAD/ESKG/6eUYK9xQfE3F0UiLR0iDXJxubk966+gClXmXiekkJEdox3HnMdHqG iRCgny8C3ze07C4sSgkNtkLIe4po4g7vane7EhF+0lH7RawSESrWfEq2s2D9JQa/TKP6QKgVA2ts O+H/s7tKRY3ny89CPA6JTC9TAFLCARfsdHyLVYk9phiBjwfyHzn2nu2qcRRCJXkfAbKnncwbsANp Rm4+kHWBV9tvmlEdsKjCNQhL5njfqesG7JI8/aW2pZqbfVXfx1RUQg72BpYSJKuiO/3HaZHFC9rD aWdMw53Pn2jjkq8mc0kqPiOEEKN5byqx2RKP3jHuLifbFUkFkJENSJ0btGwZsA/PtRLVEO+XA5UJ FLewrIMNhEcNAKQ5+ZJSIyMU/b8HM+0+QiLUvULkJ1mM+goHkGAkHwQPe3dn68zFXrr2oGuhml/o /sYSCBBCABpRdmR8p+Nh8oSikqirSoIcgeWSluws8F0gSAHejiOo5CpjxEeGCCgR9kASnlIPUptM Adep6LDvx+HZt275HArBEmCbyhRDUA7OnXTsB4IvatiTKPou+XvogItYYQyLS1I83T35INpehG0k iQIEIoQM91pIfBoPrd1d5fu7tKneHygDADqAeJoe5gHGBIlKN0gdE6LWXxh80B4DCsQuhiPTeBUE yZBeRDwu16VFMQQY958vh6D3+4txGYGyyygOw43c+/fecuJgbgW+s2zMwiCIxARARAAAEBBAQAVG xFRghbbrm4+P1bquqmICRQVpAB90QVf5nDcANQAYDAGAhAGAMDNy7U3H0ArICvGKA0Eg1KFWmk32 BWj6jjX7JzL3o994MPuPRcXVpGKmYl98y+BksVeyHAYdxgGEOQCAdB0qdj1TFPOQMKhk0EvQxEiF t537ty9UA0nmaMATYaFyjIgJ8DYuqgKAl42iAg+aXpUtESgNJayi2AiftwEDTPnIQgYF8ttsRbIe Z7SxiGw5nAInqNhmZg6BeDkIfiEEhqBoFVSYbD7qrqAokIyQoDd/EJbuC9HN6aBRDS6kYY2uHFMi 4Jxb2t2rQGjSorXn7TQa5oqVsvpgz1nzUQqix7MzwvYVshdEDta7C4htGFRFCPrICocOvKEgFSTI QULEZ58T3nbg5oNhU0yuN9Og1Oiiu+l4Z21IUCmF1aLVkOPTIGspR5Zyg/+F3pzNTY0SSsJGb6HK pWPv2CAq6hAosJlLy1mlmEJU8NQzCFoiINRtaYB/VLlsKtiBUW8SqJDcA1VfcCXxGAXAwqSERgRQ IjCgpQxWs9qGOGYEMawLDSVjAfIIBIFpYFkC1XUpLCXsaLIYXoAusIRge2inRU9Ggr3FUtYCYSRJ FHOqRUMBPB9ZrEUNFLhWMQbydAOaAwFYfnVIMiBBIon0MARoBCMIqJJqlaW2lVlVlan6BfD25b5b byLEJarfXaguQqd8ZaH3zWXAVu6aUAkQIJFUYDF9pHwwEE0gd9U7tieI8DV2yioLRFeYJzbB95EF t0vBRCMhFRDGqjakjBZYq8b2pGjcD3K7SBARgwWjEY0tgWRkJIKKBABgK0DAWkMPrMH3mQpcK8/1 7/Zb4VosBGKiGrCqjaSHFuZkIcCempxWPS0nb+OkFkGECYsoCsJIBrUqTYa0RkkYRstSZrf08Kib OwzFBL7jA8avqD8kSKFRRE6Cbg+IoflBGIkEhtYK8yJ4ncnVoQoKJRAfV9F7GKibopY7BJCfZKNH ELHAzDIXaoxE+sTwN4nwOGgicKKJIwIThCo/okhh2S5jeiMY0HvgOABpw5wD0EfRGSpAp98P41Ml hAhdGga/D85rRUPDjuR4kXu6nwK0iglMYeQohxDaNs+sYmpFSaiSZp3mX37Qrgl7jeeGesQcjynZ XL8zgMJOqbu8hSObehZc47dafTTE7QYxgoSMkVZ4hQMRAoAaAQ6zbbSGolg6THU3kpLZdE9lLOLO u5WKxnZejvB8qnPooUgpRYi1bzgGwNyZ1F9Jwm44+NT1RA7yPkMk4xOsTUeJCT1UNEIVRRPlKDeQ h9z/HGWLmWYnt+pcMt5+cvakprcJCbI2fZpqSB6YtJCY0AUAbpUDQZDUEkCPYU8T0lZRwyS1aRi/ Ol1KPB5bDtw34qaSrJW8eqKKSV4bO/OOVLu4z3LfB79Ovlgim0YZIdQQS43lovoIvSfSRhB8cH4V SnOHH89UNEPMTXAZuiLY6SQgb4+AvPZtLBU5a98EUMkHqShzKN6ih7krjn3OpN6weIqB1md7oUDJ dIvnrvoVLO8wKLRQVY2CaZgt8KCj3AlCWSH0FGTjc9SDovhaJCQUN4G8JLNM5elrhjHbJCwa8Gy7 psRomiF8GWU1oiG0QFa6mO53vGJuYWtySS0P+a0aZhmg+8JsKmZJkSsb3hpZ6pSlCFEPMC9bcJQ2 Oo9h85c0qiENUk31UkbOFrGly8VsgaQtA3EQzUkZZ7HVkJJIZEIkiHDQNNt/D3MM+CVKmcayvTl+ r1XXsCPoBuOoCeU8vMPQb/kOJz0mT04tCw3uMHQDlhgYGdHZpL2TipY68gL5nwc3pEuQyKDrj0dt 4tvm33qvvgD1b+fXs29W7dRERdbz13zLVeeTz69O6S5xR51q5NptJQyFJZsznRuAUNsLuZiA3Xmp A7byxBCqsEjeIfQA395fw9JQvCOKg56q2TKJ6hIgqloINN88atiX90VEOzFpKlYiiHVHEq1TSX0w 0QUQtgF5q00aTSRNf0KNdbTa4QRo5DqGQnZy6qBJ/DR20Q47vIDsQIK3NoDcs2jc1N23GYYKC10Q jfcWPaZIqBQgDAgigwkMcK9YAwRGxAFhAE9wKwBgKwBoSF13ovBC4QvBCIJAVj7MdxwFhFB16VNM o21y40ySSMBIqYQOHEkIyS+XIwBoCAYrxEtwTBCjWAas3Nhc6BZwKw1gAjxjyFH5iEON8dWkknwo fr+FbWn2woZjCmEKooJD83p523KKH5hRCRjuPQKIcjlD5olMQ64hg++jJ6z78AYECCFgRQseYtaL ig6n387QAntudIhDXvBWq3vnicRt7fcVp0lwImWRHZN+wZwKwDFvN6dxY9aWywv4gHl8JyFi+ddB oSNL3SBoKDG69GV0UOsjWZjRkxCHdmM6BDp5NYgSHgRhx1EwrYtXgQDEv2ugZut+/QzTv5yLOY5W N5qBgoeEPjMB8TjUchIVHfKPcXUGjJyvhqJyHGnEaOaqoONcTPkLkNMcUOwiE9ux0UV0uAfoxAx5 aBrr54JuiHhCRCw71H0Gegj2MC83Av8apU4UM0nOPWV4278CM2mSXJF5930nWCOUzXhoWhXIcY5B 6C953E5ma29PxMOhmXU8zoW7ySCXMj1gnSy6X1n2HvOBoZ6gpO3mVn8qHbPP8RRLVchUCRMA8KVF hQmJx0qDfA5mo1mYS1pRHDZ+ModCYSORj6jYU6jo12EQNZzBMrHKCKyIAwIcebum6TJ5phUMwwJu AqVVSqbNA9kzADqr0WyfkUCeMbxIgMIAEWD7Sx4Y+JgUiMB663LkGghidRGk5Ai48CcDixuPee9A wHn+XEpZaTNtPuNeGY8x5DkAcxdF0EKCR+H6/oPVbRgDeXtRPzCoWqEGcU//F3JFOFCQl/OnRA== --===============8533767047012690673==--