Merge lp:~sergei.glushchenko/percona-server/5.5-ST29724_bug1132194 into lp:percona-server/5.5

[Sergei Glushchenko]

  BUG#1132194: UPDATE/DELETE with LIMIT clause unsafe for SBR
  even when ORDER BY PK is present

  MYSQL BUGUG#42415 UPDATE/DELETE with LIMIT clause unsafe for SBL
  even with ORDER BY PK clause

  This is an adoption of http://lists.mysql.com/commits/126382

  This is only a partial solution which allows to suppress warning
  in many cases when statement with LIMIT isn't really nondeterministic.
  Partial means that in mixed mode all statements with LIMIT will be
  switched to ROW unconditionally. To determine whether the staments is
  really unsafe some analysis of query should be performed. This requires
  in particular all tables should be opened and all fields should be
  fixed. However decision to switch to ROW mode is made before this
  happens.

  Original description:
  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
     <non null unique key>
   - single table UPDATE/DELETE/INSERT..SELECT with WHERE clause
     that include <non null unique key> = <const value>, if it is
     a multi-part key, then it must be <keypart1>=<const1> AND
     <keypart2>=<const2> ..., 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=<const> 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.

http://jenkins.percona.com/view/PS%205.5/job/percona-server-5.5-param/701/

[Laurynas Biveinis (laurynas-biveinis)]

    - Unfortunately the patch is knowingly suboptimal, see
      http://lists.mysql.com/commits/128836. The question is whether
      it's OK for us in the current form or if we should spend time
      improving it. I think it's acceptable for small joins but the
      overhead might be noticable for big ones. Is it possible to
      quantify this somehow?

    - The algorithm itself looks OK to me, but I am not too confident
      in my review.

    - Low-level code review:

    - All TRUE/FALSE should be replaced with true/false where a proper
      "bool" type is used, in code and comments.

    - is_cond_equal/is_cond_mult_equal: should be static, const arg,
      s/TRUE/true, s/FALSE/false, if (x) return true; else return
      false should be replaced by return x;

    - class Node: field todo should be protected.

    - Add virtual keyword to all add_successor() and desctructor
      declarations in the children classes.

    - class Table_node: const TABLE* table; const arg for
      constructor. get_column_node: const reference arg, const
      method. create_column_node, create_key_node: const reference arg.

    - class Const_ordered_table_node: likewise (const table field,
      const args). Initialize ordered_table_node/const_table_node in
      the constructor initializer list Is there a memory leak for
      ordered_table_node/const_table_node?

    - class Join_node: likewise constify what is constifiable.

    - Likewise constify other new classes/functions.

    - sql_class.h: order_deterministic should be initialized in the
      constructor initializer list and to false, not 0.

review: Needs Fixing

[Sergei Glushchenko (sergei.glushchenko)]

Laurynas,

Yes, the problem is rather complex. I can propose 2 options.

1. Measure performance impact of this patch, try to optimize it (get rid of memory allocations, etc.)
2. Do not implement the whole thing, analyze only few simple and most common cases for example SELECT * FROM table ORDER BY UNIQUE KEY

Thanks,
Sergei

[Laurynas Biveinis (laurynas-biveinis)]

Sergei -

Let's implement the later comments on the bug and on the upstream patch review.

[Sergei Glushchenko (sergei.glushchenko)]

Hi Laurynas,

Looks like I have it:)

> - All TRUE/FALSE should be replaced with true/false where a proper
> "bool" type is used, in code and comments.

Done.

> - is_cond_equal/is_cond_mult_equal: should be static, const arg,
> s/TRUE/true, s/FALSE/false, if (x) return true; else return
> false should be replaced by return x;

Done.

> - class Node: field todo should be protected.

Field todo cannot be protected because class Join_node mantpulates it directly.

> - Add virtual keyword to all add_successor() and desctructor
> declarations in the children classes.

Done, but is any strict guidance for it? Once virtual method is always virtual.

> - class Table_node: const TABLE* table; const arg for
> constructor. get_column_node: const reference arg, const
> method. create_column_node, create_key_node: const reference arg.

Done.

> - class Const_ordered_table_node: likewise (const table field,
> const args). Initialize ordered_table_node/const_table_node in
> the constructor initializer list Is there a memory leak for
> ordered_table_node/const_table_node?

There is no memory leak, table node is the subclass of Sql_alloc.

> - class Join_node: likewise constify what is constifiable.
> - Likewise constify other new classes/functions.

Done.

> - sql_class.h: order_deterministic should be initialized in the
> constructor initializer list and to false, not 0.

Done. But I don't really like it, because it always take some time
to find a good position of initializer list when doing merge.

[Sergei Glushchenko (sergei.glushchenko)]

http://jenkins.percona.com/job/percona-server-5.5-param/773/

[Sergei Glushchenko (sergei.glushchenko)]

MP for 5.6 goes through Jenkins param build. Should be ready later today.

[Laurynas Biveinis (laurynas-biveinis)]

> > - class Node: field todo should be protected.
>
> Field todo cannot be protected because class Join_node mantpulates it
> directly.

But Join_node inherits from Node?

> > - Add virtual keyword to all add_successor() and desctructor
> > declarations in the children classes.
>
> Done, but is any strict guidance for it? Once virtual method is always
> virtual.

Yes, that's why IMHO it's a good idea to add it at a child classes. Otherwise it's hard to tell virtualness, if it was made virtual at greatgrandparent class.

[Laurynas Biveinis (laurynas-biveinis)]

    - s/propogation/propagation/g

    - is_cond_equal/is_cond_mult_equal should be static, const arg.

    - class Node: field todo should be protected.

    - class Table_node: columns should be initialized in the
      initializer list and memset in the body.

review: Needs Fixing

[Sergei Glushchenko (sergei.glushchenko)]

Well as for todo field. An attempt to compile following simple program gives me error message both for g++ and clang, and I believe it is correct.

class BaseNode {
protected:
 int todo;
};

class ChildNode : public BaseNode {
public:
 void donow(BaseNode* node) {
  node->todo++;
 }
};

~/percona/test❯ g++ -c todo.cc
todo.cc: In member function ‘void ChildNode::donow(BaseNode*)’:
todo.cc:3: error: ‘int BaseNode::todo’ is protected
todo.cc:9: error: within this context

~/percona/test❯ c++ -c todo.cc
todo.cc:9:9: error: 'todo' is a protected member of 'BaseNode'
                node->todo++;
                      ^
todo.cc:3:6: note: can only access this member on an object of type 'ChildNode'
        int todo;
            ^
1 error generated.

[Laurynas Biveinis (laurynas-biveinis)]

Sorry, I missed it was a field in another object, not this. Either leave it public, either make it protected and add a friend class declaration, as you wish.

[Sergei Glushchenko (sergei.glushchenko)]

Done.

Since both todo and predecessors are used in same manner, todo is only used in Join_node, and predecessors is used also in Or_node and And_node, they should either be both protected, or both public. I don't like to use 'friend' keyword.

Class hierarchy can be refactored to avoid 'friend' tricks, but I prefer to leave it as is. If we want to refactor class hierarchy, I'd also implement some of improvements listed in upstream review.

[Laurynas Biveinis (laurynas-biveinis)]

> Class hierarchy can be refactored to avoid 'friend' tricks, but I prefer to
> leave it as is. If we want to refactor class hierarchy, I'd also implement
> some of improvements listed in upstream review.

Agree

[Laurynas Biveinis (laurynas-biveinis)]

Approve.

Again for the record my review is quite superficial, and we know that the fix is suboptimal, but it looks good enough and it's not invasive should we need further improve it / revert it / eventually replace with the upstream fix / etc.

review: Approve

[Laurynas Biveinis (laurynas-biveinis)]

Err what about a Jenkins run?

review: Needs Information

[Sergei Glushchenko (sergei.glushchenko)]

Forgot to post it http://jenkins.percona.com/view/PS%205.5/job/percona-server-5.5-param/778/

=== modified file 'Percona-Server/mysql-test/suite/binlog/r/binlog_stm_ps.result'
--- Percona-Server/mysql-test/suite/binlog/r/binlog_stm_ps.result	2010-04-28 12:47:49 +0000
+++ Percona-Server/mysql-test/suite/binlog/r/binlog_stm_ps.result	2013-06-26 17:10:34 +0000
@@ -10,8 +10,6 @@
 prepare s from "insert into t1 select 100 limit ?";
 set @a=100;
 execute s using @a;
-Warnings:
-Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
 show binlog events from <binlog_start>;
 Log_name	Pos	Event_type	Server_id	End_log_pos	Info
 master-bin.000001	#	Query	#	#	use `test`; create table t1 (a int)

=== modified file 'Percona-Server/mysql-test/suite/binlog/r/binlog_stm_unsafe_warning.result'
--- Percona-Server/mysql-test/suite/binlog/r/binlog_stm_unsafe_warning.result	2012-01-06 10:22:56 +0000
+++ Percona-Server/mysql-test/suite/binlog/r/binlog_stm_unsafe_warning.result	2013-06-26 17:10:34 +0000
@@ -4,11 +4,7 @@
 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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
 UPDATE t1 SET b='5' WHERE a=2 ORDER BY a LIMIT 1;
-Warnings:
-Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
 DROP TABLE t1;
 ### NOT filtered database => assertion: binlog disabled and warnings ARE NOT shown
 SET SQL_LOG_BIN= 0;

=== added file 'Percona-Server/mysql-test/suite/binlog/r/percona_binlog_unsafe_limit.result'
--- Percona-Server/mysql-test/suite/binlog/r/percona_binlog_unsafe_limit.result	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/binlog/r/percona_binlog_unsafe_limit.result	2013-06-26 17:10:34 +0000
@@ -0,0 +1,1581 @@
+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);
+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 * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) [LIMIT_1]'),
+('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 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');
+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();
+Warnings:
+Error	1329	No data - zero rows fetched, selected, or processed
+SET MAX_SORT_LENGTH=50;
+UPDATE t SET nokey = nokey + 10 LIMIT 0;
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 WHERE nuk=1   ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 WHERE nuk=1   ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 WHERE nuk=1   ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 WHERE nuk=1   ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 WHERE nnuk=1  ORDER BY nnuk_str_long 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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+UPDATE t SET nokey = nokey + 10 WHERE pk=1    ORDER BY nnuk_str_long 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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 1
+DELETE FROM t ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 1
+DELETE FROM t ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 1
+DELETE FROM t ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 1
+DELETE FROM t ORDER BY nnuk LIMIT 1;
+ROWS in table t: 1
+DELETE FROM t ORDER BY nnuk_str_short LIMIT 1;
+ROWS in table t: 1
+DELETE FROM t ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 1
+DELETE FROM t WHERE nokey=1 ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 1
+DELETE FROM t WHERE nokey=1 ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 1
+DELETE FROM t WHERE nokey=1 ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 1
+DELETE FROM t WHERE nokey=1 ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 1
+DELETE FROM t WHERE nuk=1   ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 1
+DELETE FROM t WHERE nuk=1   ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 1
+DELETE FROM t WHERE nuk=1   ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 1
+DELETE FROM t WHERE nuk=1   ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 1
+DELETE FROM t WHERE nnuk=1  ORDER BY nnuk_str_long 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 nnuk_str_short LIMIT 1;
+ROWS in table t: 1
+DELETE FROM t WHERE pk=1    ORDER BY nnuk_str_long 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;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 3
+REPLACE INTO t SELECT * FROM t1 ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 3
+REPLACE INTO t SELECT * FROM t1 ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 3
+REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 3
+REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 3
+REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk_str_short LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 3
+REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 3
+REPLACE INTO t SELECT * FROM t1 ORDER BY pk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 3
+REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk1, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 3
+REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 3
+REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 3
+REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 LIMIT 0;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk_str_short LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY pk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nuk=1   LIMIT 0;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nuk=1   LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY nnuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY nnuk_str_short LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY pk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY nnuk1, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY nnuk1, nnuk2, nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY nnuk1, nokey, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1  LIMIT 0;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1  LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1  ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1  ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1  ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1  ORDER BY nnuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1  ORDER BY nnuk_str_short LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1  ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1  ORDER BY pk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1  ORDER BY nnuk1, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1  ORDER BY nnuk1, nnuk2, nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1  ORDER BY nnuk1, nokey, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE pk=1    LIMIT 0;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE pk=1    LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE pk=1    ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE pk=1    ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE pk=1    ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE pk=1    ORDER BY nnuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE pk=1    ORDER BY nnuk_str_short LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE pk=1    ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE pk=1    ORDER BY pk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE pk=1    ORDER BY nnuk1, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE pk=1    ORDER BY nnuk1, nnuk2, nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+ROWS in table t: 2
+REPLACE INTO t SELECT * FROM t1 WHERE pk=1    ORDER BY nnuk1, nokey, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on master and the slave.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT * FROM t1 ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT * FROM t1 ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT * FROM t1 ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 3
+INSERT INTO t SELECT * FROM t1 ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE nuk=1   ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE nnuk=1  ORDER BY nnuk_str_long 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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE pk=1    ORDER BY nnuk_str_long 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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk_str_short LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY pk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk1, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 5
+INSERT INTO t (SELECT * FROM t1 ORDER BY nokey LIMIT 1) UNION (SELECT * FROM t2);
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 5
+INSERT INTO t (SELECT * FROM t1 ORDER BY nuk LIMIT 1) UNION (SELECT * FROM t2);
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 5
+INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1 LIMIT 1) UNION (SELECT * FROM t2);
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1) UNION (SELECT * FROM t2);
+ROWS in table t: 5
+INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk_str_long LIMIT 1) UNION (SELECT * FROM t2);
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 5
+INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nokey LIMIT 1);
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 5
+INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nuk LIMIT 1);
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 5
+INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk1 LIMIT 1);
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1);
+ROWS in table t: 5
+INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk_str_long LIMIT 1);
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short 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 nnuk_str_long LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1);
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk_str_short LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk_str_long LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) LIMIT 0;
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY nnuk LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY pk LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY nnuk1, nnuk2 LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY nnuk1, nnuk2, nokey LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM 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, t2 LIMIT 0;
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1, t2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk_str_short LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY pk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk1, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk1, nnuk2, nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 3
+INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk_str_short LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk     ORDER BY nnuk_str_short LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk     ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk   ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk       ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nokey LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nuk LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk1 LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short 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 nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short 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 nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 2
+INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short 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 nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short 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 nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short 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_str_long 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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 3
+INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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 nnuk_str_short LIMIT 1;
+ROWS in table t: 3
+INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk_str_long LIMIT 1;
+Warnings:
+Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.
+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
+SET MAX_SORT_LENGTH=DEFAULT;
+DROP TABLE t, t1, t2, t3, t4;
+DROP TABLE queries, result_queries, limits;
+DROP PROCEDURE gen_queries;

=== added file 'Percona-Server/mysql-test/suite/binlog/t/percona_binlog_unsafe_limit.test'
--- Percona-Server/mysql-test/suite/binlog/t/percona_binlog_unsafe_limit.test	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/binlog/t/percona_binlog_unsafe_limit.test	2013-06-26 17:10:34 +0000
@@ -0,0 +1,227 @@
+# ==== 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;
+
+--disable_query_log
+call mtr.add_suppression("Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT");
+--enable_query_log
+
+#
+# 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.
+#    - nnuk_str_long is a VARCHAR UNIQUE KEY column that is longer than MAX_LENGTH_SORT in this test.
+#    - nnuk_str_short is a VARCHAR UNIQUE KEY column that is shorter than MAX_LENGTH_SORT in this test.
+#
+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 * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) [LIMIT_1]'),
+	('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 'Percona-Server/sql/sql_base.cc'
--- Percona-Server/sql/sql_base.cc	2013-05-23 08:39:28 +0000
+++ Percona-Server/sql/sql_base.cc	2013-06-26 17:10:34 +0000
@@ -9262,6 +9262,472 @@
   return 0;
 }
 
+static bool is_cond_equal(const COND *cond)
+{
+  return (cond->type() == Item::FUNC_ITEM &&
+          (((Item_func*)cond)->functype() == Item_func::EQ_FUNC ||
+           ((Item_func*)cond)->functype() == Item_func::EQUAL_FUNC));
+}
+
+static bool is_cond_mult_equal(const COND *cond)
+{
+  return (cond->type() == Item::FUNC_ITEM &&
+          (((Item_func*)cond)->functype() == Item_func::MULT_EQUAL_FUNC));
+}
+
+/*
+  And-or graph truth propagation algorithm is used to calculate if the
+  statement is ordered or not.
+
+  Nodes:
+    Join_node - And node, this is the root, successors are a list of
+              Const_ordered_table_node.
+    Const_ordered_table_node - Or node, have two Table_node as successors,
+              one for ordered table, and the other for constant table.
+    Table_node - Or node, have a list of Key_node and one All_columns_node
+              as successors.
+    Key_node - And node, successors are a list of Column_node that corresponding
+              to the fields of the key.
+    All_columns_node - And node, successors are a list of Column_node of all
+              fields of the table.
+    Column_node - Or node, represent a field of the table, it will take a
+              Table_node 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 Join_node,
+              which is used as the initial true values of the propagation.
+ */
+
+/* 
+   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<Node> predecessors;
+};
+
+/*
+  Or node will be true if any of its successors is true.
+ */
+class Or_node :public Node {
+public:
+  Or_node() :Node() {}
+  virtual 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 And_node :public Node {
+public:
+  And_node() :Node() {}
+  virtual void add_successor(Node* node)
+  {
+    todo++;
+    node->predecessors.push_back(this);
+  }
+};
+
+typedef Or_node Column_node;
+typedef And_node Key_node;
+typedef And_node All_columns_node;
+
+class Table_node :public Or_node {
+public:
+  Table_node(const TABLE* table_arg);
+  ~Table_node();
+  Column_node* get_column_node(const Field* field) const;
+  Column_node* create_column_node(const Field* field);
+  All_columns_node* create_all_columns_node();
+  Key_node* create_key_node(const KEY* key_info);
+private:
+  const TABLE* table;
+  Column_node** columns;
+};
+
+Table_node::Table_node(const TABLE* table_arg)
+  :table(table_arg), columns(new Column_node*[table->s->fields])
+{
+  memset(columns, 0, sizeof(Column_node*) * table->s->fields);
+  
+  if (table->s->primary_key == MAX_KEY && !table->s->uniques)
+  {
+    add_successor(create_all_columns_node());
+    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(create_key_node(&table->s->key_info[key]));
+  }
+}
+
+Table_node::~Table_node()
+{
+  delete [] columns;
+}
+
+inline Column_node* Table_node::get_column_node(const Field* field) const
+{
+  return columns[field->field_index];
+}
+
+inline Column_node* Table_node::create_column_node(const Field* field)
+{
+  if (!get_column_node(field))
+  {
+    Column_node* column= new Column_node;
+    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 (Or_node).
+    */
+    column->add_successor(this);
+  }
+  return get_column_node(field);
+}
+
+All_columns_node* Table_node::create_all_columns_node()
+{
+  All_columns_node* node= new All_columns_node;
+  uint i= 0;
+  for (i=0; i<table->s->fields; i++)
+  {
+    Column_node* column= create_column_node(table->field[i]);
+    node->add_successor(column);
+  }
+  return node;
+}
+
+Key_node* Table_node::create_key_node(const KEY *key_info)
+{
+  Key_node* node= new Key_node;
+  uint key_parts= key_info->key_parts;
+  uint i;
+  for (i=0; i<key_parts; i++)
+  {
+    KEY_PART_INFO *key_part= &key_info->key_part[i];
+    Field *field= table->field[key_part->fieldnr - 1];
+    node->add_successor(create_column_node(field));
+  }
+  return node;
+}
+
+class Const_ordered_table_node :public Or_node {
+public:
+  Const_ordered_table_node(const TABLE* table_arg);
+  const TABLE* get_table() const { return table; }
+  Column_node* get_ordered_column_node(const Field* field) const;
+  Column_node* get_const_column_node(const Field* field) const;
+
+private:
+  const TABLE* table;
+  Table_node* ordered_table_node;
+  Table_node* const_table_node;
+};
+
+Const_ordered_table_node::Const_ordered_table_node(const TABLE* table_arg)
+  :table(table_arg),
+   ordered_table_node(new Table_node(table)),
+   const_table_node(new Table_node(table))
+{
+  add_successor(ordered_table_node);
+  add_successor(const_table_node);
+}
+
+inline Column_node*
+Const_ordered_table_node::get_ordered_column_node(const Field* field) const
+{
+  return ordered_table_node->create_column_node(field);
+}
+
+inline Column_node*
+Const_ordered_table_node::get_const_column_node(const Field* field) const
+{
+  return const_table_node->create_column_node(field);
+}
+
+class Join_node :public And_node {
+public:
+  Join_node(List<TABLE_LIST>* join_list, COND* cond, const ORDER* order);
+  Join_node(const TABLE_LIST* table, COND* cond, const ORDER* order);
+  bool is_ordered() const;
+private:
+  void add_join_list(List<TABLE_LIST>* join_list);
+  Const_ordered_table_node* add_table(const TABLE* table);
+  Const_ordered_table_node* get_const_ordered_table_node(const TABLE* table);
+  Column_node* get_ordered_column_node(const Field* field);
+  Column_node* get_const_column_node(const Field* field);
+  void add_ordered_columns(const ORDER* order);
+  void add_const_equi_columns(COND* cond);
+  void add_const_column(const Field* field);
+  void add_equi_column(const Field* left, const Field* right);
+  bool field_belongs_to_tables(const Field* field);
+  List<Const_ordered_table_node> tables;
+  List<Node> init_nodes;
+  ulong max_sort_length;
+};
+
+inline void Join_node::add_join_list(List<TABLE_LIST>* join_list)
+{
+  List_iterator<TABLE_LIST> 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 Const_ordered_table_node* Join_node::add_table(const TABLE* table)
+{
+  Const_ordered_table_node* tableNode= new Const_ordered_table_node(table);
+  add_successor(tableNode);
+  tables.push_back(tableNode);
+  return tableNode;
+}
+
+inline Join_node::Join_node(List<TABLE_LIST>* join_list,
+                            COND* cond, const 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 Join_node::Join_node(const TABLE_LIST* table,
+                            COND* cond, const 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 Const_ordered_table_node* Join_node::get_const_ordered_table_node(const TABLE* table)
+{
+  List_iterator<Const_ordered_table_node> it(tables);
+  Const_ordered_table_node* node;
+  while ((node= it++))
+  {
+    if (node->get_table() == table)
+      return node;
+  }
+  DBUG_ASSERT(0);
+  return add_table(table);
+}
+
+inline bool Join_node::field_belongs_to_tables(const Field* field)
+{
+  List_iterator<Const_ordered_table_node> it(tables);
+  Const_ordered_table_node* node;
+  while ((node= it++))
+  {
+    if (node->get_table() == field->table)
+      return true;
+  }
+  return false;
+}
+
+inline Column_node* Join_node::get_ordered_column_node(const Field* field)
+{
+  return get_const_ordered_table_node(field->table)->get_ordered_column_node(field);
+}
+
+inline Column_node* Join_node::get_const_column_node(const Field* field)
+{
+  return get_const_ordered_table_node(field->table)->get_const_column_node(field);
+}
+
+inline void Join_node::add_const_column(const Field* field)
+{
+  Column_node* column= get_const_column_node(field);
+  init_nodes.push_back(column);
+}
+
+void Join_node::add_equi_column(const Field* left, const Field* right)
+{
+  Column_node* left_column= get_const_column_node(left);
+  Column_node* right_column= get_const_column_node(right);
+  left_column->add_successor(right_column);
+  right_column->add_successor(left_column);
+
+  left_column= get_ordered_column_node(left);
+  right_column= get_ordered_column_node(right);
+  left_column->add_successor(right_column);
+  right_column->add_successor(left_column);
+}
+
+void Join_node::add_const_equi_columns(COND* cond)
+{
+  if (!cond)
+    return;
+  if (is_cond_or(cond))
+    return;
+  if (is_cond_and(cond))
+  {
+    List<Item> *args= ((Item_cond*) cond)->argument_list();
+    List_iterator<COND> 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);
+
+    bool variable_field= false;
+    for (i=0; i<arg_count; i++)
+    {
+      if (args[i]->real_item()->type() == Item::FIELD_ITEM &&
+          (variable_field= field_belongs_to_tables(((Item_field*)args[i]->real_item())->field)))
+      {
+        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() ||
+               !variable_field)
+      {
+        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 Join_node::add_ordered_columns(const 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;
+      Column_node* column= get_ordered_column_node(field);
+      init_nodes.push_back(column);
+    }
+  }
+}
+
+bool Join_node::is_ordered() const
+{
+  List<Node> nodes(init_nodes);
+  List_iterator<Node> it(nodes);
+  Node *node;
+
+  while ((node= it++))
+  {
+    node->todo--;
+    if (node->todo == 0)
+    {
+      if (node == this)
+        return true;
+      List_iterator<Node> 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<TABLE_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;
+
+  Join_node 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;
+
+  Join_node root(table, cond, order);
+  return root.is_ordered();
+}
+
 /*
    checks if we have select tables in the table list and write tables
    with auto-increment column.

=== modified file 'Percona-Server/sql/sql_base.h'
--- Percona-Server/sql/sql_base.h	2013-03-20 05:31:58 +0000
+++ Percona-Server/sql/sql_base.h	2013-06-26 17:10:34 +0000
@@ -288,6 +288,10 @@
 bool rename_temporary_table(THD* thd, TABLE *table, const char *new_db,
 			    const char *table_name);
 bool is_equal(const LEX_STRING *a, const LEX_STRING *b);
+bool is_order_deterministic(List<TABLE_LIST>* join_list,
+                            COND* cond, ORDER* order);
+bool is_order_deterministic(TABLE_LIST *table,
+                            COND *cond, ORDER* order);
 
 /* Functions to work with system tables. */
 bool open_system_tables_for_read(THD *thd, TABLE_LIST *table_list,

=== modified file 'Percona-Server/sql/sql_class.cc'
--- Percona-Server/sql/sql_class.cc	2013-05-21 16:37:02 +0000
+++ Percona-Server/sql/sql_class.cc	2013-06-26 17:10:34 +0000
@@ -848,6 +848,7 @@
               /* statement id */ 0),
    rli_fake(0), rli_slave(NULL),
    user_time(0), in_sub_stmt(0),
+   order_deterministic(false),
    binlog_unsafe_warning_flags(0),
    binlog_table_maps(0),
    table_map_for_update(0),
@@ -5262,6 +5263,32 @@
               sizeof(binlog_unsafe_warning_flags) * CHAR_BIT);
 
   uint32 unsafe_type_flags= binlog_unsafe_warning_flags;
+
+  if ((unsafe_type_flags & (1U << LEX::BINLOG_STMT_UNSAFE_LIMIT)) != 0)
+  {
+    if ((lex->sql_command == SQLCOM_DELETE || lex->sql_command == SQLCOM_UPDATE) &&
+        lex->select_lex.select_limit)
+    {
+      ORDER *order= (ORDER *) ((lex->select_lex.order_list.elements) ?
+                               lex->select_lex.order_list.first : NULL);
+      if ((lex->select_lex.select_limit &&
+           lex->select_lex.select_limit->fixed &&
+           lex->select_lex.select_limit->val_int() == 0) ||
+          is_order_deterministic(lex->query_tables,
+                                   lex->select_lex.where, order))
+      {
+        unsafe_type_flags&= ~(1U << LEX::BINLOG_STMT_UNSAFE_LIMIT);
+      }
+    }
+    if ((lex->sql_command == SQLCOM_INSERT_SELECT ||
+         lex->sql_command == SQLCOM_REPLACE_SELECT) &&
+        order_deterministic)
+    {
+      unsafe_type_flags&= ~(1U << LEX::BINLOG_STMT_UNSAFE_LIMIT);
+    }
+
+  }
+
   /*
     For each unsafe_type, check if the statement is unsafe in this way
     and issue a warning.
@@ -5360,8 +5387,10 @@
   */
   if ((variables.option_bits & OPTION_BIN_LOG) &&
       spcont == NULL && !binlog_evt_union.do_union)
+  {
     issue_unsafe_warnings();
-
+    order_deterministic= true;
+  }
 
   switch (qtype) {
     /*

=== modified file 'Percona-Server/sql/sql_class.h'
--- Percona-Server/sql/sql_class.h	2013-05-21 16:37:02 +0000
+++ Percona-Server/sql/sql_class.h	2013-06-26 17:10:34 +0000
@@ -1732,6 +1732,8 @@
   /* container for handler's private per-connection data */
   Ha_data ha_data[MAX_HA];
 
+  bool order_deterministic;
+
 #ifndef MYSQL_CLIENT
   int binlog_setup_trx_data();
 

=== modified file 'Percona-Server/sql/sql_lex.h'
--- Percona-Server/sql/sql_lex.h	2013-05-23 08:39:28 +0000
+++ Percona-Server/sql/sql_lex.h	2013-06-26 17:10:34 +0000
@@ -1365,6 +1365,17 @@
   static const int binlog_stmt_unsafe_errcode[BINLOG_STMT_UNSAFE_COUNT];
 
   /**
+    Determine if this statement is marked as unsafe with
+    specific type
+
+    @retval false if the statement is not marked as unsafe.
+    @retval true if it is.
+  */
+  inline bool is_stmt_unsafe(enum_binlog_stmt_unsafe unsafe_type) const {
+    return ((binlog_stmt_flags & (1U << unsafe_type)) != 0);
+  }
+
+  /**
     Determine if this statement is marked as unsafe.
 
     @retval 0 if the statement is not marked as unsafe.

=== modified file 'Percona-Server/sql/sql_select.cc'
--- Percona-Server/sql/sql_select.cc	2013-05-21 16:37:02 +0000
+++ Percona-Server/sql/sql_select.cc	2013-06-26 17:10:34 +0000
@@ -977,6 +977,25 @@
     }
   }
 
+  if (thd->lex->sql_command == SQLCOM_INSERT_SELECT ||
+      thd->lex->sql_command == SQLCOM_REPLACE_SELECT)
+  {
+    /*
+      Statement-based replication of INSERT ... SELECT ... LIMIT and
+      REPLACE ... SELECT is safe as order of row is defined with either
+      ORDER BY or other condition. However it is too late for it have
+      an impact to our decision to switch to row- based. We can only
+      suppress warning here.
+    */
+    if (select_lex->select_limit &&
+        select_lex->select_limit->fixed &&
+        select_lex->select_limit->val_int() &&
+        !is_order_deterministic(join_list, conds, order))
+    {
+      thd->order_deterministic= false;
+    }
+  }
+
 #ifdef WITH_PARTITION_STORAGE_ENGINE
   {
     TABLE_LIST *tbl;

=== modified file 'Percona-Server/sql/sql_yacc.yy'
--- Percona-Server/sql/sql_yacc.yy	2013-05-15 05:05:18 +0000
+++ Percona-Server/sql/sql_yacc.yy	2013-06-26 17:10:34 +0000
@@ -9962,7 +9962,11 @@
 limit_clause:
           LIMIT limit_options
           {
-            Lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_LIMIT);
+            if (Select->select_limit->fixed &&
+                Select->select_limit->val_int() != 0)
+            {
+              Lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_LIMIT);
+            }
           }
         ;
 
@@ -10059,7 +10063,11 @@
           {
             SELECT_LEX *sel= Select;
             sel->select_limit= $2;
-            Lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_LIMIT);
+            if (Select->select_limit->fixed &&
+                Select->select_limit->val_int() != 0)
+            {
+              Lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_LIMIT);
+            }
             sel->explicit_limit= 1;
           }
         ;