1CREATE TABLE t (nokey INT, pk INT PRIMARY KEY, nnuk INT NOT NULL UNIQUE KEY, nuk INT UNIQUE KEY, 2nnuk1 INT NOT NULL, nnuk2 INT NOT NULL, UNIQUE KEY(nnuk1, nnuk2), 3nnuk_str_long VARCHAR(512) NOT NULL UNIQUE KEY, 4nnuk_str_short VARCHAR(50) NOT NULL UNIQUE KEY); 5CREATE TABLE t1 LIKE t; 6CREATE TABLE t2 LIKE t; 7CREATE TABLE t3 LIKE t; 8CREATE TABLE t4 LIKE t; 9CREATE TABLE queries (query VARCHAR(1024) NOT NULL); 10CREATE TABLE result_queries (id INT AUTO_INCREMENT PRIMARY KEY, query VARCHAR(1024) NOT NULL); 11CREATE TABLE limits (`limit` VARCHAR(256) NOT NULL); 12INSERT INTO queries(query) VALUES 13('UPDATE t SET nokey = nokey + 10 [LIMIT_1]'), 14('UPDATE t SET nokey = nokey + 10 WHERE nokey=1 [LIMIT_1]'), 15('UPDATE t SET nokey = nokey + 10 WHERE nuk=1 [LIMIT_1]'), 16('UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 [LIMIT_1]'), 17('UPDATE t SET nokey = nokey + 10 WHERE pk=1 [LIMIT_1]'), 18('DELETE FROM t [LIMIT_1]'), 19('DELETE FROM t WHERE nokey=1 [LIMIT_1]'), 20('DELETE FROM t WHERE nuk=1 [LIMIT_1]'), 21('DELETE FROM t WHERE nnuk=1 [LIMIT_1]'), 22('DELETE FROM t WHERE pk=1 [LIMIT_1]'), 23('REPLACE INTO t SELECT * FROM t1 [LIMIT_1]'), 24('REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 [LIMIT_1]'), 25('REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 [LIMIT_1]'), 26('REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 [LIMIT_1]'), 27('REPLACE INTO t SELECT * FROM t1 WHERE pk=1 [LIMIT_1]'), 28('INSERT INTO t SELECT * FROM t1 [LIMIT_1]'), 29('INSERT INTO t SELECT * FROM t1 WHERE nokey=1 [LIMIT_1]'), 30('INSERT INTO t SELECT * FROM t1 WHERE nuk=1 [LIMIT_1]'), 31('INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 [LIMIT_1]'), 32('INSERT INTO t SELECT * FROM t1 WHERE pk=1 [LIMIT_1]'), 33('INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) [LIMIT_1]'), 34('INSERT INTO t (SELECT * FROM t1 [LIMIT_1]) UNION (SELECT * FROM t2)'), 35('INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 [LIMIT_1])'), 36('INSERT INTO t (SELECT * FROM t1 [LIMIT_1]) UNION (SELECT * FROM t2 [LIMIT_2])'), 37('INSERT INTO t SELECT * FROM (SELECT * FROM t1 [LIMIT_1]) AS subselect [LIMIT_2]'), 38('INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) [LIMIT_1]'), 39('INSERT INTO t SELECT t1.* FROM t1, t2 [LIMIT_1]'), 40('INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey [LIMIT_1]'), 41('INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk [LIMIT_1]'), 42('INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk [LIMIT_1]'), 43('INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk [LIMIT_1]'), 44('INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 [LIMIT_1]'), 45('INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) [LIMIT_1]'), 46('INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 [LIMIT_1]'), 47('INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 [LIMIT_1]'), 48('INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) [LIMIT_1]'), 49('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]'), 50('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]'), 51('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]'), 52('INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk [LIMIT_1]'), 53('INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk [LIMIT_1]'); 54INSERT INTO limits (`limit`) VALUES 55('LIMIT 0'), 56('LIMIT 1'), 57('ORDER BY nokey LIMIT 1'), 58('ORDER BY nuk LIMIT 1'), 59('ORDER BY nnuk1 LIMIT 1'), 60('ORDER BY nnuk LIMIT 1'), 61('ORDER BY nnuk_str_short LIMIT 1'), 62('ORDER BY nnuk_str_long LIMIT 1'), 63('ORDER BY pk LIMIT 1'), 64('ORDER BY nnuk1, nnuk2 LIMIT 1'), 65('ORDER BY nnuk1, nnuk2, nokey LIMIT 1'), 66('ORDER BY nnuk1, nokey, nnuk2 LIMIT 1'); 67CREATE PROCEDURE gen_queries() 68BEGIN 69DECLARE done INT DEFAULT 0; 70DECLARE q VARCHAR(1024); 71DECLARE limit1, limit2 VARCHAR(256); 72DECLARE qcur CURSOR FOR SELECT * FROM queries; 73DECLARE lcur1 CURSOR FOR SELECT * FROM limits; 74DECLARE lcur2 CURSOR FOR SELECT * FROM limits; 75DECLARE CONTINUE HANDLER FOR NOT FOUND SET done=1; 76OPEN qcur; 77FETCH qcur INTO q; 78WHILE done <> 1 DO 79OPEN lcur1; 80FETCH lcur1 INTO limit1; 81WHILE done <> 1 DO 82IF LOCATE('[LIMIT_2]', q) > 0 THEN 83OPEN lcur2; 84FETCH lcur2 INTO limit2; 85WHILE done <> 1 DO 86SELECT REPLACE(REPLACE(q, '[LIMIT_1]', limit1), '[LIMIT_2]', limit2) INTO @query; 87FETCH lcur2 INTO limit2; 88END WHILE; 89CLOSE lcur2; 90SET done = 0; 91ELSE 92SELECT REPLACE(q, '[LIMIT_1]', limit1) INTO @query; 93END IF; 94INSERT INTO result_queries set query=@query; 95FETCH lcur1 INTO limit1; 96END WHILE; 97CLOSE lcur1; 98SET done = 0; 99FETCH qcur INTO q; 100END WHILE; 101CLOSE qcur; 102END| 103call gen_queries(); 104SET MAX_SORT_LENGTH=50; 105UPDATE t SET nokey = nokey + 10 LIMIT 0; 106ROWS in table t: 2 107UPDATE t SET nokey = nokey + 10 LIMIT 1; 108Warnings: 109Note 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. 110ROWS in table t: 2 111UPDATE t SET nokey = nokey + 10 ORDER BY nokey LIMIT 1; 112Warnings: 113Note 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. 114ROWS in table t: 2 115UPDATE t SET nokey = nokey + 10 ORDER BY nuk LIMIT 1; 116Warnings: 117Note 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. 118ROWS in table t: 2 119UPDATE t SET nokey = nokey + 10 ORDER BY nnuk1 LIMIT 1; 120Warnings: 121Note 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. 122ROWS in table t: 2 123UPDATE t SET nokey = nokey + 10 ORDER BY nnuk LIMIT 1; 124ROWS in table t: 2 125UPDATE t SET nokey = nokey + 10 ORDER BY nnuk_str_short LIMIT 1; 126ROWS in table t: 2 127UPDATE t SET nokey = nokey + 10 ORDER BY nnuk_str_long LIMIT 1; 128Warnings: 129Note 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. 130ROWS in table t: 2 131UPDATE t SET nokey = nokey + 10 ORDER BY pk LIMIT 1; 132ROWS in table t: 2 133UPDATE t SET nokey = nokey + 10 ORDER BY nnuk1, nnuk2 LIMIT 1; 134ROWS in table t: 2 135UPDATE t SET nokey = nokey + 10 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 136ROWS in table t: 2 137UPDATE t SET nokey = nokey + 10 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 138ROWS in table t: 2 139UPDATE t SET nokey = nokey + 10 WHERE nokey=1 LIMIT 0; 140ROWS in table t: 2 141UPDATE t SET nokey = nokey + 10 WHERE nokey=1 LIMIT 1; 142Warnings: 143Note 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. 144ROWS in table t: 2 145UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nokey LIMIT 1; 146Warnings: 147Note 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. 148ROWS in table t: 2 149UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nuk LIMIT 1; 150Warnings: 151Note 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. 152ROWS in table t: 2 153UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk1 LIMIT 1; 154Warnings: 155Note 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. 156ROWS in table t: 2 157UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk LIMIT 1; 158ROWS in table t: 2 159UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk_str_short LIMIT 1; 160ROWS in table t: 2 161UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk_str_long LIMIT 1; 162Warnings: 163Note 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. 164ROWS in table t: 2 165UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY pk LIMIT 1; 166ROWS in table t: 2 167UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 168ROWS in table t: 2 169UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 170ROWS in table t: 2 171UPDATE t SET nokey = nokey + 10 WHERE nokey=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 172ROWS in table t: 2 173UPDATE t SET nokey = nokey + 10 WHERE nuk=1 LIMIT 0; 174ROWS in table t: 2 175UPDATE t SET nokey = nokey + 10 WHERE nuk=1 LIMIT 1; 176Warnings: 177Note 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. 178ROWS in table t: 2 179UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nokey LIMIT 1; 180Warnings: 181Note 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. 182ROWS in table t: 2 183UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nuk LIMIT 1; 184Warnings: 185Note 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. 186ROWS in table t: 2 187UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk1 LIMIT 1; 188Warnings: 189Note 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. 190ROWS in table t: 2 191UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk LIMIT 1; 192ROWS in table t: 2 193UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk_str_short LIMIT 1; 194ROWS in table t: 2 195UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk_str_long LIMIT 1; 196Warnings: 197Note 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. 198ROWS in table t: 2 199UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY pk LIMIT 1; 200ROWS in table t: 2 201UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 202ROWS in table t: 2 203UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 204ROWS in table t: 2 205UPDATE t SET nokey = nokey + 10 WHERE nuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 206ROWS in table t: 2 207UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 LIMIT 0; 208ROWS in table t: 2 209UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 LIMIT 1; 210ROWS in table t: 2 211UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nokey LIMIT 1; 212ROWS in table t: 2 213UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nuk LIMIT 1; 214ROWS in table t: 2 215UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk1 LIMIT 1; 216ROWS in table t: 2 217UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk LIMIT 1; 218ROWS in table t: 2 219UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk_str_short LIMIT 1; 220ROWS in table t: 2 221UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk_str_long LIMIT 1; 222ROWS in table t: 2 223UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY pk LIMIT 1; 224ROWS in table t: 2 225UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 226ROWS in table t: 2 227UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 228ROWS in table t: 2 229UPDATE t SET nokey = nokey + 10 WHERE nnuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 230ROWS in table t: 2 231UPDATE t SET nokey = nokey + 10 WHERE pk=1 LIMIT 0; 232ROWS in table t: 2 233UPDATE t SET nokey = nokey + 10 WHERE pk=1 LIMIT 1; 234ROWS in table t: 2 235UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nokey LIMIT 1; 236ROWS in table t: 2 237UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nuk LIMIT 1; 238ROWS in table t: 2 239UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk1 LIMIT 1; 240ROWS in table t: 2 241UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk LIMIT 1; 242ROWS in table t: 2 243UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk_str_short LIMIT 1; 244ROWS in table t: 2 245UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk_str_long LIMIT 1; 246ROWS in table t: 2 247UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY pk LIMIT 1; 248ROWS in table t: 2 249UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 250ROWS in table t: 2 251UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 252ROWS in table t: 2 253UPDATE t SET nokey = nokey + 10 WHERE pk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 254ROWS in table t: 2 255DELETE FROM t LIMIT 0; 256ROWS in table t: 2 257DELETE FROM t LIMIT 1; 258Warnings: 259Note 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. 260ROWS in table t: 1 261DELETE FROM t ORDER BY nokey LIMIT 1; 262Warnings: 263Note 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. 264ROWS in table t: 1 265DELETE FROM t ORDER BY nuk LIMIT 1; 266Warnings: 267Note 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. 268ROWS in table t: 1 269DELETE FROM t ORDER BY nnuk1 LIMIT 1; 270Warnings: 271Note 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. 272ROWS in table t: 1 273DELETE FROM t ORDER BY nnuk LIMIT 1; 274ROWS in table t: 1 275DELETE FROM t ORDER BY nnuk_str_short LIMIT 1; 276ROWS in table t: 1 277DELETE FROM t ORDER BY nnuk_str_long LIMIT 1; 278Warnings: 279Note 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. 280ROWS in table t: 1 281DELETE FROM t ORDER BY pk LIMIT 1; 282ROWS in table t: 1 283DELETE FROM t ORDER BY nnuk1, nnuk2 LIMIT 1; 284ROWS in table t: 1 285DELETE FROM t ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 286ROWS in table t: 1 287DELETE FROM t ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 288ROWS in table t: 1 289DELETE FROM t WHERE nokey=1 LIMIT 0; 290ROWS in table t: 2 291DELETE FROM t WHERE nokey=1 LIMIT 1; 292Warnings: 293Note 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. 294ROWS in table t: 1 295DELETE FROM t WHERE nokey=1 ORDER BY nokey LIMIT 1; 296Warnings: 297Note 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. 298ROWS in table t: 1 299DELETE FROM t WHERE nokey=1 ORDER BY nuk LIMIT 1; 300Warnings: 301Note 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. 302ROWS in table t: 1 303DELETE FROM t WHERE nokey=1 ORDER BY nnuk1 LIMIT 1; 304Warnings: 305Note 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. 306ROWS in table t: 1 307DELETE FROM t WHERE nokey=1 ORDER BY nnuk LIMIT 1; 308ROWS in table t: 1 309DELETE FROM t WHERE nokey=1 ORDER BY nnuk_str_short LIMIT 1; 310ROWS in table t: 1 311DELETE FROM t WHERE nokey=1 ORDER BY nnuk_str_long LIMIT 1; 312Warnings: 313Note 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. 314ROWS in table t: 1 315DELETE FROM t WHERE nokey=1 ORDER BY pk LIMIT 1; 316ROWS in table t: 1 317DELETE FROM t WHERE nokey=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 318ROWS in table t: 1 319DELETE FROM t WHERE nokey=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 320ROWS in table t: 1 321DELETE FROM t WHERE nokey=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 322ROWS in table t: 1 323DELETE FROM t WHERE nuk=1 LIMIT 0; 324ROWS in table t: 2 325DELETE FROM t WHERE nuk=1 LIMIT 1; 326Warnings: 327Note 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. 328ROWS in table t: 1 329DELETE FROM t WHERE nuk=1 ORDER BY nokey LIMIT 1; 330Warnings: 331Note 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. 332ROWS in table t: 1 333DELETE FROM t WHERE nuk=1 ORDER BY nuk LIMIT 1; 334Warnings: 335Note 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. 336ROWS in table t: 1 337DELETE FROM t WHERE nuk=1 ORDER BY nnuk1 LIMIT 1; 338Warnings: 339Note 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. 340ROWS in table t: 1 341DELETE FROM t WHERE nuk=1 ORDER BY nnuk LIMIT 1; 342ROWS in table t: 1 343DELETE FROM t WHERE nuk=1 ORDER BY nnuk_str_short LIMIT 1; 344ROWS in table t: 1 345DELETE FROM t WHERE nuk=1 ORDER BY nnuk_str_long LIMIT 1; 346Warnings: 347Note 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. 348ROWS in table t: 1 349DELETE FROM t WHERE nuk=1 ORDER BY pk LIMIT 1; 350ROWS in table t: 1 351DELETE FROM t WHERE nuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 352ROWS in table t: 1 353DELETE FROM t WHERE nuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 354ROWS in table t: 1 355DELETE FROM t WHERE nuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 356ROWS in table t: 1 357DELETE FROM t WHERE nnuk=1 LIMIT 0; 358ROWS in table t: 2 359DELETE FROM t WHERE nnuk=1 LIMIT 1; 360ROWS in table t: 1 361DELETE FROM t WHERE nnuk=1 ORDER BY nokey LIMIT 1; 362ROWS in table t: 1 363DELETE FROM t WHERE nnuk=1 ORDER BY nuk LIMIT 1; 364ROWS in table t: 1 365DELETE FROM t WHERE nnuk=1 ORDER BY nnuk1 LIMIT 1; 366ROWS in table t: 1 367DELETE FROM t WHERE nnuk=1 ORDER BY nnuk LIMIT 1; 368ROWS in table t: 1 369DELETE FROM t WHERE nnuk=1 ORDER BY nnuk_str_short LIMIT 1; 370ROWS in table t: 1 371DELETE FROM t WHERE nnuk=1 ORDER BY nnuk_str_long LIMIT 1; 372ROWS in table t: 1 373DELETE FROM t WHERE nnuk=1 ORDER BY pk LIMIT 1; 374ROWS in table t: 1 375DELETE FROM t WHERE nnuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 376ROWS in table t: 1 377DELETE FROM t WHERE nnuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 378ROWS in table t: 1 379DELETE FROM t WHERE nnuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 380ROWS in table t: 1 381DELETE FROM t WHERE pk=1 LIMIT 0; 382ROWS in table t: 2 383DELETE FROM t WHERE pk=1 LIMIT 1; 384ROWS in table t: 1 385DELETE FROM t WHERE pk=1 ORDER BY nokey LIMIT 1; 386ROWS in table t: 1 387DELETE FROM t WHERE pk=1 ORDER BY nuk LIMIT 1; 388ROWS in table t: 1 389DELETE FROM t WHERE pk=1 ORDER BY nnuk1 LIMIT 1; 390ROWS in table t: 1 391DELETE FROM t WHERE pk=1 ORDER BY nnuk LIMIT 1; 392ROWS in table t: 1 393DELETE FROM t WHERE pk=1 ORDER BY nnuk_str_short LIMIT 1; 394ROWS in table t: 1 395DELETE FROM t WHERE pk=1 ORDER BY nnuk_str_long LIMIT 1; 396ROWS in table t: 1 397DELETE FROM t WHERE pk=1 ORDER BY pk LIMIT 1; 398ROWS in table t: 1 399DELETE FROM t WHERE pk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 400ROWS in table t: 1 401DELETE FROM t WHERE pk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 402ROWS in table t: 1 403DELETE FROM t WHERE pk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 404ROWS in table t: 1 405REPLACE INTO t SELECT * FROM t1 LIMIT 0; 406Warnings: 407Note 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. 408ROWS in table t: 2 409REPLACE INTO t SELECT * FROM t1 LIMIT 1; 410Warnings: 411Note 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. 412Note 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. 413ROWS in table t: 3 414REPLACE INTO t SELECT * FROM t1 ORDER BY nokey LIMIT 1; 415Warnings: 416Note 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. 417Note 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. 418ROWS in table t: 3 419REPLACE INTO t SELECT * FROM t1 ORDER BY nuk LIMIT 1; 420Warnings: 421Note 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. 422Note 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. 423ROWS in table t: 3 424REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk1 LIMIT 1; 425Warnings: 426Note 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. 427Note 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. 428ROWS in table t: 3 429REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk LIMIT 1; 430Warnings: 431Note 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. 432ROWS in table t: 3 433REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk_str_short LIMIT 1; 434Warnings: 435Note 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. 436ROWS in table t: 3 437REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk_str_long LIMIT 1; 438Warnings: 439Note 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. 440Note 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. 441ROWS in table t: 3 442REPLACE INTO t SELECT * FROM t1 ORDER BY pk LIMIT 1; 443Warnings: 444Note 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. 445ROWS in table t: 3 446REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk1, nnuk2 LIMIT 1; 447Warnings: 448Note 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. 449ROWS in table t: 3 450REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 451Warnings: 452Note 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. 453ROWS in table t: 3 454REPLACE INTO t SELECT * FROM t1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 455Warnings: 456Note 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. 457ROWS in table t: 3 458REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 LIMIT 0; 459Warnings: 460Note 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. 461ROWS in table t: 2 462REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 LIMIT 1; 463Warnings: 464Note 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. 465Note 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. 466ROWS in table t: 2 467REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nokey LIMIT 1; 468Warnings: 469Note 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. 470Note 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. 471ROWS in table t: 2 472REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nuk LIMIT 1; 473Warnings: 474Note 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. 475Note 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. 476ROWS in table t: 2 477REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1 LIMIT 1; 478Warnings: 479Note 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. 480Note 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. 481ROWS in table t: 2 482REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk LIMIT 1; 483Warnings: 484Note 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. 485ROWS in table t: 2 486REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk_str_short LIMIT 1; 487Warnings: 488Note 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. 489ROWS in table t: 2 490REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk_str_long LIMIT 1; 491Warnings: 492Note 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. 493Note 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. 494ROWS in table t: 2 495REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY pk LIMIT 1; 496Warnings: 497Note 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. 498ROWS in table t: 2 499REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 500Warnings: 501Note 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. 502ROWS in table t: 2 503REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 504Warnings: 505Note 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. 506ROWS in table t: 2 507REPLACE INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 508Warnings: 509Note 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. 510ROWS in table t: 2 511REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 LIMIT 0; 512Warnings: 513Note 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. 514ROWS in table t: 2 515REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 LIMIT 1; 516Warnings: 517Note 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. 518Note 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. 519ROWS in table t: 2 520REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nokey LIMIT 1; 521Warnings: 522Note 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. 523Note 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. 524ROWS in table t: 2 525REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nuk LIMIT 1; 526Warnings: 527Note 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. 528Note 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. 529ROWS in table t: 2 530REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1 LIMIT 1; 531Warnings: 532Note 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. 533Note 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. 534ROWS in table t: 2 535REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk LIMIT 1; 536Warnings: 537Note 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. 538ROWS in table t: 2 539REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk_str_short LIMIT 1; 540Warnings: 541Note 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. 542ROWS in table t: 2 543REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk_str_long LIMIT 1; 544Warnings: 545Note 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. 546Note 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. 547ROWS in table t: 2 548REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY pk LIMIT 1; 549Warnings: 550Note 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. 551ROWS in table t: 2 552REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 553Warnings: 554Note 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. 555ROWS in table t: 2 556REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 557Warnings: 558Note 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. 559ROWS in table t: 2 560REPLACE INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 561Warnings: 562Note 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. 563ROWS in table t: 2 564REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 LIMIT 0; 565Warnings: 566Note 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. 567ROWS in table t: 2 568REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 LIMIT 1; 569Warnings: 570Note 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. 571ROWS in table t: 2 572REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nokey LIMIT 1; 573Warnings: 574Note 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. 575ROWS in table t: 2 576REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nuk LIMIT 1; 577Warnings: 578Note 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. 579ROWS in table t: 2 580REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1 LIMIT 1; 581Warnings: 582Note 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. 583ROWS in table t: 2 584REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk LIMIT 1; 585Warnings: 586Note 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. 587ROWS in table t: 2 588REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk_str_short LIMIT 1; 589Warnings: 590Note 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. 591ROWS in table t: 2 592REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk_str_long LIMIT 1; 593Warnings: 594Note 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. 595ROWS in table t: 2 596REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY pk LIMIT 1; 597Warnings: 598Note 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. 599ROWS in table t: 2 600REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 601Warnings: 602Note 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. 603ROWS in table t: 2 604REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 605Warnings: 606Note 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. 607ROWS in table t: 2 608REPLACE INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 609Warnings: 610Note 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. 611ROWS in table t: 2 612REPLACE INTO t SELECT * FROM t1 WHERE pk=1 LIMIT 0; 613Warnings: 614Note 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. 615ROWS in table t: 2 616REPLACE INTO t SELECT * FROM t1 WHERE pk=1 LIMIT 1; 617Warnings: 618Note 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. 619ROWS in table t: 2 620REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nokey LIMIT 1; 621Warnings: 622Note 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. 623ROWS in table t: 2 624REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nuk LIMIT 1; 625Warnings: 626Note 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. 627ROWS in table t: 2 628REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1 LIMIT 1; 629Warnings: 630Note 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. 631ROWS in table t: 2 632REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk LIMIT 1; 633Warnings: 634Note 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. 635ROWS in table t: 2 636REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk_str_short LIMIT 1; 637Warnings: 638Note 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. 639ROWS in table t: 2 640REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk_str_long LIMIT 1; 641Warnings: 642Note 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. 643ROWS in table t: 2 644REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY pk LIMIT 1; 645Warnings: 646Note 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. 647ROWS in table t: 2 648REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 649Warnings: 650Note 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. 651ROWS in table t: 2 652REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 653Warnings: 654Note 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. 655ROWS in table t: 2 656REPLACE INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 657Warnings: 658Note 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. 659ROWS in table t: 2 660INSERT INTO t SELECT * FROM t1 LIMIT 0; 661ROWS in table t: 2 662INSERT INTO t SELECT * FROM t1 LIMIT 1; 663Warnings: 664Note 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. 665ROWS in table t: 3 666INSERT INTO t SELECT * FROM t1 ORDER BY nokey LIMIT 1; 667Warnings: 668Note 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. 669ROWS in table t: 3 670INSERT INTO t SELECT * FROM t1 ORDER BY nuk LIMIT 1; 671Warnings: 672Note 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. 673ROWS in table t: 3 674INSERT INTO t SELECT * FROM t1 ORDER BY nnuk1 LIMIT 1; 675Warnings: 676Note 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. 677ROWS in table t: 3 678INSERT INTO t SELECT * FROM t1 ORDER BY nnuk LIMIT 1; 679ROWS in table t: 3 680INSERT INTO t SELECT * FROM t1 ORDER BY nnuk_str_short LIMIT 1; 681ROWS in table t: 3 682INSERT INTO t SELECT * FROM t1 ORDER BY nnuk_str_long LIMIT 1; 683Warnings: 684Note 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. 685ROWS in table t: 3 686INSERT INTO t SELECT * FROM t1 ORDER BY pk LIMIT 1; 687ROWS in table t: 3 688INSERT INTO t SELECT * FROM t1 ORDER BY nnuk1, nnuk2 LIMIT 1; 689ROWS in table t: 3 690INSERT INTO t SELECT * FROM t1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 691ROWS in table t: 3 692INSERT INTO t SELECT * FROM t1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 693ROWS in table t: 3 694INSERT INTO t SELECT * FROM t1 WHERE nokey=1 LIMIT 0; 695ROWS in table t: 2 696INSERT INTO t SELECT * FROM t1 WHERE nokey=1 LIMIT 1; 697Warnings: 698Note 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. 699ROWS in table t: 2 700INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nokey LIMIT 1; 701Warnings: 702Note 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. 703ROWS in table t: 2 704INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nuk LIMIT 1; 705Warnings: 706Note 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. 707ROWS in table t: 2 708INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1 LIMIT 1; 709Warnings: 710Note 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. 711ROWS in table t: 2 712INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk LIMIT 1; 713ROWS in table t: 2 714INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk_str_short LIMIT 1; 715ROWS in table t: 2 716INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk_str_long LIMIT 1; 717Warnings: 718Note 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. 719ROWS in table t: 2 720INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY pk LIMIT 1; 721ROWS in table t: 2 722INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 723ROWS in table t: 2 724INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 725ROWS in table t: 2 726INSERT INTO t SELECT * FROM t1 WHERE nokey=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 727ROWS in table t: 2 728INSERT INTO t SELECT * FROM t1 WHERE nuk=1 LIMIT 0; 729ROWS in table t: 2 730INSERT INTO t SELECT * FROM t1 WHERE nuk=1 LIMIT 1; 731Warnings: 732Note 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. 733ROWS in table t: 2 734INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nokey LIMIT 1; 735Warnings: 736Note 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. 737ROWS in table t: 2 738INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nuk LIMIT 1; 739Warnings: 740Note 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. 741ROWS in table t: 2 742INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1 LIMIT 1; 743Warnings: 744Note 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. 745ROWS in table t: 2 746INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk LIMIT 1; 747ROWS in table t: 2 748INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk_str_short LIMIT 1; 749ROWS in table t: 2 750INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk_str_long LIMIT 1; 751Warnings: 752Note 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. 753ROWS in table t: 2 754INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY pk LIMIT 1; 755ROWS in table t: 2 756INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 757ROWS in table t: 2 758INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 759ROWS in table t: 2 760INSERT INTO t SELECT * FROM t1 WHERE nuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 761ROWS in table t: 2 762INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 LIMIT 0; 763ROWS in table t: 2 764INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 LIMIT 1; 765ROWS in table t: 2 766INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nokey LIMIT 1; 767ROWS in table t: 2 768INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nuk LIMIT 1; 769ROWS in table t: 2 770INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1 LIMIT 1; 771ROWS in table t: 2 772INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk LIMIT 1; 773ROWS in table t: 2 774INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk_str_short LIMIT 1; 775ROWS in table t: 2 776INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk_str_long LIMIT 1; 777ROWS in table t: 2 778INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY pk LIMIT 1; 779ROWS in table t: 2 780INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 781ROWS in table t: 2 782INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 783ROWS in table t: 2 784INSERT INTO t SELECT * FROM t1 WHERE nnuk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 785ROWS in table t: 2 786INSERT INTO t SELECT * FROM t1 WHERE pk=1 LIMIT 0; 787ROWS in table t: 2 788INSERT INTO t SELECT * FROM t1 WHERE pk=1 LIMIT 1; 789ROWS in table t: 2 790INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nokey LIMIT 1; 791ROWS in table t: 2 792INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nuk LIMIT 1; 793ROWS in table t: 2 794INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1 LIMIT 1; 795ROWS in table t: 2 796INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk LIMIT 1; 797ROWS in table t: 2 798INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk_str_short LIMIT 1; 799ROWS in table t: 2 800INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk_str_long LIMIT 1; 801ROWS in table t: 2 802INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY pk LIMIT 1; 803ROWS in table t: 2 804INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1, nnuk2 LIMIT 1; 805ROWS in table t: 2 806INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 807ROWS in table t: 2 808INSERT INTO t SELECT * FROM t1 WHERE pk=1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 809ROWS in table t: 2 810INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) LIMIT 0; 811ROWS in table t: 2 812INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) LIMIT 1; 813Warnings: 814Note 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. 815ROWS in table t: 3 816INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nokey LIMIT 1; 817Warnings: 818Note 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. 819ROWS in table t: 3 820INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nuk LIMIT 1; 821Warnings: 822Note 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. 823ROWS in table t: 3 824INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk1 LIMIT 1; 825Warnings: 826Note 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. 827ROWS in table t: 3 828INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk LIMIT 1; 829Warnings: 830Note 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. 831ROWS in table t: 3 832INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk_str_short LIMIT 1; 833Warnings: 834Note 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. 835ROWS in table t: 3 836INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk_str_long LIMIT 1; 837Warnings: 838Note 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. 839ROWS in table t: 3 840INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY pk LIMIT 1; 841Warnings: 842Note 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. 843ROWS in table t: 3 844INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk1, nnuk2 LIMIT 1; 845Warnings: 846Note 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. 847ROWS in table t: 3 848INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 849Warnings: 850Note 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. 851ROWS in table t: 3 852INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2) ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 853Warnings: 854Note 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. 855ROWS in table t: 3 856INSERT INTO t (SELECT * FROM t1 LIMIT 0) UNION (SELECT * FROM t2); 857ROWS in table t: 4 858INSERT INTO t (SELECT * FROM t1 LIMIT 1) UNION (SELECT * FROM t2); 859Warnings: 860Note 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. 861ROWS in table t: 5 862INSERT INTO t (SELECT * FROM t1 ORDER BY nokey LIMIT 1) UNION (SELECT * FROM t2); 863Warnings: 864Note 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. 865ROWS in table t: 5 866INSERT INTO t (SELECT * FROM t1 ORDER BY nuk LIMIT 1) UNION (SELECT * FROM t2); 867Warnings: 868Note 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. 869ROWS in table t: 5 870INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1 LIMIT 1) UNION (SELECT * FROM t2); 871Warnings: 872Note 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. 873ROWS in table t: 5 874INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk LIMIT 1) UNION (SELECT * FROM t2); 875ROWS in table t: 5 876INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk_str_short LIMIT 1) UNION (SELECT * FROM t2); 877ROWS in table t: 5 878INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk_str_long LIMIT 1) UNION (SELECT * FROM t2); 879Warnings: 880Note 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. 881ROWS in table t: 5 882INSERT INTO t (SELECT * FROM t1 ORDER BY pk LIMIT 1) UNION (SELECT * FROM t2); 883ROWS in table t: 5 884INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1, nnuk2 LIMIT 1) UNION (SELECT * FROM t2); 885ROWS in table t: 5 886INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1) UNION (SELECT * FROM t2); 887ROWS in table t: 5 888INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1) UNION (SELECT * FROM t2); 889ROWS in table t: 5 890INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 LIMIT 0); 891ROWS in table t: 4 892INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 LIMIT 1); 893Warnings: 894Note 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. 895ROWS in table t: 5 896INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nokey LIMIT 1); 897Warnings: 898Note 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. 899ROWS in table t: 5 900INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nuk LIMIT 1); 901Warnings: 902Note 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. 903ROWS in table t: 5 904INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk1 LIMIT 1); 905Warnings: 906Note 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. 907ROWS in table t: 5 908INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk LIMIT 1); 909ROWS in table t: 5 910INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk_str_short LIMIT 1); 911ROWS in table t: 5 912INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk_str_long LIMIT 1); 913Warnings: 914Note 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. 915ROWS in table t: 5 916INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY pk LIMIT 1); 917ROWS in table t: 5 918INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nnuk2 LIMIT 1); 919ROWS in table t: 5 920INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nnuk2, nokey LIMIT 1); 921ROWS in table t: 5 922INSERT INTO t (SELECT * FROM t1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); 923ROWS in table t: 5 924INSERT INTO t (SELECT * FROM t1 LIMIT 0) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); 925ROWS in table t: 3 926INSERT INTO t (SELECT * FROM t1 LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); 927Warnings: 928Note 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. 929ROWS in table t: 4 930INSERT INTO t (SELECT * FROM t1 ORDER BY nokey LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); 931Warnings: 932Note 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. 933ROWS in table t: 4 934INSERT INTO t (SELECT * FROM t1 ORDER BY nuk LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); 935Warnings: 936Note 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. 937ROWS in table t: 4 938INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1 LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); 939Warnings: 940Note 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. 941ROWS in table t: 4 942INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); 943ROWS in table t: 4 944INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk_str_short LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); 945ROWS in table t: 4 946INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk_str_long LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); 947Warnings: 948Note 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. 949ROWS in table t: 4 950INSERT INTO t (SELECT * FROM t1 ORDER BY pk LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); 951ROWS in table t: 4 952INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1, nnuk2 LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); 953ROWS in table t: 4 954INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); 955ROWS in table t: 4 956INSERT INTO t (SELECT * FROM t1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1) UNION (SELECT * FROM t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1); 957ROWS in table t: 4 958INSERT INTO t SELECT * FROM (SELECT * FROM t1 LIMIT 0) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 959Warnings: 960Note 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. 961ROWS in table t: 2 962INSERT INTO t SELECT * FROM (SELECT * FROM t1 LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 963Warnings: 964Note 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. 965ROWS in table t: 3 966INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nokey LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 967Warnings: 968Note 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. 969ROWS in table t: 3 970INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nuk LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 971Warnings: 972Note 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. 973ROWS in table t: 3 974INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk1 LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 975Warnings: 976Note 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. 977ROWS in table t: 3 978INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 979Warnings: 980Note 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. 981ROWS in table t: 3 982INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk_str_short LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 983Warnings: 984Note 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. 985ROWS in table t: 3 986INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk_str_long LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 987Warnings: 988Note 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. 989ROWS in table t: 3 990INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY pk LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 991Warnings: 992Note 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. 993ROWS in table t: 3 994INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk1, nnuk2 LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 995Warnings: 996Note 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. 997ROWS in table t: 3 998INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk1, nnuk2, nokey LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 999Warnings: 1000Note 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. 1001ROWS in table t: 3 1002INSERT INTO t SELECT * FROM (SELECT * FROM t1 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1) AS subselect ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 1003Warnings: 1004Note 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. 1005ROWS in table t: 3 1006INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) LIMIT 0; 1007ROWS in table t: 2 1008INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) LIMIT 1; 1009Warnings: 1010Note 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. 1011ROWS in table t: 2 1012INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY nokey LIMIT 1; 1013Warnings: 1014Note 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. 1015ROWS in table t: 2 1016INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY nuk LIMIT 1; 1017Warnings: 1018Note 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. 1019ROWS in table t: 2 1020INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY nnuk1 LIMIT 1; 1021Warnings: 1022Note 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. 1023ROWS in table t: 2 1024INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY nnuk LIMIT 1; 1025ROWS in table t: 2 1026INSERT 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; 1027ROWS in table t: 2 1028INSERT 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; 1029Warnings: 1030Note 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. 1031ROWS in table t: 2 1032INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY pk LIMIT 1; 1033ROWS in table t: 2 1034INSERT INTO t SELECT * FROM t1 WHERE pk IN (SELECT t2.pk FROM t2 WHERE t1.pk = t2.pk) ORDER BY nnuk1, nnuk2 LIMIT 1; 1035ROWS in table t: 2 1036INSERT 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; 1037ROWS in table t: 2 1038INSERT 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; 1039ROWS in table t: 2 1040INSERT INTO t SELECT t1.* FROM t1, t2 LIMIT 0; 1041ROWS in table t: 2 1042INSERT INTO t SELECT t1.* FROM t1, t2 LIMIT 1; 1043Warnings: 1044Note 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. 1045ROWS in table t: 3 1046INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nokey LIMIT 1; 1047Warnings: 1048Note 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. 1049ROWS in table t: 3 1050INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nuk LIMIT 1; 1051Warnings: 1052Note 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. 1053ROWS in table t: 3 1054INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk1 LIMIT 1; 1055Warnings: 1056Note 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. 1057ROWS in table t: 3 1058INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk LIMIT 1; 1059Warnings: 1060Note 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. 1061ROWS in table t: 3 1062INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk_str_short LIMIT 1; 1063Warnings: 1064Note 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. 1065ROWS in table t: 3 1066INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk_str_long LIMIT 1; 1067Warnings: 1068Note 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. 1069ROWS in table t: 3 1070INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY pk LIMIT 1; 1071Warnings: 1072Note 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. 1073ROWS in table t: 3 1074INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk1, nnuk2 LIMIT 1; 1075Warnings: 1076Note 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. 1077ROWS in table t: 3 1078INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 1079Warnings: 1080Note 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. 1081ROWS in table t: 3 1082INSERT INTO t SELECT t1.* FROM t1, t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 1083Warnings: 1084Note 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. 1085ROWS in table t: 3 1086INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey LIMIT 0; 1087ROWS in table t: 2 1088INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey LIMIT 1; 1089Warnings: 1090Note 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. 1091ROWS in table t: 2 1092INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nokey LIMIT 1; 1093Warnings: 1094Note 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. 1095ROWS in table t: 2 1096INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nuk LIMIT 1; 1097Warnings: 1098Note 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. 1099ROWS in table t: 2 1100INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk1 LIMIT 1; 1101Warnings: 1102Note 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. 1103ROWS in table t: 2 1104INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk LIMIT 1; 1105Warnings: 1106Note 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. 1107ROWS in table t: 2 1108INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk_str_short LIMIT 1; 1109Warnings: 1110Note 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. 1111ROWS in table t: 2 1112INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk_str_long LIMIT 1; 1113Warnings: 1114Note 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. 1115ROWS in table t: 2 1116INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY pk LIMIT 1; 1117Warnings: 1118Note 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. 1119ROWS in table t: 2 1120INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk1, nnuk2 LIMIT 1; 1121Warnings: 1122Note 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. 1123ROWS in table t: 2 1124INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 1125Warnings: 1126Note 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. 1127ROWS in table t: 2 1128INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nokey=t2.nokey ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 1129Warnings: 1130Note 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. 1131ROWS in table t: 2 1132INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk LIMIT 0; 1133ROWS in table t: 2 1134INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk LIMIT 1; 1135Warnings: 1136Note 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. 1137ROWS in table t: 2 1138INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nokey LIMIT 1; 1139Warnings: 1140Note 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. 1141ROWS in table t: 2 1142INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nuk LIMIT 1; 1143Warnings: 1144Note 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. 1145ROWS in table t: 2 1146INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nnuk1 LIMIT 1; 1147Warnings: 1148Note 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. 1149ROWS in table t: 2 1150INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nnuk LIMIT 1; 1151Warnings: 1152Note 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. 1153ROWS in table t: 2 1154INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nnuk_str_short LIMIT 1; 1155Warnings: 1156Note 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. 1157ROWS in table t: 2 1158INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nnuk_str_long LIMIT 1; 1159Warnings: 1160Note 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. 1161ROWS in table t: 2 1162INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY pk LIMIT 1; 1163Warnings: 1164Note 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. 1165ROWS in table t: 2 1166INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nnuk1, nnuk2 LIMIT 1; 1167Warnings: 1168Note 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. 1169ROWS in table t: 2 1170INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 1171Warnings: 1172Note 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. 1173ROWS in table t: 2 1174INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nuk=t2.nuk ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 1175Warnings: 1176Note 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. 1177ROWS in table t: 2 1178INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk LIMIT 0; 1179ROWS in table t: 2 1180INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk LIMIT 1; 1181Warnings: 1182Note 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. 1183ROWS in table t: 2 1184INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nokey LIMIT 1; 1185Warnings: 1186Note 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. 1187ROWS in table t: 2 1188INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nuk LIMIT 1; 1189Warnings: 1190Note 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. 1191ROWS in table t: 2 1192INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nnuk1 LIMIT 1; 1193Warnings: 1194Note 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. 1195ROWS in table t: 2 1196INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nnuk LIMIT 1; 1197ROWS in table t: 2 1198INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nnuk_str_short LIMIT 1; 1199ROWS in table t: 2 1200INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nnuk_str_long LIMIT 1; 1201Warnings: 1202Note 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. 1203ROWS in table t: 2 1204INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY pk LIMIT 1; 1205ROWS in table t: 2 1206INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nnuk1, nnuk2 LIMIT 1; 1207ROWS in table t: 2 1208INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 1209ROWS in table t: 2 1210INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.nnuk=t2.nnuk ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 1211ROWS in table t: 2 1212INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk LIMIT 0; 1213ROWS in table t: 2 1214INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk LIMIT 1; 1215Warnings: 1216Note 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. 1217ROWS in table t: 2 1218INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nokey LIMIT 1; 1219Warnings: 1220Note 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. 1221ROWS in table t: 2 1222INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nuk LIMIT 1; 1223Warnings: 1224Note 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. 1225ROWS in table t: 2 1226INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nnuk1 LIMIT 1; 1227Warnings: 1228Note 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. 1229ROWS in table t: 2 1230INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nnuk LIMIT 1; 1231ROWS in table t: 2 1232INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nnuk_str_short LIMIT 1; 1233ROWS in table t: 2 1234INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nnuk_str_long LIMIT 1; 1235Warnings: 1236Note 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. 1237ROWS in table t: 2 1238INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY pk LIMIT 1; 1239ROWS in table t: 2 1240INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nnuk1, nnuk2 LIMIT 1; 1241ROWS in table t: 2 1242INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 1243ROWS in table t: 2 1244INSERT INTO t SELECT t1.* FROM t1, t2 WHERE t1.pk=t2.pk ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 1245ROWS in table t: 2 1246INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 LIMIT 0; 1247ROWS in table t: 2 1248INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 LIMIT 1; 1249Warnings: 1250Note 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. 1251ROWS in table t: 2 1252INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nokey LIMIT 1; 1253Warnings: 1254Note 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. 1255ROWS in table t: 2 1256INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nuk LIMIT 1; 1257Warnings: 1258Note 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. 1259ROWS in table t: 2 1260INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk1 LIMIT 1; 1261Warnings: 1262Note 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. 1263ROWS in table t: 2 1264INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk LIMIT 1; 1265ROWS in table t: 2 1266INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk_str_short LIMIT 1; 1267ROWS in table t: 2 1268INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk_str_long LIMIT 1; 1269Warnings: 1270Note 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. 1271ROWS in table t: 2 1272INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY pk LIMIT 1; 1273ROWS in table t: 2 1274INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk1, nnuk2 LIMIT 1; 1275ROWS in table t: 2 1276INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 1277ROWS in table t: 2 1278INSERT INTO t SELECT t1.* FROM t1 NATURAL JOIN t2 ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 1279ROWS in table t: 2 1280INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) LIMIT 0; 1281ROWS in table t: 2 1282INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) LIMIT 1; 1283Warnings: 1284Note 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. 1285ROWS in table t: 2 1286INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nokey LIMIT 1; 1287Warnings: 1288Note 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. 1289ROWS in table t: 2 1290INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nuk LIMIT 1; 1291Warnings: 1292Note 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. 1293ROWS in table t: 2 1294INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk1 LIMIT 1; 1295Warnings: 1296Note 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. 1297ROWS in table t: 2 1298INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk LIMIT 1; 1299ROWS in table t: 2 1300INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk_str_short LIMIT 1; 1301ROWS in table t: 2 1302INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk_str_long LIMIT 1; 1303Warnings: 1304Note 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. 1305ROWS in table t: 2 1306INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY pk LIMIT 1; 1307ROWS in table t: 2 1308INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk1, nnuk2 LIMIT 1; 1309ROWS in table t: 2 1310INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 1311ROWS in table t: 2 1312INSERT INTO t SELECT t1.* FROM t1 JOIN t2 USING(pk) ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 1313ROWS in table t: 2 1314INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 LIMIT 0; 1315ROWS in table t: 2 1316INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 LIMIT 1; 1317Warnings: 1318Note 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. 1319ROWS in table t: 2 1320INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY nokey LIMIT 1; 1321Warnings: 1322Note 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. 1323ROWS in table t: 2 1324INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY nuk LIMIT 1; 1325Warnings: 1326Note 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. 1327ROWS in table t: 2 1328INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY nnuk1 LIMIT 1; 1329Warnings: 1330Note 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. 1331ROWS in table t: 2 1332INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY nnuk LIMIT 1; 1333ROWS in table t: 2 1334INSERT 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; 1335ROWS in table t: 2 1336INSERT 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; 1337Warnings: 1338Note 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. 1339ROWS in table t: 2 1340INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY pk LIMIT 1; 1341ROWS in table t: 2 1342INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk1 AND t1.nnuk2=t2.nnuk2 ORDER BY nnuk1, nnuk2 LIMIT 1; 1343ROWS in table t: 2 1344INSERT 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; 1345ROWS in table t: 2 1346INSERT 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; 1347ROWS in table t: 2 1348INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 LIMIT 0; 1349ROWS in table t: 2 1350INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 LIMIT 1; 1351Warnings: 1352Note 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. 1353ROWS in table t: 2 1354INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY nokey LIMIT 1; 1355Warnings: 1356Note 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. 1357ROWS in table t: 2 1358INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY nuk LIMIT 1; 1359Warnings: 1360Note 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. 1361ROWS in table t: 2 1362INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY nnuk1 LIMIT 1; 1363Warnings: 1364Note 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. 1365ROWS in table t: 2 1366INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY nnuk LIMIT 1; 1367ROWS in table t: 2 1368INSERT 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; 1369ROWS in table t: 2 1370INSERT 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; 1371Warnings: 1372Note 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. 1373ROWS in table t: 2 1374INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY pk LIMIT 1; 1375ROWS in table t: 2 1376INSERT INTO t SELECT t1.* FROM t1 JOIN t2 ON t1.nnuk1=t2.nnuk2 AND t1.nnuk2=t2.nnuk1 ORDER BY nnuk1, nnuk2 LIMIT 1; 1377ROWS in table t: 2 1378INSERT 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; 1379ROWS in table t: 2 1380INSERT 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; 1381ROWS in table t: 2 1382INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) LIMIT 0; 1383ROWS in table t: 2 1384INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) LIMIT 1; 1385Warnings: 1386Note 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. 1387ROWS in table t: 2 1388INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nokey LIMIT 1; 1389Warnings: 1390Note 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. 1391ROWS in table t: 2 1392INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nuk LIMIT 1; 1393Warnings: 1394Note 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. 1395ROWS in table t: 2 1396INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nnuk1 LIMIT 1; 1397Warnings: 1398Note 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. 1399ROWS in table t: 2 1400INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nnuk LIMIT 1; 1401ROWS in table t: 2 1402INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nnuk_str_short LIMIT 1; 1403ROWS in table t: 2 1404INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nnuk_str_long LIMIT 1; 1405Warnings: 1406Note 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. 1407ROWS in table t: 2 1408INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY pk LIMIT 1; 1409ROWS in table t: 2 1410INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nnuk1, nnuk2 LIMIT 1; 1411ROWS in table t: 2 1412INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 1413ROWS in table t: 2 1414INSERT INTO t SELECT t1.* FROM t1 JOIN (t2 JOIN t3 USING (pk)) USING(pk) ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 1415ROWS in table t: 2 1416INSERT 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; 1417ROWS in table t: 2 1418INSERT 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; 1419Warnings: 1420Note 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. 1421ROWS in table t: 2 1422INSERT 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; 1423Warnings: 1424Note 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. 1425ROWS in table t: 2 1426INSERT 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; 1427Warnings: 1428Note 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. 1429ROWS in table t: 2 1430INSERT 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; 1431Warnings: 1432Note 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. 1433ROWS in table t: 2 1434INSERT 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; 1435ROWS in table t: 2 1436INSERT 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; 1437ROWS in table t: 2 1438INSERT 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; 1439Warnings: 1440Note 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. 1441ROWS in table t: 2 1442INSERT 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; 1443ROWS in table t: 2 1444INSERT 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; 1445ROWS in table t: 2 1446INSERT 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; 1447ROWS in table t: 2 1448INSERT 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; 1449ROWS in table t: 2 1450INSERT 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; 1451ROWS in table t: 2 1452INSERT 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; 1453Warnings: 1454Note 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. 1455ROWS in table t: 2 1456INSERT 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; 1457Warnings: 1458Note 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. 1459ROWS in table t: 2 1460INSERT 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; 1461Warnings: 1462Note 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. 1463ROWS in table t: 2 1464INSERT 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; 1465Warnings: 1466Note 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. 1467ROWS in table t: 2 1468INSERT 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; 1469ROWS in table t: 2 1470INSERT 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; 1471ROWS in table t: 2 1472INSERT 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; 1473Warnings: 1474Note 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. 1475ROWS in table t: 2 1476INSERT 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; 1477ROWS in table t: 2 1478INSERT 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; 1479ROWS in table t: 2 1480INSERT 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; 1481ROWS in table t: 2 1482INSERT 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; 1483ROWS in table t: 2 1484INSERT 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; 1485ROWS in table t: 2 1486INSERT 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; 1487ROWS in table t: 2 1488INSERT 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; 1489ROWS in table t: 2 1490INSERT 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; 1491ROWS in table t: 2 1492INSERT 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; 1493ROWS in table t: 2 1494INSERT 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; 1495ROWS in table t: 2 1496INSERT 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; 1497ROWS in table t: 2 1498INSERT 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; 1499ROWS in table t: 2 1500INSERT 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; 1501ROWS in table t: 2 1502INSERT 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; 1503ROWS in table t: 2 1504INSERT 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; 1505ROWS in table t: 2 1506INSERT 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; 1507ROWS in table t: 2 1508INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk LIMIT 0; 1509ROWS in table t: 2 1510INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk LIMIT 1; 1511Warnings: 1512Note 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. 1513ROWS in table t: 3 1514INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nokey LIMIT 1; 1515Warnings: 1516Note 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. 1517ROWS in table t: 3 1518INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nuk LIMIT 1; 1519Warnings: 1520Note 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. 1521ROWS in table t: 3 1522INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1 LIMIT 1; 1523Warnings: 1524Note 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. 1525ROWS in table t: 3 1526INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk LIMIT 1; 1527ROWS in table t: 3 1528INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk_str_short LIMIT 1; 1529ROWS in table t: 3 1530INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk_str_long LIMIT 1; 1531Warnings: 1532Note 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. 1533ROWS in table t: 3 1534INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY pk LIMIT 1; 1535ROWS in table t: 3 1536INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nnuk2 LIMIT 1; 1537ROWS in table t: 3 1538INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 1539ROWS in table t: 3 1540INSERT INTO t SELECT t1.* FROM t1 LEFT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 1541ROWS in table t: 3 1542INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk LIMIT 0; 1543ROWS in table t: 2 1544INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk LIMIT 1; 1545Warnings: 1546Note 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. 1547ROWS in table t: 3 1548INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nokey LIMIT 1; 1549Warnings: 1550Note 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. 1551ROWS in table t: 3 1552INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nuk LIMIT 1; 1553Warnings: 1554Note 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. 1555ROWS in table t: 3 1556INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1 LIMIT 1; 1557Warnings: 1558Note 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. 1559ROWS in table t: 3 1560INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk LIMIT 1; 1561ROWS in table t: 3 1562INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk_str_short LIMIT 1; 1563ROWS in table t: 3 1564INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk_str_long LIMIT 1; 1565Warnings: 1566Note 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. 1567ROWS in table t: 3 1568INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY pk LIMIT 1; 1569ROWS in table t: 3 1570INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nnuk2 LIMIT 1; 1571ROWS in table t: 3 1572INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nnuk2, nokey LIMIT 1; 1573ROWS in table t: 3 1574INSERT INTO t SELECT t2.* FROM t1 RIGHT JOIN t2 ON t1.pk=t2.pk ORDER BY nnuk1, nokey, nnuk2 LIMIT 1; 1575ROWS in table t: 3 1576SET MAX_SORT_LENGTH=DEFAULT; 1577DROP TABLE t, t1, t2, t3, t4; 1578DROP TABLE queries, result_queries, limits; 1579DROP PROCEDURE gen_queries; 1580