2003-02-07 15:47:24 +02:00
|
|
|
stop slave;
|
2003-01-28 09:17:10 +02:00
|
|
|
drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
|
|
|
|
reset master;
|
|
|
|
reset slave;
|
|
|
|
drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9;
|
2003-02-07 15:47:24 +02:00
|
|
|
start slave;
|
2006-02-08 16:47:46 +01:00
|
|
|
create table t1(a int auto_increment, key(a));
|
|
|
|
create table t2(b int auto_increment, c int, key(b));
|
2003-01-28 09:17:10 +02:00
|
|
|
insert into t1 values (1),(2),(3);
|
|
|
|
insert into t1 values (null);
|
|
|
|
insert into t2 values (null,last_insert_id());
|
2006-02-08 13:08:19 +01:00
|
|
|
select * from t1 ORDER BY a;
|
2003-01-28 06:48:26 +02:00
|
|
|
a
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3
|
|
|
|
4
|
2006-02-08 13:08:19 +01:00
|
|
|
select * from t2 ORDER BY b;
|
2003-01-28 06:48:26 +02:00
|
|
|
b c
|
|
|
|
1 4
|
2003-01-28 09:17:10 +02:00
|
|
|
drop table t1;
|
|
|
|
drop table t2;
|
2003-12-10 04:31:42 +00:00
|
|
|
create table t1(a int auto_increment, key(a)) engine=innodb;
|
|
|
|
create table t2(b int auto_increment, c int, key(b), foreign key(b) references t1(a)) engine=innodb;
|
2003-05-26 15:08:17 +03:00
|
|
|
SET FOREIGN_KEY_CHECKS=0;
|
2003-01-28 09:17:10 +02:00
|
|
|
insert into t1 values (10);
|
|
|
|
insert into t1 values (null),(null),(null);
|
|
|
|
insert into t2 values (5,0);
|
|
|
|
insert into t2 values (null,last_insert_id());
|
2003-05-26 15:08:17 +03:00
|
|
|
SET FOREIGN_KEY_CHECKS=1;
|
2003-01-28 09:17:10 +02:00
|
|
|
select * from t1;
|
2003-01-28 06:48:26 +02:00
|
|
|
a
|
|
|
|
10
|
|
|
|
11
|
|
|
|
12
|
|
|
|
13
|
2003-01-28 09:17:10 +02:00
|
|
|
select * from t2;
|
2003-01-28 06:48:26 +02:00
|
|
|
b c
|
|
|
|
5 0
|
|
|
|
6 11
|
2003-01-28 09:17:10 +02:00
|
|
|
drop table t2;
|
2004-02-02 01:41:35 +02:00
|
|
|
drop table t1;
|
2006-02-08 16:47:46 +01:00
|
|
|
create table t1(a int auto_increment, key(a));
|
|
|
|
create table t2(b int auto_increment, c int, key(b));
|
2003-05-24 16:43:53 +02:00
|
|
|
insert into t1 values (10);
|
|
|
|
insert into t1 values (null),(null),(null);
|
|
|
|
insert into t2 values (5,0);
|
2006-02-08 13:08:19 +01:00
|
|
|
insert into t2 (c) select * from t1 ORDER BY a;
|
|
|
|
select * from t2 ORDER BY b;
|
2003-05-24 16:43:53 +02:00
|
|
|
b c
|
|
|
|
5 0
|
|
|
|
6 10
|
|
|
|
7 11
|
|
|
|
8 12
|
|
|
|
9 13
|
2006-02-08 13:08:19 +01:00
|
|
|
select * from t1 ORDER BY a;
|
2003-05-24 16:43:53 +02:00
|
|
|
a
|
|
|
|
10
|
|
|
|
11
|
|
|
|
12
|
|
|
|
13
|
2006-02-08 13:08:19 +01:00
|
|
|
select * from t2 ORDER BY b;
|
2003-05-24 16:43:53 +02:00
|
|
|
b c
|
|
|
|
5 0
|
|
|
|
6 10
|
|
|
|
7 11
|
|
|
|
8 12
|
|
|
|
9 13
|
|
|
|
drop table t1;
|
|
|
|
drop table t2;
|
2005-02-14 18:39:33 +01:00
|
|
|
SET TIMESTAMP=1000000000;
|
|
|
|
CREATE TABLE t1 ( a INT UNIQUE );
|
|
|
|
SET FOREIGN_KEY_CHECKS=0;
|
|
|
|
INSERT INTO t1 VALUES (1),(1);
|
2006-02-08 13:08:19 +01:00
|
|
|
Got one of the listed errors
|
2006-08-01 08:49:43 +04:00
|
|
|
drop table t1;
|
2006-07-10 16:27:03 +03:00
|
|
|
create table t1(a int auto_increment, key(a));
|
|
|
|
create table t2(a int);
|
|
|
|
insert into t1 (a) values (null);
|
|
|
|
insert into t2 (a) select a from t1 where a is null;
|
|
|
|
insert into t2 (a) select a from t1 where a is null;
|
|
|
|
select * from t2;
|
|
|
|
a
|
|
|
|
1
|
|
|
|
select * from t2;
|
|
|
|
a
|
|
|
|
1
|
2006-01-26 17:54:34 +01:00
|
|
|
drop table t1;
|
2006-07-10 16:27:03 +03:00
|
|
|
drop table t2;
|
2006-04-21 18:55:04 +04:00
|
|
|
drop function if exists bug15728;
|
|
|
|
drop function if exists bug15728_insert;
|
|
|
|
drop table if exists t1, t2;
|
|
|
|
create table t1 (
|
|
|
|
id int not null auto_increment,
|
|
|
|
last_id int,
|
|
|
|
primary key (id)
|
|
|
|
);
|
|
|
|
create function bug15728() returns int(11)
|
|
|
|
return last_insert_id();
|
|
|
|
insert into t1 (last_id) values (0);
|
|
|
|
insert into t1 (last_id) values (last_insert_id());
|
|
|
|
insert into t1 (last_id) values (bug15728());
|
|
|
|
create table t2 (
|
|
|
|
id int not null auto_increment,
|
|
|
|
last_id int,
|
|
|
|
primary key (id)
|
|
|
|
);
|
|
|
|
create function bug15728_insert() returns int(11) modifies sql data
|
|
|
|
begin
|
|
|
|
insert into t2 (last_id) values (bug15728());
|
|
|
|
return bug15728();
|
|
|
|
end|
|
|
|
|
create trigger t1_bi before insert on t1 for each row
|
|
|
|
begin
|
|
|
|
declare res int;
|
|
|
|
select bug15728_insert() into res;
|
|
|
|
set NEW.last_id = res;
|
|
|
|
end|
|
|
|
|
insert into t1 (last_id) values (0);
|
|
|
|
drop trigger t1_bi;
|
|
|
|
select last_insert_id();
|
|
|
|
last_insert_id()
|
|
|
|
4
|
|
|
|
select bug15728_insert();
|
|
|
|
bug15728_insert()
|
|
|
|
2
|
|
|
|
select last_insert_id();
|
|
|
|
last_insert_id()
|
|
|
|
4
|
|
|
|
insert into t1 (last_id) values (bug15728());
|
|
|
|
select last_insert_id();
|
|
|
|
last_insert_id()
|
|
|
|
5
|
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
|
|
|
drop procedure if exists foo;
|
|
|
|
create procedure foo()
|
|
|
|
begin
|
|
|
|
declare res int;
|
|
|
|
insert into t2 (last_id) values (bug15728());
|
|
|
|
insert into t1 (last_id) values (bug15728());
|
|
|
|
end|
|
|
|
|
call foo();
|
2006-04-21 18:55:04 +04:00
|
|
|
select * from t1;
|
|
|
|
id last_id
|
|
|
|
1 0
|
|
|
|
2 1
|
|
|
|
3 2
|
|
|
|
4 1
|
|
|
|
5 4
|
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
|
|
|
6 3
|
2006-04-21 18:55:04 +04:00
|
|
|
select * from t2;
|
|
|
|
id last_id
|
|
|
|
1 3
|
|
|
|
2 4
|
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
|
|
|
3 5
|
|
|
|
select * from t1;
|
|
|
|
id last_id
|
|
|
|
1 0
|
|
|
|
2 1
|
|
|
|
3 2
|
|
|
|
4 1
|
|
|
|
5 4
|
|
|
|
6 3
|
|
|
|
select * from t2;
|
|
|
|
id last_id
|
|
|
|
1 3
|
|
|
|
2 4
|
|
|
|
3 5
|
2006-04-21 18:55:04 +04:00
|
|
|
drop function bug15728;
|
|
|
|
drop function bug15728_insert;
|
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
|
|
|
drop table t1;
|
2006-07-10 18:41:03 +02:00
|
|
|
drop procedure foo;
|
2006-07-05 14:41:35 +02:00
|
|
|
create table t1 (n int primary key auto_increment not null,
|
|
|
|
b int, unique(b));
|
|
|
|
set sql_log_bin=0;
|
|
|
|
insert into t1 values(null,100);
|
|
|
|
replace into t1 values(null,50),(null,100),(null,150);
|
|
|
|
select * from t1 order by n;
|
|
|
|
n b
|
|
|
|
2 50
|
|
|
|
3 100
|
|
|
|
4 150
|
|
|
|
truncate table t1;
|
|
|
|
set sql_log_bin=1;
|
|
|
|
insert into t1 values(null,100);
|
|
|
|
select * from t1 order by n;
|
|
|
|
n b
|
|
|
|
1 100
|
|
|
|
insert into t1 values(null,200),(null,300);
|
|
|
|
delete from t1 where b <> 100;
|
|
|
|
select * from t1 order by n;
|
|
|
|
n b
|
|
|
|
1 100
|
|
|
|
replace into t1 values(null,100),(null,350);
|
|
|
|
select * from t1 order by n;
|
|
|
|
n b
|
|
|
|
2 100
|
|
|
|
3 350
|
|
|
|
select * from t1 order by n;
|
|
|
|
n b
|
|
|
|
2 100
|
|
|
|
3 350
|
|
|
|
insert into t1 values (NULL,400),(3,500),(NULL,600) on duplicate key UPDATE n=1000;
|
|
|
|
select * from t1 order by n;
|
|
|
|
n b
|
|
|
|
2 100
|
|
|
|
4 400
|
|
|
|
1000 350
|
|
|
|
1001 600
|
|
|
|
select * from t1 order by n;
|
|
|
|
n b
|
|
|
|
2 100
|
|
|
|
4 400
|
|
|
|
1000 350
|
|
|
|
1001 600
|
|
|
|
drop table t1;
|
|
|
|
create table t1 (n int primary key auto_increment not null,
|
|
|
|
b int, unique(b));
|
|
|
|
insert into t1 values(null,100);
|
|
|
|
select * from t1 order by n;
|
|
|
|
n b
|
|
|
|
1 100
|
|
|
|
insert into t1 values(null,200),(null,300);
|
|
|
|
delete from t1 where b <> 100;
|
|
|
|
select * from t1 order by n;
|
|
|
|
n b
|
|
|
|
1 100
|
|
|
|
insert into t1 values(null,100),(null,350) on duplicate key update n=2;
|
|
|
|
select * from t1 order by n;
|
|
|
|
n b
|
|
|
|
2 100
|
|
|
|
3 350
|
|
|
|
select * from t1 order by n;
|
|
|
|
n b
|
|
|
|
2 100
|
|
|
|
3 350
|
|
|
|
drop table t1;
|
2006-07-10 18:41:03 +02:00
|
|
|
truncate table t2;
|
|
|
|
create table t1 (id tinyint primary key);
|
|
|
|
create function insid() returns int
|
|
|
|
begin
|
|
|
|
insert into t2 (last_id) values (0);
|
|
|
|
return 0;
|
|
|
|
end|
|
|
|
|
set sql_log_bin=0;
|
|
|
|
insert into t2 (id) values(1),(2),(3);
|
|
|
|
delete from t2;
|
|
|
|
set sql_log_bin=1;
|
|
|
|
select insid();
|
|
|
|
insid()
|
|
|
|
0
|
|
|
|
set sql_log_bin=0;
|
|
|
|
insert into t2 (id) values(5),(6),(7);
|
|
|
|
delete from t2 where id>=5;
|
|
|
|
set sql_log_bin=1;
|
|
|
|
insert into t1 select insid();
|
|
|
|
select * from t1;
|
|
|
|
id
|
|
|
|
0
|
|
|
|
select * from t2;
|
|
|
|
id last_id
|
|
|
|
4 0
|
|
|
|
8 0
|
|
|
|
select * from t1;
|
|
|
|
id
|
|
|
|
0
|
|
|
|
select * from t2;
|
|
|
|
id last_id
|
|
|
|
4 0
|
|
|
|
8 0
|
|
|
|
drop table t1, t2;
|
|
|
|
drop function insid;
|