← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysql-test/include/mix2.inc

Renamed more stuff to drizzle.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysql-test/include/mix2.inc
53
53
################################################################################
54
54
 
55
55
# Set the SESSION DEFAULT STORAGE ENGINE to a value <> storage engine
56
 
# to be tested. This must not affect any create $temp table statement, where
 
56
# to be tested. This must not affect any CREATE TABLE statement, where
57
57
# the storage engine is assigned explicitely,
58
58
eval SET SESSION STORAGE_ENGINE = $other_engine_type;
59
59
 
66
66
drop database if exists mysqltest;
67
67
--enable_warnings
68
68
 
69
 
eval create $temp table t1 (id int not null auto_increment, code int not null, name char(20) not null, primary key (id), key (code), unique (name)) engine=$engine_type;
 
69
eval create table t1 (id int unsigned not null auto_increment, code tinyint unsigned not null, name char(20) not null, primary key (id), key (code), unique (name)) engine=$engine_type;
70
70
 
71
71
insert into t1 (code, name) values (1, 'Tim'), (1, 'Monty'), (2, 'David'), (2, 'Erik'), (3, 'Sasha'), (3, 'Jeremy'), (4, 'Matt');
72
72
select id, code, name from t1 order by id;
84
84
# by innodb is not always the same between runs
85
85
#
86
86
 
87
 
eval create $temp table t1 (
88
 
  id int NOT NULL auto_increment,
89
 
  parent_id int DEFAULT '0' NOT NULL,
90
 
  level int DEFAULT '0' NOT NULL,
 
87
eval CREATE TABLE t1 (
 
88
  id int(11) NOT NULL auto_increment,
 
89
  parent_id int(11) DEFAULT '0' NOT NULL,
 
90
  level tinyint(4) DEFAULT '0' NOT NULL,
91
91
  PRIMARY KEY (id),
92
92
  KEY parent_id (parent_id),
93
93
  KEY level (level)
111
111
explain select level,id,parent_id from t1 where level=1;
112
112
select level,id from t1 where level=1;
113
113
select level,id,parent_id from t1 where level=1;
114
 
eval alter table t1 engine=$engine_type;
 
114
optimize table t1;
115
115
--replace_column 7 #
116
 
#show keys from t1;
 
116
show keys from t1;
117
117
drop table t1;
118
118
 
119
119
#
120
120
# Test replace
121
121
#
122
122
 
123
 
eval create $temp table t1 (
124
 
  gesuchnr int DEFAULT '0' NOT NULL,
125
 
  benutzer_id int DEFAULT '0' NOT NULL,
 
123
eval CREATE TABLE t1 (
 
124
  gesuchnr int(11) DEFAULT '0' NOT NULL,
 
125
  benutzer_id int(11) DEFAULT '0' NOT NULL,
126
126
  PRIMARY KEY (gesuchnr,benutzer_id)
127
127
) engine=$engine_type;
128
128
 
136
136
# test delete using hidden_primary_key
137
137
#
138
138
 
139
 
eval create $temp table t1 (a int) engine=$engine_type;
 
139
eval create table t1 (a int) engine=$engine_type;
140
140
insert into t1 values (1), (2);
141
 
eval alter table t1 ENGINE=$engine_type;
 
141
optimize table t1;
142
142
delete from t1 where a = 1;
143
143
select * from t1;
144
144
check table t1;
145
145
drop table t1;
146
146
 
147
 
eval create $temp table t1 (a int,b varchar(20)) engine=$engine_type;
 
147
eval create table t1 (a int,b varchar(20)) engine=$engine_type;
148
148
insert into t1 values (1,""), (2,"testing");
149
149
delete from t1 where a = 1;
150
150
select * from t1;
152
152
insert into t1 values (3,""), (4,"testing");
153
153
analyze table t1;
154
154
--replace_column 7 #
155
 
#show keys from t1;
 
155
show keys from t1;
156
156
drop table t1;
157
157
 
158
158
 
159
159
# Test of reading on secondary key with may be null
160
160
 
161
 
eval create $temp table t1 (a int,b varchar(20),key(a)) engine=$engine_type;
 
161
eval create table t1 (a int,b varchar(20),key(a)) engine=$engine_type;
162
162
insert into t1 values (1,""), (2,"testing");
163
163
select * from t1 where a = 1;
164
164
drop table t1;
169
169
# Test rollback
170
170
#
171
171
 
172
 
eval create $temp table t1 (n int not null primary key) engine=$engine_type;
 
172
eval create table t1 (n int not null primary key) engine=$engine_type;
173
173
set autocommit=0;
174
174
insert into t1 values (4);
175
175
rollback;
222
222
# Test for commit and FLUSH TABLES WITH READ LOCK
223
223
#
224
224
 
225
 
eval create $temp table t1 (n int not null primary key) engine=$engine_type;
 
225
eval create table t1 (n int not null primary key) engine=$engine_type;
226
226
start transaction;
227
227
insert into t1 values (4);
228
228
flush tables with read lock;
239
239
# Testing transactions
240
240
#
241
241
 
242
 
eval create $temp table t1 ( id int NOT NULL PRIMARY KEY, nom varchar(64)) engine=$engine_type;
 
242
eval create table t1 ( id int NOT NULL PRIMARY KEY, nom varchar(64)) engine=$engine_type;
243
243
begin;
244
244
insert into t1 values(1,'hamdouni');
245
245
select id as afterbegin_id,nom as afterbegin_nom from t1;
257
257
# Simple not autocommit test
258
258
#
259
259
 
260
 
eval create $temp table t1 (id char(8) not null primary key, val int not null) engine=$engine_type;
 
260
eval CREATE TABLE t1 (id char(8) not null primary key, val int not null) engine=$engine_type;
261
261
insert into t1 values ('pippo', 12);
262
262
-- error ER_DUP_ENTRY
263
263
insert into t1 values ('pippo', 12); # Gives error
279
279
# Test of active transactions
280
280
#
281
281
 
282
 
eval create $temp table t1 (a integer) engine=$engine_type;
 
282
eval create table t1 (a integer) engine=$engine_type;
283
283
start transaction;
284
284
rename table t1 to t2;
285
 
eval create $temp table t1 (b integer) engine=$engine_type;
 
285
eval create table t1 (b integer) engine=$engine_type;
286
286
insert into t1 values (1);
287
287
rollback;
288
288
drop table t1;
294
294
# The following simple tests failed at some point
295
295
#
296
296
 
297
 
eval create $temp table t1 (ID INTEGER NOT NULL PRIMARY KEY, NAME VARCHAR(64)) ENGINE=$engine_type;
 
297
eval CREATE TABLE t1 (ID INTEGER NOT NULL PRIMARY KEY, NAME VARCHAR(64)) ENGINE=$engine_type;
298
298
INSERT INTO t1 VALUES (1, 'Jochen');
299
299
select * from t1;
300
300
drop table t1;
301
301
 
302
 
eval create $temp table t1 ( _userid VARCHAR(60) NOT NULL PRIMARY KEY) ENGINE=$engine_type;
 
302
eval CREATE TABLE t1 ( _userid VARCHAR(60) NOT NULL PRIMARY KEY) ENGINE=$engine_type;
303
303
set autocommit=0;
304
304
INSERT INTO t1  SET _userid='marc@anyware.co.uk';
305
305
COMMIT;
314
314
#
315
315
# Test when reading on part of unique key
316
316
#
317
 
eval create $temp table t1 (
318
 
  user_id int DEFAULT '0' NOT NULL,
 
317
eval CREATE TABLE t1 (
 
318
  user_id int(10) DEFAULT '0' NOT NULL,
319
319
  name varchar(100),
320
320
  phone varchar(100),
321
321
  ref_email varchar(100) DEFAULT '' NOT NULL,
336
336
# Test that keys are created in right order
337
337
#
338
338
 
339
 
eval create $temp table t1 (a int not null, b int not null,c int not null,
 
339
eval CREATE TABLE t1 (a int not null, b int not null,c int not null,
340
340
key(a),primary key(a,b), unique(c),key(a),unique(b)) ENGINE = $engine_type;
341
341
--replace_column 7 #
342
 
#show index from t1;
 
342
show index from t1;
343
343
drop table t1;
344
344
 
345
345
#
346
346
# Test of ALTER TABLE and innodb tables
347
347
#
348
348
 
349
 
eval create $temp table t1 (col1 int not null, col2 char(4) not null, primary key(col1)) ENGINE = $other_engine_type;
 
349
eval create table t1 (col1 int not null, col2 char(4) not null, primary key(col1)) ENGINE = $other_engine_type;
350
350
eval alter table t1 engine=$engine_type;
351
351
insert into t1 values ('1','1'),('5','2'),('2','3'),('3','4'),('4','4');
352
352
select * from t1;
362
362
# INSERT INTO innodb tables
363
363
#
364
364
 
365
 
eval create $temp table t1 (a int not null , b int, primary key (a)) engine = $engine_type;
366
 
eval create $temp table t2 (a int not null , b int, primary key (a)) engine = $other_engine_type;
 
365
eval create table t1 (a int not null , b int, primary key (a)) engine = $engine_type;
 
366
eval create table t2 (a int not null , b int, primary key (a)) engine = $other_engine_type;
367
367
insert into t1 VALUES (1,3) , (2,3), (3,3);
368
368
select * from t1;
369
369
insert into t2 select * from t1;
379
379
# Search on unique key
380
380
#
381
381
 
382
 
eval create $temp table t1 (
383
 
  id int NOT NULL auto_increment,
384
 
  ggid varchar(32) DEFAULT '' NOT NULL,
 
382
eval CREATE TABLE t1 (
 
383
  id int(11) NOT NULL auto_increment,
 
384
  ggid varchar(32) binary DEFAULT '' NOT NULL,
385
385
  email varchar(64) DEFAULT '' NOT NULL,
386
 
  passwd varchar(32) DEFAULT '' NOT NULL,
 
386
  passwd varchar(32) binary DEFAULT '' NOT NULL,
387
387
  PRIMARY KEY (id),
388
388
  UNIQUE ggid (ggid)
389
389
) ENGINE=$engine_type;
412
412
# ORDER BY on not primary key
413
413
#
414
414
 
415
 
eval create $temp table t1 (
 
415
eval CREATE TABLE t1 (
416
416
  user_name varchar(12),
417
417
  password text,
418
418
  subscribed char(1),
419
 
  user_id int DEFAULT '0' NOT NULL,
420
 
  quota bigint,
 
419
  user_id int(11) DEFAULT '0' NOT NULL,
 
420
  quota bigint(20),
421
421
  weight double,
422
422
  access_date date,
 
423
  access_time time,
423
424
  approved datetime,
424
 
  dummy_primary_key int NOT NULL auto_increment,
 
425
  dummy_primary_key int(11) NOT NULL auto_increment,
425
426
  PRIMARY KEY (dummy_primary_key)
426
427
) ENGINE=$engine_type;
427
 
INSERT INTO t1 VALUES ('user_0','somepassword','N',0,0,0,'2000-09-07','2000-09-07 23:06:59',1);
428
 
INSERT INTO t1 VALUES ('user_1','somepassword','Y',1,1,1,'2000-09-07','2000-09-07 23:06:59',2);
429
 
INSERT INTO t1 VALUES ('user_2','somepassword','N',2,2,1.4142135623731,'2000-09-07','2000-09-07 23:06:59',3);
430
 
INSERT INTO t1 VALUES ('user_3','somepassword','Y',3,3,1.7320508075689,'2000-09-07','2000-09-07 23:06:59',4);
431
 
INSERT INTO t1 VALUES ('user_4','somepassword','N',4,4,2,'2000-09-07','2000-09-07 23:06:59',5);
432
 
select  user_name, password , subscribed, user_id, quota, weight, access_date, approved, dummy_primary_key from t1 order by user_name;
 
428
INSERT INTO t1 VALUES ('user_0','somepassword','N',0,0,0,'2000-09-07','23:06:59','2000-09-07 23:06:59',1);
 
429
INSERT INTO t1 VALUES ('user_1','somepassword','Y',1,1,1,'2000-09-07','23:06:59','2000-09-07 23:06:59',2);
 
430
INSERT INTO t1 VALUES ('user_2','somepassword','N',2,2,1.4142135623731,'2000-09-07','23:06:59','2000-09-07 23:06:59',3);
 
431
INSERT INTO t1 VALUES ('user_3','somepassword','Y',3,3,1.7320508075689,'2000-09-07','23:06:59','2000-09-07 23:06:59',4);
 
432
INSERT INTO t1 VALUES ('user_4','somepassword','N',4,4,2,'2000-09-07','23:06:59','2000-09-07 23:06:59',5);
 
433
select  user_name, password , subscribed, user_id, quota, weight, access_date, access_time, approved, dummy_primary_key from t1 order by user_name;
433
434
drop table t1;
434
435
 
435
436
#
436
437
# Testing of tables without primary keys
437
438
#
438
439
 
439
 
eval create $temp table t1 (
440
 
  id int NOT NULL auto_increment,
441
 
  parent_id int DEFAULT '0' NOT NULL,
442
 
  level int DEFAULT '0' NOT NULL,
 
440
eval CREATE TABLE t1 (
 
441
  id int(11) NOT NULL auto_increment,
 
442
  parent_id int(11) DEFAULT '0' NOT NULL,
 
443
  level tinyint(4) DEFAULT '0' NOT NULL,
443
444
  KEY (id),
444
445
  KEY parent_id (parent_id),
445
446
  KEY level (level)
467
468
#
468
469
# Test of index only reads
469
470
#
470
 
eval create $temp table t1 (
 
471
eval CREATE TABLE t1 (
471
472
   sca_code char(6) NOT NULL,
472
473
   cat_code char(6) NOT NULL,
473
474
   sca_desc varchar(50),
498
499
#
499
500
# Test of opening table twice and timestamps
500
501
#
501
 
--echo $temp
502
 
if(!$using_temp)
503
 
{
504
502
set @a:=now();
505
 
eval create $temp table t1 (a int not null, b timestamp not null, primary key (a)) engine=$engine_type;
 
503
eval CREATE TABLE t1 (a int not null, b timestamp not null, primary key (a)) engine=$engine_type;
506
504
insert into t1 (a) values(1),(2),(3);
507
505
select t1.a from t1 natural join t1 as t2 where t1.b >= @a order by t1.a;
508
506
select a from t1 natural join t1 as t2 where b >= @a order by a;
509
507
update t1 set a=5 where a=1;
510
508
select a from t1;
511
509
drop table t1;
512
 
}
 
510
 
513
511
#
514
512
# Test with variable length primary key
515
513
#
516
 
eval create $temp table t1 (a varchar(100) not null, primary key(a), b int not null) engine=$engine_type;
 
514
eval create table t1 (a varchar(100) not null, primary key(a), b int not null) engine=$engine_type;
517
515
insert into t1 values("hello",1),("world",2);
518
516
select * from t1 order by b desc;
519
 
eval alter table t1 ENGINE=$engine_type;
 
517
optimize table t1;
520
518
--replace_column 7 #
521
 
#show keys from t1;
 
519
show keys from t1;
522
520
drop table t1;
523
521
 
524
522
#
525
523
# Test of create index with NULL columns
526
524
#
527
 
eval create $temp table t1 (i int, j int ) ENGINE=$engine_type;
 
525
eval create table t1 (i int, j int ) ENGINE=$engine_type;
528
526
insert into t1 values (1,2);
529
527
select * from t1 where i=1 and j=2;
530
528
create index ax1 on t1 (i,j);
535
533
# Test min-max optimization
536
534
#
537
535
 
538
 
eval create $temp table t1 (
539
 
  a int NOT NULL,
540
 
  b int NOT NULL,
 
536
eval CREATE TABLE t1 (
 
537
  a int3 unsigned NOT NULL,
 
538
  b int1 unsigned NOT NULL,
541
539
  UNIQUE (a, b)
542
540
) ENGINE = $engine_type;
543
541
 
549
547
# Test INSERT DELAYED
550
548
#
551
549
 
552
 
eval create $temp table t1 (a int NOT NULL) engine=$engine_type;
 
550
eval CREATE TABLE t1 (a int unsigned NOT NULL) engine=$engine_type;
553
551
# Can't test this in 3.23
554
552
# INSERT DELAYED INTO t1 VALUES (1);
555
553
INSERT INTO t1 VALUES (1);
561
559
# Crash when using many tables (Test case by Jeremy D Zawodny)
562
560
#
563
561
 
564
 
eval create $temp table t1 (a int  primary key,b int, c int, d int, e int, f int, g int, h int, i int, j int, k int, l int, m int, n int, o int, p int, q int, r int, s int, t int, u int, v int, w int, x int, y int, z int, a1 int, a2 int, a3 int, a4 int, a5 int, a6 int, a7 int, a8 int, a9 int, b1 int, b2 int, b3 int, b4 int, b5 int, b6 int) engine = $engine_type;
 
562
eval create table t1 (a int  primary key,b int, c int, d int, e int, f int, g int, h int, i int, j int, k int, l int, m int, n int, o int, p int, q int, r int, s int, t int, u int, v int, w int, x int, y int, z int, a1 int, a2 int, a3 int, a4 int, a5 int, a6 int, a7 int, a8 int, a9 int, b1 int, b2 int, b3 int, b4 int, b5 int, b6 int) engine = $engine_type;
565
563
insert into t1 values (1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1);
566
564
--replace_column 9 #
567
565
explain select * from t1 where a > 0 and a < 50;
568
566
drop table t1;
569
567
 
570
568
#
 
569
# Test lock tables
 
570
#
 
571
 
 
572
eval create table t1 (id int NOT NULL,id2 int NOT NULL,id3 int NOT NULL,dummy1 char(30),primary key (id,id2),index index_id3 (id3)) engine=$engine_type;
 
573
insert into t1 values (0,0,0,'ABCDEFGHIJ'),(2,2,2,'BCDEFGHIJK'),(1,1,1,'CDEFGHIJKL');
 
574
LOCK TABLES t1 WRITE;
 
575
--error ER_DUP_ENTRY
 
576
insert into t1 values (99,1,2,'D'),(1,1,2,'D');
 
577
select id from t1;
 
578
select id from t1;
 
579
UNLOCK TABLES;
 
580
DROP TABLE t1;
 
581
 
 
582
eval create table t1 (id int NOT NULL,id2 int NOT NULL,id3 int NOT NULL,dummy1 char(30),primary key (id,id2),index index_id3 (id3)) engine=$engine_type;
 
583
insert into t1 values (0,0,0,'ABCDEFGHIJ'),(2,2,2,'BCDEFGHIJK'),(1,1,1,'CDEFGHIJKL');
 
584
LOCK TABLES t1 WRITE;
 
585
begin;
 
586
--error ER_DUP_ENTRY
 
587
insert into t1 values (99,1,2,'D'),(1,1,2,'D');
 
588
select id from t1;
 
589
insert ignore into t1 values (100,1,2,'D'),(1,1,99,'D');
 
590
commit;
 
591
select id,id3 from t1;
 
592
UNLOCK TABLES;
 
593
DROP TABLE t1;
 
594
 
 
595
#
571
596
# Test prefix key
572
597
#
573
 
eval create $temp table t1 (a char(20), unique (a(5))) engine=$engine_type;
 
598
eval create table t1 (a char(20), unique (a(5))) engine=$engine_type;
574
599
drop table t1;
575
 
eval create $temp table t1 (a char(20), index (a(5))) engine=$engine_type;
 
600
eval create table t1 (a char(20), index (a(5))) engine=$engine_type;
576
601
show create table t1;
577
602
drop table t1;
578
603
 
590
615
drop table t1;
591
616
 
592
617
#Slashdot bug
593
 
eval create $temp table t1
 
618
eval create table t1
594
619
 (
595
620
  id int auto_increment primary key,
596
621
  name varchar(32) not null,
600
625
 ) engine=$engine_type;
601
626
insert into t1 values (1,'one','one value',101),
602
627
 (2,'two','two value',102),(3,'three','three value',103);
 
628
set insert_id=5;
603
629
replace into t1 (value,name,uid) values ('other value','two',102);
604
630
delete from t1 where uid=102;
 
631
set insert_id=5;
605
632
replace into t1 (value,name,uid) values ('other value','two',102);
 
633
set insert_id=6;
606
634
replace into t1 (value,name,uid) values ('other value','two',102);
607
635
select * from t1;
608
636
drop table t1;
616
644
#     storage engines) not prevent the dropping of this database.
617
645
 
618
646
create database mysqltest;
619
 
eval create $temp table mysqltest.t1 (a int not null) engine= $engine_type;
 
647
eval create table mysqltest.t1 (a int not null) engine= $engine_type;
620
648
insert into mysqltest.t1 values(1);
621
 
eval create $temp table mysqltest.t2 (a int not null) engine= $other_engine_type;
 
649
eval create table mysqltest.t2 (a int not null) engine= $other_engine_type;
622
650
insert into mysqltest.t2 values(1);
623
 
eval create $temp table mysqltest.t3 (a int not null) engine= $other_engine_type1;
 
651
eval create table mysqltest.t3 (a int not null) engine= $other_engine_type1;
624
652
insert into mysqltest.t3 values(1);
625
653
commit;
626
654
drop database mysqltest;
633
661
#
634
662
 
635
663
set autocommit=0;
636
 
eval create $temp table t1 (a int not null) engine= $engine_type;
 
664
eval create table t1 (a int not null) engine= $engine_type;
637
665
insert into t1 values(1),(2);
638
666
truncate table t1;
639
667
commit;
647
675
drop table t1;
648
676
set autocommit=1;
649
677
 
650
 
eval create $temp table t1 (a int not null) engine= $engine_type;
 
678
eval create table t1 (a int not null) engine= $engine_type;
651
679
insert into t1 values(1),(2);
652
680
truncate table t1;
653
681
insert into t1 values(1),(2);
662
690
# Test of how ORDER BY works when doing it on the whole table
663
691
#
664
692
 
665
 
eval create $temp table t1 (a int not null, b int not null, c int not null, primary key (a),key(b)) engine=$engine_type;
 
693
eval create table t1 (a int not null, b int not null, c int not null, primary key (a),key(b)) engine=$engine_type;
666
694
insert into t1 values (3,3,3),(1,1,1),(2,2,2),(4,4,4);
667
695
--replace_column 9 #
668
696
explain select * from t1 order by a;
686
714
# Check describe
687
715
#
688
716
 
689
 
eval create $temp table t1 (t int not null default 1, key (t)) engine=$engine_type;
690
 
#desc t1;
 
717
eval create table t1 (t int not null default 1, key (t)) engine=$engine_type;
 
718
desc t1;
691
719
drop table t1;
692
720
 
693
721
#
 
722
# Test of multi-table-delete
 
723
#
 
724
 
 
725
eval CREATE TABLE t1 (
 
726
  number bigint(20) NOT NULL default '0',
 
727
  cname char(15) NOT NULL default '',
 
728
  carrier_id smallint(6) NOT NULL default '0',
 
729
  privacy tinyint(4) NOT NULL default '0',
 
730
  last_mod_date timestamp NOT NULL,
 
731
  last_mod_id smallint(6) NOT NULL default '0',
 
732
  last_app_date timestamp NOT NULL,
 
733
  last_app_id smallint(6) default '-1',
 
734
  version smallint(6) NOT NULL default '0',
 
735
  assigned_scps int(11) default '0',
 
736
  status tinyint(4) default '0'
 
737
) ENGINE=$engine_type;
 
738
INSERT INTO t1 VALUES (4077711111,'SeanWheeler',90,2,20020111112846,500,00000000000000,-1,2,3,1);
 
739
INSERT INTO t1 VALUES (9197722223,'berry',90,3,20020111112809,500,20020102114532,501,4,10,0);
 
740
INSERT INTO t1 VALUES (650,'San Francisco',0,0,20011227111336,342,00000000000000,-1,1,24,1);
 
741
INSERT INTO t1 VALUES (302467,'Sue\'s Subshop',90,3,20020109113241,500,20020102115111,501,7,24,0);
 
742
INSERT INTO t1 VALUES (6014911113,'SudzCarwash',520,1,20020102115234,500,20020102115259,501,33,32768,0);
 
743
INSERT INTO t1 VALUES (333,'tubs',99,2,20020109113440,501,20020109113440,500,3,10,0);
 
744
eval CREATE TABLE t2 (
 
745
  number bigint(20) NOT NULL default '0',
 
746
  cname char(15) NOT NULL default '',
 
747
  carrier_id smallint(6) NOT NULL default '0',
 
748
  privacy tinyint(4) NOT NULL default '0',
 
749
  last_mod_date timestamp NOT NULL,
 
750
  last_mod_id smallint(6) NOT NULL default '0',
 
751
  last_app_date timestamp NOT NULL,
 
752
  last_app_id smallint(6) default '-1',
 
753
  version smallint(6) NOT NULL default '0',
 
754
  assigned_scps int(11) default '0',
 
755
  status tinyint(4) default '0'
 
756
) ENGINE=$engine_type;
 
757
INSERT INTO t2 VALUES (4077711111,'SeanWheeler',0,2,20020111112853,500,00000000000000,-1,2,3,1);
 
758
INSERT INTO t2 VALUES (9197722223,'berry',90,3,20020111112818,500,20020102114532,501,4,10,0);
 
759
INSERT INTO t2 VALUES (650,'San Francisco',90,0,20020109113158,342,00000000000000,-1,1,24,1);
 
760
INSERT INTO t2 VALUES (333,'tubs',99,2,20020109113453,501,20020109113453,500,3,10,0);
 
761
select * from t1;
 
762
select * from t2;
 
763
delete t1, t2 from t1 left join t2 on t1.number=t2.number where (t1.carrier_id=90 and t1.number=t2.number) or (t2.carrier_id=90 and t1.number=t2.number) or  (t1.carrier_id=90 and t2.number is null);
 
764
select * from t1;
 
765
select * from t2;
 
766
select * from t2;
 
767
drop table t1,t2;
 
768
 
 
769
#
694
770
# A simple test with some isolation levels
695
771
# TODO: Make this into a test using replication to really test how
696
772
# this works.
697
773
#
698
774
 
699
 
eval create $temp table t1 (id int not null auto_increment, code int not null, name char(20) not null, primary key (id), key (code), unique (name)) engine=$engine_type;
 
775
eval create table t1 (id int unsigned not null auto_increment, code tinyint unsigned not null, name char(20) not null, primary key (id), key (code), unique (name)) engine=$engine_type;
700
776
 
701
777
BEGIN;
702
778
SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;
719
795
DROP TABLE t1;
720
796
 
721
797
#
 
798
# Test of multi-table-update
 
799
#
 
800
eval create table t1 (n int(10), d int(10)) engine=$engine_type;
 
801
eval create table t2 (n int(10), d int(10)) engine=$engine_type;
 
802
insert into t1 values(1,1),(1,2);
 
803
insert into t2 values(1,10),(2,20);
 
804
UPDATE t1,t2 SET t1.d=t2.d,t2.d=30 WHERE t1.n=t2.n;
 
805
select * from t1;
 
806
select * from t2;
 
807
drop table t1,t2;
 
808
 
 
809
#
722
810
# Testing of IFNULL
723
811
#
724
 
if(!$using_temp)
725
 
{
726
 
eval create $temp table t1 (a int, b int) engine=$engine_type;
 
812
eval create table t1 (a int, b int) engine=$engine_type;
727
813
insert into t1 values(20,null);
728
814
select t2.b, ifnull(t2.b,"this is null") from t1 as t2 left join t1 as t3 on
729
815
t2.b=t3.a;
733
819
select t2.b, ifnull(t2.b,"this is null") from t1 as t2 left join t1 as t3 on
734
820
t2.b=t3.a order by 1;
735
821
drop table t1;
736
 
}
 
822
 
 
823
#
 
824
# Test of read_through not existing const_table
 
825
#
 
826
 
 
827
eval create table t1 (a varchar(10) not null) engine = $other_engine_type;
 
828
eval create table t2 (b varchar(10) not null unique) engine=$engine_type;
 
829
select t1.a from t1,t2 where t1.a=t2.b;
 
830
drop table t1,t2;
 
831
eval create table t1 (a int not null, b int, primary key (a)) engine = $engine_type;
 
832
eval create table t2 (a int not null, b int, primary key (a)) engine = $engine_type;
 
833
insert into t1 values (10, 20);
 
834
insert into t2 values (10, 20);
 
835
update t1, t2 set t1.b = 150, t2.b = t1.b where t2.a = t1.a and t1.a = 10;
 
836
drop table t1,t2;
737
837
 
738
838
if ($test_foreign_keys)
739
839
{
741
841
# Test of multi-table-delete with foreign key constraints
742
842
#
743
843
 
744
 
eval create $temp table t1 (id INT NOT NULL, PRIMARY KEY (id)) ENGINE=$engine_type;
745
 
eval create $temp table t2 (id INT PRIMARY KEY, t1_id INT, INDEX par_ind (t1_id), FOREIGN KEY (t1_id) REFERENCES t1(id)  ON DELETE CASCADE ) ENGINE=$engine_type;
 
844
eval CREATE TABLE t1 (id INT NOT NULL, PRIMARY KEY (id)) ENGINE=$engine_type;
 
845
eval CREATE TABLE t2 (id INT PRIMARY KEY, t1_id INT, INDEX par_ind (t1_id), FOREIGN KEY (t1_id) REFERENCES t1(id)  ON DELETE CASCADE ) ENGINE=$engine_type;
746
846
insert into t1 set id=1;
747
847
insert into t2 set id=1, t1_id=1;
748
848
delete t1,t2 from t1,t2 where t1.id=t2.t1_id;
749
849
select * from t1;
750
850
select * from t2;
751
851
drop table t2,t1;
752
 
eval create $temp table t1(id INT NOT NULL,  PRIMARY KEY (id)) ENGINE=$engine_type;
753
 
eval create $temp table t2(id  INT PRIMARY KEY, t1_id INT, INDEX par_ind (t1_id)  ) ENGINE=$engine_type;
 
852
eval CREATE TABLE t1(id INT NOT NULL,  PRIMARY KEY (id)) ENGINE=$engine_type;
 
853
eval CREATE TABLE t2(id  INT PRIMARY KEY, t1_id INT, INDEX par_ind (t1_id)  ) ENGINE=$engine_type;
754
854
INSERT INTO t1 VALUES(1);
755
855
INSERT INTO t2 VALUES(1, 1);
756
856
SELECT * from t1;
769
869
 
770
870
set autocommit=0;
771
871
 
772
 
eval create $temp table t1 (id CHAR(15) NOT NULL, value CHAR(40) NOT NULL, PRIMARY KEY(id)) ENGINE=$engine_type;
773
 
 
774
 
eval create $temp table t2 (id CHAR(15) NOT NULL, value CHAR(40) NOT NULL, PRIMARY KEY(id)) ENGINE=$engine_type;
775
 
 
776
 
eval create $temp table t3 (id1 CHAR(15) NOT NULL, id2 CHAR(15) NOT NULL, PRIMARY KEY(id1, id2)) ENGINE=$engine_type;
 
872
eval CREATE TABLE t1 (id CHAR(15) NOT NULL, value CHAR(40) NOT NULL, PRIMARY KEY(id)) ENGINE=$engine_type;
 
873
 
 
874
eval CREATE TABLE t2 (id CHAR(15) NOT NULL, value CHAR(40) NOT NULL, PRIMARY KEY(id)) ENGINE=$engine_type;
 
875
 
 
876
eval CREATE TABLE t3 (id1 CHAR(15) NOT NULL, id2 CHAR(15) NOT NULL, PRIMARY KEY(id1, id2)) ENGINE=$engine_type;
777
877
 
778
878
INSERT INTO t3 VALUES("my-test-1", "my-test-2");
779
879
COMMIT;
800
900
# Check update with conflicting key
801
901
#
802
902
 
803
 
eval create $temp table t1 (a int not null primary key, b int not null, unique (b)) engine=$engine_type;
 
903
eval CREATE TABLE t1 (a int not null primary key, b int not null, unique (b)) engine=$engine_type;
804
904
INSERT INTO t1 values (1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7),(8,8),(9,9);
805
905
# We need the a < 1000 test here to quard against the halloween problems
806
906
UPDATE t1 set a=a+100 where b between 2 and 3 and a < 1000;
808
908
drop table t1;
809
909
 
810
910
#
 
911
# Test multi update with different join methods
 
912
#
 
913
 
 
914
eval CREATE TABLE t1 (a int not null primary key, b int not null, key (b)) engine=$engine_type;
 
915
eval CREATE TABLE t2 (a int not null primary key, b int not null, key (b)) engine=$engine_type;
 
916
INSERT INTO t1 values (1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7),(8,8),(9,9),(10,10),(11,11),(12,12);
 
917
INSERT INTO t2 values (1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7),(8,8),(9,9);
 
918
 
 
919
# Full join, without key
 
920
update t1,t2 set t1.a=t1.a+100;
 
921
select * from t1;
 
922
 
 
923
# unique key
 
924
update t1,t2 set t1.a=t1.a+100 where t1.a=101;
 
925
select * from t1;
 
926
 
 
927
# ref key
 
928
update t1,t2 set t1.b=t1.b+10 where t1.b=2;
 
929
select * from t1;
 
930
 
 
931
# Range key (in t1)
 
932
update t1,t2 set t1.b=t1.b+2,t2.b=t1.b+10 where t1.b between 3 and 5 and t1.a=t2.a+100;
 
933
select * from t1;
 
934
select * from t2;
 
935
 
 
936
drop table t1,t2;
 
937
eval CREATE TABLE t2 (  NEXT_T         BIGINT NOT NULL PRIMARY KEY) ENGINE=$other_non_trans_engine_type;
 
938
eval CREATE TABLE t1 (  B_ID           INTEGER NOT NULL PRIMARY KEY) ENGINE=$engine_type;
 
939
SET AUTOCOMMIT=0;
 
940
INSERT INTO t1 ( B_ID ) VALUES ( 1 );
 
941
INSERT INTO t2 ( NEXT_T ) VALUES ( 1 );
 
942
ROLLBACK;
 
943
SELECT * FROM t1;
 
944
drop table  t1,t2;
 
945
eval create table t1  ( pk         int primary key,    parent     int not null,    child      int not null,       index (parent)  ) engine = $engine_type;
 
946
insert into t1 values   (1,0,4),  (2,1,3),  (3,2,1),  (4,1,2);
 
947
select distinct  parent,child   from t1   order by parent;
 
948
drop table t1;
 
949
 
 
950
#
811
951
# Test that MySQL priorities clustered indexes
812
952
#
813
 
eval create $temp table t1 (a int not null auto_increment primary key, b int, c int, key(c)) engine=$engine_type;
814
 
eval create $temp table t2 (a int not null auto_increment primary key, b int) ENGINE = $other_engine_type;
 
953
eval create table t1 (a int not null auto_increment primary key, b int, c int, key(c)) engine=$engine_type;
 
954
eval create table t2 (a int not null auto_increment primary key, b int) ENGINE = $other_engine_type;
815
955
insert into t1 (b) values (null),(null),(null),(null),(null),(null),(null);
816
956
insert into t2 (a) select b from t1;
817
957
insert into t1 (b) select b from t2;
843
983
# Test of UPDATE ... ORDER BY
844
984
#
845
985
 
846
 
eval create $temp table t1 (id int primary key auto_increment, fk int, index index_fk (fk)) engine=$engine_type;
 
986
eval create table t1 (id int primary key auto_increment, fk int, index index_fk (fk)) engine=$engine_type;
847
987
 
848
988
insert into t1 (id) values (null),(null),(null),(null),(null);
849
989
update t1 set fk=69 where fk is null order by id limit 1;
850
990
SELECT * from t1;
851
991
drop table t1;
852
992
 
853
 
eval create $temp table t1 (a int not null, b int not null, key (a)) engine=$engine_type;
 
993
eval create table t1 (a int not null, b int not null, key (a)) engine=$engine_type;
854
994
insert into t1 values (1,1),(1,2),(1,3),(3,1),(3,2),(3,3),(3,1),(3,2),(3,3),(2,1),(2,2),(2,3);
855
995
SET @tmp=0;
856
996
update t1 set b=(@tmp:=@tmp+1) order by a;
861
1001
drop table t1;
862
1002
 
863
1003
#
 
1004
# Test of multi-table-updates (bug #1980).
 
1005
#
 
1006
 
 
1007
eval create table t1 ( c char(8) not null ) engine=$engine_type;
 
1008
insert into t1 values ('0'),('1'),('2'),('3'),('4'),('5'),('6'),('7'),('8'),('9');
 
1009
insert into t1 values ('A'),('B'),('C'),('D'),('E'),('F');
 
1010
 
 
1011
alter table t1 add b char(8) not null;
 
1012
alter table t1 add a char(8) not null;
 
1013
alter table t1 add primary key (a,b,c);
 
1014
update t1 set a=c, b=c;
 
1015
 
 
1016
eval create table t2 (c char(8) not null, b char(8) not null, a char(8) not null, primary key(a,b,c)) engine=$engine_type;
 
1017
insert into t2 select * from t1;
 
1018
 
 
1019
delete t1,t2 from t2,t1 where t1.a<'B' and t2.b=t1.b;
 
1020
drop table t1,t2;
 
1021
 
 
1022
#
864
1023
# test autoincrement with TRUNCATE
865
1024
#
866
1025
 
867
1026
SET AUTOCOMMIT=1;
868
 
eval create $temp table t1 (a integer auto_increment primary key) engine=$engine_type;
 
1027
eval create table t1 (a integer auto_increment primary key) engine=$engine_type;
869
1028
insert into t1 (a) values (NULL),(NULL);
870
1029
truncate table t1;
871
1030
insert into t1 (a) values (NULL),(NULL);
879
1038
# Test dictionary handling with spaceand quoting
880
1039
#
881
1040
 
882
 
eval create $temp table t1 (`id 1` INT NOT NULL, PRIMARY KEY (`id 1`)) ENGINE=$engine_type;
883
 
eval create $temp table t2 (id INT PRIMARY KEY, t1_id INT, INDEX par_ind (t1_id), FOREIGN KEY (`t1_id`) REFERENCES `t1`(`id 1`)  ON DELETE CASCADE ) ENGINE=$engine_type;
 
1041
eval CREATE TABLE t1 (`id 1` INT NOT NULL, PRIMARY KEY (`id 1`)) ENGINE=$engine_type;
 
1042
eval CREATE TABLE t2 (id INT PRIMARY KEY, t1_id INT, INDEX par_ind (t1_id), FOREIGN KEY (`t1_id`) REFERENCES `t1`(`id 1`)  ON DELETE CASCADE ) ENGINE=$engine_type;
884
1043
#show create table t2;
885
1044
drop table t2,t1;
886
1045
 
888
1047
# Test of multi updated and foreign keys
889
1048
#
890
1049
 
891
 
eval create $temp table `t1` (`id` int not null  ,primary key ( `id` )) engine = $engine_type;
 
1050
eval create table `t1` (`id` int( 11 ) not null  ,primary key ( `id` )) engine = $engine_type;
892
1051
insert into `t1`values ( 1 ) ;
893
 
eval create $temp table `t2` (`id` int not null default '0',unique key `id` ( `id` ) ,constraint `t1_id_fk` foreign key ( `id` ) references `t1` (`id` )) engine = $engine_type;
 
1052
eval create table `t2` (`id` int( 11 ) not null default '0',unique key `id` ( `id` ) ,constraint `t1_id_fk` foreign key ( `id` ) references `t1` (`id` )) engine = $engine_type;
894
1053
insert into `t2`values ( 1 ) ;
895
 
eval create $temp table `t3` (`id` int not null default '0',key `id` ( `id` ) ,constraint `t2_id_fk` foreign key ( `id` ) references `t2` (`id` )) engine = $engine_type;
 
1054
eval create table `t3` (`id` int( 11 ) not null default '0',key `id` ( `id` ) ,constraint `t2_id_fk` foreign key ( `id` ) references `t2` (`id` )) engine = $engine_type;
896
1055
insert into `t3`values ( 1 ) ;
897
1056
--error 1451
898
1057
delete t3,t2,t1 from t1,t2,t3 where t1.id =1 and t2.id = t1.id and t3.id = t2.id;
905
1064
#
906
1065
# test for recursion depth limit
907
1066
#
908
 
eval create $temp table t1(
 
1067
eval create table t1(
909
1068
        id int primary key,
910
1069
        pid int,
911
1070
        index(pid),
925
1084
# Test timestamps
926
1085
#
927
1086
 
928
 
eval create $temp table t1 (col1 int)ENGINE=$engine_type;
929
 
eval create $temp table t2 (col1 int,stamp TIMESTAMP,INDEX stamp_idx
 
1087
eval CREATE TABLE t1 (col1 int(1))ENGINE=$engine_type;
 
1088
eval CREATE TABLE t2 (col1 int(1),stamp TIMESTAMP,INDEX stamp_idx
930
1089
(stamp))ENGINE=$engine_type;
931
1090
insert into t1 values (1),(2),(3);
932
1091
# Note that timestamp 3 is wrong
933
 
--error 1685 # Bad timestamp
934
1092
insert into t2 values (1, 20020204130000),(2, 20020204130000),(4,20020204310000 ),(5,20020204230000);
935
1093
SELECT col1 FROM t1 UNION SELECT col1 FROM t2 WHERE stamp <
936
1094
'20020204120000' GROUP BY col1;
940
1098
# Test by Francois MASUREL
941
1099
#
942
1100
 
943
 
if(!$using_temp)
944
 
{
945
 
eval create $temp table t1 (
946
 
  `id` int NOT NULL auto_increment,
947
 
  `id_object` int default '0',
948
 
  `id_version` int NOT NULL default '1',
 
1101
eval CREATE TABLE t1 (
 
1102
  `id` int(10) unsigned NOT NULL auto_increment,
 
1103
  `id_object` int(10) unsigned default '0',
 
1104
  `id_version` int(10) unsigned NOT NULL default '1',
949
1105
  `label` varchar(100) NOT NULL default '',
950
1106
  `description` text,
951
1107
  PRIMARY KEY  (`id`),
955
1111
 
956
1112
INSERT INTO t1 VALUES("6", "3382", "9", "Test", NULL), ("7", "102", "5", "Le Pekin (Test)", NULL),("584", "1794", "4", "Test de resto", NULL),("837", "1822", "6", "Test 3", NULL),("1119", "3524", "1", "Societe Test", NULL),("1122", "3525", "1", "Fournisseur Test", NULL);
957
1113
 
958
 
eval create $temp table t2 (
959
 
  `id` int NOT NULL auto_increment,
960
 
  `id_version` int NOT NULL default '1',
 
1114
eval CREATE TABLE t2 (
 
1115
  `id` int(10) unsigned NOT NULL auto_increment,
 
1116
  `id_version` int(10) unsigned NOT NULL default '1',
961
1117
  PRIMARY KEY  (`id`),
962
1118
  KEY `id_version` (`id_version`)
963
1119
) ENGINE=$engine_type;
968
1124
(SELECT t1.id_object as id_object FROM t1 WHERE t1.`label` LIKE '%test%') AS lbl
969
1125
ON (t2.id = lbl.id_object) INNER JOIN t1 ON (t2.id = t1.id_object);
970
1126
drop table t1,t2;
971
 
}
972
1127
 
973
1128
# Live checksum feature available + enabled
974
 
eval create $temp table t1 (a int, b varchar(200), c text not null) engine=$other_live_chks_engine_type;
 
1129
eval create table t1 (a int, b varchar(200), c text not null) checksum=1 engine=$other_live_chks_engine_type;
975
1130
# Live checksum feature available + disabled
976
 
eval create $temp table t2 (a int, b varchar(200), c text not null) engine=$other_live_chks_engine_type;
 
1131
eval create table t2 (a int, b varchar(200), c text not null) checksum=0 engine=$other_live_chks_engine_type;
977
1132
#
978
1133
# Live checksum feature not available + enabled
979
 
eval create $temp table t3 (a int, b varchar(200), c varchar(200) not null) engine=$other_non_live_chks_engine_type;
 
1134
eval create table t3 (a int, b varchar(200), c varchar(200) not null) checksum=1 engine=$other_non_live_chks_engine_type;
980
1135
# Live checksum feature not available + disabled
981
 
eval create $temp table t4 (a int, b varchar(200), c varchar(200) not null) engine=$other_non_live_chks_engine_type;
 
1136
eval create table t4 (a int, b varchar(200), c varchar(200) not null) checksum=0 engine=$other_non_live_chks_engine_type;
982
1137
#
983
1138
# Live checksum feature probably available + enabled
984
 
eval create $temp table t5 (a int, b varchar(200), c text not null) engine=$engine_type;
 
1139
eval create table t5 (a int, b varchar(200), c text not null) checksum=1 engine=$engine_type;
985
1140
# Live checksum feature probably available + disabled
986
 
eval create $temp table t6 (a int, b varchar(200), c text not null) engine=$engine_type;
 
1141
eval create table t6 (a int, b varchar(200), c text not null) checksum=0 engine=$engine_type;
987
1142
#
988
1143
insert t1 values (1, "aaa", "bbb"), (NULL, "", "ccccc"), (0, NULL, "");
989
1144
insert t2 select * from t1;
991
1146
insert t4 select * from t1;
992
1147
insert t5 select * from t1;
993
1148
insert t6 select * from t1;
 
1149
checksum table t1, t2, t3, t4, t5, t6, t7 quick;
 
1150
checksum table t1, t2, t3, t4, t5, t6, t7;
 
1151
checksum table t1, t2, t3, t4, t5, t6, t7 extended;
994
1152
# #show table status;
995
1153
drop table t1,t2,t3, t4, t5, t6;
996
1154
 
998
1156
# Test problem with refering to different fields in same table in UNION
999
1157
# (Bug#2552: UNION returns NULL instead of expected value (innoDB only tables))
1000
1158
#
1001
 
if(!$using_temp)
1002
 
{
1003
 
eval create $temp table t1 (id int,  name char(10) not null,  name2 char(10) not null) engine=$engine_type;
 
1159
eval create table t1 (id int,  name char(10) not null,  name2 char(10) not null) engine=$engine_type;
1004
1160
insert into t1 values(1,'first','fff'),(2,'second','sss'),(3,'third','ttt');
1005
1161
select trim(name2) from t1  union all  select trim(name) from t1 union all select trim(id) from t1;
1006
1162
drop table t1;
1007
 
}
1008
 
#
1009
 
# Bug#2160: Extra error message for create $temp table LIKE with InnoDB
1010
 
#
1011
 
eval create $temp table t1 (a int) engine=$engine_type;
1012
 
--error 1005
 
1163
 
 
1164
#
 
1165
# Bug#2160: Extra error message for CREATE TABLE LIKE with InnoDB
 
1166
#
 
1167
eval create table t1 (a int) engine=$engine_type;
1013
1168
create table t2 like t1;
1014
 
create table t2 like t1 engine=innodb;
1015
1169
show create table t2;
1016
1170
drop table t1,t2;
1017
1171
 
1021
1175
# Test of automaticly created foreign keys
1022
1176
#
1023
1177
 
1024
 
eval create $temp table t1 (id int not null, id2 int not null, unique (id,id2)) engine=$engine_type;
1025
 
eval create $temp table t2 (id int not null, constraint t1_id_fk foreign key ( id ) references t1 (id)) engine = $engine_type;
 
1178
eval create table t1 (id int(11) not null, id2 int(11) not null, unique (id,id2)) engine=$engine_type;
 
1179
eval create table t2 (id int(11) not null, constraint t1_id_fk foreign key ( id ) references t1 (id)) engine = $engine_type;
1026
1180
show create table t1;
1027
1181
show create table t2;
1028
1182
create index id on t2 (id);
1035
1189
show create table t2;
1036
1190
drop table t2;
1037
1191
 
1038
 
eval create $temp table t2 (id int not null, id2 int not null, constraint t1_id_fk foreign key (id,id2) references t1 (id,id2)) engine = $engine_type;
 
1192
eval create table t2 (id int(11) not null, id2 int(11) not null, constraint t1_id_fk foreign key (id,id2) references t1 (id,id2)) engine = $engine_type;
1039
1193
show create table t2;
1040
1194
create unique index id on t2 (id,id2);
1041
1195
show create table t2;
1042
1196
drop table t2;
1043
1197
 
1044
1198
# Check foreign key columns created in different order than key columns
1045
 
eval create $temp table t2 (id int not null, id2 int not null, unique (id,id2),constraint t1_id_fk foreign key (id2,id) references t1 (id,id2)) engine = $engine_type;
1046
 
show create table t2;
1047
 
drop table t2;
1048
 
 
1049
 
eval create $temp table t2 (id int not null, id2 int not null, unique (id,id2), constraint t1_id_fk foreign key (id) references t1 (id)) engine = $engine_type;
1050
 
show create table t2;
1051
 
drop table t2;
1052
 
 
1053
 
eval create $temp table t2 (id int not null, id2 int not null, unique (id,id2),constraint t1_id_fk foreign key (id2,id) references t1 (id,id2)) engine = $engine_type;
1054
 
show create table t2;
1055
 
drop table t2;
1056
 
 
1057
 
eval create $temp table t2 (id int not null auto_increment, id2 int not null, constraint t1_id_fk foreign key (id) references t1 (id), primary key (id), index (id,id2)) engine = $engine_type;
1058
 
show create table t2;
1059
 
drop table t2;
1060
 
 
1061
 
eval create $temp table t2 (id int not null auto_increment, id2 int not null, constraint t1_id_fk foreign key (id) references t1 (id)) engine= $engine_type;
 
1199
eval create table t2 (id int(11) not null, id2 int(11) not null, unique (id,id2),constraint t1_id_fk foreign key (id2,id) references t1 (id,id2)) engine = $engine_type;
 
1200
show create table t2;
 
1201
drop table t2;
 
1202
 
 
1203
eval create table t2 (id int(11) not null, id2 int(11) not null, unique (id,id2), constraint t1_id_fk foreign key (id) references t1 (id)) engine = $engine_type;
 
1204
show create table t2;
 
1205
drop table t2;
 
1206
 
 
1207
eval create table t2 (id int(11) not null, id2 int(11) not null, unique (id,id2),constraint t1_id_fk foreign key (id2,id) references t1 (id,id2)) engine = $engine_type;
 
1208
show create table t2;
 
1209
drop table t2;
 
1210
 
 
1211
eval create table t2 (id int(11) not null auto_increment, id2 int(11) not null, constraint t1_id_fk foreign key (id) references t1 (id), primary key (id), index (id,id2)) engine = $engine_type;
 
1212
show create table t2;
 
1213
drop table t2;
 
1214
 
 
1215
eval create table t2 (id int(11) not null auto_increment, id2 int(11) not null, constraint t1_id_fk foreign key (id) references t1 (id)) engine= $engine_type;
1062
1216
show create table t2;
1063
1217
alter table t2 add index id_test (id), add index id_test2 (id,id2);
1064
1218
show create table t2;
1068
1222
 
1069
1223
# Clean up filename -- embedded server reports whole path without .frm,
1070
1224
# regular server reports relative path with .frm (argh!)
1071
 
--replace_result \\ / $DRIZZLE_TEST_DIR . /var/master-data/ / t2.frm t2
 
1225
--replace_result \\ / $MYSQL_TEST_DIR . /var/master-data/ / t2.frm t2
1072
1226
--error 1005
1073
 
eval create $temp table t2 (id int not null, id2 int not null, constraint t1_id_fk foreign key (id2,id) references t1 (id)) engine = $engine_type;
 
1227
eval create table t2 (id int(11) not null, id2 int(11) not null, constraint t1_id_fk foreign key (id2,id) references t1 (id)) engine = $engine_type;
1074
1228
 
1075
1229
# bug#3749
1076
1230
 
1077
 
eval create $temp table t2 (a int auto_increment primary key, b int, index(b), foreign key (b) references t1(id), unique(b)) engine=$engine_type;
 
1231
eval create table t2 (a int auto_increment primary key, b int, index(b), foreign key (b) references t1(id), unique(b)) engine=$engine_type;
1078
1232
show create table t2;
1079
1233
drop table t2;
1080
 
eval create $temp table t2 (a int auto_increment primary key, b int, foreign key (b) references t1(id), foreign key (b) references t1(id), unique(b)) engine=$engine_type;
 
1234
eval create table t2 (a int auto_increment primary key, b int, foreign key (b) references t1(id), foreign key (b) references t1(id), unique(b)) engine=$engine_type;
1081
1235
show create table t2;
1082
1236
drop table t2, t1;
1083
1237
}
1093
1247
show status like "binlog_cache_use";
1094
1248
show status like "binlog_cache_disk_use";
1095
1249
 
1096
 
eval create $temp table t1 (a int) engine=$engine_type;
 
1250
eval create table t1 (a int) engine=$engine_type;
1097
1251
 
1098
1252
# Now we are going to create transaction which is long enough so its
1099
1253
# transaction binlog will be flushed to disk...
1123
1277
# Bug #6126: Duplicate columns in keys gives misleading error message
1124
1278
#
1125
1279
--error 1060
1126
 
eval create $temp table t1 (c char(10), index (c,c)) engine=$engine_type;
1127
 
--error 1060
1128
 
eval create $temp table t1 (c1 char(10), c2 char(10), index (c1,c2,c1)) engine=$engine_type;
1129
 
--error 1060
1130
 
eval create $temp table t1 (c1 char(10), c2 char(10), index (c1,c1,c2)) engine=$engine_type;
1131
 
--error 1060
1132
 
eval create $temp table t1 (c1 char(10), c2 char(10), index (c2,c1,c1)) engine=$engine_type;
1133
 
eval create $temp table t1 (c1 char(10), c2 char(10)) engine=$engine_type;
 
1280
eval create table t1 (c char(10), index (c,c)) engine=$engine_type;
 
1281
--error 1060
 
1282
eval create table t1 (c1 char(10), c2 char(10), index (c1,c2,c1)) engine=$engine_type;
 
1283
--error 1060
 
1284
eval create table t1 (c1 char(10), c2 char(10), index (c1,c1,c2)) engine=$engine_type;
 
1285
--error 1060
 
1286
eval create table t1 (c1 char(10), c2 char(10), index (c2,c1,c1)) engine=$engine_type;
 
1287
eval create table t1 (c1 char(10), c2 char(10)) engine=$engine_type;
1134
1288
--error 1060
1135
1289
alter table t1 add key (c1,c1);
1136
1290
--error 1060
1145
1299
# Bug #4082: integer truncation
1146
1300
#
1147
1301
 
1148
 
eval create $temp table t1(a int, b int) engine=$engine_type;
 
1302
eval create table t1(a int(1) , b int(1)) engine=$engine_type;
1149
1303
insert into t1 values ('1111', '3333');
1150
1304
select distinct concat(a, b) from t1;
1151
1305
drop table t1;
1157
1311
#                      engines does not fail
1158
1312
#
1159
1313
 
1160
 
eval create $temp table t1 ( a char(10) ) ENGINE=$engine_type;
 
1314
eval CREATE TABLE t1 ( a char(10) ) ENGINE=$engine_type;
1161
1315
--error 1214
1162
1316
SELECT a FROM t1 WHERE MATCH (a) AGAINST ('test' IN BOOLEAN MODE);
1163
1317
DROP TABLE t1;
1170
1324
#
1171
1325
 
1172
1326
--disable_warnings
1173
 
eval create $temp table t1 (a_id int NOT NULL default '0', PRIMARY KEY  (a_id)) ENGINE=$engine_type DEFAULT CHARSET=latin1;
 
1327
eval CREATE TABLE t1 (a_id tinyint(4) NOT NULL default '0', PRIMARY KEY  (a_id)) ENGINE=$engine_type DEFAULT CHARSET=latin1;
1174
1328
INSERT INTO t1 VALUES (1),(2),(3);
1175
 
eval create $temp table t2 (b_id int NOT NULL default '0',b_a int NOT NULL default '0', PRIMARY KEY  (b_id), KEY  (b_a),
 
1329
eval CREATE TABLE t2 (b_id tinyint(4) NOT NULL default '0',b_a tinyint(4) NOT NULL default '0', PRIMARY KEY  (b_id), KEY  (b_a),
1176
1330
                CONSTRAINT fk_b_a FOREIGN KEY (b_a) REFERENCES t1 (a_id) ON DELETE CASCADE ON UPDATE NO ACTION) ENGINE=$engine_type DEFAULT CHARSET=latin1;
1177
1331
--enable_warnings
1178
1332
INSERT INTO t2 VALUES (1,1),(2,1),(3,1),(4,2),(5,2);
1192
1346
select * from t1;
1193
1347
drop table t1;
1194
1348
# Show that it works with permanent tables too.
1195
 
eval create $temp table t1 (a int) engine=$engine_type;
 
1349
eval create table t1 (a int) engine=$engine_type;
1196
1350
insert into t1 values (4711);
1197
1351
truncate t1;
1198
1352
insert into t1 values (42);
1203
1357
# Bug #13025  Server crash during filesort      
1204
1358
#
1205
1359
 
1206
 
eval create $temp table t1 (a int not null, b int not null, c blob not null, d int not null, e int, primary key (a,b,c(255),d)) engine=$engine_type;
 
1360
eval create table t1 (a int not null, b int not null, c blob not null, d int not null, e int, primary key (a,b,c(255),d)) engine=$engine_type;
1207
1361
insert into t1 values (2,2,"b",2,2),(1,1,"a",1,1),(3,3,"ab",3,3);
1208
1362
select * from t1 order by a,b,c,d;
1209
1363
explain select * from t1 order by a,b,c,d;
1213
1367
# BUG#11039,#13218 Wrong key length in min()
1214
1368
#
1215
1369
 
1216
 
eval create $temp table t1 (a char(1), b char(1), key(a, b)) engine=$engine_type;
 
1370
eval create table t1 (a char(1), b char(1), key(a, b)) engine=$engine_type;
1217
1371
insert into t1 values ('8', '6'), ('4', '7');
1218
1372
select min(a) from t1;
1219
1373
select min(b) from t1 where a='8';
1225
1379
# range optimizer problem
1226
1380
#
1227
1381
 
1228
 
eval create $temp table t1 (x bigint not null primary key) engine=$engine_type;
1229
 
# The below is out of range for a BIGINT (signed)
1230
 
--error 1264
 
1382
eval create table t1 (x bigint unsigned not null primary key) engine=$engine_type;
1231
1383
insert into t1(x) values (0xfffffffffffffff0),(0xfffffffffffffff1);
1232
1384
select * from t1;
1233
1385
select count(*) from t1 where x>0;
1315
1467
 
1316
1468
# Clean up filename -- embedded server reports whole path without .frm,
1317
1469
# regular server reports relative path with .frm (argh!)
1318
 
# @TODO The below fails because it assumes latin1
1319
 
# as the charset.  Possibly re-enable a similar test
1320
 
#--replace_result \\ / $DRIZZLE_TEST_DIR . /var/master-data/ / t1.frm t1
1321
 
#create $temp table t1 (v varchar(65530), key(v));
1322
 
#drop table t1;
1323
 
#create $temp table t1 (v varchar(65536));
1324
 
#show create table t1;
1325
 
#drop table t1;
1326
 
#create $temp table t1 (v varchar(65530) character set utf8);
1327
 
#show create table t1;
1328
 
#drop table t1;
1329
 
#
1330
 
#eval set storage_engine=$default;
1331
 
#
 
1470
--replace_result \\ / $MYSQL_TEST_DIR . /var/master-data/ / t1.frm t1
 
1471
create table t1 (v varchar(65530), key(v));
 
1472
drop table t1;
 
1473
create table t1 (v varchar(65536));
 
1474
show create table t1;
 
1475
drop table t1;
 
1476
create table t1 (v varchar(65530) character set utf8);
 
1477
show create table t1;
 
1478
drop table t1;
 
1479
 
 
1480
eval set storage_engine=$default;
 
1481
 
1332
1482
# InnoDB specific varchar tests
1333
 
#eval create $temp table t1 (v varchar(16384)) engine=$engine_type;
1334
 
#drop table t1;
 
1483
eval create table t1 (v varchar(16384)) engine=$engine_type;
 
1484
drop table t1;
1335
1485
 
1336
1486
#
1337
1487
# BUG#11039 Wrong key length in min()
1338
1488
#
1339
1489
 
1340
 
eval create $temp table t1 (a char(1), b char(1), key(a, b)) engine=$engine_type;
 
1490
eval create table t1 (a char(1), b char(1), key(a, b)) engine=$engine_type;
1341
1491
insert into t1 values ('8', '6'), ('4', '7');
1342
1492
select min(a) from t1;
1343
1493
select min(b) from t1 where a='8';
1347
1497
# Bug #11080 & #11005  Multi-row REPLACE fails on a duplicate key error
1348
1498
#
1349
1499
 
1350
 
eval create $temp table t1 ( `a` int NOT NULL auto_increment, `b` int default NULL,PRIMARY KEY  (`a`),UNIQUE KEY `b` (`b`)) ENGINE=$engine_type;
 
1500
eval CREATE TABLE t1 ( `a` int(11) NOT NULL auto_increment, `b` int(11) default NULL,PRIMARY KEY  (`a`),UNIQUE KEY `b` (`b`)) ENGINE=$engine_type;
1351
1501
insert into t1 (b) values (1);
1352
1502
replace into t1 (b) values (2), (1), (3);
1353
1503
select * from t1;
1359
1509
select * from t1;
1360
1510
drop table t1;
1361
1511
 
1362
 
eval create $temp table t1 (rowid int not null auto_increment, val int not null,primary
 
1512
eval create table t1 (rowid int not null auto_increment, val int not null,primary
1363
1513
key (rowid), unique(val)) engine=$engine_type;
1364
1514
replace into t1 (val) values ('1'),('2');
1365
1515
replace into t1 (val) values ('1'),('2');
1374
1524
# Test that update does not change internal auto-increment value
1375
1525
#
1376
1526
 
1377
 
eval create $temp table t1 (a int not null auto_increment primary key, val int) engine=$engine_type;
 
1527
eval create table t1 (a int not null auto_increment primary key, val int) engine=$engine_type;
1378
1528
insert into t1 (val) values (1);
1379
1529
update t1 set a=2 where a=1;
1380
1530
# We should get the following error because InnoDB does not update the counter
1390
1540
#
1391
1541
 
1392
1542
--disable_warnings
1393
 
eval create $temp table t1 (GRADE DECIMAL(4) NOT NULL, PRIMARY KEY (GRADE)) ENGINE=$engine_type;
 
1543
eval CREATE TABLE t1 (GRADE DECIMAL(4) NOT NULL, PRIMARY KEY (GRADE)) ENGINE=$engine_type;
1394
1544
--enable_warnings
1395
1545
INSERT INTO t1 (GRADE) VALUES (151),(252),(343);
1396
1546
SELECT GRADE  FROM t1 WHERE GRADE > 160 AND GRADE < 300;
1397
1547
SELECT GRADE  FROM t1 WHERE GRADE= 151;
1398
1548
DROP TABLE t1;
1399
1549
 
 
1550
#
 
1551
# Bug #12340 multitable delete deletes only one record
 
1552
#
 
1553
eval create table t1 (f1 varchar(10), f2 varchar(10), primary key (f1,f2)) engine=$engine_type;
 
1554
eval create table t2 (f3 varchar(10), f4 varchar(10), key (f4)) engine=$engine_type;
 
1555
insert into t2 values ('aa','cc');
 
1556
insert into t1 values ('aa','bb'),('aa','cc');
 
1557
delete t1 from t1,t2 where f1=f3 and f4='cc';
 
1558
select * from t1;
 
1559
drop table t1,t2;
 
1560
 
1400
1561
if ($test_foreign_keys)
1401
1562
{
1402
1563
#
1404
1565
# (bug #11946)
1405
1566
#
1406
1567
 
1407
 
eval create $temp table t1 (
 
1568
eval CREATE TABLE t1 (
1408
1569
id INTEGER NOT NULL AUTO_INCREMENT, PRIMARY KEY (id)
1409
1570
) ENGINE=$engine_type;
1410
1571
 
1411
 
eval create $temp table t2 (
 
1572
eval CREATE TABLE t2 (
1412
1573
id INTEGER NOT NULL,
1413
1574
FOREIGN KEY (id) REFERENCES t1 (id)
1414
1575
) ENGINE=$engine_type;
1428
1589
DROP TABLE t2, t1;
1429
1590
 
1430
1591
# Test that foreign keys in temporary tables are not accepted (bug #12084)
1431
 
eval create $temp table t1
 
1592
eval CREATE TABLE t1
1432
1593
(
1433
1594
 id INT PRIMARY KEY
1434
1595
) ENGINE=$engine_type;
1455
1616
#
1456
1617
 
1457
1618
# prefix index
1458
 
eval create $temp table t1 (col1 varchar(2000), index (col1(767)))
 
1619
eval create table t1 (col1 varchar(2000), index (col1(767)))
1459
1620
 character set = latin1 engine = $engine_type;
1460
1621
 
1461
1622
# normal indexes
1462
 
eval create $temp table t2 (col1 char(255), index (col1))
1463
 
 character set = latin1 engine = $engine_type;
1464
 
eval create $temp table t3 (col1 binary(255), index (col1))
1465
 
 character set = latin1 engine = $engine_type;
1466
 
eval create $temp table t4 (col1 varchar(767), index (col1))
1467
 
 character set = latin1 engine = $engine_type;
1468
 
eval create $temp table t5 (col1 varchar(767) primary key)
1469
 
 character set = latin1 engine = $engine_type;
1470
 
eval create $temp table t6 (col1 varbinary(767) primary key)
1471
 
 character set = latin1 engine = $engine_type;
1472
 
eval create $temp table t7 (col1 text, index(col1(767)))
1473
 
 character set = latin1 engine = $engine_type;
1474
 
eval create $temp table t8 (col1 blob, index(col1(767)))
 
1623
eval create table t2 (col1 char(255), index (col1))
 
1624
 character set = latin1 engine = $engine_type;
 
1625
eval create table t3 (col1 binary(255), index (col1))
 
1626
 character set = latin1 engine = $engine_type;
 
1627
eval create table t4 (col1 varchar(767), index (col1))
 
1628
 character set = latin1 engine = $engine_type;
 
1629
eval create table t5 (col1 varchar(767) primary key)
 
1630
 character set = latin1 engine = $engine_type;
 
1631
eval create table t6 (col1 varbinary(767) primary key)
 
1632
 character set = latin1 engine = $engine_type;
 
1633
eval create table t7 (col1 text, index(col1(767)))
 
1634
 character set = latin1 engine = $engine_type;
 
1635
eval create table t8 (col1 blob, index(col1(767)))
1475
1636
 character set = latin1 engine = $engine_type;
1476
1637
 
1477
1638
 
1478
1639
# multi-column indexes are allowed to be longer
1479
 
eval create $temp table t9 (col1 varchar(512), col2 varchar(512), index(col1, col2))
 
1640
eval create table t9 (col1 varchar(512), col2 varchar(512), index(col1, col2))
1480
1641
 character set = latin1 engine = $engine_type;
1481
1642
 
1482
1643
show create table t9;
1484
1645
drop table t1, t2, t3, t4, t5, t6, t7, t8, t9;
1485
1646
 
1486
1647
# these should have their index length trimmed
1487
 
eval create $temp table t1 (col1 varchar(768), index(col1))
1488
 
 character set = latin1 engine = $engine_type;
1489
 
eval create $temp table t2 (col1 varbinary(768), index(col1))
1490
 
 character set = latin1 engine = $engine_type;
1491
 
eval create $temp table t3 (col1 text, index(col1(768)))
1492
 
 character set = latin1 engine = $engine_type;
1493
 
eval create $temp table t4 (col1 blob, index(col1(768)))
 
1648
eval create table t1 (col1 varchar(768), index(col1))
 
1649
 character set = latin1 engine = $engine_type;
 
1650
eval create table t2 (col1 varbinary(768), index(col1))
 
1651
 character set = latin1 engine = $engine_type;
 
1652
eval create table t3 (col1 text, index(col1(768)))
 
1653
 character set = latin1 engine = $engine_type;
 
1654
eval create table t4 (col1 blob, index(col1(768)))
1494
1655
 character set = latin1 engine = $engine_type;
1495
1656
 
1496
1657
show create table t1;
1508
1669
 
1509
1670
# these should be refused
1510
1671
--error 1071
1511
 
eval create $temp table t1 (col1 varchar(768) primary key)
1512
 
 character set = latin1 engine = $engine_type;
1513
 
--error 1071
1514
 
eval create $temp table t2 (col1 varbinary(768) primary key)
1515
 
 character set = latin1 engine = $engine_type;
1516
 
--error 1071
1517
 
eval create $temp table t3 (col1 text, primary key(col1(768)))
1518
 
 character set = latin1 engine = $engine_type;
1519
 
--error 1071
1520
 
eval create $temp table t4 (col1 blob, primary key(col1(768)))
 
1672
eval create table t1 (col1 varchar(768) primary key)
 
1673
 character set = latin1 engine = $engine_type;
 
1674
--error 1071
 
1675
eval create table t2 (col1 varbinary(768) primary key)
 
1676
 character set = latin1 engine = $engine_type;
 
1677
--error 1071
 
1678
eval create table t3 (col1 text, primary key(col1(768)))
 
1679
 character set = latin1 engine = $engine_type;
 
1680
--error 1071
 
1681
eval create table t4 (col1 blob, primary key(col1(768)))
1521
1682
 character set = latin1 engine = $engine_type;
1522
1683
 
1523
1684
}
1528
1689
# Test improved foreign key error messages (bug #3443)
1529
1690
#
1530
1691
 
1531
 
eval create $temp table t1
 
1692
eval CREATE TABLE t1
1532
1693
(
1533
1694
 id INT PRIMARY KEY
1534
1695
) ENGINE=$engine_type;
1535
1696
 
1536
 
eval create $temp table t2
 
1697
eval CREATE TABLE t2
1537
1698
(
1538
1699
 v INT,
1539
1700
 CONSTRAINT c1 FOREIGN KEY (v) REFERENCES t1(id)
1562
1723
}
1563
1724
# End of FOREIGN tests
1564
1725
 
 
1726
if ($test_transactions)
 
1727
{
 
1728
#
 
1729
# Test that checksum table uses a consistent read Bug #12669
 
1730
#
 
1731
connect (a,localhost,root,,);
 
1732
connect (b,localhost,root,,);
 
1733
connection a;
 
1734
eval create table t1(a int not null) engine=$engine_type DEFAULT CHARSET=latin1;
 
1735
insert into t1 values (1),(2);
 
1736
set autocommit=0;
 
1737
checksum table t1;
 
1738
connection b;
 
1739
insert into t1 values(3);
 
1740
connection a;
 
1741
#
 
1742
# Here checksum should not see insert
 
1743
#
 
1744
checksum table t1;
 
1745
connection a;
 
1746
commit;
 
1747
checksum table t1;
 
1748
commit;
 
1749
drop table t1;
 
1750
#
 
1751
# autocommit = 1
 
1752
#
 
1753
connection a;
 
1754
eval create table t1(a int not null) engine=$engine_type DEFAULT CHARSET=latin1;
 
1755
insert into t1 values (1),(2);
 
1756
set autocommit=1;
 
1757
checksum table t1;
 
1758
connection b;
 
1759
set autocommit=1;
 
1760
insert into t1 values(3);
 
1761
connection a;
 
1762
#
 
1763
# Here checksum sees insert
 
1764
#
 
1765
checksum table t1;
 
1766
drop table t1;
 
1767
 
 
1768
connection default;
 
1769
disconnect a;
 
1770
disconnect b;
 
1771
}
 
1772
 
1565
1773
# tests for bugs #9802 and #13778
1566
1774
 
1567
1775
if ($test_foreign_keys)
1569
1777
# test that FKs between invalid types are not accepted
1570
1778
 
1571
1779
set foreign_key_checks=0;
1572
 
eval create $temp table t2 (a int primary key, b int, foreign key (b) references t1(a)) engine = $engine_type;
 
1780
eval create table t2 (a int primary key, b int, foreign key (b) references t1(a)) engine = $engine_type;
1573
1781
--replace_result $MYSQLTEST_VARDIR . master-data/ ''
1574
1782
-- error 1005
1575
 
eval create $temp table t1(a char(10) primary key, b varchar(20)) engine = $engine_type;
 
1783
eval create table t1(a char(10) primary key, b varchar(20)) engine = $engine_type;
1576
1784
set foreign_key_checks=1;
1577
1785
drop table t2;
1578
1786
 
1580
1788
# when f_k_c is 0
1581
1789
 
1582
1790
set foreign_key_checks=0;
1583
 
eval create $temp table t1(a varchar(10) primary key) engine = $engine_type DEFAULT CHARSET=latin1;
 
1791
eval create table t1(a varchar(10) primary key) engine = $engine_type DEFAULT CHARSET=latin1;
1584
1792
--replace_result $MYSQLTEST_VARDIR . master-data/ ''
1585
1793
-- error 1005
1586
 
eval create $temp table t2 (a varchar(10), foreign key (a) references t1(a)) engine = $engine_type DEFAULT CHARSET=utf8;
 
1794
eval create table t2 (a varchar(10), foreign key (a) references t1(a)) engine = $engine_type DEFAULT CHARSET=utf8;
1587
1795
set foreign_key_checks=1;
1588
1796
drop table t1;
1589
1797
 
1590
1798
# test that invalid datatype conversions with ALTER are not allowed
1591
1799
 
1592
1800
set foreign_key_checks=0;
1593
 
eval create $temp table t2 (a varchar(10), foreign key (a) references t1(a)) engine = $engine_type;
1594
 
eval create $temp table t1(a varchar(10) primary key) engine = $engine_type;
 
1801
eval create table t2 (a varchar(10), foreign key (a) references t1(a)) engine = $engine_type;
 
1802
eval create table t1(a varchar(10) primary key) engine = $engine_type;
1595
1803
-- error 1025,1025
1596
1804
alter table t1 modify column a int;
1597
1805
set foreign_key_checks=1;
1600
1808
# test that charset conversions with ALTER are allowed when f_k_c is 0
1601
1809
 
1602
1810
set foreign_key_checks=0;
1603
 
eval create $temp table t2 (a varchar(10), foreign key (a) references t1(a)) engine = $engine_type DEFAULT CHARSET=latin1;
1604
 
eval create $temp table t1(a varchar(10) primary key) engine = $engine_type DEFAULT CHARSET=latin1;
 
1811
eval create table t2 (a varchar(10), foreign key (a) references t1(a)) engine = $engine_type DEFAULT CHARSET=latin1;
 
1812
eval create table t1(a varchar(10) primary key) engine = $engine_type DEFAULT CHARSET=latin1;
1605
1813
alter table t1 convert to character set utf8;
1606
1814
set foreign_key_checks=1;
1607
1815
drop table t2,t1;
1609
1817
# test that RENAME does not allow invalid charsets when f_k_c is 0
1610
1818
 
1611
1819
set foreign_key_checks=0;
1612
 
eval create $temp table t2 (a varchar(10), foreign key (a) references t1(a)) engine = $engine_type DEFAULT CHARSET=latin1;
1613
 
eval create $temp table t3(a varchar(10) primary key) engine = $engine_type DEFAULT CHARSET=utf8;
 
1820
eval create table t2 (a varchar(10), foreign key (a) references t1(a)) engine = $engine_type DEFAULT CHARSET=latin1;
 
1821
eval create table t3(a varchar(10) primary key) engine = $engine_type DEFAULT CHARSET=utf8;
1614
1822
--replace_result $MYSQLTEST_VARDIR . master-data/ ''
1615
1823
-- error 1025
1616
1824
rename table t3 to t1;
1619
1827
 
1620
1828
# test that foreign key errors are reported correctly (Bug #15550)
1621
1829
 
1622
 
eval create $temp table t1(a int primary key) row_format=redundant engine=$engine_type;
1623
 
eval create $temp table t2(a int primary key,constraint foreign key(a)references t1(a)) row_format=compact engine=$engine_type;
1624
 
eval create $temp table t3(a int primary key) row_format=compact engine=$engine_type;
1625
 
eval create $temp table t4(a int primary key,constraint foreign key(a)references t3(a)) row_format=redundant engine=$engine_type;
 
1830
eval create table t1(a int primary key) row_format=redundant engine=$engine_type;
 
1831
eval create table t2(a int primary key,constraint foreign key(a)references t1(a)) row_format=compact engine=$engine_type;
 
1832
eval create table t3(a int primary key) row_format=compact engine=$engine_type;
 
1833
eval create table t4(a int primary key,constraint foreign key(a)references t3(a)) row_format=redundant engine=$engine_type;
1626
1834
 
1627
1835
insert into t1 values(1);
1628
1836
insert into t3 values(1);
1663
1871
#
1664
1872
# Test that we can create a large (>1K) key
1665
1873
#
1666
 
eval create $temp table t1 (a varchar(255) character set utf8,
 
1874
eval create table t1 (a varchar(255) character set utf8,
1667
1875
                 b varchar(255) character set utf8,
1668
1876
                 c varchar(255) character set utf8,
1669
1877
                 d varchar(255) character set utf8,
1670
1878
                 key (a,b,c,d)) engine=$engine_type;
1671
1879
drop table t1;
1672
1880
--error ER_TOO_LONG_KEY
1673
 
eval create $temp table t1 (a varchar(255) character set utf8,
 
1881
eval create table t1 (a varchar(255) character set utf8,
1674
1882
                 b varchar(255) character set utf8,
1675
1883
                 c varchar(255) character set utf8,
1676
1884
                 d varchar(255) character set utf8,
1680
1888
 
1681
1889
# test the padding of BINARY types and collations (Bug #14189)
1682
1890
 
1683
 
eval create $temp table t1 (s1 varbinary(2),primary key (s1)) engine=$engine_type;
1684
 
eval create $temp table t2 (s1 binary(2),primary key (s1)) engine=$engine_type;
1685
 
eval create $temp table t3 (s1 varchar(2),primary key (s1)) engine=$engine_type;
1686
 
eval create $temp table t4 (s1 char(2),primary key (s1)) engine=$engine_type;
 
1891
eval create table t1 (s1 varbinary(2),primary key (s1)) engine=$engine_type;
 
1892
eval create table t2 (s1 binary(2),primary key (s1)) engine=$engine_type;
 
1893
eval create table t3 (s1 varchar(2) binary,primary key (s1)) engine=$engine_type;
 
1894
eval create table t4 (s1 char(2) binary,primary key (s1)) engine=$engine_type;
1687
1895
 
1688
1896
insert into t1 values (0x41),(0x4120),(0x4100);
1689
1897
-- error ER_DUP_ENTRY
1704
1912
 
1705
1913
if (test_foreign_keys)
1706
1914
{
1707
 
eval create $temp table t1 (a int primary key,s1 varbinary(3) not null unique) engine=$engine_type;
1708
 
eval create $temp table t2 (s1 binary(2) not null, constraint c foreign key(s1) references t1(s1) on update cascade) engine=$engine_type;
 
1915
eval create table t1 (a int primary key,s1 varbinary(3) not null unique) engine=$engine_type;
 
1916
eval create table t2 (s1 binary(2) not null, constraint c foreign key(s1) references t1(s1) on update cascade) engine=$engine_type;
1709
1917
 
1710
1918
insert into t1 values(1,0x4100),(2,0x41),(3,0x4120),(4,0x42);
1711
1919
-- error 1452
1738
1946
 
1739
1947
drop table t2,t1;
1740
1948
 
1741
 
eval create $temp table t1 (a int primary key,s1 varchar(2) not null unique) engine=$engine_type;
1742
 
eval create $temp table t2 (s1 char(2) not null, constraint c foreign key(s1) references t1(s1) on update cascade) engine=$engine_type;
 
1949
eval create table t1 (a int primary key,s1 varchar(2) binary not null unique) engine=$engine_type;
 
1950
eval create table t2 (s1 char(2) binary not null, constraint c foreign key(s1) references t1(s1) on update cascade) engine=$engine_type;
1743
1951
 
1744
1952
insert into t1 values(1,0x4100),(2,0x41);
1745
1953
insert into t2 values(0x41);
1763
1971
# Ensure that <tablename>_ibfk_0 is not mistreated as a
1764
1972
# generated foreign key identifier.  (Bug #16387)
1765
1973
 
1766
 
eval create $temp table t1(a INT, PRIMARY KEY(a)) ENGINE=$engine_type;
1767
 
eval create $temp table t2(a INT) ENGINE=$engine_type;
 
1974
eval CREATE TABLE t1(a INT, PRIMARY KEY(a)) ENGINE=$engine_type;
 
1975
eval CREATE TABLE t2(a INT) ENGINE=$engine_type;
1768
1976
ALTER TABLE t2 ADD FOREIGN KEY (a) REFERENCES t1(a);
1769
1977
ALTER TABLE t2 DROP FOREIGN KEY t2_ibfk_1;
1770
1978
ALTER TABLE t2 ADD CONSTRAINT t2_ibfk_0 FOREIGN KEY (a) REFERENCES t1(a);
1771
1979
ALTER TABLE t2 DROP FOREIGN KEY t2_ibfk_0;
1772
 
SHOW create $temp table t2;
 
1980
SHOW CREATE TABLE t2;
1773
1981
DROP TABLE t2,t1;
1774
1982
}
1775
1983
 
 
1984
#
 
1985
# Test case for bug #16229: MySQL/InnoDB uses full explicit table locks in trigger processing
 
1986
#
 
1987
 
 
1988
connect (a,localhost,root,,);
 
1989
connect (b,localhost,root,,);
 
1990
connection a;
 
1991
eval create table t1(a int not null, b int, c int, d int, primary key(a)) engine=$engine_type;
 
1992
insert into t1(a) values (1),(2),(3);
 
1993
commit;
 
1994
connection b;
 
1995
set autocommit = 0;
 
1996
update t1 set b = 5 where a = 2;
 
1997
connection a;
 
1998
delimiter |;
 
1999
create trigger t1t before insert on t1 for each row begin set NEW.b = NEW.a * 10 + 5, NEW.c = NEW.a / 10; end |
 
2000
delimiter ;|
 
2001
set autocommit = 0;
 
2002
connection a;
 
2003
insert into t1(a) values (10),(20),(30),(40),(50),(60),(70),(80),(90),(100),
 
2004
(11),(21),(31),(41),(51),(61),(71),(81),(91),(101),
 
2005
(12),(22),(32),(42),(52),(62),(72),(82),(92),(102),
 
2006
(13),(23),(33),(43),(53),(63),(73),(83),(93),(103),
 
2007
(14),(24),(34),(44),(54),(64),(74),(84),(94),(104);
 
2008
connection b;
 
2009
commit;
 
2010
connection a;
 
2011
commit;
 
2012
drop trigger t1t;
 
2013
drop table t1;
 
2014
disconnect a;
 
2015
disconnect b;
 
2016
#
 
2017
# Another trigger test
 
2018
#
 
2019
connect (a,localhost,root,,);
 
2020
connect (b,localhost,root,,);
 
2021
connection a;
 
2022
eval create table t1(a int not null, b int, c int, d int, primary key(a)) engine=$engine_type;
 
2023
eval create table t2(a int not null, b int, c int, d int, primary key(a)) engine=$engine_type;
 
2024
eval create table t3(a int not null, b int, c int, d int, primary key(a)) engine=$engine_type;
 
2025
eval create table t4(a int not null, b int, c int, d int, primary key(a)) engine=$engine_type;
 
2026
eval create table t5(a int not null, b int, c int, d int, primary key(a)) engine=$engine_type;
 
2027
insert into t1(a) values (1),(2),(3);
 
2028
insert into t2(a) values (1),(2),(3);
 
2029
insert into t3(a) values (1),(2),(3);
 
2030
insert into t4(a) values (1),(2),(3);
 
2031
insert into t3(a) values (5),(7),(8);
 
2032
insert into t4(a) values (5),(7),(8);
 
2033
insert into t5(a) values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),(12);
 
2034
 
 
2035
delimiter |;
 
2036
create trigger t1t before insert on t1 for each row begin
 
2037
    INSERT INTO t2 SET a = NEW.a;
 
2038
end |
 
2039
 
 
2040
create trigger t2t before insert on t2 for each row begin
 
2041
    DELETE FROM t3 WHERE a = NEW.a;
 
2042
end |
 
2043
 
 
2044
create trigger t3t before delete on t3 for each row begin
 
2045
    UPDATE t4 SET b = b + 1 WHERE a = OLD.a;
 
2046
end |
 
2047
 
 
2048
create trigger t4t before update on t4 for each row begin
 
2049
    UPDATE t5 SET b = b + 1 where a = NEW.a;
 
2050
end |
 
2051
delimiter ;|
 
2052
commit;
 
2053
set autocommit = 0;
 
2054
update t1 set b = b + 5 where a = 1;
 
2055
update t2 set b = b + 5 where a = 1;
 
2056
update t3 set b = b + 5 where a = 1;
 
2057
update t4 set b = b + 5 where a = 1;
 
2058
insert into t5(a) values(20);
 
2059
connection b;
 
2060
set autocommit = 0;
 
2061
insert into t1(a) values(7);
 
2062
insert into t2(a) values(8);
 
2063
delete from t2 where a = 3;
 
2064
update t4 set b = b + 1 where a = 3;
 
2065
commit;
 
2066
drop trigger t1t;
 
2067
drop trigger t2t;
 
2068
drop trigger t3t;
 
2069
drop trigger t4t;
 
2070
drop table t1, t2, t3, t4, t5;
 
2071
connection default;
 
2072
disconnect a;
 
2073
disconnect b;
 
2074
 
1776
2075
if ($test_foreign_keys)
1777
2076
{
1778
2077
#
1780
2079
# error message (bug #9680)
1781
2080
#
1782
2081
 
1783
 
eval create $temp table t1 (
 
2082
eval CREATE TABLE t1 (
1784
2083
  field1 varchar(8) NOT NULL DEFAULT '',
1785
2084
  field2 varchar(8) NOT NULL DEFAULT '',
1786
2085
  PRIMARY KEY  (field1, field2)
1787
2086
) ENGINE=$engine_type;
1788
2087
 
1789
 
eval create $temp table t2 (
 
2088
eval CREATE TABLE t2 (
1790
2089
  field1 varchar(8) NOT NULL DEFAULT '' PRIMARY KEY,
1791
2090
  FOREIGN KEY (field1) REFERENCES t1 (field1)
1792
2091
    ON DELETE CASCADE ON UPDATE CASCADE
1807
2106
#
1808
2107
# Bug#18477 - MySQL/InnoDB Ignoring Foreign Keys in ALTER TABLE
1809
2108
#
1810
 
eval create $temp table t1 (
 
2109
eval create table t1 (
1811
2110
  c1 bigint not null,
1812
2111
  c2 bigint not null,
1813
2112
  primary key (c1),
1814
2113
  unique  key (c2)
1815
2114
) engine=$engine_type;
1816
2115
#
1817
 
eval create $temp table t2 (
 
2116
eval create table t2 (
1818
2117
  c1 bigint not null,
1819
2118
  primary key (c1)
1820
2119
) engine=$engine_type;
1834
2133
# Bug #14360: problem with intervals
1835
2134
#
1836
2135
 
1837
 
eval create $temp table t1(a date) engine=$engine_type;
1838
 
eval create $temp table t2(a date, key(a)) engine=$engine_type;
 
2136
eval create table t1(a date) engine=$engine_type;
 
2137
eval create table t2(a date, key(a)) engine=$engine_type;
1839
2138
insert into t1 values('2005-10-01');
1840
2139
insert into t2 values('2005-10-01');
1841
2140
select * from t1, t2
1842
2141
  where t2.a between t1.a - interval 2 day and t1.a + interval 2 day;
1843
2142
drop table t1, t2;
1844
2143
 
1845
 
eval create $temp table t1 (id int not null, f_id int not null, f int not null,
 
2144
eval create table t1 (id int not null, f_id int not null, f int not null,
1846
2145
primary key(f_id, id)) engine=$engine_type;
1847
 
eval create $temp table t2 (id int not null,s_id int not null,s varchar(200),
 
2146
eval create table t2 (id int not null,s_id int not null,s varchar(200),
1848
2147
primary key(id)) engine=$engine_type;
1849
2148
INSERT INTO t1 VALUES (8, 1, 3);
1850
2149
INSERT INTO t1 VALUES (1, 2, 1);
1851
2150
INSERT INTO t2 VALUES (1, 0, '');
1852
2151
INSERT INTO t2 VALUES (8, 1, '');
1853
2152
commit;
 
2153
DELETE ml.* FROM t1 AS ml LEFT JOIN t2 AS mm ON (mm.id=ml.id)
 
2154
WHERE mm.id IS NULL;
1854
2155
select ml.* from t1 as ml left join t2 as mm on (mm.id=ml.id)
1855
2156
where mm.id is null lock in share mode;
1856
2157
drop table t1,t2;
1859
2160
# Test case where X-locks on unused rows should be released in a
1860
2161
# update (because READ COMMITTED isolation level)
1861
2162
#
1862
 
if(!$using_temp)
1863
 
{
 
2163
 
1864
2164
connect (a,localhost,root,,);
1865
2165
connect (b,localhost,root,,);
1866
2166
connection a;
1867
 
eval create $temp table t1(a int not null, b int, primary key(a)) engine=$engine_type;
 
2167
eval create table t1(a int not null, b int, primary key(a)) engine=$engine_type;
1868
2168
insert into t1 values(1,1),(2,2),(3,1),(4,2),(5,1),(6,2),(7,3);
1869
2169
commit;
1870
2170
set autocommit = 0;
1885
2185
connection default;
1886
2186
disconnect a;
1887
2187
disconnect b;
1888
 
}
 
2188
 
1889
2189
if ($test_transactions)
1890
2190
{
1891
2191
#
1896
2196
connect (a,localhost,root,,);
1897
2197
connect (b,localhost,root,,);
1898
2198
connection a;
1899
 
eval create $temp table t1(a int not null, b int, primary key(a)) engine=$engine_type;
 
2199
eval create table t1(a int not null, b int, primary key(a)) engine=$engine_type;
1900
2200
insert into t1 values(1,1),(2,2),(3,1),(4,2),(5,1),(6,2);
1901
2201
commit;
1902
2202
set autocommit = 0;
1932
2232
connect (a,localhost,root,,);
1933
2233
connect (b,localhost,root,,);
1934
2234
connection a;
1935
 
eval create $temp table t1(a int not null, b int, primary key(a)) engine=$engine_type;
 
2235
eval create table t1(a int not null, b int, primary key(a)) engine=$engine_type;
1936
2236
insert into t1 values (1,2),(5,3),(4,2);
1937
 
eval create $temp table t2(d int not null, e int, primary key(d)) engine=$engine_type;
 
2237
eval create table t2(d int not null, e int, primary key(d)) engine=$engine_type;
1938
2238
insert into t2 values (8,6),(12,1),(3,1);
1939
2239
commit;
1940
2240
set autocommit = 0;
1944
2244
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
1945
2245
insert into t1 select * from t2;
1946
2246
update t1 set b = (select e from t2 where a = d);
1947
 
eval create $temp table t3(d int not null, e int, primary key(d)) engine=$engine_type
 
2247
eval create table t3(d int not null, e int, primary key(d)) engine=$engine_type
1948
2248
select * from t2;
1949
2249
commit;
1950
2250
connection a;
1988
2288
connect (j,localhost,root,,);
1989
2289
eval SET SESSION STORAGE_ENGINE = $engine_type;
1990
2290
connection a;
1991
 
create $temp table t1(a int not null, b int, primary key(a));
 
2291
create table t1(a int not null, b int, primary key(a));
1992
2292
insert into t1 values (1,2),(5,3),(4,2);
1993
 
create $temp table t2(a int not null, b int, primary key(a));
 
2293
create table t2(a int not null, b int, primary key(a));
1994
2294
insert into t2 values (8,6),(12,1),(3,1);
1995
 
create $temp table t3(d int not null, b int, primary key(d));
 
2295
create table t3(d int not null, b int, primary key(d));
1996
2296
insert into t3 values (8,6),(12,1),(3,1);
1997
 
create $temp table t5(a int not null, b int, primary key(a));
 
2297
create table t5(a int not null, b int, primary key(a));
1998
2298
insert into t5 values (1,2),(5,3),(4,2);
1999
 
create $temp table t6(d int not null, e int, primary key(d));
 
2299
create table t6(d int not null, e int, primary key(d));
2000
2300
insert into t6 values (8,6),(12,1),(3,1);
2001
 
create $temp table t8(a int not null, b int, primary key(a));
 
2301
create table t8(a int not null, b int, primary key(a));
2002
2302
insert into t8 values (1,2),(5,3),(4,2);
2003
 
create $temp table t9(d int not null, e int, primary key(d));
 
2303
create table t9(d int not null, e int, primary key(d));
2004
2304
insert into t9 values (8,6),(12,1),(3,1);
2005
2305
commit;
2006
2306
set autocommit = 0;
2019
2319
set autocommit = 0;
2020
2320
SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;
2021
2321
--send
2022
 
create $temp table t4(a int not null, b int, primary key(a)) select * from t2;
 
2322
create table t4(a int not null, b int, primary key(a)) select * from t2;
2023
2323
connection e;
2024
2324
set autocommit = 0;
2025
2325
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
2034
2334
set autocommit = 0;
2035
2335
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
2036
2336
--send
2037
 
create $temp table t7(a int not null, b int, primary key(a)) select * from t2 lock in share mode;
 
2337
create table t7(a int not null, b int, primary key(a)) select * from t2 lock in share mode;
2038
2338
connection h;
2039
2339
set autocommit = 0;
2040
2340
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
2049
2349
set autocommit = 0;
2050
2350
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
2051
2351
--send
2052
 
create $temp table t10(a int not null, b int, primary key(a)) select * from t2 for update;
 
2352
create table t10(a int not null, b int, primary key(a)) select * from t2 for update;
2053
2353
 
2054
2354
connection b;
2055
2355
--error 1205
2109
2409
{
2110
2410
# bug 18934, "InnoDB crashes when table uses column names like DB_ROW_ID"
2111
2411
--error 1005
2112
 
eval create $temp table t1 (DB_ROW_ID int) engine=$engine_type;
 
2412
eval CREATE TABLE t1 (DB_ROW_ID int) engine=$engine_type;
2113
2413
 
2114
2414
#
2115
2415
# Bug #17152: Wrong result with BINARY comparison on aliased column
2116
2416
#
2117
2417
 
2118
 
eval create $temp table t1 (
 
2418
eval CREATE TABLE t1 (
2119
2419
   a BIGINT(20) NOT NULL,
2120
2420
    PRIMARY KEY  (a)
2121
2421
 ) ENGINE=$engine_type DEFAULT CHARSET=UTF8;
2122
2422
 
2123
 
eval create $temp table t2 (
 
2423
eval CREATE TABLE t2 (
2124
2424
  a BIGINT(20) NOT NULL,
2125
2425
  b VARCHAR(128) NOT NULL,
2126
2426
  c TEXT NOT NULL,
2152
2452
# Bug #15680 (SPATIAL key in innodb)
2153
2453
#
2154
2454
--error ER_TABLE_CANT_HANDLE_SPKEYS
2155
 
eval create $temp table t1 (g geometry not null, spatial gk(g)) engine=$engine_type;
 
2455
eval create table t1 (g geometry not null, spatial gk(g)) engine=$engine_type;
2156
2456
}
2157
2457
 
2158
2458
#
2159
2459
# Test optimize on table with open transaction
2160
2460
#
2161
2461
 
2162
 
eval create $temp table t1 ( a int ) ENGINE=$engine_type;
 
2462
eval CREATE TABLE t1 ( a int ) ENGINE=$engine_type;
2163
2463
BEGIN;
2164
2464
INSERT INTO t1 VALUES (1);
2165
 
eval ALTER TABLE t1 ENGINE=$engine_type;
 
2465
OPTIMIZE TABLE t1;
2166
2466
DROP TABLE t1;
2167
2467
 
2168
2468
#######################################################################