← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to tests/include/commit.inc

pandora-build v0.71. Added check for avahi.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/include/commit.inc
6
6
## - $engine_type should be set
7
7
##
8
8
 
9
 
set sql_mode=no_engine_substitution;
10
9
eval set storage_engine = $engine_type;
11
10
set autocommit=1;
12
11
 
14
13
drop table if exists t1;
15
14
drop table if exists t2;
16
15
drop table if exists t3;
17
 
drop function if exists f2;
18
 
drop procedure if exists bug12713_call;
19
 
drop procedure if exists bug12713_dump_spvars;
20
 
drop procedure if exists dummy;
21
16
--enable_warnings
22
17
 
23
18
create table t1 (a int);
24
19
create table t2 (a int unique);
25
20
create table t3 (a int);
26
21
 
27
 
# a workaround for Bug#32633: Can not create any routine if
28
 
# SQL_MODE=no_engine_substitution
29
 
 
30
 
set sql_mode=default;
31
 
 
32
22
insert into t1 (a) values (1), (2);
33
23
insert into t3 (a) values (1), (2);
34
24
 
35
 
delimiter |;
36
 
 
37
 
## Cause a failure every time
38
 
create function f2(x int) returns int
39
 
begin
40
 
  insert into t2 (a) values (x);
41
 
  insert into t2 (a) values (x);
42
 
  return x;
43
 
end|
44
 
 
45
 
delimiter ;|
46
 
 
47
 
set autocommit=0;
48
 
 
49
 
flush status;
50
25
##============================================================================
51
26
## Design notes
52
27
##
63
38
##============================================================================
64
39
 
65
40
insert into t2 (a) values (1001);
66
 
--error ER_DUP_ENTRY
67
 
insert into t1 (a) values (f2(1));
 
41
insert into t1 (a) values (1);
68
42
select * from t2;
69
43
rollback;
70
44
select * from t2;
71
45
 
72
46
insert into t2 (a) values (1002);
73
 
--error ER_DUP_ENTRY
74
 
insert into t3 (a) select f2(2) from t1;
75
47
select * from t2;
76
48
rollback;
77
49
select * from t2;
78
50
 
79
51
insert into t2 (a) values (1003);
80
 
--error ER_DUP_ENTRY
81
 
update t1 set a= a + f2(3);
 
52
update t1 set a= a + 3;
82
53
select * from t2;
83
54
rollback;
84
55
select * from t2;
85
56
 
86
57
insert into t2 (a) values (1004);
87
 
--error ER_DUP_ENTRY
88
 
update t1, t3 set t1.a = 0, t3.a = 0 where (f2(4) = 4) and (t1.a = t3.a);
 
58
update t1, t3 set t1.a = 0, t3.a = 0 where (4 = 4) and (t1.a = t3.a);
89
59
select * from t2;
90
60
rollback;
91
61
select * from t2;
92
62
 
93
63
insert into t2 (a) values (1005);
94
 
--error ER_DUP_ENTRY
95
 
delete from t1 where (a = f2(5));
 
64
delete from t1 where (a = 5);
96
65
select * from t2;
97
66
rollback;
98
67
select * from t2;
99
68
 
100
69
insert into t2 (a) values (1006);
101
 
--error ER_DUP_ENTRY
102
 
delete from t1, t3 using t1, t3 where (f2(6) = 6) ;
 
70
delete from t1, t3 using t1, t3 where (6 = 6) ;
103
71
select * from t2;
104
72
rollback;
105
73
select * from t2;
106
74
 
107
75
insert into t2 (a) values (1007);
108
 
--error ER_DUP_ENTRY
109
 
replace t1 values (f2(7));
 
76
replace t1 values (7);
110
77
select * from t2;
111
78
rollback;
112
79
select * from t2;
113
80
 
114
81
insert into t2 (a) values (1008);
115
 
--error ER_DUP_ENTRY
116
 
replace into t3 (a) select f2(8) from t1;
 
82
replace into t3 (a) select 8 from t1;
117
83
select * from t2;
118
84
rollback;
119
85
select * from t2;
120
86
 
121
87
insert into t2 (a) values (1009);
122
 
--error ER_DUP_ENTRY
123
 
select f2(9) from t1 ;
 
88
select 9 from t1 ;
124
89
select * from t2;
125
90
rollback;
126
91
select * from t2;
127
92
 
128
93
insert into t2 (a) values (1010);
129
 
--error ER_DUP_ENTRY
130
 
show databases where (f2(10) = 10);
131
94
select * from t2;
132
95
rollback;
133
96
select * from t2;
134
97
 
135
98
insert into t2 (a) values (1011);
136
 
--error ER_DUP_ENTRY
137
 
show tables where (f2(11) = 11);
138
99
select * from t2;
139
100
rollback;
140
101
select * from t2;
141
102
 
142
 
insert into t2 (a) values (1012);
143
 
--error ER_DUP_ENTRY
144
 
show triggers where (f2(12) = 12);
145
 
select * from t2;
146
 
rollback;
147
103
select * from t2;
148
104
 
149
105
insert into t2 (a) values (1013);
150
 
--error ER_DUP_ENTRY
151
 
show table status where (f2(13) = 13);
152
106
select * from t2;
153
107
rollback;
154
108
select * from t2;
155
109
 
156
110
insert into t2 (a) values (1014);
157
 
--error ER_DUP_ENTRY
158
 
show open tables where (f2(14) = 14);
 
111
show open tables;
159
112
select * from t2;
160
113
rollback;
161
114
select * from t2;
162
115
 
163
116
insert into t2 (a) values (1015);
164
 
--error ER_DUP_ENTRY
165
 
show columns in mysql.proc where (f2(15) = 15);
166
117
select * from t2;
167
118
rollback;
168
119
select * from t2;
169
120
 
170
121
insert into t2 (a) values (1016);
171
 
--error ER_DUP_ENTRY
172
 
show status where (f2(16) = 16);
173
122
select * from t2;
174
123
rollback;
175
124
select * from t2;
176
125
 
177
126
insert into t2 (a) values (1017);
178
 
--error ER_DUP_ENTRY
179
 
show variables where (f2(17) = 17);
180
127
select * from t2;
181
128
rollback;
182
129
select * from t2;
183
130
 
184
131
insert into t2 (a) values (1018);
185
 
--error ER_DUP_ENTRY
186
 
show charset where (f2(18) = 18);
187
132
select * from t2;
188
133
rollback;
189
134
select * from t2;
190
135
 
191
136
insert into t2 (a) values (1019);
192
 
--error ER_DUP_ENTRY
193
 
show collation where (f2(19) = 19);
194
137
select * from t2;
195
138
rollback;
196
139
select * from t2;
197
140
 
198
 
--echo # We need at least one procedure to make sure the WHERE clause is
199
 
--echo # evaluated
200
 
create procedure dummy() begin end;
201
 
insert into t2 (a) values (1020);
202
 
--error ER_DUP_ENTRY
203
 
show procedure status where (f2(20) = 20);
204
141
select * from t2;
205
142
rollback;
206
143
select * from t2;
207
 
drop procedure dummy;
208
144
 
209
145
insert into t2 (a) values (1021);
210
 
--error ER_DUP_ENTRY
211
 
show function status where (f2(21) = 21);
212
146
select * from t2;
213
147
rollback;
214
148
select * from t2;
215
149
 
216
150
insert into t2 (a) values (1022);
217
 
prepare stmt from "insert into t1 (a) values (f2(22))";
218
 
--error ER_DUP_ENTRY
219
 
execute stmt;
220
151
select * from t2;
221
152
rollback;
222
153
select * from t2;
223
154
 
224
155
insert into t2 (a) values (1023);
225
 
do (f2(23));
226
 
select * from t2;
227
 
rollback;
228
 
select * from t2;
229
 
 
230
 
## Please note :
231
 
## This will insert a record 1024 in t1 (statement commit)
232
 
## This will insert a record 24 in t1 (statement commit)
233
 
## then will rollback the second insert only (24) (statement rollback)
234
 
## then will rollback the complete transaction (transaction rollback)
235
 
 
236
 
delimiter |;
237
 
 
238
 
create procedure bug12713_call ()
239
 
begin
240
 
  insert into t2 (a) values (24);
241
 
  insert into t2 (a) values (24);
242
 
end|
243
 
 
244
 
delimiter ;|
245
 
 
246
 
insert into t2 (a) values (1024);
247
 
--error ER_DUP_ENTRY
248
 
call bug12713_call();
249
156
select * from t2;
250
157
rollback;
251
158
select * from t2;
257
164
insert into t2 (a) values (1025);
258
165
 
259
166
--replace_result $MYSQLTEST_VARDIR ..
260
 
--error ER_DUP_ENTRY
261
 
eval select f2(25) into outfile "$MYSQLTEST_VARDIR/tmp/dml.out" from t1;
 
167
eval select 25 into outfile "$MYSQLTEST_VARDIR/tmp/dml.out" from t1;
262
168
select * from t2;
263
169
rollback;
264
170
select * from t2;
266
172
 
267
173
insert into t2 (a) values (1026);
268
174
--replace_result $MYSQLTEST_VARDIR ..
269
 
--error ER_DUP_ENTRY
270
 
eval load data infile "../std_data_ln/words.dat" into table t1 (a) set a:=f2(26);
 
175
--error 1366
 
176
eval load data infile "../std_data_ln/words.dat" into table t1 (a) set a:=26;
271
177
 
272
178
select * from t2;
273
179
rollback;
278
184
--echo =======================================================================
279
185
 
280
186
insert into t2 (a) values (1027);
281
 
--error ER_DUP_ENTRY
282
 
select f2(27) into @foo;
283
 
select * from t2;
284
 
rollback;
285
 
select * from t2;
286
 
 
287
 
--echo =======================================================================
288
 
--echo Testing Select_fetch_into_spvars 
289
 
--echo =======================================================================
290
 
 
291
 
delimiter |;
292
 
 
293
 
create procedure bug12713_dump_spvars ()
294
 
begin
295
 
  declare foo int;
296
 
 
297
 
  declare continue handler for sqlexception
298
 
  begin
299
 
    select "Exception trapped";
300
 
  end;
301
 
 
302
 
  select f2(28) into foo;
303
 
  select * from t2;
304
 
end|
305
 
 
306
 
delimiter ;|
307
 
 
308
 
insert into t2 (a) values (1028);
309
 
call bug12713_dump_spvars ();
 
187
select 27 into @foo;
 
188
select * from t2;
310
189
rollback;
311
190
select * from t2;
312
191
 
319
198
drop table t1;
320
199
drop table t2;
321
200
drop table t3;
322
 
drop function f2;
323
 
drop procedure bug12713_call;
324
 
drop procedure bug12713_dump_spvars;
325
201
--echo #
326
202
--echo # Bug#12713 Error in a stored function called from a SELECT doesn't
327
203
--echo # cause ROLLBACK of statem
337
213
--disable_warnings
338
214
drop table if exists t1;
339
215
drop table if exists t2;
340
 
drop function if exists f1;
341
 
drop procedure if exists p_verify_status_increment;
 
216
drop table if exists t3;
342
217
--enable_warnings
343
 
 
344
 
# Save binlog_format in a user variable. References to system
345
 
# variables are "unsafe", meaning they are written as rows instead of
346
 
# as statements to the binlog, if the loggging mode is 'mixed'.  But
347
 
# we don't want p_verify_status_increment to affect the logging mode.
348
 
# Hence, we save binlog_format in a user variable (which is not
349
 
# unsafe) and use that inside p_verify_status_increment.
350
 
set @binlog_format=@@global.binlog_format;
351
 
 
352
 
set sql_mode=no_engine_substitution;
353
 
create table t1 (a int unique); 
354
 
create table t2 (a int) engine=myisam;
355
 
set sql_mode=default;
356
 
--echo #
357
 
--echo # An auxiliary procedure to track Handler_prepare and Handler_commit
358
 
--echo # statistics.
359
 
--echo #
360
 
delimiter |;
361
 
create procedure
362
 
p_verify_status_increment(commit_inc_mixed int, prepare_inc_mixed int,
363
 
                          commit_inc_row int, prepare_inc_row int)
364
 
begin
365
 
  declare commit_inc int;
366
 
  declare prepare_inc int;
367
 
  declare old_commit_count int default ifnull(@commit_count, 0);
368
 
  declare old_prepare_count int default ifnull(@prepare_count, 0);
369
 
  declare c_res int;
370
 
# Use a cursor to have just one access to I_S instead of 2, it is very slow
371
 
# and amounts for over 90% of test CPU time
372
 
  declare c cursor for
373
 
     select variable_value
374
 
     from information_schema.session_status
375
 
     where variable_name='Handler_commit' or variable_name='Handler_prepare'
376
 
     order by variable_name;
377
 
 
378
 
  if @binlog_format = 'ROW' then
379
 
    set commit_inc= commit_inc_row;
380
 
    set prepare_inc= prepare_inc_row;
381
 
  else
382
 
    set commit_inc= commit_inc_mixed;
383
 
    set prepare_inc= prepare_inc_mixed;
384
 
  end if;
385
 
 
386
 
  open c;
387
 
  fetch c into c_res;
388
 
  set @commit_count=c_res;
389
 
  fetch c into c_res;
390
 
  set @prepare_count=c_res;
391
 
  close c;
392
 
 
393
 
  if old_commit_count + commit_inc <> @commit_count then
394
 
    select concat("Expected commit increment: ", commit_inc,
395
 
        " actual: ", @commit_count - old_commit_count)
396
 
    as 'ERROR';
397
 
  elseif old_prepare_count + prepare_inc <> @prepare_count then
398
 
    select concat("Expected prepare increment: ", prepare_inc,
399
 
        " actual: ", @prepare_count - old_prepare_count)
400
 
    as 'ERROR';
401
 
  else
402
 
    select '' as 'SUCCESS';
403
 
  end if;
404
 
end|
405
 
delimiter ;|
406
 
--echo # Reset Handler_commit and Handler_prepare counters
407
 
flush status;
408
 
--echo #
409
 
--echo # 1. Read-only statement: SELECT
410
 
--echo #
411
 
select * from t1;
412
 
call p_verify_status_increment(1, 0, 1, 0);
413
 
commit;
414
 
call p_verify_status_increment(1, 0, 1, 0);
415
 
 
416
 
--echo # 2. Read-write statement: INSERT, insert 1 row. 
417
 
--echo #
418
 
insert into t1 (a) values (1);
419
 
call p_verify_status_increment(2, 2, 2, 2);
420
 
commit;
421
 
call p_verify_status_increment(2, 2, 2, 2);
422
 
 
423
 
--echo # 3. Read-write statement: UPDATE, update 1 row. 
424
 
--echo #
425
 
update t1 set a=2;
426
 
call p_verify_status_increment(2, 2, 2, 2);
427
 
commit;
428
 
call p_verify_status_increment(2, 2, 2, 2);
429
 
 
430
 
--echo # 4. Read-write statement: UPDATE, update 0 rows, 1 row matches WHERE 
431
 
--echo #
432
 
update t1 set a=2;
433
 
call p_verify_status_increment(2, 2, 1, 0);
434
 
commit;
435
 
call p_verify_status_increment(2, 2, 1, 0);
436
 
 
437
 
--echo # 5. Read-write statement: UPDATE, update 0 rows, 0 rows match WHERE 
438
 
--echo #
439
 
--echo # In mixed replication mode, there is a read-only transaction
440
 
--echo # in InnoDB and also the statement is written to the binary log.
441
 
--echo # So we have two commits but no 2pc, since the first engine's
442
 
--echo # transaction is read-only.
443
 
--echo # In the row level replication mode, we only have the read-only
444
 
--echo # transaction in InnoDB and nothing is written to the binary log.
445
 
--echo #
446
 
update t1 set a=3 where a=1;
447
 
call p_verify_status_increment(2, 0, 1, 0);
448
 
commit;
449
 
call p_verify_status_increment(2, 0, 1, 0);
450
 
 
451
 
--echo # 6. Read-write statement: DELETE, delete 0 rows. 
452
 
--echo #
453
 
delete from t1 where a=1;
454
 
call p_verify_status_increment(2, 0, 1, 0);
455
 
commit;
456
 
call p_verify_status_increment(2, 0, 1, 0);
457
 
 
458
 
--echo # 7. Read-write statement: DELETE, delete 1 row. 
459
 
--echo #
460
 
delete from t1 where a=2;
461
 
call p_verify_status_increment(2, 2, 2, 2);
462
 
commit;
463
 
call p_verify_status_increment(2, 2, 2, 2);
464
 
 
465
 
--echo # 8. Read-write statement: unqualified DELETE
466
 
--echo #
467
 
--echo # In statement or mixed replication mode, we call
468
 
--echo # handler::ha_delete_all_rows() and write statement text
469
 
--echo # to the binary log. This results in two read-write transactions.
470
 
--echo # In row level replication mode, we do not call
471
 
--echo # handler::ha_delete_all_rows(), but delete rows one by one.
472
 
--echo # Since there are no rows, nothing is written to the binary log.
473
 
--echo # Thus we have just one read-only transaction in InnoDB.
474
 
delete from t1;
475
 
call p_verify_status_increment(2, 2, 1, 0);
476
 
commit;
477
 
call p_verify_status_increment(2, 2, 1, 0);
478
 
 
479
 
--echo # 9. Read-write statement: REPLACE, change 1 row. 
480
 
--echo #
481
 
replace t1 set a=1;
482
 
call p_verify_status_increment(2, 2, 2, 2);
483
 
commit;
484
 
call p_verify_status_increment(2, 2, 2, 2);
485
 
 
486
 
--echo # 10. Read-write statement: REPLACE, change 0 rows. 
487
 
--echo #
488
 
replace t1 set a=1;
489
 
call p_verify_status_increment(2, 2, 1, 0);
490
 
commit;
491
 
call p_verify_status_increment(2, 2, 1, 0);
492
 
 
493
 
--echo # 11. Read-write statement: IODKU, change 1 row. 
494
 
--echo #
495
 
insert t1 set a=1 on duplicate key update a=a+1;
496
 
call p_verify_status_increment(2, 2, 2, 2);
497
 
select * from t1;
498
 
call p_verify_status_increment(1, 0, 1, 0);
499
 
commit;
500
 
call p_verify_status_increment(2, 2, 2, 2);
501
 
 
502
 
--echo # 12. Read-write statement: IODKU, change 0 rows. 
503
 
--echo #
504
 
insert t1 set a=2 on duplicate key update a=2;
505
 
call p_verify_status_increment(1, 0, 1, 0);
506
 
commit;
507
 
call p_verify_status_increment(1, 0, 1, 0);
508
 
 
509
 
--echo # 13. Read-write statement: INSERT IGNORE, change 0 rows. 
510
 
--echo #
511
 
insert ignore t1 set a=2;
512
 
call p_verify_status_increment(1, 0, 1, 0);
513
 
commit;
514
 
call p_verify_status_increment(1, 0, 1, 0);
515
 
 
516
 
--echo # 14. Read-write statement: INSERT IGNORE, change 1 row. 
517
 
--echo #
518
 
insert ignore t1 set a=1;
519
 
call p_verify_status_increment(2, 2, 2, 2);
520
 
commit;
521
 
call p_verify_status_increment(2, 2, 2, 2);
522
 
--echo # 15. Read-write statement: UPDATE IGNORE, change 0 rows. 
523
 
--echo #
524
 
update ignore t1 set a=2 where a=1;
525
 
call p_verify_status_increment(2, 2, 1, 0);
526
 
commit;
527
 
call p_verify_status_increment(2, 2, 1, 0);
528
 
--echo #
529
 
--echo # Create a stored function that modifies a
530
 
--echo # non-transactional table. Demonstrate that changes in
531
 
--echo # non-transactional tables do not affect the two phase commit
532
 
--echo # algorithm.
533
 
--echo #
534
 
delimiter |;
535
 
create function f1() returns int
536
 
begin
537
 
  insert t2 set a=2;
538
 
  return 2;
539
 
end|
540
 
delimiter ;|
541
 
call p_verify_status_increment(0, 0, 0, 0);
542
 
 
543
 
--echo # 16. A function changes non-trans-table.
544
 
--echo #
545
 
--echo # For row-based logging, there is an extra commit for the
546
 
--echo # non-transactional changes saved in the transaction cache to
547
 
--echo # the binary log. 
548
 
--echo #
549
 
select f1();
550
 
call p_verify_status_increment(0, 0, 1, 0);
551
 
commit;
552
 
call p_verify_status_increment(0, 0, 1, 0);
553
 
 
554
 
--echo # 17. Read-only statement, a function changes non-trans-table.
555
 
--echo #
556
 
--echo # For row-based logging, there is an extra commit for the
557
 
--echo # non-transactional changes saved in the transaction cache to
558
 
--echo # the binary log. 
559
 
--echo #
560
 
select f1() from t1;
561
 
call p_verify_status_increment(1, 0, 2, 0);
562
 
commit;
563
 
call p_verify_status_increment(1, 0, 2, 0);
564
 
 
565
 
--echo # 18. Read-write statement: UPDATE, change 0 (transactional) rows. 
566
 
--echo #
567
 
select count(*) from t2;
568
 
update t1 set a=2 where a=f1()+10;
569
 
select count(*) from t2;
570
 
call p_verify_status_increment(2, 0, 2, 0);
571
 
commit;
572
 
call p_verify_status_increment(2, 0, 2, 0);
573
 
--echo #
574
 
--echo # Replace the non-transactional table with a temporary
575
 
--echo # transactional table. Demonstrate that a change to a temporary
576
 
--echo # transactional table does not provoke 2-phase commit, although
577
 
--echo # does trigger a commit and a binlog write (in statement mode).
578
 
--echo #
579
 
drop table t2;
580
 
set sql_mode=no_engine_substitution;
581
 
create temporary table t2 (a int);
582
 
call p_verify_status_increment(0, 0, 0, 0);
583
 
set sql_mode=default;
584
 
--echo # 19. A function changes temp-trans-table.
585
 
--echo #
586
 
select f1();
587
 
--echo # Two commits because a binary log record is written
588
 
call p_verify_status_increment(2, 0, 1, 0);
589
 
commit;
590
 
call p_verify_status_increment(2, 0, 1, 0);
591
 
 
592
 
--echo # 20. Read-only statement, a function changes non-trans-table.
593
 
--echo #
594
 
select f1() from t1;
595
 
--echo # Two commits because a binary log record is written
596
 
call p_verify_status_increment(2, 0, 1, 0);
597
 
commit;
598
 
call p_verify_status_increment(2, 0, 1, 0);
599
 
 
600
 
--echo # 21. Read-write statement: UPDATE, change 0 (transactional) rows. 
601
 
--echo #
602
 
update t1 set a=2 where a=f1()+10;
603
 
call p_verify_status_increment(2, 0, 1, 0);
604
 
commit;
605
 
call p_verify_status_increment(2, 0, 1, 0);
606
 
 
607
 
--echo # 22. DDL: ALTER TEMPORARY TABLE, should not cause a 2pc
608
 
--echo #
609
 
alter table t2 add column b int default 5;
610
 
--echo # A commit is done internally by ALTER. 
611
 
call p_verify_status_increment(2, 0, 2, 0);
612
 
commit;
613
 
--echo # There is nothing left to commit
614
 
call p_verify_status_increment(0, 0, 0, 0);
615
 
 
616
 
--echo # 23. DDL: RENAME TEMPORARY TABLE, does not start a transaction
617
 
--echo
618
 
--echo # No test because of Bug#8729 "rename table fails on temporary table"
619
 
 
620
 
--echo # 24. DDL: TRUNCATE TEMPORARY TABLE, does not start a transaction
621
 
--echo
622
 
truncate table t2;
623
 
call p_verify_status_increment(2, 0, 2, 0);
624
 
commit;
625
 
--echo # There is nothing left to commit
626
 
call p_verify_status_increment(0, 0, 0, 0);
627
 
 
628
 
--echo # 25. Read-write statement: unqualified DELETE 
629
 
--echo
630
 
delete from t2;
631
 
call p_verify_status_increment(2, 0, 1, 0);
632
 
commit;
633
 
--echo # There is nothing left to commit
634
 
call p_verify_status_increment(2, 0, 1, 0);
635
 
 
636
 
--echo # 25. DDL: DROP TEMPORARY TABLE, does not start a transaction
637
 
--echo #
638
 
drop temporary table t2;
639
 
call p_verify_status_increment(0, 0, 0, 0);
640
 
commit;
641
 
call p_verify_status_increment(0, 0, 0, 0);
642
 
 
643
 
--echo # 26. Verify that SET AUTOCOMMIT issues an implicit commit
644
 
--echo #
645
 
insert t1 set a=3;
646
 
call p_verify_status_increment(2, 2, 2, 2);
647
 
set autocommit=1;
648
 
call p_verify_status_increment(2, 2, 2, 2);
649
 
rollback;
650
 
select a from t1 where a=3;
651
 
call p_verify_status_increment(1, 0, 1, 0);
652
 
delete from t1 where a=3;
653
 
call p_verify_status_increment(2, 2, 2, 2);
654
 
commit;
655
 
call p_verify_status_increment(0, 0, 0, 0);
656
 
set autocommit=0;
657
 
call p_verify_status_increment(0, 0, 0, 0);
658
 
insert t1 set a=3;
659
 
call p_verify_status_increment(2, 2, 2, 2);
660
 
--echo # Sic: not actually changing the value of autocommit
661
 
set autocommit=0;
662
 
call p_verify_status_increment(0, 0, 0, 0);
663
 
rollback;
664
 
select a from t1 where a=3;
665
 
call p_verify_status_increment(1, 0, 1, 0);
666
 
 
667
 
--echo # 27. Savepoint management
668
 
--echo #
669
 
insert t1 set a=3;
670
 
call p_verify_status_increment(2, 2, 2, 2);
671
 
savepoint a;
672
 
call p_verify_status_increment(0, 0, 0, 0);
673
 
insert t1 set a=4;
674
 
--echo # Sic: a bug. Binlog did not register itself this time.
675
 
call p_verify_status_increment(1, 0, 1, 0);
676
 
release savepoint a;
677
 
rollback;
678
 
call p_verify_status_increment(0, 0, 0, 0);
679
 
select a from t1 where a=3;
680
 
call p_verify_status_increment(1, 0, 1, 0);
681
 
commit;
682
 
call p_verify_status_increment(1, 0, 1, 0);
683
 
 
684
 
--echo # 28. Read-write statement: DO
685
 
--echo #
686
 
create table t2 (a int);
687
 
call p_verify_status_increment(0, 0, 0, 0);
688
 
do (select f1() from t1 where a=2);
689
 
call p_verify_status_increment(2, 2, 2, 2);
690
 
commit;
691
 
call p_verify_status_increment(2, 2, 2, 2);
692
 
 
693
 
--echo # 29. Read-write statement: MULTI-DELETE
694
 
--echo # 
695
 
delete t1, t2 from t1 join t2 on (t1.a=t2.a) where t1.a=2;
696
 
commit;
697
 
call p_verify_status_increment(4, 4, 4, 4);
698
 
 
699
 
--echo # 30. Read-write statement: INSERT-SELECT, MULTI-UPDATE, REPLACE-SELECT
700
 
--echo # 
701
 
insert into t2 select a from t1;
702
 
commit;
703
 
replace into t2 select a from t1;
704
 
commit;
705
 
call p_verify_status_increment(8, 8, 8, 8);
706
 
#
707
 
# Multi-update is one of the few remaining statements that still
708
 
# locks the tables at prepare step (and hence starts the transaction.
709
 
# Disable the PS protocol, since in this protocol we get a different
710
 
# number of commmits (there is an extra commit after prepare
711
 
#
712
 
--disable_ps_protocol
713
 
update t1, t2 set t1.a=4, t2.a=8 where t1.a=t2.a and t1.a=1;
714
 
--enable_ps_protocol
715
 
commit;
716
 
call p_verify_status_increment(4, 4, 4, 4);
717
 
 
718
 
--echo # 31. DDL: various DDL with transactional tables
719
 
--echo #
720
 
--echo # Sic: no table is created.
721
 
create table if not exists t2 (a int) select 6 union select 7;
722
 
--echo # Sic: first commits the statement, and then the transaction.
723
 
call p_verify_status_increment(4, 4, 4, 4);
724
 
create table t3 select a from t2;
725
 
call p_verify_status_increment(4, 4, 4, 4);
726
 
alter table t3 add column (b int);
727
 
call p_verify_status_increment(2, 0, 2, 0);
728
 
alter table t3 rename t4;
729
 
call p_verify_status_increment(1, 0, 1, 0);
730
 
rename table t4 to t3;
731
 
call p_verify_status_increment(1, 0, 1, 0);
732
 
truncate table t3;
733
 
call p_verify_status_increment(2, 2, 2, 2);
734
 
create view v1 as select * from t2;
735
 
call p_verify_status_increment(1, 0, 1, 0);
736
 
check table t1;
737
 
call p_verify_status_increment(3, 0, 3, 0);
738
 
--echo # Sic: after this bug is fixed, CHECK leaves no pending transaction
739
 
commit;
740
 
call p_verify_status_increment(0, 0, 0, 0);
741
 
check table t1, t2, t3;
742
 
call p_verify_status_increment(6, 0, 6, 0);
743
 
commit;
744
 
call p_verify_status_increment(0, 0, 0, 0);
745
 
drop view v1;
746
 
call p_verify_status_increment(0, 0, 0, 0);
747
 
 
748
 
--echo #
749
 
--echo # Cleanup
750
 
--echo #
751
 
drop table t1, t2, t3;
752
 
drop procedure p_verify_status_increment;
753
 
drop function f1;