2000-12-28 02:56:38 +01:00
|
|
|
#
|
|
|
|
|
# Test of auto_increment; The test for BDB tables is in bdb.test
|
|
|
|
|
#
|
2003-01-06 00:48:59 +01:00
|
|
|
--disable_warnings
|
2001-10-08 03:58:07 +02:00
|
|
|
drop table if exists t1;
|
2004-06-22 11:10:50 +02:00
|
|
|
drop table if exists t2;
|
2003-01-06 00:48:59 +01:00
|
|
|
--enable_warnings
|
2003-08-18 23:08:08 +02:00
|
|
|
SET SQL_WARNINGS=1;
|
2003-01-06 00:48:59 +01:00
|
|
|
|
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;
|
2000-12-28 02:56:38 +01: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;
|
|
|
|
|
delete from t1 where a=6;
|
|
|
|
|
#show table status like "t1";
|
|
|
|
|
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;
|
|
|
|
|
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;
|
|
|
|
|
select _rowid,t1._rowid,skey,sval from t1;
|
|
|
|
|
drop table t1;
|
|
|
|
|
|
|
|
|
|
#
|
|
|
|
|
# Test auto_increment on sub key
|
|
|
|
|
#
|
|
|
|
|
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;
|
|
|
|
|
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;
|
|
|
|
|
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;
|
|
|
|
|
drop table t1;
|
2001-07-16 02:04:30 +02:00
|
|
|
|
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;
|
|
|
|
|
drop table t1,t2;
|
|
|
|
|
|
2001-07-16 02:04:30 +02:00
|
|
|
#
|
|
|
|
|
# Test of auto_increment columns when they are set to 0
|
|
|
|
|
#
|
|
|
|
|
|
|
|
|
|
create table t1 (a int not null primary key auto_increment);
|
|
|
|
|
insert into t1 values (0);
|
|
|
|
|
update t1 set a=0;
|
|
|
|
|
select * from t1;
|
|
|
|
|
check table t1;
|
|
|
|
|
drop table t1;
|
2003-03-02 01:48:57 +01:00
|
|
|
|
2003-12-12 21:26:58 +01:00
|
|
|
#
|
|
|
|
|
# Test negative values (Bug #1366)
|
|
|
|
|
#
|
|
|
|
|
|
|
|
|
|
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();
|
|
|
|
|
insert into t1 values (NULL);
|
|
|
|
|
select * from t1;
|
|
|
|
|
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-12 21:26:58 +01:00
|
|
|
insert into t1 values (NULL);
|
|
|
|
|
insert into t1 values (-1);
|
|
|
|
|
select last_insert_id();
|
|
|
|
|
insert into t1 values (NULL);
|
|
|
|
|
select * from t1;
|
|
|
|
|
drop table t1;
|
2003-03-31 21:14:26 +02:00
|
|
|
#
|
|
|
|
|
# last_insert_id() madness
|
|
|
|
|
#
|
|
|
|
|
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();
|
2003-10-30 11:57:26 +01:00
|
|
|
explain extended select last_insert_id();
|
2007-06-06 19:57:07 +02:00
|
|
|
--error ER_DUP_ENTRY
|
2003-06-30 12:28:36 +02:00
|
|
|
insert into t1 set i = 254;
|
|
|
|
|
select last_insert_id();
|
2007-06-06 19:57:07 +02:00
|
|
|
--error ER_DUP_ENTRY
|
2003-03-31 21:14:26 +02:00
|
|
|
insert into t1 set i = null;
|
|
|
|
|
select last_insert_id();
|
|
|
|
|
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();
|
|
|
|
|
insert into t1 set i = null;
|
|
|
|
|
select last_insert_id();
|
|
|
|
|
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();
|
|
|
|
|
insert into t1 values (NULL, 15);
|
|
|
|
|
select last_insert_id();
|
2007-06-06 19:57:07 +02:00
|
|
|
--error ER_DUP_ENTRY
|
2003-03-31 21:14:26 +02:00
|
|
|
insert into t1 values (NULL, 10);
|
|
|
|
|
select last_insert_id();
|
2003-06-30 12:28:36 +02:00
|
|
|
|
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;
|
2004-07-30 09:47:56 +02:00
|
|
|
alter table t1 modify b mediumint;
|
|
|
|
|
select * from t1 order by b;
|
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;
|
|
|
|
|
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;
|
|
|
|
|
delete from t1 where a=0;
|
|
|
|
|
update t1 set a=NULL where b=6;
|
|
|
|
|
update t1 set a=300 where b=7;
|
2003-07-23 00:58:30 +02:00
|
|
|
SET SQL_MODE='';
|
2003-07-28 16:57:46 +02:00
|
|
|
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;
|
|
|
|
|
delete from t1 where a=0;
|
|
|
|
|
update t1 set a=0 where b=12;
|
|
|
|
|
select * from t1 order by b;
|
|
|
|
|
delete from t1 where a=0;
|
|
|
|
|
update t1 set a=NULL where b=13;
|
|
|
|
|
update t1 set a=500 where b=14;
|
|
|
|
|
select * from t1 order by b;
|
2003-07-23 00:58:30 +02:00
|
|
|
drop table t1;
|
2004-10-07 11:02:39 +02:00
|
|
|
|
|
|
|
|
#
|
|
|
|
|
# Test of behavior of ALTER TABLE when coulmn containing NULL or zeroes is
|
|
|
|
|
# converted to AUTO_INCREMENT column
|
|
|
|
|
#
|
|
|
|
|
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;
|
|
|
|
|
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;
|
|
|
|
|
drop table t1;
|
|
|
|
|
|
|
|
|
|
# We still should be able to preserve zero in NO_AUTO_VALUE_ON_ZERO mode
|
|
|
|
|
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;
|
|
|
|
|
drop table t1;
|
|
|
|
|
|
|
|
|
|
# It also sensible to preserve zeroes if we are converting auto_increment
|
|
|
|
|
# column to auto_increment column (or not touching it at all, which is more
|
|
|
|
|
# common case probably)
|
|
|
|
|
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;
|
|
|
|
|
set sql_mode= '';
|
|
|
|
|
alter table t1 modify b varchar(255);
|
|
|
|
|
insert into t1 values (0,4);
|
|
|
|
|
select * from t1;
|
|
|
|
|
drop table t1;
|
2005-05-13 22:08:29 +02:00
|
|
|
|
|
|
|
|
#
|
|
|
|
|
# BUG #10045: Problem with composite AUTO_INCREMENT + BLOB key
|
|
|
|
|
|
|
|
|
|
CREATE TABLE t1 ( a INT AUTO_INCREMENT, b BLOB, PRIMARY KEY (a,b(10)));
|
|
|
|
|
INSERT INTO t1 (b) VALUES ('aaaa');
|
|
|
|
|
CHECK TABLE t1;
|
|
|
|
|
INSERT INTO t1 (b) VALUES ('');
|
|
|
|
|
CHECK TABLE t1;
|
|
|
|
|
INSERT INTO t1 (b) VALUES ('bbbb');
|
|
|
|
|
CHECK TABLE t1;
|
|
|
|
|
DROP TABLE IF EXISTS t1;
|
2005-06-06 19:41:52 +02:00
|
|
|
|
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.
mysql-test/r/auto_increment.result:
test for creation of AUTO_INCREMENT=... clause
mysql-test/r/gis-rtree.result:
Add AUTO_INCREMENT=... clauses where appropriate
mysql-test/r/mysqldump.result:
show that AUTO_INCREMENT=... will survive dump/restore cycles
mysql-test/r/symlink.result:
Add AUTO_INCREMENT=... clauses where appropriate
mysql-test/t/auto_increment.test:
test for creation of AUTO_INCREMENT=... clause
mysql-test/t/mysqldump.test:
show that AUTO_INCREMENT=... will survive dump/restore cycles
sql/sql_show.cc:
Add AUTO_INCREMENT=... to output of SHOW CREATE TABLE if there is an
AUTO_INCREMENT column, and NEXT_ID > 1 (the default). We must not print
the clause for engines that do not support this as it would break the
import of dumps, but as of this writing, the test for whether
AUTO_INCREMENT columns are allowed and wether AUTO_INCREMENT=...
is supported is identical, !(file->table_flags() & HA_NO_AUTO_INCREMENT))
Because of that, we do not explicitly test for the feature,
but may extrapolate its existence from that of an AUTO_INCREMENT column.
2006-05-04 03:12:51 +02:00
|
|
|
# BUG #19025:
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
SHOW CREATE TABLE `t1`;
|
|
|
|
|
|
|
|
|
|
DROP TABLE `t1`;
|
|
|
|
|
|
2006-06-07 11:01:10 +02:00
|
|
|
#
|
|
|
|
|
# Bug #6880: LAST_INSERT_ID() within a statement
|
|
|
|
|
#
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
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.
mysql-test/r/auto_increment.result:
test for creation of AUTO_INCREMENT=... clause
mysql-test/r/gis-rtree.result:
Add AUTO_INCREMENT=... clauses where appropriate
mysql-test/r/mysqldump.result:
show that AUTO_INCREMENT=... will survive dump/restore cycles
mysql-test/r/symlink.result:
Add AUTO_INCREMENT=... clauses where appropriate
mysql-test/t/auto_increment.test:
test for creation of AUTO_INCREMENT=... clause
mysql-test/t/mysqldump.test:
show that AUTO_INCREMENT=... will survive dump/restore cycles
sql/sql_show.cc:
Add AUTO_INCREMENT=... to output of SHOW CREATE TABLE if there is an
AUTO_INCREMENT column, and NEXT_ID > 1 (the default). We must not print
the clause for engines that do not support this as it would break the
import of dumps, but as of this writing, the test for whether
AUTO_INCREMENT columns are allowed and wether AUTO_INCREMENT=...
is supported is identical, !(file->table_flags() & HA_NO_AUTO_INCREMENT))
Because of that, we do not explicitly test for the feature,
but may extrapolate its existence from that of an AUTO_INCREMENT column.
2006-05-04 03:12:51 +02:00
|
|
|
--echo End of 4.1 tests
|
2005-07-28 16:09:54 +02:00
|
|
|
|
2005-06-06 19:41:52 +02:00
|
|
|
#
|
|
|
|
|
# Bug #11080 & #11005 Multi-row REPLACE fails on a duplicate key error
|
|
|
|
|
#
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
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;
|
|
|
|
|
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');
|
2007-06-06 19:57:07 +02:00
|
|
|
--error ER_DUP_ENTRY
|
2005-06-06 19:41:52 +02:00
|
|
|
insert into t1 (val) values ('1'),('2');
|
|
|
|
|
select * from t1;
|
|
|
|
|
drop table t1;
|
|
|
|
|
|
|
|
|
|
#
|
|
|
|
|
# Test that update changes internal auto-increment value
|
|
|
|
|
#
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
drop table t1;
|
2006-05-12 15:02:42 +02:00
|
|
|
|
|
|
|
|
#
|
|
|
|
|
# Test key duplications with auto-increment in ALTER TABLE
|
|
|
|
|
# bug #14573
|
|
|
|
|
#
|
|
|
|
|
CREATE TABLE t1 (t1 INT(10) PRIMARY KEY, t2 INT(10));
|
|
|
|
|
INSERT INTO t1 VALUES(0, 0);
|
|
|
|
|
INSERT INTO t1 VALUES(1, 1);
|
2007-06-06 19:57:07 +02:00
|
|
|
--error ER_DUP_ENTRY
|
2006-05-12 15:02:42 +02:00
|
|
|
ALTER TABLE t1 CHANGE t1 t1 INT(10) auto_increment;
|
|
|
|
|
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.
mysql-test/extra/binlog_tests/binlog.test:
Testing that if INSERT_ID is set to a value too big for the
column's type, the binlogged INSERT_ID is the truncated value
(important if slave has a column of a "wider" numeric type).
Testing binlogging of INSERT_ID with INSERT DELAYED, to be sure that
we binlog an INSERT_ID event only for the delayed rows which use one.
mysql-test/extra/rpl_tests/rpl_insert_id.test:
Testcase for BUG#20339 "stored procedure using
LAST_INSERT_ID() does not replicate statement-based".
Testcase for BUG#20341 "stored function inserting into one
auto_increment puts bad data in slave".
mysql-test/extra/rpl_tests/rpl_loaddata.test:
Test that LOAD DATA INFILE sets a value for a future LAST_INSERT_ID().
mysql-test/r/auto_increment.result:
behaviour change: when INSERT totally fails (not even succeeds
partially and then rolls back), don't change last_insert_id().
Behaviour change: LAST_INSERT_ID() is now the first successfully inserted,
autogenerated, id.
Behaviour change: if INSERT ON DUPLICATE KEY UPDATE, if the table has auto_increment
and a row is updated, then LAST_INSERT_ID() returns the id of this row.
mysql-test/r/binlog_row_binlog.result:
result update
mysql-test/r/binlog_stm_binlog.result:
result update
mysql-test/r/insert.result:
result update
mysql-test/r/rpl_insert_id.result:
result update
mysql-test/r/rpl_loaddata.result:
result update
mysql-test/r/rpl_ndb_auto_inc.result:
ndb's behaviour is now like other engines wrt SET INSERT_ID
in a multi-row INSERT:
- with INSERT IGNORE: the id passed in SET INSERT_ID is re-used until
a row succeeds.
- generally, SET INSERT_ID sets the first value and other values are
simply computed from this first value, instead of previously where
the 2nd and subsequent values where not influenced by SET INSERT_ID;
this good change is due to the removal of "thd->next_insert_id=0"
from ha_ndbcluster.
mysql-test/t/auto_increment.test:
A testcase of BUG#19243: if ON DUPLICATE KEY UPDATE updates a row,
LAST_INSERT_ID() now returns the id of the row.
Test of new behaviour of last_insert_id() when no autogenerated value was
inserted, or when only some autogenerated value (not the first of them) was
inserted.
mysql-test/t/insert.test:
testing INSERT IGNORE re-using generated values
sql/ha_federated.cc:
update for new variables.
sql/ha_ndbcluster.cc:
handler::auto_increment_column_changed not needed, equivalent to
(insert_id_for_cur_row > 0).
thd->next_insert_id=0 not needed anymore; it was used to force
handler::update_auto_increment() to call ha_ndbcluster::get_auto_increment()
for each row of a multi-row INSERT, now this happens naturally
because NDB says "I have reserved you *one* value" in get_auto_increment(),
so handler::update_auto_increment() calls again for next row.
sql/handler.cc:
More comments, use of new methods and variables. Hopes to be clearer
than current code.
thd->prev_insert_id not in THD anymore: it is managed locally by inserters
(like mysql_insert()).
THD::clear_next_insert_id is now equivalent to
handler::next_insert_id > 0.
get_auto_increment() reserves an interval of values from the engine,
uses this interval for next rows of the statement, until interval
is exhausted then it asks for another interval (of a bigger size
than the first one; size doubles until reaching 65535 then it stays constant).
If doing statement-based binlogging, intervals are remembered in a list
for storage in the binlog.
For "forced" insert_id values (SET INSERT_ID or replication slave),
forced_auto_inc_intervals is non-empty and the handler takes its intervals
from there, without calling get_auto_increment().
ha_release_auto_increment() resets the handler's auto_increment variables;
it calls release_auto_increment() which is handler-dependent and
serves to return to the engine any unused tail of the last used
interval.
If ending a statement, next_insert_id>0 means that autoinc values have been
generated or taken from the master's binlog (in a replication slave) so
we clear those values read from binlog, so that next top- or sub-
statement does not use them.
sql/handler.h:
handler::auto_increment_changed can be replaced by
(handler::insert_id_for_cur_row > 0).
THD::next_insert_id moves into handler (more natural, and prepares
for the day when we'll support a single statement inserting into
two tables - "multi-table INSERT" like we have UPDATE - will this
happen?).
This move makes the backup/restore of THD::next_insert_id when entering
a substatement unneeded, as each substatement has its own handler
objects.
sql/item_func.cc:
new names for variables.
For the setting of what mysql_insert_id() will return to the client,
LAST_INSERT_ID(X) used to simply pretend that the generated autoinc
value for the current row was X, but this led to having no reliable
way to know the really generated value, so we now have a bool:
thd->arg_of_last_insert_id_function which enables us to know that
LAST_INSERT_ID(X) was called (and then X can be found in
thd->first_successful_insert_id_in_prev_stmt).
sql/log.cc:
new variable names for insert_ids. Removing some unused variables in the slow
log.
sql/log_event.cc:
new variable names, comments. Preparing for when master's won't binlog
LAST_INSERT_ID if it was 0.
sql/set_var.cc:
new variable names.
The last change repeats how Bar fixed BUG#20392
"INSERT_ID session variable has weird value" in 5.0.
sql/sql_class.cc:
new variables for insert_id. In THD::cleanup_after_query() we fix
BUG#20339 "stored procedure using LAST_INSERT_ID() does not replicate
statement-based" (will one want to fix it in 5.0?). Many comments
about what stored functions do to auto_increment.
In reset|restore_sub_statement_state(), we need to backup less
auto_inc variables as some of them have moved to the handler;
we backup/restore those which are about the current top- or sub-
statement, *not* those about the statement-based binlog
(which evolve as the top- and sub-statement execute).
Because we split THD::last_insert_id into
THD::first_successful_insert_id_in_prev_stmt and
THD::auto_inc_intervals_for_binlog (among others), we fix
BUG#20341 "stored function inserting into one auto_increment
puts bad data in slave": indeed we can afford to not backup/restore
THD::auto_inc_intervals_for_binlog (which fixes the bug) while still
backing up / restoring THD::first_successful_insert_id_in_prev_stmt
(ensuring that the top-level LAST_INSERT_ID() is not affected by INSERTs
done by sub-statements, as is desirable and tested in rpl_insert_id.test).
sql/sql_class.h:
new variables and methods for auto_increment.
Some THD members move into handler (those which are really about
the table being inserted), some stay in THD (those which are
about what a future LAST_INSERT_ID() should return, or about
what should be stored into the statement-based binlog).
THD::next_insert_id moves to handler::.
THD::clear_next_insert_id removed (had become equivalent
to next_insert_id > 0).
THD::last_insert_id becomes four:
THD::first_successful_insert_id_in_cur_stmt,
THD::auto_inc_intervals_for_binlog,
handler::insert_id_for_cur_row,
THD::first_successful_insert_id_in_prev_stmt.
THD::current_insert_id becomes:
THD::first_successful_insert_id_in_prev_stmt_for_binlog
THD::prev_insert_id is removed, handler can just use
handler::insert_id_for_cur_row instead (which is more accurate:
for the first row, prev_insert_id was set before get_auto_increment
was called, so was 0, causing a call to
get_auto_increment() for the 2nd row if the 1st row fails;
here we don't need the call as insert_id_for_cur_row has
the value of the first row).
THD::last_insert_id_used becomes: stmt_depends_on_first_row_in_prev_stmt
THD::insert_id_used is removed (equivalent to
auto_inc_intervals_for_binlog non empty).
The interval returned by get_auto_increment() and currently being
consumed is handler::auto_inc_interval_for_cur_row.
Comments to explain each of them.
select_insert::last_insert_id becomes autoinc_value_of_last_inserted_row.
sql/sql_insert.cc:
the "id" variable is not changed for each row now; it used to compensate for
this contradiction:
- thd->last_insert_id supposed job was to keep the id of the first row
- but it was updated for every row
- so mysql_insert() made sure to catch its first value and restore it at the end of stmt.
Now THD keeps the first value in first_successful_insert_id_in_cur_stmt,
and value of the row in insert_id_for_cur_row. So "id" only serves to fill
mysql_insert_id(), as depending on some conditions, "id" must be different
values.
Prev_insert_id moves from THD to write_record().
We now set LAST_INSERT_ID() in ON DUPLICATE KEY UPDATE too (BUG#19243).
In an INSERT DELAYED, we still "reset auto-increment caching" but differently
(by calling ha_release_auto_increment()).
sql/sql_load.cc:
no need to fiddle with "id", THD maintains
THD::first_successful_insert_id_in_cur_stmt by itself and correctly now.
ha_release_auto_increment() is now (logically) called before we unlock
the table.
sql/sql_parse.cc:
update to new variable names.
Assertion that reset_thd_for_next_command() is not called for every
substatement of a routine (I'm not against it, but if we do this change,
statement-based binlogging needs some adjustments).
sql/sql_select.cc:
update for new variable names
sql/sql_table.cc:
next_insert_id not needed in mysql_alter_table(), THD manages.
sql/sql_update.cc:
update for new variable names.
Even though this is UPDATE, an insert id can be generated (by
LAST_INSERT_ID(X)) and should be recorded because mysql_insert_id() wants
to know about it.
sql/structs.h:
A class for "discrete" intervals (intervals of integer numbers with a certain
increment between them): Discrete_interval, and a class for a list of such
intervals: Discrete_intervals_list
tests/mysql_client_test.c:
tests of behaviour of mysql_insert_id(): there were no such tests, while in
our manual we document its behaviour. In comments you'll notice the behaviour
changes introduced (there are 5).
2006-07-09 17:52:19 +02:00
|
|
|
|
|
|
|
|
# Test of REPLACE when it does INSERT+DELETE and not UPDATE:
|
|
|
|
|
# see if it sets LAST_INSERT_ID() ok
|
|
|
|
|
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);
|
|
|
|
|
# this will delete two rows
|
|
|
|
|
replace into t1 values(null,1,0,null);
|
|
|
|
|
select last_insert_id();
|
2008-09-16 15:07:59 +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.
mysql-test/extra/binlog_tests/binlog.test:
Testing that if INSERT_ID is set to a value too big for the
column's type, the binlogged INSERT_ID is the truncated value
(important if slave has a column of a "wider" numeric type).
Testing binlogging of INSERT_ID with INSERT DELAYED, to be sure that
we binlog an INSERT_ID event only for the delayed rows which use one.
mysql-test/extra/rpl_tests/rpl_insert_id.test:
Testcase for BUG#20339 "stored procedure using
LAST_INSERT_ID() does not replicate statement-based".
Testcase for BUG#20341 "stored function inserting into one
auto_increment puts bad data in slave".
mysql-test/extra/rpl_tests/rpl_loaddata.test:
Test that LOAD DATA INFILE sets a value for a future LAST_INSERT_ID().
mysql-test/r/auto_increment.result:
behaviour change: when INSERT totally fails (not even succeeds
partially and then rolls back), don't change last_insert_id().
Behaviour change: LAST_INSERT_ID() is now the first successfully inserted,
autogenerated, id.
Behaviour change: if INSERT ON DUPLICATE KEY UPDATE, if the table has auto_increment
and a row is updated, then LAST_INSERT_ID() returns the id of this row.
mysql-test/r/binlog_row_binlog.result:
result update
mysql-test/r/binlog_stm_binlog.result:
result update
mysql-test/r/insert.result:
result update
mysql-test/r/rpl_insert_id.result:
result update
mysql-test/r/rpl_loaddata.result:
result update
mysql-test/r/rpl_ndb_auto_inc.result:
ndb's behaviour is now like other engines wrt SET INSERT_ID
in a multi-row INSERT:
- with INSERT IGNORE: the id passed in SET INSERT_ID is re-used until
a row succeeds.
- generally, SET INSERT_ID sets the first value and other values are
simply computed from this first value, instead of previously where
the 2nd and subsequent values where not influenced by SET INSERT_ID;
this good change is due to the removal of "thd->next_insert_id=0"
from ha_ndbcluster.
mysql-test/t/auto_increment.test:
A testcase of BUG#19243: if ON DUPLICATE KEY UPDATE updates a row,
LAST_INSERT_ID() now returns the id of the row.
Test of new behaviour of last_insert_id() when no autogenerated value was
inserted, or when only some autogenerated value (not the first of them) was
inserted.
mysql-test/t/insert.test:
testing INSERT IGNORE re-using generated values
sql/ha_federated.cc:
update for new variables.
sql/ha_ndbcluster.cc:
handler::auto_increment_column_changed not needed, equivalent to
(insert_id_for_cur_row > 0).
thd->next_insert_id=0 not needed anymore; it was used to force
handler::update_auto_increment() to call ha_ndbcluster::get_auto_increment()
for each row of a multi-row INSERT, now this happens naturally
because NDB says "I have reserved you *one* value" in get_auto_increment(),
so handler::update_auto_increment() calls again for next row.
sql/handler.cc:
More comments, use of new methods and variables. Hopes to be clearer
than current code.
thd->prev_insert_id not in THD anymore: it is managed locally by inserters
(like mysql_insert()).
THD::clear_next_insert_id is now equivalent to
handler::next_insert_id > 0.
get_auto_increment() reserves an interval of values from the engine,
uses this interval for next rows of the statement, until interval
is exhausted then it asks for another interval (of a bigger size
than the first one; size doubles until reaching 65535 then it stays constant).
If doing statement-based binlogging, intervals are remembered in a list
for storage in the binlog.
For "forced" insert_id values (SET INSERT_ID or replication slave),
forced_auto_inc_intervals is non-empty and the handler takes its intervals
from there, without calling get_auto_increment().
ha_release_auto_increment() resets the handler's auto_increment variables;
it calls release_auto_increment() which is handler-dependent and
serves to return to the engine any unused tail of the last used
interval.
If ending a statement, next_insert_id>0 means that autoinc values have been
generated or taken from the master's binlog (in a replication slave) so
we clear those values read from binlog, so that next top- or sub-
statement does not use them.
sql/handler.h:
handler::auto_increment_changed can be replaced by
(handler::insert_id_for_cur_row > 0).
THD::next_insert_id moves into handler (more natural, and prepares
for the day when we'll support a single statement inserting into
two tables - "multi-table INSERT" like we have UPDATE - will this
happen?).
This move makes the backup/restore of THD::next_insert_id when entering
a substatement unneeded, as each substatement has its own handler
objects.
sql/item_func.cc:
new names for variables.
For the setting of what mysql_insert_id() will return to the client,
LAST_INSERT_ID(X) used to simply pretend that the generated autoinc
value for the current row was X, but this led to having no reliable
way to know the really generated value, so we now have a bool:
thd->arg_of_last_insert_id_function which enables us to know that
LAST_INSERT_ID(X) was called (and then X can be found in
thd->first_successful_insert_id_in_prev_stmt).
sql/log.cc:
new variable names for insert_ids. Removing some unused variables in the slow
log.
sql/log_event.cc:
new variable names, comments. Preparing for when master's won't binlog
LAST_INSERT_ID if it was 0.
sql/set_var.cc:
new variable names.
The last change repeats how Bar fixed BUG#20392
"INSERT_ID session variable has weird value" in 5.0.
sql/sql_class.cc:
new variables for insert_id. In THD::cleanup_after_query() we fix
BUG#20339 "stored procedure using LAST_INSERT_ID() does not replicate
statement-based" (will one want to fix it in 5.0?). Many comments
about what stored functions do to auto_increment.
In reset|restore_sub_statement_state(), we need to backup less
auto_inc variables as some of them have moved to the handler;
we backup/restore those which are about the current top- or sub-
statement, *not* those about the statement-based binlog
(which evolve as the top- and sub-statement execute).
Because we split THD::last_insert_id into
THD::first_successful_insert_id_in_prev_stmt and
THD::auto_inc_intervals_for_binlog (among others), we fix
BUG#20341 "stored function inserting into one auto_increment
puts bad data in slave": indeed we can afford to not backup/restore
THD::auto_inc_intervals_for_binlog (which fixes the bug) while still
backing up / restoring THD::first_successful_insert_id_in_prev_stmt
(ensuring that the top-level LAST_INSERT_ID() is not affected by INSERTs
done by sub-statements, as is desirable and tested in rpl_insert_id.test).
sql/sql_class.h:
new variables and methods for auto_increment.
Some THD members move into handler (those which are really about
the table being inserted), some stay in THD (those which are
about what a future LAST_INSERT_ID() should return, or about
what should be stored into the statement-based binlog).
THD::next_insert_id moves to handler::.
THD::clear_next_insert_id removed (had become equivalent
to next_insert_id > 0).
THD::last_insert_id becomes four:
THD::first_successful_insert_id_in_cur_stmt,
THD::auto_inc_intervals_for_binlog,
handler::insert_id_for_cur_row,
THD::first_successful_insert_id_in_prev_stmt.
THD::current_insert_id becomes:
THD::first_successful_insert_id_in_prev_stmt_for_binlog
THD::prev_insert_id is removed, handler can just use
handler::insert_id_for_cur_row instead (which is more accurate:
for the first row, prev_insert_id was set before get_auto_increment
was called, so was 0, causing a call to
get_auto_increment() for the 2nd row if the 1st row fails;
here we don't need the call as insert_id_for_cur_row has
the value of the first row).
THD::last_insert_id_used becomes: stmt_depends_on_first_row_in_prev_stmt
THD::insert_id_used is removed (equivalent to
auto_inc_intervals_for_binlog non empty).
The interval returned by get_auto_increment() and currently being
consumed is handler::auto_inc_interval_for_cur_row.
Comments to explain each of them.
select_insert::last_insert_id becomes autoinc_value_of_last_inserted_row.
sql/sql_insert.cc:
the "id" variable is not changed for each row now; it used to compensate for
this contradiction:
- thd->last_insert_id supposed job was to keep the id of the first row
- but it was updated for every row
- so mysql_insert() made sure to catch its first value and restore it at the end of stmt.
Now THD keeps the first value in first_successful_insert_id_in_cur_stmt,
and value of the row in insert_id_for_cur_row. So "id" only serves to fill
mysql_insert_id(), as depending on some conditions, "id" must be different
values.
Prev_insert_id moves from THD to write_record().
We now set LAST_INSERT_ID() in ON DUPLICATE KEY UPDATE too (BUG#19243).
In an INSERT DELAYED, we still "reset auto-increment caching" but differently
(by calling ha_release_auto_increment()).
sql/sql_load.cc:
no need to fiddle with "id", THD maintains
THD::first_successful_insert_id_in_cur_stmt by itself and correctly now.
ha_release_auto_increment() is now (logically) called before we unlock
the table.
sql/sql_parse.cc:
update to new variable names.
Assertion that reset_thd_for_next_command() is not called for every
substatement of a routine (I'm not against it, but if we do this change,
statement-based binlogging needs some adjustments).
sql/sql_select.cc:
update for new variable names
sql/sql_table.cc:
next_insert_id not needed in mysql_alter_table(), THD manages.
sql/sql_update.cc:
update for new variable names.
Even though this is UPDATE, an insert id can be generated (by
LAST_INSERT_ID(X)) and should be recorded because mysql_insert_id() wants
to know about it.
sql/structs.h:
A class for "discrete" intervals (intervals of integer numbers with a certain
increment between them): Discrete_interval, and a class for a list of such
intervals: Discrete_intervals_list
tests/mysql_client_test.c:
tests of behaviour of mysql_insert_id(): there were no such tests, while in
our manual we document its behaviour. In comments you'll notice the behaviour
changes introduced (there are 5).
2006-07-09 17:52:19 +02:00
|
|
|
|
2008-09-16 15:07:59 +02:00
|
|
|
# Test of REPLACE when it does a INSERT+DELETE for all the conflicting rows
|
|
|
|
|
# (i.e.) when there are three rows conflicting in unique key columns with
|
|
|
|
|
# a row that is being inserted, all the three rows will be deleted and then
|
|
|
|
|
# the new rows will be inserted.
|
|
|
|
|
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();
|
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.
mysql-test/extra/binlog_tests/binlog.test:
Testing that if INSERT_ID is set to a value too big for the
column's type, the binlogged INSERT_ID is the truncated value
(important if slave has a column of a "wider" numeric type).
Testing binlogging of INSERT_ID with INSERT DELAYED, to be sure that
we binlog an INSERT_ID event only for the delayed rows which use one.
mysql-test/extra/rpl_tests/rpl_insert_id.test:
Testcase for BUG#20339 "stored procedure using
LAST_INSERT_ID() does not replicate statement-based".
Testcase for BUG#20341 "stored function inserting into one
auto_increment puts bad data in slave".
mysql-test/extra/rpl_tests/rpl_loaddata.test:
Test that LOAD DATA INFILE sets a value for a future LAST_INSERT_ID().
mysql-test/r/auto_increment.result:
behaviour change: when INSERT totally fails (not even succeeds
partially and then rolls back), don't change last_insert_id().
Behaviour change: LAST_INSERT_ID() is now the first successfully inserted,
autogenerated, id.
Behaviour change: if INSERT ON DUPLICATE KEY UPDATE, if the table has auto_increment
and a row is updated, then LAST_INSERT_ID() returns the id of this row.
mysql-test/r/binlog_row_binlog.result:
result update
mysql-test/r/binlog_stm_binlog.result:
result update
mysql-test/r/insert.result:
result update
mysql-test/r/rpl_insert_id.result:
result update
mysql-test/r/rpl_loaddata.result:
result update
mysql-test/r/rpl_ndb_auto_inc.result:
ndb's behaviour is now like other engines wrt SET INSERT_ID
in a multi-row INSERT:
- with INSERT IGNORE: the id passed in SET INSERT_ID is re-used until
a row succeeds.
- generally, SET INSERT_ID sets the first value and other values are
simply computed from this first value, instead of previously where
the 2nd and subsequent values where not influenced by SET INSERT_ID;
this good change is due to the removal of "thd->next_insert_id=0"
from ha_ndbcluster.
mysql-test/t/auto_increment.test:
A testcase of BUG#19243: if ON DUPLICATE KEY UPDATE updates a row,
LAST_INSERT_ID() now returns the id of the row.
Test of new behaviour of last_insert_id() when no autogenerated value was
inserted, or when only some autogenerated value (not the first of them) was
inserted.
mysql-test/t/insert.test:
testing INSERT IGNORE re-using generated values
sql/ha_federated.cc:
update for new variables.
sql/ha_ndbcluster.cc:
handler::auto_increment_column_changed not needed, equivalent to
(insert_id_for_cur_row > 0).
thd->next_insert_id=0 not needed anymore; it was used to force
handler::update_auto_increment() to call ha_ndbcluster::get_auto_increment()
for each row of a multi-row INSERT, now this happens naturally
because NDB says "I have reserved you *one* value" in get_auto_increment(),
so handler::update_auto_increment() calls again for next row.
sql/handler.cc:
More comments, use of new methods and variables. Hopes to be clearer
than current code.
thd->prev_insert_id not in THD anymore: it is managed locally by inserters
(like mysql_insert()).
THD::clear_next_insert_id is now equivalent to
handler::next_insert_id > 0.
get_auto_increment() reserves an interval of values from the engine,
uses this interval for next rows of the statement, until interval
is exhausted then it asks for another interval (of a bigger size
than the first one; size doubles until reaching 65535 then it stays constant).
If doing statement-based binlogging, intervals are remembered in a list
for storage in the binlog.
For "forced" insert_id values (SET INSERT_ID or replication slave),
forced_auto_inc_intervals is non-empty and the handler takes its intervals
from there, without calling get_auto_increment().
ha_release_auto_increment() resets the handler's auto_increment variables;
it calls release_auto_increment() which is handler-dependent and
serves to return to the engine any unused tail of the last used
interval.
If ending a statement, next_insert_id>0 means that autoinc values have been
generated or taken from the master's binlog (in a replication slave) so
we clear those values read from binlog, so that next top- or sub-
statement does not use them.
sql/handler.h:
handler::auto_increment_changed can be replaced by
(handler::insert_id_for_cur_row > 0).
THD::next_insert_id moves into handler (more natural, and prepares
for the day when we'll support a single statement inserting into
two tables - "multi-table INSERT" like we have UPDATE - will this
happen?).
This move makes the backup/restore of THD::next_insert_id when entering
a substatement unneeded, as each substatement has its own handler
objects.
sql/item_func.cc:
new names for variables.
For the setting of what mysql_insert_id() will return to the client,
LAST_INSERT_ID(X) used to simply pretend that the generated autoinc
value for the current row was X, but this led to having no reliable
way to know the really generated value, so we now have a bool:
thd->arg_of_last_insert_id_function which enables us to know that
LAST_INSERT_ID(X) was called (and then X can be found in
thd->first_successful_insert_id_in_prev_stmt).
sql/log.cc:
new variable names for insert_ids. Removing some unused variables in the slow
log.
sql/log_event.cc:
new variable names, comments. Preparing for when master's won't binlog
LAST_INSERT_ID if it was 0.
sql/set_var.cc:
new variable names.
The last change repeats how Bar fixed BUG#20392
"INSERT_ID session variable has weird value" in 5.0.
sql/sql_class.cc:
new variables for insert_id. In THD::cleanup_after_query() we fix
BUG#20339 "stored procedure using LAST_INSERT_ID() does not replicate
statement-based" (will one want to fix it in 5.0?). Many comments
about what stored functions do to auto_increment.
In reset|restore_sub_statement_state(), we need to backup less
auto_inc variables as some of them have moved to the handler;
we backup/restore those which are about the current top- or sub-
statement, *not* those about the statement-based binlog
(which evolve as the top- and sub-statement execute).
Because we split THD::last_insert_id into
THD::first_successful_insert_id_in_prev_stmt and
THD::auto_inc_intervals_for_binlog (among others), we fix
BUG#20341 "stored function inserting into one auto_increment
puts bad data in slave": indeed we can afford to not backup/restore
THD::auto_inc_intervals_for_binlog (which fixes the bug) while still
backing up / restoring THD::first_successful_insert_id_in_prev_stmt
(ensuring that the top-level LAST_INSERT_ID() is not affected by INSERTs
done by sub-statements, as is desirable and tested in rpl_insert_id.test).
sql/sql_class.h:
new variables and methods for auto_increment.
Some THD members move into handler (those which are really about
the table being inserted), some stay in THD (those which are
about what a future LAST_INSERT_ID() should return, or about
what should be stored into the statement-based binlog).
THD::next_insert_id moves to handler::.
THD::clear_next_insert_id removed (had become equivalent
to next_insert_id > 0).
THD::last_insert_id becomes four:
THD::first_successful_insert_id_in_cur_stmt,
THD::auto_inc_intervals_for_binlog,
handler::insert_id_for_cur_row,
THD::first_successful_insert_id_in_prev_stmt.
THD::current_insert_id becomes:
THD::first_successful_insert_id_in_prev_stmt_for_binlog
THD::prev_insert_id is removed, handler can just use
handler::insert_id_for_cur_row instead (which is more accurate:
for the first row, prev_insert_id was set before get_auto_increment
was called, so was 0, causing a call to
get_auto_increment() for the 2nd row if the 1st row fails;
here we don't need the call as insert_id_for_cur_row has
the value of the first row).
THD::last_insert_id_used becomes: stmt_depends_on_first_row_in_prev_stmt
THD::insert_id_used is removed (equivalent to
auto_inc_intervals_for_binlog non empty).
The interval returned by get_auto_increment() and currently being
consumed is handler::auto_inc_interval_for_cur_row.
Comments to explain each of them.
select_insert::last_insert_id becomes autoinc_value_of_last_inserted_row.
sql/sql_insert.cc:
the "id" variable is not changed for each row now; it used to compensate for
this contradiction:
- thd->last_insert_id supposed job was to keep the id of the first row
- but it was updated for every row
- so mysql_insert() made sure to catch its first value and restore it at the end of stmt.
Now THD keeps the first value in first_successful_insert_id_in_cur_stmt,
and value of the row in insert_id_for_cur_row. So "id" only serves to fill
mysql_insert_id(), as depending on some conditions, "id" must be different
values.
Prev_insert_id moves from THD to write_record().
We now set LAST_INSERT_ID() in ON DUPLICATE KEY UPDATE too (BUG#19243).
In an INSERT DELAYED, we still "reset auto-increment caching" but differently
(by calling ha_release_auto_increment()).
sql/sql_load.cc:
no need to fiddle with "id", THD maintains
THD::first_successful_insert_id_in_cur_stmt by itself and correctly now.
ha_release_auto_increment() is now (logically) called before we unlock
the table.
sql/sql_parse.cc:
update to new variable names.
Assertion that reset_thd_for_next_command() is not called for every
substatement of a routine (I'm not against it, but if we do this change,
statement-based binlogging needs some adjustments).
sql/sql_select.cc:
update for new variable names
sql/sql_table.cc:
next_insert_id not needed in mysql_alter_table(), THD manages.
sql/sql_update.cc:
update for new variable names.
Even though this is UPDATE, an insert id can be generated (by
LAST_INSERT_ID(X)) and should be recorded because mysql_insert_id() wants
to know about it.
sql/structs.h:
A class for "discrete" intervals (intervals of integer numbers with a certain
increment between them): Discrete_interval, and a class for a list of such
intervals: Discrete_intervals_list
tests/mysql_client_test.c:
tests of behaviour of mysql_insert_id(): there were no such tests, while in
our manual we document its behaviour. In comments you'll notice the behaviour
changes introduced (there are 5).
2006-07-09 17:52:19 +02:00
|
|
|
drop table t1;
|
2009-08-20 14:30:59 +02:00
|
|
|
|
2009-08-20 13:56:29 +02:00
|
|
|
--echo #
|
|
|
|
|
--echo # Bug#46616: Assertion `!table->auto_increment_field_not_null' on view
|
|
|
|
|
--echo # manipulations
|
|
|
|
|
--echo #
|
|
|
|
|
CREATE TABLE t1 ( a INT );
|
|
|
|
|
INSERT INTO t1 VALUES (1), (1);
|
|
|
|
|
|
|
|
|
|
CREATE TABLE t2 ( a INT AUTO_INCREMENT KEY );
|
|
|
|
|
--error ER_DUP_ENTRY
|
|
|
|
|
CREATE TABLE IF NOT EXISTS t2 AS SELECT a FROM t1;
|
|
|
|
|
|
|
|
|
|
UPDATE t2 SET a = 2;
|
|
|
|
|
|
|
|
|
|
SELECT a FROM t2;
|
|
|
|
|
|
|
|
|
|
DROP TABLE t1, t2;
|
2009-08-20 14:30:59 +02:00
|
|
|
|