mirror of
https://github.com/MariaDB/server.git
synced 2025-01-22 06:44:16 +01:00
1ab519d91f
Fix for bug #46947 "Embedded SELECT without FOR UPDATE is causing a lock", with after-review fixes. SELECT statements with subqueries referencing InnoDB tables were acquiring shared locks on rows in these tables when they were executed in REPEATABLE-READ mode and with statement or mixed mode binary logging turned on. This was a regression which were introduced when fixing bug 39843. The problem was that for tables belonging to subqueries parser set TL_READ_DEFAULT as a lock type. In cases when statement/mixed binary logging at open_tables() time this type of lock was converted to TL_READ_NO_INSERT lock at open_tables() time and caused InnoDB engine to acquire shared locks on reads from these tables. Although in some cases such behavior was correct (e.g. for subqueries in DELETE) in case of SELECT it has caused unnecessary locking. This patch tries to solve this problem by rethinking our approach to how we handle locking for SELECT and subqueries. Now we always set TL_READ_DEFAULT lock type for all cases when we read data. When at open_tables() time this lock is interpreted as TL_READ_NO_INSERT or TL_READ depending on whether this statement as a whole or call to function which uses particular table should be written to the binary log or not (if yes then statement should be properly serialized with concurrent statements and stronger lock should be acquired). Test coverage is added for both InnoDB and MyISAM. This patch introduces an "incompatible" change in locking scheme for subqueries used in SELECT ... FOR UPDATE and SELECT .. IN SHARE MODE. In 4.1 the server would use a snapshot InnoDB read for subqueries in SELECT FOR UPDATE and SELECT .. IN SHARE MODE statements, regardless of whether the binary log is on or off. If the user required a different type of read (i.e. locking read), he/she could request so explicitly by providing FOR UPDATE/IN SHARE MODE clause for each individual subquery. On of the patches for 5.0 broke this behaviour (which was not documented or tested), and started to use locking reads fora all subqueries in SELECT ... FOR UPDATE/IN SHARE MODE. This patch restored 4.1 behaviour. mysql-test/include/check_concurrent_insert.inc: Added auxiliary script which allows to check if statement reading table allows concurrent inserts in it. mysql-test/include/check_no_concurrent_insert.inc: Added auxiliary script which allows to check that statement reading table doesn't allow concurrent inserts in it. mysql-test/include/check_no_row_lock.inc: Added auxiliary script which allows to check if statement reading table doesn't take locks on its rows. mysql-test/include/check_shared_row_lock.inc: Added auxiliary script which allows to check if statement reading table takes shared locks on some of its rows. mysql-test/r/bug39022.result: After bug #46947 'Embedded SELECT without FOR UPDATE is causing a lock' was fixed test case for bug 39022 has to be adjusted in order to trigger execution path on which original problem was encountered. mysql-test/r/innodb_mysql_lock2.result: Added coverage for handling of locking in various cases when we read data from InnoDB tables (includes test case for bug #46947 'Embedded SELECT without FOR UPDATE is causing a lock'). mysql-test/r/lock_sync.result: Added coverage for handling of locking in various cases when we read data from MyISAM tables. mysql-test/t/bug39022.test: After bug #46947 'Embedded SELECT without FOR UPDATE is causing a lock' was fixed test case for bug 39022 has to be adjusted in order to trigger execution path on which original problem was encountered. mysql-test/t/innodb_mysql_lock2.test: Added coverage for handling of locking in various cases when we read data from InnoDB tables (includes test case for bug #46947 'Embedded SELECT without FOR UPDATE is causing a lock'). mysql-test/t/lock_sync.test: Added coverage for handling of locking in various cases when we read data from MyISAM tables. sql/log_event.cc: Since LEX::lock_option member was removed we no longer can rely on its value in Load_log_event::print_query() to determine that log event correponds to LOAD DATA CONCURRENT statement (this was not correct in all situations anyway). A new Load_log_event's member was introduced as a replacement. It is initialized at event object construction time and explicitly indicates whether LOAD DATA was concurrent. sql/log_event.h: Since LEX::lock_option member was removed we no longer can rely on its value in Load_log_event::print_query() to determine that log event correponds to LOAD DATA CONCURRENT statement (this was not correct in all situations anyway). A new Load_log_event's member was introduced as a replacement. It is initialized at event object construction time and explicitly indicates whether LOAD DATA was concurrent. sql/sp_head.cc: sp_head::reset_lex(): Before parsing substatement reset part of parser state which needs this (e.g. set Yacc_state::m_lock_type to default value). sql/sql_acl.cc: Since LEX::reset_n_backup_query_tables_list() now also resets LEX::sql_command member (as it became part of Query_tables_list class) we have to restore it in cases when while working with proxy Query_table_list we assume that LEX::sql_command still corresponds to original SQL command being executed (for example, when we are logging statement to the binary log while having Query_tables_list reset and backed up). sql/sql_base.cc: Changed read_lock_type_for_table() to return a weak TL_READ type of lock in cases when we are executing statement which won't update tables directly and table doesn't belong to statement's prelocking list and thus can't be used by a stored function. It is OK to do so since in this case table won't be used by statement or function call which will be written to the binary log, so serializability requirements for it can be relaxed. One of results from this change is that SELECTs on InnoDB tables no longer takes shared row locks for tables which are used in subqueries (i.e. bug #46947 is fixed). Another result is that for similar SELECTs on MyISAM tables concurrent inserts are allowed. In order to implement this change signature of read_lock_type_for_table() function was changed to take pointers to Query_tables_list and TABLE_LIST objects. sql/sql_base.h: - Function read_lock_type_for_table() now takes pointers to Query_tables_list and TABLE_LIST elements as its arguments since to correctly determine lock type it needs to know what statement is being performed and whether table element for which lock type to be determined belongs to prelocking list. sql/sql_lex.cc: - Removed LEX::lock_option and st_select_lex::lock_option members. Places in parser that were using them now use Yacc_state::m_lock_type instead. - To emphasize that LEX::sql_command member is used during process of opening and locking of tables it was moved to Query_tables_list class. It is now reset by Query_tables_list::reset_query_tables_list() method. sql/sql_lex.h: - Removed st_select_lex::lock_option member as there is no real need for per-SELECT lock type (HIGH_PRIORITY option should apply to the whole statement. FOR UPDATE/LOCK IN SHARE MODE clauses can be handled without this member). The main effect which was achieved by introduction of this member, i.e. using TL_READ_DEFAULT lock type for subqueries, is now achieved by setting LEX::lock_option (or rather its replacement - Yacc_state::m_lock_type) to TL_READ_DEFAULT in almost all cases. - To emphasize that LEX::sql_command member is used during process of opening and locking of tables it was moved to Query_tables_list class. - Replaced LEX::lock_option with Yacc_state::m_lock_type in order to emphasize that this value is relevant only during parsing. Unlike for LEX::lock_option the default value for Yacc_state::m_lock_type is TL_READ_DEFAULT. Note that for cases when it is OK to take a "weak" read lock (e.g. simple SELECT) this lock type will be converted to TL_READ at open_tables() time. So this change won't cause negative change in behavior for such statements. OTOH this change ensures that, for example, for SELECTs which are used in stored functions TL_READ_NO_INSERT lock is taken when necessary and as result calls to such stored functions can be written to the binary log with correct serialization. sql/sql_load.cc: Load_log_event constructor now requires a parameter that indicates whether LOAD DATA is concurrent. sql/sql_parse.cc: LEX::lock_option was replaced with Yacc_state::m_lock_type. And instead of resetting the latter implicitly in mysql_init_multi_delete() we do it explicitly in the places in parser which call this function. sql/sql_priv.h: - To be able more easily distinguish high-priority SELECTs in st_select_lex::print() method added flag for HIGH_PRIORITY option. sql/sql_select.cc: Changed code not to rely on LEX::lock_option to determine that it is high-priority SELECT. It was replaced with Yacc_state::m_lock_type which is accessible only at parse time. So instead of LEX::lock_option we now rely on a newly introduced flag for st_select_lex::options - SELECT_HIGH_PRIORITY. sql/sql_show.cc: Since LEX::reset_n_backup_query_tables_list() now also resets LEX::sql_command member (as it became part of Query_tables_list class) we have to restore it in cases when while working with proxy Query_table_list we assume that LEX::sql_command still corresponds to original SQL command being executed. sql/sql_table.cc: Since LEX::reset_query_tables_list() now also resets LEX::sql_command member (as it became part of Query_tables_list class) we have to restore value of this member when this method is called by mysql_admin_table(), to make this code safe for re-execution. sql/sql_trigger.cc: Since LEX::reset_n_backup_query_tables_list() now also resets LEX::sql_command member (as it became part of Query_tables_list class) we have to restore it in cases when while working with proxy Query_table_list we assume that LEX::sql_command still corresponds to original SQL command being executed (for example, when we are logging statement to the binary log while having Query_tables_list reset and backed up). sql/sql_update.cc: Function read_lock_type_for_table() now takes pointers to Query_tables_list and TABLE_LIST elements as its arguments since to correctly determine lock type it needs to know what statement is being performed and whether table element for which lock type to be determined belongs to prelocking list. sql/sql_yacc.yy: - Removed st_select_lex::lock_option member as there is no real need for per-SELECT lock type (HIGH_PRIORITY option should apply to the whole statement. FOR UPDATE/LOCK IN SHARE MODE clauses can be handled without this member). The main effect which was achieved by introduction of this member, i.e. using TL_READ_DEFAULT lock type for subqueries, is now achieved by setting LEX::lock_option (or rather its replacement - Yacc_state::m_lock_type) to TL_READ_DEFAULT in almost all cases. - Replaced LEX::lock_option with Yacc_state::m_lock_type in order to emphasize that this value is relevant only during parsing. Unlike for LEX::lock_option the default value for Yacc_state::m_lock_type is TL_READ_DEFAULT. Note that for cases when it is OK to take a "weak" read lock (e.g. simple SELECT) this lock type will be converted to TL_READ at open_tables() time. So this change won't cause negative change in behavior for such statements. OTOH this change ensures that, for example, for SELECTs which are used in stored functions TL_READ_NO_INSERT lock is taken when necessary and as result calls to such stored functions can be written to the binary log with correct serialization. - To be able more easily distinguish high-priority SELECTs in st_select_lex::print() method we now use new flag in st_select_lex::options bit-field.
564 lines
19 KiB
Text
564 lines
19 KiB
Text
#
|
|
# Test how do we handle locking in various cases when
|
|
# we read data from InnoDB tables.
|
|
#
|
|
# In fact by performing this test we check two things:
|
|
# 1) That SQL-layer correctly determine type of thr_lock.c
|
|
# lock to be acquired/passed to InnoDB engine.
|
|
# 2) That InnoDB engine correctly interprets this lock
|
|
# type and takes necessary row locks or does not
|
|
# take them if they are not necessary.
|
|
#
|
|
# This test makes sense only in REPEATABLE-READ mode as
|
|
# in SERIALIZABLE mode all statements that read data take
|
|
# shared lock on them to enforce its semantics.
|
|
select @@session.tx_isolation;
|
|
@@session.tx_isolation
|
|
REPEATABLE-READ
|
|
# Prepare playground by creating tables, views,
|
|
# routines and triggers used in tests.
|
|
drop table if exists t0, t1, t2, t3, t4, t5;
|
|
drop view if exists v1, v2;
|
|
drop procedure if exists p1;
|
|
drop procedure if exists p2;
|
|
drop function if exists f1;
|
|
drop function if exists f2;
|
|
drop function if exists f3;
|
|
drop function if exists f4;
|
|
drop function if exists f5;
|
|
drop function if exists f6;
|
|
drop function if exists f7;
|
|
drop function if exists f8;
|
|
drop function if exists f9;
|
|
drop function if exists f10;
|
|
drop function if exists f11;
|
|
drop function if exists f12;
|
|
drop function if exists f13;
|
|
drop function if exists f14;
|
|
drop function if exists f15;
|
|
create table t1 (i int primary key) engine=innodb;
|
|
insert into t1 values (1), (2), (3), (4), (5);
|
|
create table t2 (j int primary key) engine=innodb;
|
|
insert into t2 values (1), (2), (3), (4), (5);
|
|
create table t3 (k int primary key) engine=innodb;
|
|
insert into t3 values (1), (2), (3);
|
|
create table t4 (l int primary key) engine=innodb;
|
|
insert into t4 values (1);
|
|
create table t5 (l int primary key) engine=innodb;
|
|
insert into t5 values (1);
|
|
create view v1 as select i from t1;
|
|
create view v2 as select j from t2 where j in (select i from t1);
|
|
create procedure p1(k int) insert into t2 values (k);
|
|
create function f1() returns int
|
|
begin
|
|
declare j int;
|
|
select i from t1 where i = 1 into j;
|
|
return j;
|
|
end|
|
|
create function f2() returns int
|
|
begin
|
|
declare k int;
|
|
select i from t1 where i = 1 into k;
|
|
insert into t2 values (k + 5);
|
|
return 0;
|
|
end|
|
|
create function f3() returns int
|
|
begin
|
|
return (select i from t1 where i = 3);
|
|
end|
|
|
create function f4() returns int
|
|
begin
|
|
if (select i from t1 where i = 3) then
|
|
return 1;
|
|
else
|
|
return 0;
|
|
end if;
|
|
end|
|
|
create function f5() returns int
|
|
begin
|
|
insert into t2 values ((select i from t1 where i = 1) + 5);
|
|
return 0;
|
|
end|
|
|
create function f6() returns int
|
|
begin
|
|
declare k int;
|
|
select i from v1 where i = 1 into k;
|
|
return k;
|
|
end|
|
|
create function f7() returns int
|
|
begin
|
|
declare k int;
|
|
select j from v2 where j = 1 into k;
|
|
return k;
|
|
end|
|
|
create function f8() returns int
|
|
begin
|
|
declare k int;
|
|
select i from v1 where i = 1 into k;
|
|
insert into t2 values (k+5);
|
|
return k;
|
|
end|
|
|
create function f9() returns int
|
|
begin
|
|
update v2 set j=j+10 where j=1;
|
|
return 1;
|
|
end|
|
|
create function f10() returns int
|
|
begin
|
|
return f1();
|
|
end|
|
|
create function f11() returns int
|
|
begin
|
|
declare k int;
|
|
set k= f1();
|
|
insert into t2 values (k+5);
|
|
return k;
|
|
end|
|
|
create function f12(p int) returns int
|
|
begin
|
|
insert into t2 values (p);
|
|
return p;
|
|
end|
|
|
create function f13(p int) returns int
|
|
begin
|
|
return p;
|
|
end|
|
|
create procedure p2(inout p int)
|
|
begin
|
|
select i from t1 where i = 1 into p;
|
|
end|
|
|
create function f14() returns int
|
|
begin
|
|
declare k int;
|
|
call p2(k);
|
|
insert into t2 values (k+5);
|
|
return k;
|
|
end|
|
|
create function f15() returns int
|
|
begin
|
|
declare k int;
|
|
call p2(k);
|
|
return k;
|
|
end|
|
|
create trigger t4_bi before insert on t4 for each row
|
|
begin
|
|
declare k int;
|
|
select i from t1 where i=1 into k;
|
|
set new.l= k+1;
|
|
end|
|
|
create trigger t4_bu before update on t4 for each row
|
|
begin
|
|
if (select i from t1 where i=1) then
|
|
set new.l= 2;
|
|
end if;
|
|
end|
|
|
create trigger t4_bd before delete on t4 for each row
|
|
begin
|
|
if !(select i from v1 where i=1) then
|
|
signal sqlstate '45000';
|
|
end if;
|
|
end|
|
|
create trigger t5_bi before insert on t5 for each row
|
|
begin
|
|
set new.l= f1()+1;
|
|
end|
|
|
create trigger t5_bu before update on t5 for each row
|
|
begin
|
|
declare j int;
|
|
call p2(j);
|
|
set new.l= j + 1;
|
|
end|
|
|
#
|
|
# Set common variables to be used by scripts called below.
|
|
#
|
|
#
|
|
# 1. Statements that read tables and do not use subqueries.
|
|
#
|
|
#
|
|
# 1.1 Simple SELECT statement.
|
|
#
|
|
# No locks are necessary as this statement won't be written
|
|
# to the binary log and thanks to how MyISAM works SELECT
|
|
# will see version of the table prior to concurrent insert.
|
|
Success: 'select * from t1' doesn't take row locks on 't1'.
|
|
#
|
|
# 1.2 Multi-UPDATE statement.
|
|
#
|
|
# Has to take shared locks on rows in the table being read as this
|
|
# statement will be written to the binary log and therefore should
|
|
# be serialized with concurrent statements.
|
|
Success: 'update t2, t1 set j= j - 1 where i = j' takes shared row locks on 't1'.
|
|
#
|
|
# 1.3 Multi-DELETE statement.
|
|
#
|
|
# The above is true for this statement as well.
|
|
Success: 'delete t2 from t1, t2 where i = j' takes shared row locks on 't1'.
|
|
#
|
|
# 1.4 DESCRIBE statement.
|
|
#
|
|
# This statement does not really read data from the
|
|
# target table and thus does not take any lock on it.
|
|
# We check this for completeness of coverage.
|
|
Success: 'describe t1' doesn't take row locks on 't1'.
|
|
#
|
|
# 1.5 SHOW statements.
|
|
#
|
|
# The above is true for SHOW statements as well.
|
|
Success: 'show create table t1' doesn't take row locks on 't1'.
|
|
Success: 'show keys from t1' doesn't take row locks on 't1'.
|
|
#
|
|
# 2. Statements which read tables through subqueries.
|
|
#
|
|
#
|
|
# 2.1 CALL with a subquery.
|
|
#
|
|
# A strong lock is not necessary as this statement is not
|
|
# written to the binary log as a whole (it is written
|
|
# statement-by-statement) and thanks to MVCC we can always get
|
|
# versions of rows prior to the update that has locked them.
|
|
# But in practice InnoDB does locking reads for all statements
|
|
# other than SELECT (unless it is a READ-COMITTED mode or
|
|
# innodb_locks_unsafe_for_binlog is ON).
|
|
Success: 'call p1((select i + 5 from t1 where i = 1))' takes shared row locks on 't1'.
|
|
#
|
|
# 2.2 CREATE TABLE with a subquery.
|
|
#
|
|
# Has to take shared locks on rows in the table being read as
|
|
# this statement is written to the binary log and therefore
|
|
# should be serialized with concurrent statements.
|
|
Success: 'create table t0 engine=innodb select * from t1' takes shared row locks on 't1'.
|
|
drop table t0;
|
|
Success: 'create table t0 engine=innodb select j from t2 where j in (select i from t1)' takes shared row locks on 't1'.
|
|
drop table t0;
|
|
#
|
|
# 2.3 DELETE with a subquery.
|
|
#
|
|
# The above is true for this statement as well.
|
|
Success: 'delete from t2 where j in (select i from t1)' takes shared row locks on 't1'.
|
|
#
|
|
# 2.4 MULTI-DELETE with a subquery.
|
|
#
|
|
# Same is true for this statement as well.
|
|
Success: 'delete t2 from t3, t2 where k = j and j in (select i from t1)' takes shared row locks on 't1'.
|
|
#
|
|
# 2.5 DO with a subquery.
|
|
#
|
|
# In theory should not take row locks as it is not logged.
|
|
# In practice InnoDB takes shared row locks.
|
|
Success: 'do (select i from t1 where i = 1)' takes shared row locks on 't1'.
|
|
#
|
|
# 2.6 INSERT with a subquery.
|
|
#
|
|
# Has to take shared locks on rows in the table being read as
|
|
# this statement is written to the binary log and therefore
|
|
# should be serialized with concurrent statements.
|
|
Success: 'insert into t2 select i+5 from t1' takes shared row locks on 't1'.
|
|
Success: 'insert into t2 values ((select i+5 from t1 where i = 4))' takes shared row locks on 't1'.
|
|
#
|
|
# 2.7 LOAD DATA with a subquery.
|
|
#
|
|
# The above is true for this statement as well.
|
|
Success: 'load data infile '../../std_data/rpl_loaddata.dat' into table t2 (@a, @b) set j= @b + (select i from t1 where i = 1)' takes shared row locks on 't1'.
|
|
#
|
|
# 2.8 REPLACE with a subquery.
|
|
#
|
|
# Same is true for this statement as well.
|
|
Success: 'replace into t2 select i+5 from t1' takes shared row locks on 't1'.
|
|
Success: 'replace into t2 values ((select i+5 from t1 where i = 4))' takes shared row locks on 't1'.
|
|
#
|
|
# 2.9 SELECT with a subquery.
|
|
#
|
|
# Locks are not necessary as this statement is not written
|
|
# to the binary log and thanks to MVCC we can always get
|
|
# versions of rows prior to the update that has locked them.
|
|
#
|
|
# Also serves as a test case for bug #46947 "Embedded SELECT
|
|
# without FOR UPDATE is causing a lock".
|
|
Success: 'select * from t2 where j in (select i from t1)' doesn't take row locks on 't1'.
|
|
#
|
|
# 2.10 SET with a subquery.
|
|
#
|
|
# In theory should not require locking as it is not written
|
|
# to the binary log. In practice InnoDB acquires shared row
|
|
# locks.
|
|
Success: 'set @a:= (select i from t1 where i = 1)' takes shared row locks on 't1'.
|
|
#
|
|
# 2.11 SHOW with a subquery.
|
|
#
|
|
# Similarly to the previous case, in theory should not require locking
|
|
# as it is not written to the binary log. In practice InnoDB
|
|
# acquires shared row locks.
|
|
Success: 'show tables from test where Tables_in_test = 't2' and (select i from t1 where i = 1)' takes shared row locks on 't1'.
|
|
Success: 'show columns from t2 where (select i from t1 where i = 1)' takes shared row locks on 't1'.
|
|
#
|
|
# 2.12 UPDATE with a subquery.
|
|
#
|
|
# Has to take shared locks on rows in the table being read as
|
|
# this statement is written to the binary log and therefore
|
|
# should be serialized with concurrent statements.
|
|
Success: 'update t2 set j= j-10 where j in (select i from t1)' takes shared row locks on 't1'.
|
|
#
|
|
# 2.13 MULTI-UPDATE with a subquery.
|
|
#
|
|
# Same is true for this statement as well.
|
|
Success: 'update t2, t3 set j= j -10 where j=k and j in (select i from t1)' takes shared row locks on 't1'.
|
|
#
|
|
# 3. Statements which read tables through a view.
|
|
#
|
|
#
|
|
# 3.1 SELECT statement which uses some table through a view.
|
|
#
|
|
# Since this statement is not written to the binary log
|
|
# and old version of rows are accessible thanks to MVCC,
|
|
# no locking is necessary.
|
|
Success: 'select * from v1' doesn't take row locks on 't1'.
|
|
Success: 'select * from v2' doesn't take row locks on 't1'.
|
|
Success: 'select * from t2 where j in (select i from v1)' doesn't take row locks on 't1'.
|
|
Success: 'select * from t3 where k in (select j from v2)' doesn't take row locks on 't1'.
|
|
#
|
|
# 3.2 Statements which modify a table and use views.
|
|
#
|
|
# Since such statements are going to be written to the binary
|
|
# log they need to be serialized against concurrent statements
|
|
# and therefore should take shared row locks on data read.
|
|
Success: 'update t2 set j= j-10 where j in (select i from v1)' takes shared row locks on 't1'.
|
|
Success: 'update t3 set k= k-10 where k in (select j from v2)' takes shared row locks on 't1'.
|
|
Success: 'update t2, v1 set j= j-10 where j = i' takes shared row locks on 't1'.
|
|
Success: 'update v2 set j= j-10 where j = 3' takes shared row locks on 't1'.
|
|
#
|
|
# 4. Statements which read tables through stored functions.
|
|
#
|
|
#
|
|
# 4.1 SELECT/SET with a stored function which does not
|
|
# modify data and uses SELECT in its turn.
|
|
#
|
|
# In theory there is no need to take row locks on the table
|
|
# being selected from in SF as the call to such function
|
|
# won't get into the binary log. In practice, however, we
|
|
# discover that fact too late in the process to be able to
|
|
# affect the decision what locks should be taken.
|
|
# Hence, strong locks are taken in this case.
|
|
Success: 'select f1()' takes shared row locks on 't1'.
|
|
Success: 'set @a:= f1()' takes shared row locks on 't1'.
|
|
#
|
|
# 4.2 INSERT (or other statement which modifies data) with
|
|
# a stored function which does not modify data and uses
|
|
# SELECT.
|
|
#
|
|
# Since such statement is written to the binary log it should
|
|
# be serialized with concurrent statements affecting the data
|
|
# it uses. Therefore it should take row locks on the data
|
|
# it reads.
|
|
Success: 'insert into t2 values (f1() + 5)' takes shared row locks on 't1'.
|
|
#
|
|
# 4.3 SELECT/SET with a stored function which
|
|
# reads and modifies data.
|
|
#
|
|
# Since a call to such function is written to the binary log,
|
|
# it should be serialized with concurrent statements affecting
|
|
# the data it uses. Hence, row locks on the data read
|
|
# should be taken.
|
|
Success: 'select f2()' takes shared row locks on 't1'.
|
|
Success: 'set @a:= f2()' takes shared row locks on 't1'.
|
|
#
|
|
# 4.4. SELECT/SET with a stored function which does not
|
|
# modify data and reads a table through subselect
|
|
# in a control construct.
|
|
#
|
|
# Again, in theory a call to this function won't get to the
|
|
# binary log and thus no locking is needed. But in practice
|
|
# we don't detect this fact early enough (get_lock_type_for_table())
|
|
# to avoid taking row locks.
|
|
Success: 'select f3()' takes shared row locks on 't1'.
|
|
Success: 'set @a:= f3()' takes shared row locks on 't1'.
|
|
Success: 'select f4()' takes shared row locks on 't1'.
|
|
Success: 'set @a:= f4()' takes shared row locks on 't1'.
|
|
#
|
|
# 4.5. INSERT (or other statement which modifies data) with
|
|
# a stored function which does not modify data and reads
|
|
# the table through a subselect in one of its control
|
|
# constructs.
|
|
#
|
|
# Since such statement is written to the binary log it should
|
|
# be serialized with concurrent statements affecting data it
|
|
# uses. Therefore it should take row locks on the data
|
|
# it reads.
|
|
Success: 'insert into t2 values (f3() + 5)' takes shared row locks on 't1'.
|
|
Success: 'insert into t2 values (f4() + 6)' takes shared row locks on 't1'.
|
|
#
|
|
# 4.6 SELECT/SET which uses a stored function with
|
|
# DML which reads a table via a subquery.
|
|
#
|
|
# Since call to such function is written to the binary log
|
|
# it should be serialized with concurrent statements.
|
|
# Hence reads should take row locks.
|
|
Success: 'select f5()' takes shared row locks on 't1'.
|
|
Success: 'set @a:= f5()' takes shared row locks on 't1'.
|
|
#
|
|
# 4.7 SELECT/SET which uses a stored function which
|
|
# doesn't modify data and reads tables through
|
|
# a view.
|
|
#
|
|
# Once again, in theory, calls to such functions won't
|
|
# get into the binary log and thus don't need row
|
|
# locks. But in practice this fact is discovered
|
|
# too late to have any effect.
|
|
Success: 'select f6()' takes shared row locks on 't1'.
|
|
Success: 'set @a:= f6()' takes shared row locks on 't1'.
|
|
Success: 'select f7()' takes shared row locks on 't1'.
|
|
Success: 'set @a:= f7()' takes shared row locks on 't1'.
|
|
#
|
|
# 4.8 INSERT which uses stored function which
|
|
# doesn't modify data and reads a table
|
|
# through a view.
|
|
#
|
|
# Since such statement is written to the binary log and
|
|
# should be serialized with concurrent statements affecting
|
|
# the data it uses. Therefore it should take row locks on
|
|
# the rows it reads.
|
|
Success: 'insert into t3 values (f6() + 5)' takes shared row locks on 't1'.
|
|
Success: 'insert into t3 values (f7() + 5)' takes shared row locks on 't1'.
|
|
#
|
|
# 4.9 SELECT which uses a stored function which
|
|
# modifies data and reads tables through a view.
|
|
#
|
|
# Since a call to such function is written to the binary log
|
|
# it should be serialized with concurrent statements.
|
|
# Hence, reads should take row locks.
|
|
Success: 'select f8()' takes shared row locks on 't1'.
|
|
Success: 'select f9()' takes shared row locks on 't1'.
|
|
#
|
|
# 4.10 SELECT which uses stored function which doesn't modify
|
|
# data and reads a table indirectly, by calling another
|
|
# function.
|
|
#
|
|
# In theory, calls to such functions won't get into the binary
|
|
# log and thus don't need to acquire row locks. But in practice
|
|
# this fact is discovered too late to have any effect.
|
|
Success: 'select f10()' takes shared row locks on 't1'.
|
|
#
|
|
# 4.11 INSERT which uses a stored function which doesn't modify
|
|
# data and reads a table indirectly, by calling another
|
|
# function.
|
|
#
|
|
# Since such statement is written to the binary log, it should
|
|
# be serialized with concurrent statements affecting the data it
|
|
# uses. Therefore it should take row locks on data it reads.
|
|
Success: 'insert into t2 values (f10() + 5)' takes shared row locks on 't1'.
|
|
#
|
|
# 4.12 SELECT which uses a stored function which modifies
|
|
# data and reads a table indirectly, by calling another
|
|
# function.
|
|
#
|
|
# Since a call to such function is written to the binary log
|
|
# it should be serialized from concurrent statements.
|
|
# Hence, reads should take row locks.
|
|
Success: 'select f11()' takes shared row locks on 't1'.
|
|
#
|
|
# 4.13 SELECT that reads a table through a subquery passed
|
|
# as a parameter to a stored function which modifies
|
|
# data.
|
|
#
|
|
# Even though a call to this function is written to the
|
|
# binary log, values of its parameters are written as literals.
|
|
# So there is no need to acquire row locks on rows used in
|
|
# the subquery.
|
|
Success: 'select f12((select i+10 from t1 where i=1))' doesn't take row locks on 't1'.
|
|
#
|
|
# 4.14 INSERT that reads a table via a subquery passed
|
|
# as a parameter to a stored function which doesn't
|
|
# modify data.
|
|
#
|
|
# Since this statement is written to the binary log it should
|
|
# be serialized with concurrent statements affecting the data it
|
|
# uses. Therefore it should take row locks on the data it reads.
|
|
Success: 'insert into t2 values (f13((select i+10 from t1 where i=1)))' takes shared row locks on 't1'.
|
|
#
|
|
# 5. Statements that read tables through stored procedures.
|
|
#
|
|
#
|
|
# 5.1 CALL statement which reads a table via SELECT.
|
|
#
|
|
# Since neither this statement nor its components are
|
|
# written to the binary log, there is no need to take
|
|
# row locks on the data it reads.
|
|
Success: 'call p2(@a)' doesn't take row locks on 't1'.
|
|
#
|
|
# 5.2 Function that modifes data and uses CALL,
|
|
# which reads a table through SELECT.
|
|
#
|
|
# Since a call to such function is written to the binary
|
|
# log, it should be serialized with concurrent statements.
|
|
# Hence, in this case reads should take row locks on data.
|
|
Success: 'select f14()' takes shared row locks on 't1'.
|
|
#
|
|
# 5.3 SELECT that calls a function that doesn't modify data and
|
|
# uses a CALL statement that reads a table via SELECT.
|
|
#
|
|
# In theory, calls to such functions won't get into the binary
|
|
# log and thus don't need to acquire row locks. But in practice
|
|
# this fact is discovered too late to have any effect.
|
|
Success: 'select f15()' takes shared row locks on 't1'.
|
|
#
|
|
# 5.4 INSERT which calls function which doesn't modify data and
|
|
# uses CALL statement which reads table through SELECT.
|
|
#
|
|
# Since such statement is written to the binary log it should
|
|
# be serialized with concurrent statements affecting data it
|
|
# uses. Therefore it should take row locks on data it reads.
|
|
Success: 'insert into t2 values (f15()+5)' takes shared row locks on 't1'.
|
|
#
|
|
# 6. Statements that use triggers.
|
|
#
|
|
#
|
|
# 6.1 Statement invoking a trigger that reads table via SELECT.
|
|
#
|
|
# Since this statement is written to the binary log it should
|
|
# be serialized with concurrent statements affecting the data
|
|
# it uses. Therefore, it should take row locks on the data
|
|
# it reads.
|
|
Success: 'insert into t4 values (2)' takes shared row locks on 't1'.
|
|
#
|
|
# 6.2 Statement invoking a trigger that reads table through
|
|
# a subquery in a control construct.
|
|
#
|
|
# The above is true for this statement as well.
|
|
Success: 'update t4 set l= 2 where l = 1' takes shared row locks on 't1'.
|
|
#
|
|
# 6.3 Statement invoking a trigger that reads a table through
|
|
# a view.
|
|
#
|
|
# And for this statement.
|
|
Success: 'delete from t4 where l = 1' takes shared row locks on 't1'.
|
|
#
|
|
# 6.4 Statement invoking a trigger that reads a table through
|
|
# a stored function.
|
|
#
|
|
# And for this statement.
|
|
Success: 'insert into t5 values (2)' takes shared row locks on 't1'.
|
|
#
|
|
# 6.5 Statement invoking a trigger that reads a table through
|
|
# stored procedure.
|
|
#
|
|
# And for this statement.
|
|
Success: 'update t5 set l= 2 where l = 1' takes shared row locks on 't1'.
|
|
# Clean-up.
|
|
drop function f1;
|
|
drop function f2;
|
|
drop function f3;
|
|
drop function f4;
|
|
drop function f5;
|
|
drop function f6;
|
|
drop function f7;
|
|
drop function f8;
|
|
drop function f9;
|
|
drop function f10;
|
|
drop function f11;
|
|
drop function f12;
|
|
drop function f13;
|
|
drop function f14;
|
|
drop function f15;
|
|
drop view v1, v2;
|
|
drop procedure p1;
|
|
drop procedure p2;
|
|
drop table t1, t2, t3, t4, t5;
|