2001-10-08 06:24:04 +02:00
|
|
|
drop table if exists t1;
|
2004-06-22 11:10:50 +02:00
|
|
|
drop table if exists t2;
|
2003-08-18 23:08:08 +02:00
|
|
|
SET SQL_WARNINGS=1;
|
2003-12-10 05:31:42 +01:00
|
|
|
create table t1 (a int not null auto_increment,b int, primary key (a)) engine=myisam auto_increment=3;
|
2001-09-28 07:05:54 +02:00
|
|
|
insert into t1 values (1,1),(NULL,3),(NULL,4);
|
|
|
|
|
delete from t1 where a=4;
|
|
|
|
|
insert into t1 values (NULL,5),(NULL,6);
|
|
|
|
|
select * from t1;
|
2000-12-28 02:56:38 +01:00
|
|
|
a b
|
|
|
|
|
1 1
|
|
|
|
|
3 3
|
|
|
|
|
5 5
|
|
|
|
|
6 6
|
2001-09-28 07:05:54 +02:00
|
|
|
delete from t1 where a=6;
|
|
|
|
|
replace t1 values (3,1);
|
|
|
|
|
ALTER TABLE t1 add c int;
|
|
|
|
|
replace t1 values (3,3,3);
|
|
|
|
|
insert into t1 values (NULL,7,7);
|
|
|
|
|
update t1 set a=8,b=b+1,c=c+1 where a=7;
|
|
|
|
|
insert into t1 values (NULL,9,9);
|
|
|
|
|
select * from t1;
|
2000-12-28 02:56:38 +01:00
|
|
|
a b c
|
|
|
|
|
1 1 NULL
|
|
|
|
|
3 3 3
|
|
|
|
|
5 5 NULL
|
|
|
|
|
8 8 8
|
|
|
|
|
9 9 9
|
2001-09-28 07:05:54 +02:00
|
|
|
drop table t1;
|
|
|
|
|
create table t1 (
|
|
|
|
|
skey tinyint unsigned NOT NULL auto_increment PRIMARY KEY,
|
|
|
|
|
sval char(20)
|
|
|
|
|
);
|
|
|
|
|
insert into t1 values (NULL, "hello");
|
|
|
|
|
insert into t1 values (NULL, "hey");
|
|
|
|
|
select * from t1;
|
2000-12-28 02:56:38 +01:00
|
|
|
skey sval
|
|
|
|
|
1 hello
|
|
|
|
|
2 hey
|
2001-09-28 07:05:54 +02:00
|
|
|
select _rowid,t1._rowid,skey,sval from t1;
|
2000-12-28 02:56:38 +01:00
|
|
|
_rowid _rowid skey sval
|
|
|
|
|
1 1 1 hello
|
|
|
|
|
2 2 2 hey
|
2001-09-28 07:05:54 +02:00
|
|
|
drop table t1;
|
|
|
|
|
create table t1 (a char(10) not null, b int not null auto_increment, primary key(a,b));
|
|
|
|
|
insert into t1 values ("a",1),("b",2),("a",2),("c",1);
|
|
|
|
|
insert into t1 values ("a",NULL),("b",NULL),("c",NULL),("e",NULL);
|
|
|
|
|
insert into t1 (a) values ("a"),("b"),("c"),("d");
|
|
|
|
|
insert into t1 (a) values ('k'),('d');
|
|
|
|
|
insert into t1 (a) values ("a");
|
|
|
|
|
insert into t1 values ("d",last_insert_id());
|
|
|
|
|
select * from t1;
|
2000-12-28 02:56:38 +01:00
|
|
|
a b
|
|
|
|
|
a 1
|
|
|
|
|
a 2
|
|
|
|
|
a 3
|
|
|
|
|
a 4
|
|
|
|
|
a 5
|
|
|
|
|
b 2
|
|
|
|
|
b 3
|
|
|
|
|
b 4
|
|
|
|
|
c 1
|
|
|
|
|
c 2
|
|
|
|
|
c 3
|
|
|
|
|
d 1
|
|
|
|
|
d 2
|
|
|
|
|
d 5
|
|
|
|
|
e 1
|
|
|
|
|
k 1
|
2001-09-28 07:05:54 +02:00
|
|
|
drop table t1;
|
|
|
|
|
create table t1 (ordid int(8) not null auto_increment, ord varchar(50) not null, primary key (ordid), index(ord,ordid));
|
|
|
|
|
insert into t1 (ordid,ord) values (NULL,'sdj'),(NULL,'sdj');
|
|
|
|
|
select * from t1;
|
2000-12-28 02:56:38 +01:00
|
|
|
ordid ord
|
|
|
|
|
1 sdj
|
|
|
|
|
2 sdj
|
2001-09-28 07:05:54 +02:00
|
|
|
drop table t1;
|
|
|
|
|
create table t1 (ordid int(8) not null auto_increment, ord varchar(50) not null, primary key (ord,ordid));
|
|
|
|
|
insert into t1 values (NULL,'sdj'),(NULL,'sdj'),(NULL,"abc"),(NULL,'abc'),(NULL,'zzz'),(NULL,'sdj'),(NULL,'abc');
|
|
|
|
|
select * from t1;
|
2000-12-28 02:56:38 +01:00
|
|
|
ordid ord
|
|
|
|
|
1 abc
|
|
|
|
|
2 abc
|
|
|
|
|
3 abc
|
|
|
|
|
1 sdj
|
|
|
|
|
2 sdj
|
|
|
|
|
3 sdj
|
|
|
|
|
1 zzz
|
2001-09-28 07:05:54 +02:00
|
|
|
drop table t1;
|
2003-03-02 01:48:57 +01:00
|
|
|
create table t1 (sid char(5), id int(2) NOT NULL auto_increment, key(sid, id));
|
|
|
|
|
create table t2 (sid char(20), id int(2));
|
|
|
|
|
insert into t2 values ('skr',NULL),('skr',NULL),('test',NULL);
|
|
|
|
|
insert into t1 select * from t2;
|
|
|
|
|
select * from t1;
|
|
|
|
|
sid id
|
|
|
|
|
skr 1
|
|
|
|
|
skr 2
|
|
|
|
|
test 1
|
|
|
|
|
drop table t1,t2;
|
2001-09-28 07:05:54 +02:00
|
|
|
create table t1 (a int not null primary key auto_increment);
|
|
|
|
|
insert into t1 values (0);
|
|
|
|
|
update t1 set a=0;
|
|
|
|
|
select * from t1;
|
2001-07-16 02:04:30 +02:00
|
|
|
a
|
|
|
|
|
0
|
2001-09-28 07:05:54 +02:00
|
|
|
check table t1;
|
2001-07-16 02:04:30 +02:00
|
|
|
Table Op Msg_type Msg_text
|
|
|
|
|
test.t1 check warning Found row where the auto_increment column has the value 0
|
|
|
|
|
test.t1 check status OK
|
2001-09-28 07:05:54 +02:00
|
|
|
drop table t1;
|
2003-12-19 15:25:50 +01:00
|
|
|
create table t1 (a int not null auto_increment primary key);
|
|
|
|
|
insert into t1 values (NULL);
|
|
|
|
|
insert into t1 values (-1);
|
|
|
|
|
select last_insert_id();
|
|
|
|
|
last_insert_id()
|
|
|
|
|
1
|
|
|
|
|
insert into t1 values (NULL);
|
|
|
|
|
select * from t1;
|
|
|
|
|
a
|
|
|
|
|
-1
|
|
|
|
|
1
|
|
|
|
|
2
|
|
|
|
|
drop table t1;
|
2003-12-19 16:15:54 +01:00
|
|
|
create table t1 (a int not null auto_increment primary key) /*!40102 engine=heap */;
|
2003-12-19 15:25:50 +01:00
|
|
|
insert into t1 values (NULL);
|
|
|
|
|
insert into t1 values (-1);
|
|
|
|
|
select last_insert_id();
|
|
|
|
|
last_insert_id()
|
|
|
|
|
1
|
|
|
|
|
insert into t1 values (NULL);
|
|
|
|
|
select * from t1;
|
|
|
|
|
a
|
|
|
|
|
1
|
2003-12-19 16:15:54 +01:00
|
|
|
-1
|
2003-12-19 15:25:50 +01:00
|
|
|
2
|
|
|
|
|
drop table t1;
|
2003-03-31 21:14:26 +02:00
|
|
|
create table t1 (i tinyint unsigned not null auto_increment primary key);
|
|
|
|
|
insert into t1 set i = 254;
|
|
|
|
|
insert into t1 set i = null;
|
|
|
|
|
select last_insert_id();
|
|
|
|
|
last_insert_id()
|
|
|
|
|
255
|
2003-10-30 11:57:26 +01:00
|
|
|
explain extended select last_insert_id();
|
2006-07-28 19:27:01 +02:00
|
|
|
id select_type table type possible_keys key key_len ref rows filtered Extra
|
|
|
|
|
1 SIMPLE NULL NULL NULL NULL NULL NULL NULL NULL No tables used
|
2003-10-30 11:57:26 +01:00
|
|
|
Warnings:
|
2006-06-27 19:28:32 +02:00
|
|
|
Note 1003 select last_insert_id() AS `last_insert_id()`
|
2003-06-30 12:28:36 +02:00
|
|
|
insert into t1 set i = 254;
|
2006-01-23 12:17:05 +01:00
|
|
|
ERROR 23000: Duplicate entry '254' for key 'PRIMARY'
|
2003-06-30 12:28:36 +02:00
|
|
|
select last_insert_id();
|
|
|
|
|
last_insert_id()
|
|
|
|
|
255
|
2003-03-31 21:14:26 +02:00
|
|
|
insert into t1 set i = null;
|
2006-01-23 12:17:05 +01:00
|
|
|
ERROR 23000: Duplicate entry '255' for key 'PRIMARY'
|
2003-03-31 21:14:26 +02:00
|
|
|
select last_insert_id();
|
|
|
|
|
last_insert_id()
|
WL#3146 "less locking in auto_increment":
this is a cleanup patch for our current auto_increment handling:
new names for auto_increment variables in THD, new methods to manipulate them
(see sql_class.h), some move into handler::, causing less backup/restore
work when executing substatements.
This makes the logic hopefully clearer, less work is is needed in
mysql_insert().
By cleaning up, using different variables for different purposes (instead
of one for 3 things...), we fix those bugs, which someone may want to fix
in 5.0 too:
BUG#20339 "stored procedure using LAST_INSERT_ID() does not replicate
statement-based"
BUG#20341 "stored function inserting into one auto_increment puts bad
data in slave"
BUG#19243 "wrong LAST_INSERT_ID() after ON DUPLICATE KEY UPDATE"
(now if a row is updated, LAST_INSERT_ID() will return its id)
and re-fixes:
BUG#6880 "LAST_INSERT_ID() value changes during multi-row INSERT"
(already fixed differently by Ramil in 4.1)
Test of documented behaviour of mysql_insert_id() (there was no test).
The behaviour changes introduced are:
- LAST_INSERT_ID() now returns "the first autogenerated auto_increment value
successfully inserted", instead of "the first autogenerated auto_increment
value if any row was successfully inserted", see auto_increment.test.
Same for mysql_insert_id(), see mysql_client_test.c.
- LAST_INSERT_ID() returns the id of the updated row if ON DUPLICATE KEY
UPDATE, see auto_increment.test. Same for mysql_insert_id(), see
mysql_client_test.c.
- LAST_INSERT_ID() does not change if no autogenerated value was successfully
inserted (it used to then be 0), see auto_increment.test.
- if in INSERT SELECT no autogenerated value was successfully inserted,
mysql_insert_id() now returns the id of the last inserted row (it already
did this for INSERT VALUES), see mysql_client_test.c.
- if INSERT SELECT uses LAST_INSERT_ID(X), mysql_insert_id() now returns X
(it already did this for INSERT VALUES), see mysql_client_test.c.
- NDB now behaves like other engines wrt SET INSERT_ID: with INSERT IGNORE,
the id passed in SET INSERT_ID is re-used until a row succeeds; SET INSERT_ID
influences not only the first row now.
Additionally, when unlocking a table we check that the thread is not keeping
a next_insert_id (as the table is unlocked that id is potentially out-of-date);
forgetting about this next_insert_id is done in a new
handler::ha_release_auto_increment().
Finally we prepare for engines capable of reserving finite-length intervals
of auto_increment values: we store such intervals in THD. The next step
(to be done by the replication team in 5.1) is to read those intervals from
THD and actually store them in the statement-based binary log. NDB
will be a good engine to test that.
2006-07-09 17:52:19 +02:00
|
|
|
255
|
2003-03-31 21:14:26 +02:00
|
|
|
drop table t1;
|
|
|
|
|
create table t1 (i tinyint unsigned not null auto_increment, key (i));
|
|
|
|
|
insert into t1 set i = 254;
|
|
|
|
|
insert into t1 set i = null;
|
|
|
|
|
select last_insert_id();
|
|
|
|
|
last_insert_id()
|
|
|
|
|
255
|
|
|
|
|
insert into t1 set i = null;
|
2003-04-30 09:07:37 +02:00
|
|
|
Warnings:
|
2005-12-02 12:01:44 +01:00
|
|
|
Warning 1264 Out of range value for column 'i' at row 1
|
2003-03-31 21:14:26 +02:00
|
|
|
select last_insert_id();
|
|
|
|
|
last_insert_id()
|
|
|
|
|
255
|
|
|
|
|
drop table t1;
|
|
|
|
|
create table t1 (i tinyint unsigned not null auto_increment primary key, b int, unique (b));
|
|
|
|
|
insert into t1 values (NULL, 10);
|
|
|
|
|
select last_insert_id();
|
|
|
|
|
last_insert_id()
|
|
|
|
|
1
|
|
|
|
|
insert into t1 values (NULL, 15);
|
|
|
|
|
select last_insert_id();
|
|
|
|
|
last_insert_id()
|
|
|
|
|
2
|
|
|
|
|
insert into t1 values (NULL, 10);
|
2006-01-23 12:17:05 +01:00
|
|
|
ERROR 23000: Duplicate entry '10' for key 'b'
|
2003-03-31 21:14:26 +02:00
|
|
|
select last_insert_id();
|
|
|
|
|
last_insert_id()
|
WL#3146 "less locking in auto_increment":
this is a cleanup patch for our current auto_increment handling:
new names for auto_increment variables in THD, new methods to manipulate them
(see sql_class.h), some move into handler::, causing less backup/restore
work when executing substatements.
This makes the logic hopefully clearer, less work is is needed in
mysql_insert().
By cleaning up, using different variables for different purposes (instead
of one for 3 things...), we fix those bugs, which someone may want to fix
in 5.0 too:
BUG#20339 "stored procedure using LAST_INSERT_ID() does not replicate
statement-based"
BUG#20341 "stored function inserting into one auto_increment puts bad
data in slave"
BUG#19243 "wrong LAST_INSERT_ID() after ON DUPLICATE KEY UPDATE"
(now if a row is updated, LAST_INSERT_ID() will return its id)
and re-fixes:
BUG#6880 "LAST_INSERT_ID() value changes during multi-row INSERT"
(already fixed differently by Ramil in 4.1)
Test of documented behaviour of mysql_insert_id() (there was no test).
The behaviour changes introduced are:
- LAST_INSERT_ID() now returns "the first autogenerated auto_increment value
successfully inserted", instead of "the first autogenerated auto_increment
value if any row was successfully inserted", see auto_increment.test.
Same for mysql_insert_id(), see mysql_client_test.c.
- LAST_INSERT_ID() returns the id of the updated row if ON DUPLICATE KEY
UPDATE, see auto_increment.test. Same for mysql_insert_id(), see
mysql_client_test.c.
- LAST_INSERT_ID() does not change if no autogenerated value was successfully
inserted (it used to then be 0), see auto_increment.test.
- if in INSERT SELECT no autogenerated value was successfully inserted,
mysql_insert_id() now returns the id of the last inserted row (it already
did this for INSERT VALUES), see mysql_client_test.c.
- if INSERT SELECT uses LAST_INSERT_ID(X), mysql_insert_id() now returns X
(it already did this for INSERT VALUES), see mysql_client_test.c.
- NDB now behaves like other engines wrt SET INSERT_ID: with INSERT IGNORE,
the id passed in SET INSERT_ID is re-used until a row succeeds; SET INSERT_ID
influences not only the first row now.
Additionally, when unlocking a table we check that the thread is not keeping
a next_insert_id (as the table is unlocked that id is potentially out-of-date);
forgetting about this next_insert_id is done in a new
handler::ha_release_auto_increment().
Finally we prepare for engines capable of reserving finite-length intervals
of auto_increment values: we store such intervals in THD. The next step
(to be done by the replication team in 5.1) is to read those intervals from
THD and actually store them in the statement-based binary log. NDB
will be a good engine to test that.
2006-07-09 17:52:19 +02:00
|
|
|
2
|
2003-03-31 21:14:26 +02:00
|
|
|
drop table t1;
|
2003-07-23 00:58:30 +02:00
|
|
|
create table t1(a int auto_increment,b int null,primary key(a));
|
|
|
|
|
SET SQL_MODE=NO_AUTO_VALUE_ON_ZERO;
|
|
|
|
|
insert into t1(a,b)values(NULL,1);
|
|
|
|
|
insert into t1(a,b)values(200,2);
|
|
|
|
|
insert into t1(a,b)values(0,3);
|
|
|
|
|
insert into t1(b)values(4);
|
2003-07-28 16:57:46 +02:00
|
|
|
insert into t1(b)values(5);
|
|
|
|
|
insert into t1(b)values(6);
|
|
|
|
|
insert into t1(b)values(7);
|
|
|
|
|
select * from t1 order by b;
|
2003-07-23 00:58:30 +02:00
|
|
|
a b
|
|
|
|
|
1 1
|
|
|
|
|
200 2
|
|
|
|
|
0 3
|
|
|
|
|
201 4
|
|
|
|
|
202 5
|
2003-07-28 16:57:46 +02:00
|
|
|
203 6
|
|
|
|
|
204 7
|
2004-07-30 09:47:56 +02:00
|
|
|
alter table t1 modify b mediumint;
|
|
|
|
|
select * from t1 order by b;
|
|
|
|
|
a b
|
|
|
|
|
1 1
|
|
|
|
|
200 2
|
2004-07-30 14:17:12 +02:00
|
|
|
0 3
|
2004-07-30 09:47:56 +02:00
|
|
|
201 4
|
|
|
|
|
202 5
|
|
|
|
|
203 6
|
|
|
|
|
204 7
|
2004-07-30 14:17:12 +02:00
|
|
|
create table t2 (a int);
|
|
|
|
|
insert t2 values (1),(2);
|
|
|
|
|
alter table t2 add b int auto_increment primary key;
|
|
|
|
|
select * from t2;
|
|
|
|
|
a b
|
|
|
|
|
1 1
|
|
|
|
|
2 2
|
|
|
|
|
drop table t2;
|
2003-07-28 16:57:46 +02:00
|
|
|
delete from t1 where a=0;
|
|
|
|
|
update t1 set a=0 where b=5;
|
|
|
|
|
select * from t1 order by b;
|
|
|
|
|
a b
|
|
|
|
|
1 1
|
|
|
|
|
200 2
|
|
|
|
|
201 4
|
|
|
|
|
0 5
|
|
|
|
|
203 6
|
|
|
|
|
204 7
|
|
|
|
|
delete from t1 where a=0;
|
|
|
|
|
update t1 set a=NULL where b=6;
|
2008-01-11 02:06:08 +01:00
|
|
|
ERROR 23000: Column 'a' cannot be null
|
2003-07-28 16:57:46 +02:00
|
|
|
update t1 set a=300 where b=7;
|
|
|
|
|
SET SQL_MODE='';
|
|
|
|
|
insert into t1(a,b)values(NULL,8);
|
|
|
|
|
insert into t1(a,b)values(400,9);
|
|
|
|
|
insert into t1(a,b)values(0,10);
|
|
|
|
|
insert into t1(b)values(11);
|
|
|
|
|
insert into t1(b)values(12);
|
|
|
|
|
insert into t1(b)values(13);
|
|
|
|
|
insert into t1(b)values(14);
|
|
|
|
|
select * from t1 order by b;
|
|
|
|
|
a b
|
|
|
|
|
1 1
|
|
|
|
|
200 2
|
|
|
|
|
201 4
|
2008-01-11 02:06:08 +01:00
|
|
|
203 6
|
2003-07-28 16:57:46 +02:00
|
|
|
300 7
|
|
|
|
|
301 8
|
|
|
|
|
400 9
|
|
|
|
|
401 10
|
|
|
|
|
402 11
|
|
|
|
|
403 12
|
|
|
|
|
404 13
|
|
|
|
|
405 14
|
|
|
|
|
delete from t1 where a=0;
|
|
|
|
|
update t1 set a=0 where b=12;
|
|
|
|
|
select * from t1 order by b;
|
|
|
|
|
a b
|
|
|
|
|
1 1
|
|
|
|
|
200 2
|
|
|
|
|
201 4
|
2008-01-11 02:06:08 +01:00
|
|
|
203 6
|
2003-07-28 16:57:46 +02:00
|
|
|
300 7
|
|
|
|
|
301 8
|
|
|
|
|
400 9
|
|
|
|
|
401 10
|
|
|
|
|
402 11
|
|
|
|
|
0 12
|
|
|
|
|
404 13
|
|
|
|
|
405 14
|
|
|
|
|
delete from t1 where a=0;
|
|
|
|
|
update t1 set a=NULL where b=13;
|
2008-01-11 02:06:08 +01:00
|
|
|
ERROR 23000: Column 'a' cannot be null
|
2003-07-28 16:57:46 +02:00
|
|
|
update t1 set a=500 where b=14;
|
|
|
|
|
select * from t1 order by b;
|
|
|
|
|
a b
|
|
|
|
|
1 1
|
|
|
|
|
200 2
|
|
|
|
|
201 4
|
2008-01-11 02:06:08 +01:00
|
|
|
203 6
|
2003-07-28 16:57:46 +02:00
|
|
|
300 7
|
|
|
|
|
301 8
|
|
|
|
|
400 9
|
|
|
|
|
401 10
|
|
|
|
|
402 11
|
2008-01-11 02:06:08 +01:00
|
|
|
404 13
|
2003-07-28 16:57:46 +02:00
|
|
|
500 14
|
2003-07-23 00:58:30 +02:00
|
|
|
drop table t1;
|
2004-10-07 11:02:39 +02:00
|
|
|
create table t1 (a bigint);
|
|
|
|
|
insert into t1 values (1), (2), (3), (NULL), (NULL);
|
|
|
|
|
alter table t1 modify a bigint not null auto_increment primary key;
|
|
|
|
|
select * from t1;
|
|
|
|
|
a
|
|
|
|
|
1
|
|
|
|
|
2
|
|
|
|
|
3
|
|
|
|
|
4
|
|
|
|
|
5
|
|
|
|
|
drop table t1;
|
|
|
|
|
create table t1 (a bigint);
|
|
|
|
|
insert into t1 values (1), (2), (3), (0), (0);
|
|
|
|
|
alter table t1 modify a bigint not null auto_increment primary key;
|
|
|
|
|
select * from t1;
|
|
|
|
|
a
|
|
|
|
|
1
|
|
|
|
|
2
|
|
|
|
|
3
|
|
|
|
|
4
|
|
|
|
|
5
|
|
|
|
|
drop table t1;
|
|
|
|
|
create table t1 (a bigint);
|
|
|
|
|
insert into t1 values (0), (1), (2), (3);
|
|
|
|
|
set sql_mode=NO_AUTO_VALUE_ON_ZERO;
|
|
|
|
|
alter table t1 modify a bigint not null auto_increment primary key;
|
|
|
|
|
set sql_mode= '';
|
|
|
|
|
select * from t1;
|
|
|
|
|
a
|
|
|
|
|
0
|
|
|
|
|
1
|
|
|
|
|
2
|
|
|
|
|
3
|
|
|
|
|
drop table t1;
|
|
|
|
|
create table t1 (a int auto_increment primary key , b int null);
|
|
|
|
|
set sql_mode=NO_AUTO_VALUE_ON_ZERO;
|
|
|
|
|
insert into t1 values (0,1),(1,2),(2,3);
|
|
|
|
|
select * from t1;
|
|
|
|
|
a b
|
|
|
|
|
0 1
|
|
|
|
|
1 2
|
|
|
|
|
2 3
|
|
|
|
|
set sql_mode= '';
|
|
|
|
|
alter table t1 modify b varchar(255);
|
|
|
|
|
insert into t1 values (0,4);
|
|
|
|
|
select * from t1;
|
|
|
|
|
a b
|
|
|
|
|
0 1
|
|
|
|
|
1 2
|
|
|
|
|
2 3
|
|
|
|
|
3 4
|
|
|
|
|
drop table t1;
|
2005-05-13 22:08:29 +02:00
|
|
|
CREATE TABLE t1 ( a INT AUTO_INCREMENT, b BLOB, PRIMARY KEY (a,b(10)));
|
|
|
|
|
INSERT INTO t1 (b) VALUES ('aaaa');
|
|
|
|
|
CHECK TABLE t1;
|
|
|
|
|
Table Op Msg_type Msg_text
|
|
|
|
|
test.t1 check status OK
|
|
|
|
|
INSERT INTO t1 (b) VALUES ('');
|
|
|
|
|
CHECK TABLE t1;
|
|
|
|
|
Table Op Msg_type Msg_text
|
|
|
|
|
test.t1 check status OK
|
|
|
|
|
INSERT INTO t1 (b) VALUES ('bbbb');
|
|
|
|
|
CHECK TABLE t1;
|
|
|
|
|
Table Op Msg_type Msg_text
|
|
|
|
|
test.t1 check status OK
|
|
|
|
|
DROP TABLE IF EXISTS t1;
|
Bug#19025 4.1 mysqldump doesn't correctly dump "auto_increment = [int]"
mysqldump / SHOW CREATE TABLE will show the NEXT available value for
the PK, rather than the *first* one that was available (that named in
the original CREATE TABLE ... AUTO_INCREMENT = ... statement).
This should produce correct and robust behaviour for the obvious use
cases -- when no data were inserted, then we'll produce a statement
featuring the same value the original CREATE TABLE had; if we dump
with values, INSERTing the values on the target machine should set the
correct next_ID anyway (and if not, we'll still have our AUTO_INCREMENT =
... to do that). Lastly, just the CREATE statement (with no data) for
a table that saw inserts would still result in a table that new values
could safely be inserted to).
There seems to be no robust way however to see whether the next_ID
field is > 1 because it was set to something else with CREATE TABLE
... AUTO_INCREMENT = ..., or because there is an AUTO_INCREMENT column
in the table (but no initial value was set with AUTO_INCREMENT = ...)
and then one or more rows were INSERTed, counting up next_ID. This
means that in both cases, we'll generate an AUTO_INCREMENT =
... clause in SHOW CREATE TABLE / mysqldump. As we also show info on,
say, charsets even if the user did not explicitly give that info in
their own CREATE TABLE, this shouldn't be an issue.
As per above, the next_ID will be affected by any INSERTs that have
taken place, though. This /should/ result in correct and robust
behaviour, but it may look non-intuitive to some users if they CREATE
TABLE ... AUTO_INCREMENT = 1000 and later (after some INSERTs) have
SHOW CREATE TABLE give them a different value (say, CREATE TABLE
... AUTO_INCREMENT = 1006), so the docs should possibly feature a
caveat to that effect.
It's not very intuitive the way it works now (with the fix), but it's
*correct*. We're not storing the original value anyway, if we wanted
that, we'd have to change on-disk representation?
If we do dump/load cycles with empty DBs, nothing will change. This
changeset includes an additional test case that proves that tables
with rows will create the same next_ID for AUTO_INCREMENT = ... across
dump/restore cycles.
Confirmed by support as likely solution for client's problem.
2006-05-04 03:12:51 +02:00
|
|
|
CREATE TABLE `t1` (
|
|
|
|
|
t1_name VARCHAR(255) DEFAULT NULL,
|
|
|
|
|
t1_id INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
|
|
|
|
|
KEY (t1_name),
|
|
|
|
|
PRIMARY KEY (t1_id)
|
|
|
|
|
) AUTO_INCREMENT = 1000;
|
|
|
|
|
INSERT INTO t1 (t1_name) VALUES('MySQL');
|
|
|
|
|
INSERT INTO t1 (t1_name) VALUES('MySQL');
|
|
|
|
|
INSERT INTO t1 (t1_name) VALUES('MySQL');
|
|
|
|
|
SELECT * from t1;
|
|
|
|
|
t1_name t1_id
|
|
|
|
|
MySQL 1000
|
|
|
|
|
MySQL 1001
|
|
|
|
|
MySQL 1002
|
|
|
|
|
SHOW CREATE TABLE `t1`;
|
|
|
|
|
Table Create Table
|
|
|
|
|
t1 CREATE TABLE `t1` (
|
2006-05-10 20:39:26 +02:00
|
|
|
`t1_name` varchar(255) DEFAULT NULL,
|
|
|
|
|
`t1_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
|
|
|
|
|
PRIMARY KEY (`t1_id`),
|
Bug#19025 4.1 mysqldump doesn't correctly dump "auto_increment = [int]"
mysqldump / SHOW CREATE TABLE will show the NEXT available value for
the PK, rather than the *first* one that was available (that named in
the original CREATE TABLE ... AUTO_INCREMENT = ... statement).
This should produce correct and robust behaviour for the obvious use
cases -- when no data were inserted, then we'll produce a statement
featuring the same value the original CREATE TABLE had; if we dump
with values, INSERTing the values on the target machine should set the
correct next_ID anyway (and if not, we'll still have our AUTO_INCREMENT =
... to do that). Lastly, just the CREATE statement (with no data) for
a table that saw inserts would still result in a table that new values
could safely be inserted to).
There seems to be no robust way however to see whether the next_ID
field is > 1 because it was set to something else with CREATE TABLE
... AUTO_INCREMENT = ..., or because there is an AUTO_INCREMENT column
in the table (but no initial value was set with AUTO_INCREMENT = ...)
and then one or more rows were INSERTed, counting up next_ID. This
means that in both cases, we'll generate an AUTO_INCREMENT =
... clause in SHOW CREATE TABLE / mysqldump. As we also show info on,
say, charsets even if the user did not explicitly give that info in
their own CREATE TABLE, this shouldn't be an issue.
As per above, the next_ID will be affected by any INSERTs that have
taken place, though. This /should/ result in correct and robust
behaviour, but it may look non-intuitive to some users if they CREATE
TABLE ... AUTO_INCREMENT = 1000 and later (after some INSERTs) have
SHOW CREATE TABLE give them a different value (say, CREATE TABLE
... AUTO_INCREMENT = 1006), so the docs should possibly feature a
caveat to that effect.
It's not very intuitive the way it works now (with the fix), but it's
*correct*. We're not storing the original value anyway, if we wanted
that, we'd have to change on-disk representation?
If we do dump/load cycles with empty DBs, nothing will change. This
changeset includes an additional test case that proves that tables
with rows will create the same next_ID for AUTO_INCREMENT = ... across
dump/restore cycles.
Confirmed by support as likely solution for client's problem.
2006-05-04 03:12:51 +02:00
|
|
|
KEY `t1_name` (`t1_name`)
|
|
|
|
|
) ENGINE=MyISAM AUTO_INCREMENT=1003 DEFAULT CHARSET=latin1
|
|
|
|
|
DROP TABLE `t1`;
|
2006-06-07 11:01:10 +02:00
|
|
|
create table t1(a int not null auto_increment primary key);
|
|
|
|
|
create table t2(a int not null auto_increment primary key, t1a int);
|
|
|
|
|
insert into t1 values(NULL);
|
|
|
|
|
insert into t2 values (NULL, LAST_INSERT_ID()), (NULL, LAST_INSERT_ID());
|
|
|
|
|
insert into t1 values (NULL);
|
|
|
|
|
insert into t2 values (NULL, LAST_INSERT_ID()), (NULL, LAST_INSERT_ID()),
|
|
|
|
|
(NULL, LAST_INSERT_ID());
|
|
|
|
|
insert into t1 values (NULL);
|
|
|
|
|
insert into t2 values (NULL, LAST_INSERT_ID()), (NULL, LAST_INSERT_ID()),
|
|
|
|
|
(NULL, LAST_INSERT_ID()), (NULL, LAST_INSERT_ID());
|
|
|
|
|
select * from t2;
|
|
|
|
|
a t1a
|
|
|
|
|
1 1
|
|
|
|
|
2 1
|
|
|
|
|
3 2
|
|
|
|
|
4 2
|
|
|
|
|
5 2
|
|
|
|
|
6 3
|
|
|
|
|
7 3
|
|
|
|
|
8 3
|
|
|
|
|
9 3
|
|
|
|
|
drop table t1, t2;
|
Bug#19025 4.1 mysqldump doesn't correctly dump "auto_increment = [int]"
mysqldump / SHOW CREATE TABLE will show the NEXT available value for
the PK, rather than the *first* one that was available (that named in
the original CREATE TABLE ... AUTO_INCREMENT = ... statement).
This should produce correct and robust behaviour for the obvious use
cases -- when no data were inserted, then we'll produce a statement
featuring the same value the original CREATE TABLE had; if we dump
with values, INSERTing the values on the target machine should set the
correct next_ID anyway (and if not, we'll still have our AUTO_INCREMENT =
... to do that). Lastly, just the CREATE statement (with no data) for
a table that saw inserts would still result in a table that new values
could safely be inserted to).
There seems to be no robust way however to see whether the next_ID
field is > 1 because it was set to something else with CREATE TABLE
... AUTO_INCREMENT = ..., or because there is an AUTO_INCREMENT column
in the table (but no initial value was set with AUTO_INCREMENT = ...)
and then one or more rows were INSERTed, counting up next_ID. This
means that in both cases, we'll generate an AUTO_INCREMENT =
... clause in SHOW CREATE TABLE / mysqldump. As we also show info on,
say, charsets even if the user did not explicitly give that info in
their own CREATE TABLE, this shouldn't be an issue.
As per above, the next_ID will be affected by any INSERTs that have
taken place, though. This /should/ result in correct and robust
behaviour, but it may look non-intuitive to some users if they CREATE
TABLE ... AUTO_INCREMENT = 1000 and later (after some INSERTs) have
SHOW CREATE TABLE give them a different value (say, CREATE TABLE
... AUTO_INCREMENT = 1006), so the docs should possibly feature a
caveat to that effect.
It's not very intuitive the way it works now (with the fix), but it's
*correct*. We're not storing the original value anyway, if we wanted
that, we'd have to change on-disk representation?
If we do dump/load cycles with empty DBs, nothing will change. This
changeset includes an additional test case that proves that tables
with rows will create the same next_ID for AUTO_INCREMENT = ... across
dump/restore cycles.
Confirmed by support as likely solution for client's problem.
2006-05-04 03:12:51 +02:00
|
|
|
End of 4.1 tests
|
2005-06-06 19:41:52 +02:00
|
|
|
CREATE TABLE t1 ( `a` int(11) NOT NULL auto_increment, `b` int(11) default NULL,PRIMARY KEY (`a`),UNIQUE KEY `b` (`b`));
|
|
|
|
|
insert into t1 (b) values (1);
|
|
|
|
|
replace into t1 (b) values (2), (1), (3);
|
|
|
|
|
select * from t1;
|
|
|
|
|
a b
|
|
|
|
|
3 1
|
|
|
|
|
2 2
|
|
|
|
|
4 3
|
|
|
|
|
truncate table t1;
|
|
|
|
|
insert into t1 (b) values (1);
|
|
|
|
|
replace into t1 (b) values (2);
|
|
|
|
|
replace into t1 (b) values (1);
|
|
|
|
|
replace into t1 (b) values (3);
|
|
|
|
|
select * from t1;
|
|
|
|
|
a b
|
|
|
|
|
3 1
|
|
|
|
|
2 2
|
|
|
|
|
4 3
|
|
|
|
|
drop table t1;
|
|
|
|
|
create table t1 (rowid int not null auto_increment, val int not null,primary
|
|
|
|
|
key (rowid), unique(val));
|
|
|
|
|
replace into t1 (val) values ('1'),('2');
|
|
|
|
|
replace into t1 (val) values ('1'),('2');
|
|
|
|
|
insert into t1 (val) values ('1'),('2');
|
2006-01-23 12:17:05 +01:00
|
|
|
ERROR 23000: Duplicate entry '1' for key 'val'
|
2005-06-06 19:41:52 +02:00
|
|
|
select * from t1;
|
|
|
|
|
rowid val
|
|
|
|
|
3 1
|
|
|
|
|
4 2
|
|
|
|
|
drop table t1;
|
|
|
|
|
create table t1 (a int not null auto_increment primary key, val int);
|
|
|
|
|
insert into t1 (val) values (1);
|
|
|
|
|
update t1 set a=2 where a=1;
|
|
|
|
|
insert into t1 (val) values (1);
|
|
|
|
|
select * from t1;
|
|
|
|
|
a val
|
|
|
|
|
2 1
|
|
|
|
|
3 1
|
|
|
|
|
drop table t1;
|
2006-05-12 15:02:42 +02:00
|
|
|
CREATE TABLE t1 (t1 INT(10) PRIMARY KEY, t2 INT(10));
|
|
|
|
|
INSERT INTO t1 VALUES(0, 0);
|
|
|
|
|
INSERT INTO t1 VALUES(1, 1);
|
|
|
|
|
ALTER TABLE t1 CHANGE t1 t1 INT(10) auto_increment;
|
2006-05-18 09:42:38 +02:00
|
|
|
ERROR 23000: ALTER TABLE causes auto_increment resequencing, resulting in duplicate entry '1' for key 'PRIMARY'
|
2006-05-12 15:02:42 +02:00
|
|
|
DROP TABLE t1;
|
WL#3146 "less locking in auto_increment":
this is a cleanup patch for our current auto_increment handling:
new names for auto_increment variables in THD, new methods to manipulate them
(see sql_class.h), some move into handler::, causing less backup/restore
work when executing substatements.
This makes the logic hopefully clearer, less work is is needed in
mysql_insert().
By cleaning up, using different variables for different purposes (instead
of one for 3 things...), we fix those bugs, which someone may want to fix
in 5.0 too:
BUG#20339 "stored procedure using LAST_INSERT_ID() does not replicate
statement-based"
BUG#20341 "stored function inserting into one auto_increment puts bad
data in slave"
BUG#19243 "wrong LAST_INSERT_ID() after ON DUPLICATE KEY UPDATE"
(now if a row is updated, LAST_INSERT_ID() will return its id)
and re-fixes:
BUG#6880 "LAST_INSERT_ID() value changes during multi-row INSERT"
(already fixed differently by Ramil in 4.1)
Test of documented behaviour of mysql_insert_id() (there was no test).
The behaviour changes introduced are:
- LAST_INSERT_ID() now returns "the first autogenerated auto_increment value
successfully inserted", instead of "the first autogenerated auto_increment
value if any row was successfully inserted", see auto_increment.test.
Same for mysql_insert_id(), see mysql_client_test.c.
- LAST_INSERT_ID() returns the id of the updated row if ON DUPLICATE KEY
UPDATE, see auto_increment.test. Same for mysql_insert_id(), see
mysql_client_test.c.
- LAST_INSERT_ID() does not change if no autogenerated value was successfully
inserted (it used to then be 0), see auto_increment.test.
- if in INSERT SELECT no autogenerated value was successfully inserted,
mysql_insert_id() now returns the id of the last inserted row (it already
did this for INSERT VALUES), see mysql_client_test.c.
- if INSERT SELECT uses LAST_INSERT_ID(X), mysql_insert_id() now returns X
(it already did this for INSERT VALUES), see mysql_client_test.c.
- NDB now behaves like other engines wrt SET INSERT_ID: with INSERT IGNORE,
the id passed in SET INSERT_ID is re-used until a row succeeds; SET INSERT_ID
influences not only the first row now.
Additionally, when unlocking a table we check that the thread is not keeping
a next_insert_id (as the table is unlocked that id is potentially out-of-date);
forgetting about this next_insert_id is done in a new
handler::ha_release_auto_increment().
Finally we prepare for engines capable of reserving finite-length intervals
of auto_increment values: we store such intervals in THD. The next step
(to be done by the replication team in 5.1) is to read those intervals from
THD and actually store them in the statement-based binary log. NDB
will be a good engine to test that.
2006-07-09 17:52:19 +02:00
|
|
|
create table t1 (a int primary key auto_increment, b int, c int, d timestamp default current_timestamp, unique(b),unique(c));
|
|
|
|
|
insert into t1 values(null,1,1,now());
|
|
|
|
|
insert into t1 values(null,0,0,null);
|
|
|
|
|
replace into t1 values(null,1,0,null);
|
|
|
|
|
select last_insert_id();
|
|
|
|
|
last_insert_id()
|
|
|
|
|
3
|
|
|
|
|
drop table t1;
|
2008-09-16 15:07:59 +02:00
|
|
|
create table t1 (a int primary key auto_increment, b int, c int, e int, d timestamp default current_timestamp, unique(b),unique(c),unique(e));
|
|
|
|
|
insert into t1 values(null,1,1,1,now());
|
|
|
|
|
insert into t1 values(null,0,0,0,null);
|
|
|
|
|
replace into t1 values(null,1,0,2,null);
|
|
|
|
|
select last_insert_id();
|
|
|
|
|
last_insert_id()
|
|
|
|
|
3
|
|
|
|
|
drop table t1;
|