2006-09-21 13:19:52 +02:00
|
|
|
#
|
|
|
|
# Setup
|
|
|
|
#
|
|
|
|
use test;
|
|
|
|
drop table if exists t1, t2, t3;
|
|
|
|
#
|
|
|
|
# See if queries that use both auto_increment and LAST_INSERT_ID()
|
|
|
|
# are replicated well
|
|
|
|
#
|
|
|
|
# We also check how the foreign_key_check variable is replicated
|
|
|
|
#
|
2006-09-21 14:19:17 +02:00
|
|
|
stop slave;
|
|
|
|
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;
|
|
|
|
start slave;
|
2008-05-15 17:22:53 +02:00
|
|
|
create table t1(a int auto_increment, key(a)) engine=innodb;
|
|
|
|
create table t2(b int auto_increment, c int, key(b)) engine=innodb;
|
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
|
2006-09-21 13:19:52 +02:00
|
|
|
#
|
|
|
|
# check if INSERT SELECT in auto_increment is well replicated (bug #490)
|
|
|
|
#
|
2003-01-28 09:17:10 +02:00
|
|
|
drop table t2;
|
2004-02-02 01:41:35 +02:00
|
|
|
drop table t1;
|
2008-05-15 17:22:53 +02:00
|
|
|
create table t1(a int auto_increment, key(a)) engine=innodb;
|
|
|
|
create table t2(b int auto_increment, c int, key(b)) engine=innodb;
|
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;
|
2006-09-21 13:19:52 +02:00
|
|
|
#
|
|
|
|
# Bug#8412: Error codes reported in binary log for CHARACTER SET,
|
|
|
|
# FOREIGN_KEY_CHECKS
|
|
|
|
#
|
2005-02-14 18:39:33 +01:00
|
|
|
SET TIMESTAMP=1000000000;
|
2008-05-15 17:22:53 +02:00
|
|
|
CREATE TABLE t1 ( a INT UNIQUE ) engine=innodb;
|
2005-02-14 18:39:33 +01:00
|
|
|
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-09-21 13:19:52 +02:00
|
|
|
#
|
|
|
|
# Bug#14553: NULL in WHERE resets LAST_INSERT_ID
|
|
|
|
#
|
2008-05-15 17:22:53 +02:00
|
|
|
create table t1(a int auto_increment, key(a)) engine=innodb;
|
|
|
|
create table t2(a int) engine=innodb;
|
2006-07-10 16:27:03 +03:00
|
|
|
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-09-21 13:19:52 +02:00
|
|
|
#
|
|
|
|
# End of 4.1 tests
|
|
|
|
#
|
2006-09-21 14:19:17 +02:00
|
|
|
#
|
|
|
|
# BUG#15728: LAST_INSERT_ID function inside a stored function returns 0
|
|
|
|
#
|
|
|
|
# The solution is not to reset last_insert_id on enter to sub-statement.
|
|
|
|
#
|
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)
|
2008-05-15 17:22:53 +02:00
|
|
|
) engine=innodb;
|
2006-04-21 18:55:04 +04:00
|
|
|
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)
|
2008-05-15 17:22:53 +02:00
|
|
|
) engine=innodb;
|
2006-04-21 18:55:04 +04:00
|
|
|
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;
|
Manual merge from 5.0-rpl, of fixes for:
1)
BUG#25507 "multi-row insert delayed + auto increment causes
duplicate key entries on slave" (two concurrrent connections doing
multi-row INSERT DELAYED to insert into an auto_increment column,
caused replication slave to stop with "duplicate key error" (and
binlog was wrong), and BUG#26116 "If multi-row INSERT
DELAYED has errors, statement-based binlogging breaks" (the binlog
was not accounting for all rows inserted, or slave could stop).
The fix is that: in statement-based binlogging, a multi-row INSERT
DELAYED is silently converted to a non-delayed INSERT.
This is supposed to not affect many 5.1 users as in 5.1, the default
binlog format is "mixed", which does not have the bug (the bug is
only with binlog_format=STATEMENT).
We should document how the system delayed_insert thread decides of
its binlog format (which is not modified by this patch):
this decision is taken when the thread is created
and holds until it is terminated (is not affected by any later change
via SET GLOBAL BINLOG_FORMAT). It is also not affected by the binlog
format of the connection which issues INSERT DELAYED (this binlog
format does not affect how the row will be binlogged).
If one wants to change the binlog format of its server with SET
GLOBAL BINLOG_FORMAT, it should do FLUSH TABLES to be sure all
delayed_insert threads terminate and thus new threads are created,
taking into account the new format.
2)
BUG#24432
"INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values".
When in an INSERT ON DUPLICATE KEY UPDATE, using
an autoincrement column, we inserted some autogenerated values and
also updated some rows, some autogenerated values were not used
(for example, even if 10 was the largest autoinc value in the table
at the start of the statement, 12 could be the first autogenerated
value inserted by the statement, instead of 11). One autogenerated
value was lost per updated row. Led to exhausting the range of the
autoincrement column faster.
Bug introduced by fix of BUG#20188; present since 5.0.24 and 5.1.12.
This bug breaks replication from a pre-5.0.24/pre-5.1.12 master.
But the present bugfix, as it makes INSERT ON DUP KEY UPDATE
behave like pre-5.0.24/pre-5.1.12, breaks replication from a
[5.0.24,5.0.34]/[5.1.12,5.1.15]
master to a fixed (5.0.36/5.1.16) slave! To warn users against this when
they upgrade their slave, as agreed with the support team, we add
code for a fixed slave to detect that it is connected to a buggy
master in a situation (INSERT ON DUP KEY UPDATE into autoinc column)
likely to break replication, in which case it cannot replicate so
stops and prints a message to the slave's error log and to SHOW SLAVE
STATUS.
For 5.0.36->[5.0.24,5.0.34] replication or 5.1.16->[5.1.12,5.1.15]
replication we cannot warn as master
does not know the slave's version (but we always recommended to users
to have slave at least as new as master).
As agreed with support, I have asked for an alert to be put into
the MySQL Network Monitoring and Advisory Service.
3) note that I'll re-enable rpl_insert_id as soon as 5.1-rpl gets
the changes from the main 5.1.
2007-02-15 20:28:58 +01:00
|
|
|
drop table t1,t2;
|
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,
|
2008-05-15 17:22:53 +02:00
|
|
|
b int, unique(b)) engine=innodb;
|
2006-07-05 14:41:35 +02:00
|
|
|
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,
|
2008-05-15 17:22:53 +02:00
|
|
|
b int, unique(b)) engine=innodb;
|
2006-07-05 14:41:35 +02:00
|
|
|
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;
|
Fix for BUG#24432
"INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values".
When in an INSERT ON DUPLICATE KEY UPDATE, using
an autoincrement column, we inserted some autogenerated values and
also updated some rows, some autogenerated values were not used
(for example, even if 10 was the largest autoinc value in the table
at the start of the statement, 12 could be the first autogenerated
value inserted by the statement, instead of 11). One autogenerated
value was lost per updated row. Led to exhausting the range of the
autoincrement column faster.
Bug introduced by fix of BUG#20188; present since 5.0.24 and 5.1.12.
This bug breaks replication from a pre-5.0.24 master.
But the present bugfix, as it makes INSERT ON DUP KEY UPDATE
behave like pre-5.0.24, breaks replication from a [5.0.24,5.0.34]
master to a fixed (5.0.36) slave! To warn users against this when
they upgrade their slave, as agreed with the support team, we add
code for a fixed slave to detect that it is connected to a buggy
master in a situation (INSERT ON DUP KEY UPDATE into autoinc column)
likely to break replication, in which case it cannot replicate so
stops and prints a message to the slave's error log and to SHOW SLAVE
STATUS.
For 5.0.36->[5.0.24,5.0.34] replication we cannot warn as master
does not know the slave's version (but we always recommended to users
to have slave at least as new as master).
As agreed with support, I'll also ask for an alert to be put into
the MySQL Network Monitoring and Advisory Service.
2007-02-08 15:53:14 +01:00
|
|
|
CREATE TABLE t1 (a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b INT,
|
2008-05-15 17:22:53 +02:00
|
|
|
UNIQUE(b)) ENGINE=innodb;
|
Fix for BUG#24432
"INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values".
When in an INSERT ON DUPLICATE KEY UPDATE, using
an autoincrement column, we inserted some autogenerated values and
also updated some rows, some autogenerated values were not used
(for example, even if 10 was the largest autoinc value in the table
at the start of the statement, 12 could be the first autogenerated
value inserted by the statement, instead of 11). One autogenerated
value was lost per updated row. Led to exhausting the range of the
autoincrement column faster.
Bug introduced by fix of BUG#20188; present since 5.0.24 and 5.1.12.
This bug breaks replication from a pre-5.0.24 master.
But the present bugfix, as it makes INSERT ON DUP KEY UPDATE
behave like pre-5.0.24, breaks replication from a [5.0.24,5.0.34]
master to a fixed (5.0.36) slave! To warn users against this when
they upgrade their slave, as agreed with the support team, we add
code for a fixed slave to detect that it is connected to a buggy
master in a situation (INSERT ON DUP KEY UPDATE into autoinc column)
likely to break replication, in which case it cannot replicate so
stops and prints a message to the slave's error log and to SHOW SLAVE
STATUS.
For 5.0.36->[5.0.24,5.0.34] replication we cannot warn as master
does not know the slave's version (but we always recommended to users
to have slave at least as new as master).
As agreed with support, I'll also ask for an alert to be put into
the MySQL Network Monitoring and Advisory Service.
2007-02-08 15:53:14 +01:00
|
|
|
INSERT INTO t1(b) VALUES(1),(1),(2) ON DUPLICATE KEY UPDATE t1.b=10;
|
2008-05-15 17:22:53 +02:00
|
|
|
SELECT * FROM t1 ORDER BY a;
|
Fix for BUG#24432
"INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values".
When in an INSERT ON DUPLICATE KEY UPDATE, using
an autoincrement column, we inserted some autogenerated values and
also updated some rows, some autogenerated values were not used
(for example, even if 10 was the largest autoinc value in the table
at the start of the statement, 12 could be the first autogenerated
value inserted by the statement, instead of 11). One autogenerated
value was lost per updated row. Led to exhausting the range of the
autoincrement column faster.
Bug introduced by fix of BUG#20188; present since 5.0.24 and 5.1.12.
This bug breaks replication from a pre-5.0.24 master.
But the present bugfix, as it makes INSERT ON DUP KEY UPDATE
behave like pre-5.0.24, breaks replication from a [5.0.24,5.0.34]
master to a fixed (5.0.36) slave! To warn users against this when
they upgrade their slave, as agreed with the support team, we add
code for a fixed slave to detect that it is connected to a buggy
master in a situation (INSERT ON DUP KEY UPDATE into autoinc column)
likely to break replication, in which case it cannot replicate so
stops and prints a message to the slave's error log and to SHOW SLAVE
STATUS.
For 5.0.36->[5.0.24,5.0.34] replication we cannot warn as master
does not know the slave's version (but we always recommended to users
to have slave at least as new as master).
As agreed with support, I'll also ask for an alert to be put into
the MySQL Network Monitoring and Advisory Service.
2007-02-08 15:53:14 +01:00
|
|
|
a b
|
|
|
|
1 10
|
|
|
|
2 2
|
2008-05-15 17:22:53 +02:00
|
|
|
SELECT * FROM t1 ORDER BY a;
|
Fix for BUG#24432
"INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values".
When in an INSERT ON DUPLICATE KEY UPDATE, using
an autoincrement column, we inserted some autogenerated values and
also updated some rows, some autogenerated values were not used
(for example, even if 10 was the largest autoinc value in the table
at the start of the statement, 12 could be the first autogenerated
value inserted by the statement, instead of 11). One autogenerated
value was lost per updated row. Led to exhausting the range of the
autoincrement column faster.
Bug introduced by fix of BUG#20188; present since 5.0.24 and 5.1.12.
This bug breaks replication from a pre-5.0.24 master.
But the present bugfix, as it makes INSERT ON DUP KEY UPDATE
behave like pre-5.0.24, breaks replication from a [5.0.24,5.0.34]
master to a fixed (5.0.36) slave! To warn users against this when
they upgrade their slave, as agreed with the support team, we add
code for a fixed slave to detect that it is connected to a buggy
master in a situation (INSERT ON DUP KEY UPDATE into autoinc column)
likely to break replication, in which case it cannot replicate so
stops and prints a message to the slave's error log and to SHOW SLAVE
STATUS.
For 5.0.36->[5.0.24,5.0.34] replication we cannot warn as master
does not know the slave's version (but we always recommended to users
to have slave at least as new as master).
As agreed with support, I'll also ask for an alert to be put into
the MySQL Network Monitoring and Advisory Service.
2007-02-08 15:53:14 +01:00
|
|
|
a b
|
|
|
|
1 10
|
|
|
|
2 2
|
|
|
|
drop table t1;
|
|
|
|
CREATE TABLE t1 (
|
|
|
|
id bigint(20) unsigned NOT NULL auto_increment,
|
|
|
|
field_1 int(10) unsigned NOT NULL,
|
|
|
|
field_2 varchar(255) NOT NULL,
|
|
|
|
field_3 varchar(255) NOT NULL,
|
|
|
|
PRIMARY KEY (id),
|
|
|
|
UNIQUE KEY field_1 (field_1, field_2)
|
2008-05-15 17:22:53 +02:00
|
|
|
) ENGINE=innodb;
|
Fix for BUG#24432
"INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values".
When in an INSERT ON DUPLICATE KEY UPDATE, using
an autoincrement column, we inserted some autogenerated values and
also updated some rows, some autogenerated values were not used
(for example, even if 10 was the largest autoinc value in the table
at the start of the statement, 12 could be the first autogenerated
value inserted by the statement, instead of 11). One autogenerated
value was lost per updated row. Led to exhausting the range of the
autoincrement column faster.
Bug introduced by fix of BUG#20188; present since 5.0.24 and 5.1.12.
This bug breaks replication from a pre-5.0.24 master.
But the present bugfix, as it makes INSERT ON DUP KEY UPDATE
behave like pre-5.0.24, breaks replication from a [5.0.24,5.0.34]
master to a fixed (5.0.36) slave! To warn users against this when
they upgrade their slave, as agreed with the support team, we add
code for a fixed slave to detect that it is connected to a buggy
master in a situation (INSERT ON DUP KEY UPDATE into autoinc column)
likely to break replication, in which case it cannot replicate so
stops and prints a message to the slave's error log and to SHOW SLAVE
STATUS.
For 5.0.36->[5.0.24,5.0.34] replication we cannot warn as master
does not know the slave's version (but we always recommended to users
to have slave at least as new as master).
As agreed with support, I'll also ask for an alert to be put into
the MySQL Network Monitoring and Advisory Service.
2007-02-08 15:53:14 +01:00
|
|
|
CREATE TABLE t2 (
|
|
|
|
field_a int(10) unsigned NOT NULL,
|
|
|
|
field_b varchar(255) NOT NULL,
|
|
|
|
field_c varchar(255) NOT NULL
|
2008-05-15 17:22:53 +02:00
|
|
|
) ENGINE=innodb;
|
Fix for BUG#24432
"INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values".
When in an INSERT ON DUPLICATE KEY UPDATE, using
an autoincrement column, we inserted some autogenerated values and
also updated some rows, some autogenerated values were not used
(for example, even if 10 was the largest autoinc value in the table
at the start of the statement, 12 could be the first autogenerated
value inserted by the statement, instead of 11). One autogenerated
value was lost per updated row. Led to exhausting the range of the
autoincrement column faster.
Bug introduced by fix of BUG#20188; present since 5.0.24 and 5.1.12.
This bug breaks replication from a pre-5.0.24 master.
But the present bugfix, as it makes INSERT ON DUP KEY UPDATE
behave like pre-5.0.24, breaks replication from a [5.0.24,5.0.34]
master to a fixed (5.0.36) slave! To warn users against this when
they upgrade their slave, as agreed with the support team, we add
code for a fixed slave to detect that it is connected to a buggy
master in a situation (INSERT ON DUP KEY UPDATE into autoinc column)
likely to break replication, in which case it cannot replicate so
stops and prints a message to the slave's error log and to SHOW SLAVE
STATUS.
For 5.0.36->[5.0.24,5.0.34] replication we cannot warn as master
does not know the slave's version (but we always recommended to users
to have slave at least as new as master).
As agreed with support, I'll also ask for an alert to be put into
the MySQL Network Monitoring and Advisory Service.
2007-02-08 15:53:14 +01:00
|
|
|
INSERT INTO t2 (field_a, field_b, field_c) VALUES (1, 'a', '1a');
|
|
|
|
INSERT INTO t2 (field_a, field_b, field_c) VALUES (2, 'b', '2b');
|
|
|
|
INSERT INTO t2 (field_a, field_b, field_c) VALUES (3, 'c', '3c');
|
|
|
|
INSERT INTO t2 (field_a, field_b, field_c) VALUES (4, 'd', '4d');
|
|
|
|
INSERT INTO t2 (field_a, field_b, field_c) VALUES (5, 'e', '5e');
|
|
|
|
INSERT INTO t1 (field_1, field_2, field_3)
|
|
|
|
SELECT t2.field_a, t2.field_b, t2.field_c
|
|
|
|
FROM t2
|
|
|
|
ON DUPLICATE KEY UPDATE
|
|
|
|
t1.field_3 = t2.field_c;
|
|
|
|
INSERT INTO t2 (field_a, field_b, field_c) VALUES (6, 'f', '6f');
|
|
|
|
INSERT INTO t1 (field_1, field_2, field_3)
|
|
|
|
SELECT t2.field_a, t2.field_b, t2.field_c
|
|
|
|
FROM t2
|
|
|
|
ON DUPLICATE KEY UPDATE
|
|
|
|
t1.field_3 = t2.field_c;
|
2008-05-15 17:22:53 +02:00
|
|
|
SELECT * FROM t1 ORDER BY id;
|
Fix for BUG#24432
"INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values".
When in an INSERT ON DUPLICATE KEY UPDATE, using
an autoincrement column, we inserted some autogenerated values and
also updated some rows, some autogenerated values were not used
(for example, even if 10 was the largest autoinc value in the table
at the start of the statement, 12 could be the first autogenerated
value inserted by the statement, instead of 11). One autogenerated
value was lost per updated row. Led to exhausting the range of the
autoincrement column faster.
Bug introduced by fix of BUG#20188; present since 5.0.24 and 5.1.12.
This bug breaks replication from a pre-5.0.24 master.
But the present bugfix, as it makes INSERT ON DUP KEY UPDATE
behave like pre-5.0.24, breaks replication from a [5.0.24,5.0.34]
master to a fixed (5.0.36) slave! To warn users against this when
they upgrade their slave, as agreed with the support team, we add
code for a fixed slave to detect that it is connected to a buggy
master in a situation (INSERT ON DUP KEY UPDATE into autoinc column)
likely to break replication, in which case it cannot replicate so
stops and prints a message to the slave's error log and to SHOW SLAVE
STATUS.
For 5.0.36->[5.0.24,5.0.34] replication we cannot warn as master
does not know the slave's version (but we always recommended to users
to have slave at least as new as master).
As agreed with support, I'll also ask for an alert to be put into
the MySQL Network Monitoring and Advisory Service.
2007-02-08 15:53:14 +01:00
|
|
|
id field_1 field_2 field_3
|
|
|
|
1 1 a 1a
|
|
|
|
2 2 b 2b
|
|
|
|
3 3 c 3c
|
|
|
|
4 4 d 4d
|
|
|
|
5 5 e 5e
|
|
|
|
6 6 f 6f
|
2008-05-15 17:22:53 +02:00
|
|
|
SELECT * FROM t1 ORDER BY id;
|
Fix for BUG#24432
"INSERT... ON DUPLICATE KEY UPDATE skips auto_increment values".
When in an INSERT ON DUPLICATE KEY UPDATE, using
an autoincrement column, we inserted some autogenerated values and
also updated some rows, some autogenerated values were not used
(for example, even if 10 was the largest autoinc value in the table
at the start of the statement, 12 could be the first autogenerated
value inserted by the statement, instead of 11). One autogenerated
value was lost per updated row. Led to exhausting the range of the
autoincrement column faster.
Bug introduced by fix of BUG#20188; present since 5.0.24 and 5.1.12.
This bug breaks replication from a pre-5.0.24 master.
But the present bugfix, as it makes INSERT ON DUP KEY UPDATE
behave like pre-5.0.24, breaks replication from a [5.0.24,5.0.34]
master to a fixed (5.0.36) slave! To warn users against this when
they upgrade their slave, as agreed with the support team, we add
code for a fixed slave to detect that it is connected to a buggy
master in a situation (INSERT ON DUP KEY UPDATE into autoinc column)
likely to break replication, in which case it cannot replicate so
stops and prints a message to the slave's error log and to SHOW SLAVE
STATUS.
For 5.0.36->[5.0.24,5.0.34] replication we cannot warn as master
does not know the slave's version (but we always recommended to users
to have slave at least as new as master).
As agreed with support, I'll also ask for an alert to be put into
the MySQL Network Monitoring and Advisory Service.
2007-02-08 15:53:14 +01:00
|
|
|
id field_1 field_2 field_3
|
|
|
|
1 1 a 1a
|
|
|
|
2 2 b 2b
|
|
|
|
3 3 c 3c
|
|
|
|
4 4 d 4d
|
|
|
|
5 5 e 5e
|
|
|
|
6 6 f 6f
|
|
|
|
drop table t1, t2;
|
2006-10-02 14:28:23 +04:00
|
|
|
DROP PROCEDURE IF EXISTS p1;
|
|
|
|
DROP TABLE IF EXISTS t1, t2;
|
|
|
|
SELECT LAST_INSERT_ID(0);
|
|
|
|
LAST_INSERT_ID(0)
|
|
|
|
0
|
|
|
|
CREATE TABLE t1 (
|
|
|
|
id INT NOT NULL DEFAULT 0,
|
|
|
|
last_id INT,
|
|
|
|
PRIMARY KEY (id)
|
2008-05-15 17:22:53 +02:00
|
|
|
) ENGINE=innodb;
|
2006-10-02 14:28:23 +04:00
|
|
|
CREATE TABLE t2 (
|
|
|
|
id INT NOT NULL AUTO_INCREMENT,
|
|
|
|
last_id INT,
|
|
|
|
PRIMARY KEY (id)
|
2008-05-15 17:22:53 +02:00
|
|
|
) ENGINE=innodb;
|
2006-10-02 14:28:23 +04:00
|
|
|
CREATE PROCEDURE p1()
|
|
|
|
BEGIN
|
|
|
|
INSERT INTO t2 (last_id) VALUES (LAST_INSERT_ID());
|
|
|
|
INSERT INTO t1 (last_id) VALUES (LAST_INSERT_ID());
|
|
|
|
END|
|
|
|
|
CALL p1();
|
2008-05-15 17:22:53 +02:00
|
|
|
SELECT * FROM t1 ORDER BY id;
|
2006-10-02 14:28:23 +04:00
|
|
|
id last_id
|
|
|
|
0 1
|
2008-05-15 17:22:53 +02:00
|
|
|
SELECT * FROM t2 ORDER BY id;
|
2006-10-02 14:28:23 +04:00
|
|
|
id last_id
|
|
|
|
1 0
|
2008-05-15 17:22:53 +02:00
|
|
|
SELECT * FROM t1 ORDER BY id;
|
2006-10-02 14:28:23 +04:00
|
|
|
id last_id
|
|
|
|
0 1
|
2008-05-15 17:22:53 +02:00
|
|
|
SELECT * FROM t2 ORDER BY id;
|
2006-10-02 14:28:23 +04:00
|
|
|
id last_id
|
|
|
|
1 0
|
|
|
|
DROP PROCEDURE p1;
|
|
|
|
DROP TABLE t1, t2;
|
|
|
|
DROP PROCEDURE IF EXISTS p1;
|
|
|
|
DROP FUNCTION IF EXISTS f1;
|
|
|
|
DROP FUNCTION IF EXISTS f2;
|
2006-10-03 13:38:16 +04:00
|
|
|
DROP FUNCTION IF EXISTS f3;
|
2006-10-02 14:28:23 +04:00
|
|
|
DROP TABLE IF EXISTS t1, t2;
|
|
|
|
CREATE TABLE t1 (
|
|
|
|
i INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
|
|
|
|
j INT DEFAULT 0
|
2008-05-15 17:22:53 +02:00
|
|
|
) ENGINE=innodb;
|
|
|
|
CREATE TABLE t2 (i INT) ENGINE=innodb;
|
2006-10-02 14:28:23 +04:00
|
|
|
CREATE PROCEDURE p1()
|
|
|
|
BEGIN
|
|
|
|
INSERT INTO t1 (i) VALUES (NULL);
|
|
|
|
INSERT INTO t2 (i) VALUES (LAST_INSERT_ID());
|
|
|
|
INSERT INTO t1 (i) VALUES (NULL), (NULL);
|
|
|
|
INSERT INTO t2 (i) VALUES (LAST_INSERT_ID());
|
|
|
|
END |
|
|
|
|
CREATE FUNCTION f1() RETURNS INT MODIFIES SQL DATA
|
|
|
|
BEGIN
|
|
|
|
INSERT INTO t1 (i) VALUES (NULL);
|
|
|
|
INSERT INTO t2 (i) VALUES (LAST_INSERT_ID());
|
|
|
|
INSERT INTO t1 (i) VALUES (NULL), (NULL);
|
|
|
|
INSERT INTO t2 (i) VALUES (LAST_INSERT_ID());
|
|
|
|
RETURN 0;
|
|
|
|
END |
|
|
|
|
CREATE FUNCTION f2() RETURNS INT NOT DETERMINISTIC
|
|
|
|
RETURN LAST_INSERT_ID() |
|
2006-10-03 13:38:16 +04:00
|
|
|
CREATE FUNCTION f3() RETURNS INT MODIFIES SQL DATA
|
|
|
|
BEGIN
|
|
|
|
INSERT INTO t2 (i) VALUES (LAST_INSERT_ID());
|
|
|
|
RETURN 0;
|
|
|
|
END |
|
2006-10-02 14:28:23 +04:00
|
|
|
INSERT INTO t1 VALUES (NULL, -1);
|
|
|
|
CALL p1();
|
|
|
|
SELECT f1();
|
|
|
|
f1()
|
|
|
|
0
|
|
|
|
INSERT INTO t1 VALUES (NULL, f2()), (NULL, LAST_INSERT_ID()),
|
|
|
|
(NULL, LAST_INSERT_ID()), (NULL, f2()), (NULL, f2());
|
|
|
|
INSERT INTO t1 VALUES (NULL, f2());
|
|
|
|
INSERT INTO t1 VALUES (NULL, LAST_INSERT_ID()), (NULL, LAST_INSERT_ID(5)),
|
|
|
|
(NULL, @@LAST_INSERT_ID);
|
|
|
|
INSERT INTO t1 VALUES (NULL, 0), (NULL, LAST_INSERT_ID());
|
|
|
|
UPDATE t1 SET j= -1 WHERE i IS NULL;
|
2006-10-03 13:38:16 +04:00
|
|
|
INSERT INTO t1 (i) VALUES (NULL);
|
2008-05-15 17:22:53 +02:00
|
|
|
SET @old_concurrent_insert= @@global.concurrent_insert;
|
|
|
|
SET @@global.concurrent_insert= 0;
|
2006-10-03 13:38:16 +04:00
|
|
|
INSERT INTO t1 (i) VALUES (NULL);
|
|
|
|
SELECT f3();
|
|
|
|
f3()
|
|
|
|
0
|
2008-05-15 17:22:53 +02:00
|
|
|
SET @@global.concurrent_insert= @old_concurrent_insert;
|
|
|
|
SELECT * FROM t1 ORDER BY i;
|
2006-10-02 14:28:23 +04:00
|
|
|
i j
|
|
|
|
1 -1
|
|
|
|
2 0
|
|
|
|
3 0
|
|
|
|
4 0
|
|
|
|
5 0
|
|
|
|
6 0
|
|
|
|
7 0
|
|
|
|
8 3
|
|
|
|
9 3
|
|
|
|
10 3
|
|
|
|
11 3
|
|
|
|
12 3
|
|
|
|
13 8
|
|
|
|
14 13
|
|
|
|
15 5
|
|
|
|
16 13
|
|
|
|
17 -1
|
|
|
|
18 14
|
2006-10-03 13:38:16 +04:00
|
|
|
19 0
|
|
|
|
20 0
|
2008-05-15 17:22:53 +02:00
|
|
|
SELECT * FROM t2 ORDER BY i;
|
2006-10-02 14:28:23 +04:00
|
|
|
i
|
|
|
|
2
|
|
|
|
3
|
|
|
|
5
|
|
|
|
6
|
2006-10-03 13:38:16 +04:00
|
|
|
19
|
2006-10-02 14:28:23 +04:00
|
|
|
SELECT * FROM t1;
|
|
|
|
i j
|
|
|
|
1 -1
|
|
|
|
2 0
|
|
|
|
3 0
|
|
|
|
4 0
|
|
|
|
5 0
|
|
|
|
6 0
|
|
|
|
7 0
|
|
|
|
8 3
|
|
|
|
9 3
|
|
|
|
10 3
|
|
|
|
11 3
|
|
|
|
12 3
|
|
|
|
13 8
|
|
|
|
14 13
|
|
|
|
15 5
|
|
|
|
16 13
|
|
|
|
17 -1
|
|
|
|
18 14
|
2006-10-03 13:38:16 +04:00
|
|
|
19 0
|
|
|
|
20 0
|
2006-10-02 14:28:23 +04:00
|
|
|
SELECT * FROM t2;
|
|
|
|
i
|
|
|
|
2
|
|
|
|
3
|
|
|
|
5
|
|
|
|
6
|
2006-10-03 13:38:16 +04:00
|
|
|
19
|
2006-10-02 14:28:23 +04:00
|
|
|
DROP PROCEDURE p1;
|
|
|
|
DROP FUNCTION f1;
|
|
|
|
DROP FUNCTION f2;
|
2006-10-03 13:38:16 +04:00
|
|
|
DROP FUNCTION f3;
|
2006-10-02 14:28:23 +04:00
|
|
|
DROP TABLE t1, t2;
|
2006-09-21 14:19:17 +02:00
|
|
|
#
|
2006-09-21 13:38:01 +02:00
|
|
|
# End of 5.0 tests
|
2006-09-21 14:19:17 +02:00
|
|
|
#
|
2006-10-02 15:26:01 +04:00
|
|
|
create table t2 (
|
|
|
|
id int not null auto_increment,
|
|
|
|
last_id int,
|
|
|
|
primary key (id)
|
2008-05-15 17:22:53 +02:00
|
|
|
) engine=innodb;
|
2006-07-10 18:41:03 +02:00
|
|
|
truncate table t2;
|
2008-05-15 17:22:53 +02:00
|
|
|
create table t1 (id tinyint primary key) engine=innodb;
|
2006-07-10 18:41:03 +02:00
|
|
|
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();
|
2008-05-15 17:22:53 +02:00
|
|
|
select * from t1 order by id;
|
2006-07-10 18:41:03 +02:00
|
|
|
id
|
|
|
|
0
|
2008-05-15 17:22:53 +02:00
|
|
|
select * from t2 order by id;
|
2006-07-10 18:41:03 +02:00
|
|
|
id last_id
|
|
|
|
4 0
|
|
|
|
8 0
|
2008-05-15 17:22:53 +02:00
|
|
|
select * from t1 order by id;
|
2006-07-10 18:41:03 +02:00
|
|
|
id
|
|
|
|
0
|
2008-05-15 17:22:53 +02:00
|
|
|
select * from t2 order by id;
|
2006-07-10 18:41:03 +02:00
|
|
|
id last_id
|
|
|
|
4 0
|
|
|
|
8 0
|
2006-09-12 15:42:13 +02:00
|
|
|
drop table t1;
|
2006-07-10 18:41:03 +02:00
|
|
|
drop function insid;
|
2006-09-12 15:42:13 +02:00
|
|
|
truncate table t2;
|
|
|
|
create table t1 (n int primary key auto_increment not null,
|
2008-05-15 17:22:53 +02:00
|
|
|
b int, unique(b)) engine=innodb;
|
2006-09-12 15:42:13 +02:00
|
|
|
create procedure foo()
|
|
|
|
begin
|
|
|
|
insert into t1 values(null,10);
|
|
|
|
insert ignore into t1 values(null,10);
|
|
|
|
insert ignore into t1 values(null,10);
|
|
|
|
insert into t2 values(null,3);
|
|
|
|
end|
|
|
|
|
call foo();
|
2008-05-15 17:22:53 +02:00
|
|
|
select * from t1 order by n;
|
2006-09-12 15:42:13 +02:00
|
|
|
n b
|
|
|
|
1 10
|
2008-05-15 17:22:53 +02:00
|
|
|
select * from t2 order by id;
|
2006-09-12 15:42:13 +02:00
|
|
|
id last_id
|
|
|
|
1 3
|
2008-05-15 17:22:53 +02:00
|
|
|
select * from t1 order by n;
|
2006-09-12 15:42:13 +02:00
|
|
|
n b
|
|
|
|
1 10
|
2008-05-15 17:22:53 +02:00
|
|
|
select * from t2 order by id;
|
2006-09-12 15:42:13 +02:00
|
|
|
id last_id
|
|
|
|
1 3
|
|
|
|
drop table t1, t2;
|
|
|
|
drop procedure foo;
|