← 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.72 - Moved remaining hard-coded tests into pandora-build
macros.
Add PANDORA_DRIZZLE_BUILD to run the extra checks that drizzle needs that 
plugins would also need to run so we can just use that macro in generated
external plugin builds.
Added support to register_plugins for external plugin building.
Renamed register_plugins.py to pandora-plugin.

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;