1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add TL_FIRST_WRITE in SQL layer for determining R/W

Browse Source 
Use < TL_FIRST_WRITE for determining a READ transaction.

Use TL_FIRST_WRITE as the relative operator replacing TL_WRITE_ALLOW_WRITE
as the minimium WRITE lock type.
This commit is contained in:
Daniel Black 2021-03-24 15:41:10 +11:00
parent cf552f5886
commit 058484687a
18 changed files with 57 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/thr_lock.h
View File

@ -72,6 +72,15 @@ enum thr_lock_type { TL_IGNORE=-1,
/* Abort new lock request with an error */ /* Abort new lock request with an error */
TL_WRITE_ONLY}; TL_WRITE_ONLY};
/*
TL_FIRST_WRITE is here to impose some consistency in the sql
layer on determining read/write transactions and to
provide some API compatibility if additional transactions
are added. Above or equal to TL_FIRST_WRITE is a write transaction
while < TL_FIRST_WRITE is a read transaction.
*/
#define TL_FIRST_WRITE TL_WRITE_ALLOW_WRITE
enum enum_thr_lock_result { THR_LOCK_SUCCESS= 0, THR_LOCK_ABORTED= 1, enum enum_thr_lock_result { THR_LOCK_SUCCESS= 0, THR_LOCK_ABORTED= 1,
THR_LOCK_WAIT_TIMEOUT= 2, THR_LOCK_DEADLOCK= 3 }; THR_LOCK_WAIT_TIMEOUT= 2, THR_LOCK_DEADLOCK= 3 };

8
mysys/thr_lock.c
View File

@ -216,8 +216,8 @@ static int check_lock(struct st_lock_list *list, const char* lock_type,
lock_type, where); lock_type, where);
return 1; return 1;
} }
if ((read_lock && data->type > TL_READ_NO_INSERT) || if ((read_lock && data->type >= TL_FIRST_WRITE) ||
(!read_lock && data->type <= TL_READ_NO_INSERT)) (!read_lock && data->type < TL_FIRST_WRITE))
{ {
fprintf(stderr, fprintf(stderr,
"Warning: Found %s lock in %s queue at %s: %s\n", "Warning: Found %s lock in %s queue at %s: %s\n",
@ -765,9 +765,9 @@ thr_lock(THR_LOCK_DATA *data, THR_LOCK_INFO *owner, ulong lock_wait_timeout)
DBUG_PRINT("lock",("data:%p thread:%lu lock:%p type: %d", DBUG_PRINT("lock",("data:%p thread:%lu lock:%p type: %d",
data, (ulong) data->owner->thread_id, data, (ulong) data->owner->thread_id,
lock, (int) lock_type)); lock, (int) lock_type));
check_locks(lock,(uint) lock_type <= (uint) TL_READ_NO_INSERT ? check_locks(lock,(uint) lock_type < (uint) TL_FIRST_WRITE ?
"enter read_lock" : "enter write_lock", lock_type, 0); "enter read_lock" : "enter write_lock", lock_type, 0);
if ((int) lock_type <= (int) TL_READ_NO_INSERT) if ((int) lock_type < (int) TL_FIRST_WRITE)
{ {
/* Request for READ lock */ /* Request for READ lock */
if (lock->write.data) if (lock->write.data)

10
sql/ha_partition.cc
View File

@ -4244,15 +4244,8 @@ int ha_partition::start_stmt(THD *thd, thr_lock_type lock_type)
/* Add partition to be called in reset(). */ /* Add partition to be called in reset(). */
bitmap_set_bit(&m_partitions_to_reset, i); bitmap_set_bit(&m_partitions_to_reset, i);
} }
switch (lock_type) if (lock_type >= TL_FIRST_WRITE)
{ {
case TL_WRITE_ALLOW_WRITE:
case TL_WRITE_CONCURRENT_INSERT:
case TL_WRITE_DELAYED:
case TL_WRITE_DEFAULT:
case TL_WRITE_LOW_PRIORITY:
case TL_WRITE:
case TL_WRITE_ONLY:
if (m_part_info->part_expr) if (m_part_info->part_expr)
m_part_info->part_expr->walk(&Item::register_field_in_read_map, 1, 0); m_part_info->part_expr->walk(&Item::register_field_in_read_map, 1, 0);
if (m_part_info->part_type == VERSIONING_PARTITION && if (m_part_info->part_type == VERSIONING_PARTITION &&
@ -4260,7 +4253,6 @@ int ha_partition::start_stmt(THD *thd, thr_lock_type lock_type)
thd->lex->sql_command != SQLCOM_SELECT && thd->lex->sql_command != SQLCOM_SELECT &&
thd->lex->sql_command != SQLCOM_INSERT_SELECT) thd->lex->sql_command != SQLCOM_INSERT_SELECT)
m_part_info->vers_set_hist_part(thd); m_part_info->vers_set_hist_part(thd);
default:;
} }
DBUG_RETURN(error); DBUG_RETURN(error);
} }

14
sql/lock.cc
View File

@ -140,7 +140,7 @@ lock_tables_check(THD *thd, TABLE **tables, uint count, uint flags)
or hold any type of lock in a session, or hold any type of lock in a session,
since this would be a DOS attack. since this would be a DOS attack.
*/ */
if ((t->reginfo.lock_type >= TL_READ_NO_INSERT) if ((t->reginfo.lock_type >= TL_FIRST_WRITE)
|| (thd->lex->sql_command == SQLCOM_LOCK_TABLES)) || (thd->lex->sql_command == SQLCOM_LOCK_TABLES))
{ {
my_error(ER_CANT_LOCK_LOG_TABLE, MYF(0)); my_error(ER_CANT_LOCK_LOG_TABLE, MYF(0));
@ -148,7 +148,7 @@ lock_tables_check(THD *thd, TABLE **tables, uint count, uint flags)
} }
} }
if (t->reginfo.lock_type >= TL_WRITE_ALLOW_WRITE) if (t->reginfo.lock_type >= TL_FIRST_WRITE)
{ {
if (t->s->table_category == TABLE_CATEGORY_SYSTEM) if (t->s->table_category == TABLE_CATEGORY_SYSTEM)
system_count++; system_count++;
@ -170,7 +170,7 @@ lock_tables_check(THD *thd, TABLE **tables, uint count, uint flags)
DBUG_ASSERT(t->s->tmp_table || DBUG_ASSERT(t->s->tmp_table ||
thd->mdl_context.is_lock_owner(MDL_key::TABLE, thd->mdl_context.is_lock_owner(MDL_key::TABLE,
t->s->db.str, t->s->table_name.str, t->s->db.str, t->s->table_name.str,
t->reginfo.lock_type >= TL_WRITE_ALLOW_WRITE ? t->reginfo.lock_type >= TL_FIRST_WRITE ?
MDL_SHARED_WRITE : MDL_SHARED_READ)); MDL_SHARED_WRITE : MDL_SHARED_READ));
/* /*
@ -179,7 +179,7 @@ lock_tables_check(THD *thd, TABLE **tables, uint count, uint flags)
*/ */
if (!(flags & MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY) && !t->s->tmp_table) if (!(flags & MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY) && !t->s->tmp_table)
{ {
if (t->reginfo.lock_type >= TL_WRITE_ALLOW_WRITE && if (t->reginfo.lock_type >= TL_FIRST_WRITE &&
!ignore_read_only && opt_readonly && !thd->slave_thread) !ignore_read_only && opt_readonly && !thd->slave_thread)
{ {
my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only"); my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
@ -387,7 +387,7 @@ static int lock_external(THD *thd, TABLE **tables, uint count)
lock_type=F_WRLCK; /* Lock exclusive */ lock_type=F_WRLCK; /* Lock exclusive */
if ((*tables)->db_stat & HA_READ_ONLY || if ((*tables)->db_stat & HA_READ_ONLY ||
((*tables)->reginfo.lock_type >= TL_READ && ((*tables)->reginfo.lock_type >= TL_READ &&
(*tables)->reginfo.lock_type <= TL_READ_NO_INSERT)) (*tables)->reginfo.lock_type < TL_FIRST_WRITE))
lock_type=F_RDLCK; lock_type=F_RDLCK;
if (unlikely((error=(*tables)->file->ha_external_lock(thd,lock_type)))) if (unlikely((error=(*tables)->file->ha_external_lock(thd,lock_type))))
@ -481,7 +481,7 @@ int mysql_unlock_read_tables(THD *thd, MYSQL_LOCK *sql_lock)
for (i=found=0 ; i < sql_lock->table_count ; i++) for (i=found=0 ; i < sql_lock->table_count ; i++)
{ {
DBUG_ASSERT(sql_lock->table[i]->lock_position == i); DBUG_ASSERT(sql_lock->table[i]->lock_position == i);
if ((uint) sql_lock->table[i]->reginfo.lock_type > TL_WRITE_ALLOW_WRITE) if ((uint) sql_lock->table[i]->reginfo.lock_type >= TL_FIRST_WRITE)
{ {
swap_variables(TABLE *, *table, sql_lock->table[i]); swap_variables(TABLE *, *table, sql_lock->table[i]);
table++; table++;
@ -501,7 +501,7 @@ int mysql_unlock_read_tables(THD *thd, MYSQL_LOCK *sql_lock)
THR_LOCK_DATA **lock=sql_lock->locks; THR_LOCK_DATA **lock=sql_lock->locks;
for (i=found=0 ; i < sql_lock->lock_count ; i++) for (i=found=0 ; i < sql_lock->lock_count ; i++)
{ {
if (sql_lock->locks[i]->type >= TL_WRITE_ALLOW_WRITE) if (sql_lock->locks[i]->type >= TL_FIRST_WRITE)
{ {
swap_variables(THR_LOCK_DATA *, *lock, sql_lock->locks[i]); swap_variables(THR_LOCK_DATA *, *lock, sql_lock->locks[i]);
lock++; lock++;

2
sql/records.cc
View File

@ -255,7 +255,7 @@ bool init_read_record(READ_RECORD *info,THD *thd, TABLE *table,
thd->variables.read_rnd_buff_size && thd->variables.read_rnd_buff_size &&
!(table->file->ha_table_flags() & HA_FAST_KEY_READ) && !(table->file->ha_table_flags() & HA_FAST_KEY_READ) &&
(table->db_stat & HA_READ_ONLY || (table->db_stat & HA_READ_ONLY ||
table->reginfo.lock_type <= TL_READ_NO_INSERT) && table->reginfo.lock_type < TL_FIRST_WRITE) &&
(ulonglong) table->s->reclength* (table->file->stats.records+ (ulonglong) table->s->reclength* (table->file->stats.records+
table->file->stats.deleted) > table->file->stats.deleted) >
(ulonglong) MIN_FILE_LENGTH_TO_USE_ROW_CACHE && (ulonglong) MIN_FILE_LENGTH_TO_USE_ROW_CACHE &&

2
sql/session_tracker.cc
View File

@ -996,7 +996,7 @@ enum_tx_state Transaction_state_tracker::calc_trx_state(THD *thd,
bool has_trx) bool has_trx)
{ {
enum_tx_state s; enum_tx_state s;
bool read= (l <= TL_READ_NO_INSERT); bool read= (l < TL_FIRST_WRITE);
if (read) if (read)
s= has_trx ? TX_READ_TRX : TX_READ_UNSAFE; s= has_trx ? TX_READ_TRX : TX_READ_UNSAFE;

10
sql/sql_acl.cc
View File

@ -1942,7 +1942,7 @@ class Grant_tables
We can read privilege tables even when !initialized. We can read privilege tables even when !initialized.
This can be acl_load() - server startup or FLUSH PRIVILEGES This can be acl_load() - server startup or FLUSH PRIVILEGES
*/ */
if (lock_type >= TL_WRITE_ALLOW_WRITE && !initialized) if (lock_type >= TL_FIRST_WRITE && !initialized)
{ {
my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--skip-grant-tables"); my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--skip-grant-tables");
DBUG_RETURN(-1); DBUG_RETURN(-1);
@ -1957,7 +1957,7 @@ class Grant_tables
NULL, lock_type); NULL, lock_type);
tl->open_type= OT_BASE_ONLY; tl->open_type= OT_BASE_ONLY;
tl->i_s_requested_object= OPEN_TABLE_ONLY; tl->i_s_requested_object= OPEN_TABLE_ONLY;
tl->updating= lock_type >= TL_WRITE_ALLOW_WRITE; tl->updating= lock_type >= TL_FIRST_WRITE;
if (i >= FIRST_OPTIONAL_TABLE) if (i >= FIRST_OPTIONAL_TABLE)
tl->open_strategy= TABLE_LIST::OPEN_IF_EXISTS; tl->open_strategy= TABLE_LIST::OPEN_IF_EXISTS;
tl->next_global= tl->next_local= first; tl->next_global= tl->next_local= first;
@ -1982,7 +1982,7 @@ class Grant_tables
NULL, lock_type); NULL, lock_type);
tl->open_type= OT_BASE_ONLY; tl->open_type= OT_BASE_ONLY;
tl->i_s_requested_object= OPEN_TABLE_ONLY; tl->i_s_requested_object= OPEN_TABLE_ONLY;
tl->updating= lock_type >= TL_WRITE_ALLOW_WRITE; tl->updating= lock_type >= TL_FIRST_WRITE;
p_user_table= &m_user_table_tabular; p_user_table= &m_user_table_tabular;
counter++; counter++;
res= really_open(thd, tl, &unused); res= really_open(thd, tl, &unused);
@ -2049,7 +2049,7 @@ class Grant_tables
{ {
DBUG_ENTER("Grant_tables::really_open:"); DBUG_ENTER("Grant_tables::really_open:");
#ifdef HAVE_REPLICATION #ifdef HAVE_REPLICATION
if (tables->lock_type >= TL_WRITE_ALLOW_WRITE && if (tables->lock_type >= TL_FIRST_WRITE &&
thd->slave_thread && !thd->spcont) thd->slave_thread && !thd->spcont)
{ {
/* /*
@ -8116,7 +8116,7 @@ bool check_grant(THD *thd, privilege_t want_access, TABLE_LIST *tables,
We want to have either SELECT or INSERT rights to sequences depending We want to have either SELECT or INSERT rights to sequences depending
on how they are accessed on how they are accessed
*/ */
orig_want_access= ((t_ref->lock_type == TL_WRITE_ALLOW_WRITE) ? orig_want_access= ((t_ref->lock_type >= TL_FIRST_WRITE) ?
INSERT_ACL : SELECT_ACL); INSERT_ACL : SELECT_ACL);
} }

2
sql/sql_admin.cc
View File

@ -570,7 +570,7 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
*/ */
table->mdl_request.set_type(lex->sql_command == SQLCOM_REPAIR table->mdl_request.set_type(lex->sql_command == SQLCOM_REPAIR
? MDL_SHARED_NO_READ_WRITE ? MDL_SHARED_NO_READ_WRITE
: lock_type >= TL_WRITE_ALLOW_WRITE : lock_type >= TL_FIRST_WRITE
? MDL_SHARED_WRITE : MDL_SHARED_READ); ? MDL_SHARED_WRITE : MDL_SHARED_READ);
/* open only one table from local list of command */ /* open only one table from local list of command */

18
sql/sql_base.cc
View File

@ -2724,7 +2724,7 @@ bool Locked_tables_list::restore_lock(THD *thd, TABLE_LIST *dst_table_list,
add_back_last_deleted_lock(dst_table_list); add_back_last_deleted_lock(dst_table_list);
table->mdl_ticket->downgrade_lock(table->reginfo.lock_type >= table->mdl_ticket->downgrade_lock(table->reginfo.lock_type >=
TL_WRITE_ALLOW_WRITE ? TL_FIRST_WRITE ?
MDL_SHARED_NO_READ_WRITE : MDL_SHARED_NO_READ_WRITE :
MDL_SHARED_READ); MDL_SHARED_READ);
@ -3518,7 +3518,7 @@ bool extend_table_list(THD *thd, TABLE_LIST *tables,
bool error= false; bool error= false;
LEX *lex= thd->lex; LEX *lex= thd->lex;
bool maybe_need_prelocking= bool maybe_need_prelocking=
(tables->updating && tables->lock_type >= TL_WRITE_ALLOW_WRITE) (tables->updating && tables->lock_type >= TL_FIRST_WRITE)
|| thd->lex->default_used; || thd->lex->default_used;
if (thd->locked_tables_mode <= LTM_LOCK_TABLES && if (thd->locked_tables_mode <= LTM_LOCK_TABLES &&
@ -4709,7 +4709,7 @@ handle_table(THD *thd, Query_tables_list *prelocking_ctx,
DBUG_ENTER("handle_table"); DBUG_ENTER("handle_table");
TABLE *table= table_list->table; TABLE *table= table_list->table;
/* We rely on a caller to check that table is going to be changed. */ /* We rely on a caller to check that table is going to be changed. */
DBUG_ASSERT(table_list->lock_type >= TL_WRITE_ALLOW_WRITE || DBUG_ASSERT(table_list->lock_type >= TL_FIRST_WRITE ||
thd->lex->default_used); thd->lex->default_used);
if (table_list->trg_event_map) if (table_list->trg_event_map)
@ -4891,7 +4891,7 @@ handle_table(THD *thd, Query_tables_list *prelocking_ctx,
tl->open_strategy= TABLE_LIST::OPEN_NORMAL; tl->open_strategy= TABLE_LIST::OPEN_NORMAL;
/* We rely on a caller to check that table is going to be changed. */ /* We rely on a caller to check that table is going to be changed. */
DBUG_ASSERT(table_list->lock_type >= TL_WRITE_ALLOW_WRITE); DBUG_ASSERT(table_list->lock_type >= TL_FIRST_WRITE);
return FALSE; return FALSE;
} }
@ -4998,8 +4998,8 @@ static bool check_lock_and_start_stmt(THD *thd,
else else
lock_type= table_list->lock_type; lock_type= table_list->lock_type;
if ((int) lock_type >= (int) TL_WRITE_ALLOW_WRITE && if ((int) lock_type >= (int) TL_FIRST_WRITE &&
(int) table_list->table->reginfo.lock_type < (int) TL_WRITE_ALLOW_WRITE) (int) table_list->table->reginfo.lock_type < (int) TL_FIRST_WRITE)
{ {
my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),
table_list->table->alias.c_ptr()); table_list->table->alias.c_ptr());
@ -5436,7 +5436,7 @@ static bool fix_all_session_vcol_exprs(THD *thd, TABLE_LIST *tables)
{ {
TABLE *t= table->table; TABLE *t= table->table;
if (!table->placeholder() && t->s->vcols_need_refixing && if (!table->placeholder() && t->s->vcols_need_refixing &&
table->lock_type >= TL_WRITE_ALLOW_WRITE) table->lock_type >= TL_FIRST_WRITE)
{ {
Query_arena *stmt_backup= thd->stmt_arena; Query_arena *stmt_backup= thd->stmt_arena;
if (thd->stmt_arena->is_conventional()) if (thd->stmt_arena->is_conventional())
@ -5594,7 +5594,7 @@ bool lock_tables(THD *thd, TABLE_LIST *tables, uint count, uint flags)
a table that is already used by the calling statement. a table that is already used by the calling statement.
*/ */
if (thd->locked_tables_mode >= LTM_PRELOCKED && if (thd->locked_tables_mode >= LTM_PRELOCKED &&
table->lock_type >= TL_WRITE_ALLOW_WRITE) table->lock_type >= TL_FIRST_WRITE)
{ {
for (TABLE* opentab= thd->open_tables; opentab; opentab= opentab->next) for (TABLE* opentab= thd->open_tables; opentab; opentab= opentab->next)
{ {
@ -9043,7 +9043,7 @@ open_system_tables_for_read(THD *thd, TABLE_LIST *table_list)
if (open_and_lock_tables(thd, table_list, FALSE, if (open_and_lock_tables(thd, table_list, FALSE,
(MYSQL_OPEN_IGNORE_FLUSH | (MYSQL_OPEN_IGNORE_FLUSH |
MYSQL_OPEN_IGNORE_LOGGING_FORMAT | MYSQL_OPEN_IGNORE_LOGGING_FORMAT |
(table_list->lock_type < TL_WRITE_ALLOW_WRITE ? (table_list->lock_type < TL_FIRST_WRITE ?
MYSQL_LOCK_IGNORE_TIMEOUT : 0)))) MYSQL_LOCK_IGNORE_TIMEOUT : 0))))
{ {
lex->restore_backup_query_tables_list(&query_tables_list_backup); lex->restore_backup_query_tables_list(&query_tables_list_backup);

2
sql/sql_cache.cc
View File

@ -2291,7 +2291,7 @@ void Query_cache::invalidate_locked_for_write(THD *thd,
for (; tables_used; tables_used= tables_used->next_local) for (; tables_used; tables_used= tables_used->next_local)
{ {
THD_STAGE_INFO(thd, stage_invalidating_query_cache_entries_table); THD_STAGE_INFO(thd, stage_invalidating_query_cache_entries_table);
if (tables_used->lock_type >= TL_WRITE_ALLOW_WRITE && if (tables_used->lock_type >= TL_FIRST_WRITE &&
tables_used->table) tables_used->table)
{ {
invalidate_table(thd, tables_used->table); invalidate_table(thd, tables_used->table);

10
sql/sql_class.cc
View File

@ -6237,7 +6237,7 @@ int THD::decide_logging_format(TABLE_LIST *tables)
*/ */
lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_TABLE); lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_TABLE);
if (tbl->lock_type >= TL_WRITE_ALLOW_WRITE) if (tbl->lock_type >= TL_FIRST_WRITE)
{ {
non_replicated_tables_count++; non_replicated_tables_count++;
continue; continue;
@ -6250,10 +6250,10 @@ int THD::decide_logging_format(TABLE_LIST *tables)
if (tbl->prelocking_placeholder != TABLE_LIST::PRELOCK_FK) if (tbl->prelocking_placeholder != TABLE_LIST::PRELOCK_FK)
{ {
if (tbl->lock_type <= TL_READ_NO_INSERT) if (tbl->lock_type < TL_FIRST_WRITE)
has_read_tables= true; has_read_tables= true;
else if (table->found_next_number_field && else if (table->found_next_number_field &&
(tbl->lock_type >= TL_WRITE_ALLOW_WRITE)) (tbl->lock_type >= TL_FIRST_WRITE))
{ {
has_auto_increment_write_tables= true; has_auto_increment_write_tables= true;
has_auto_increment_write_tables_not_first= found_first_not_own_table; has_auto_increment_write_tables_not_first= found_first_not_own_table;
@ -6262,7 +6262,7 @@ int THD::decide_logging_format(TABLE_LIST *tables)
} }
} }
if (tbl->lock_type >= TL_WRITE_ALLOW_WRITE) if (tbl->lock_type >= TL_FIRST_WRITE)
{ {
bool trans; bool trans;
if (prev_write_table && prev_write_table->file->ht != if (prev_write_table && prev_write_table->file->ht !=
@ -6532,7 +6532,7 @@ int THD::decide_logging_format(TABLE_LIST *tables)
if (table->placeholder()) if (table->placeholder())
continue; continue;
if (table->table->file->ht->db_type == DB_TYPE_BLACKHOLE_DB && if (table->table->file->ht->db_type == DB_TYPE_BLACKHOLE_DB &&
table->lock_type >= TL_WRITE_ALLOW_WRITE) table->lock_type >= TL_FIRST_WRITE)
{ {
table_names.append(&table->table_name); table_names.append(&table->table_name);
table_names.append(","); table_names.append(",");

2
sql/sql_lex.cc
View File

@ -4369,7 +4369,7 @@ void LEX::set_trg_event_type_for_tables()
parsing. parsing.
*/ */
if (static_cast<int>(tables->lock_type) >= if (static_cast<int>(tables->lock_type) >=
static_cast<int>(TL_WRITE_ALLOW_WRITE)) static_cast<int>(TL_FIRST_WRITE))
tables->trg_event_map= new_trg_event_map; tables->trg_event_map= new_trg_event_map;
tables= tables->next_local; tables= tables->next_local;
} }

8
sql/sql_parse.cc
View File

@ -3648,7 +3648,7 @@ mysql_execute_command(THD *thd)
{ {
for (TABLE_LIST *table= all_tables; table; table= table->next_global) for (TABLE_LIST *table= all_tables; table; table= table->next_global)
{ {
if (table->lock_type >= TL_WRITE_ALLOW_WRITE) if (table->lock_type >= TL_FIRST_WRITE)
{ {
lex->sql_command= SQLCOM_BEGIN; lex->sql_command= SQLCOM_BEGIN;
thd->wsrep_converted_lock_session= true; thd->wsrep_converted_lock_session= true;
@ -7096,7 +7096,7 @@ check_table_access(THD *thd, privilege_t requirements, TABLE_LIST *tables,
/* We want to have either SELECT or INSERT rights to sequences depending /* We want to have either SELECT or INSERT rights to sequences depending
on how they are accessed on how they are accessed
*/ */
want_access= ((table_ref->lock_type == TL_WRITE_ALLOW_WRITE) ? want_access= ((table_ref->lock_type >= TL_FIRST_WRITE) ?
INSERT_ACL : SELECT_ACL); INSERT_ACL : SELECT_ACL);
} }
@ -8894,7 +8894,7 @@ void st_select_lex::set_lock_for_tables(thr_lock_type lock_type, bool for_update
{ {
tables->lock_type= lock_type; tables->lock_type= lock_type;
tables->updating= for_update; tables->updating= for_update;
tables->mdl_request.set_type((lock_type >= TL_WRITE_ALLOW_WRITE) ? tables->mdl_request.set_type((lock_type >= TL_FIRST_WRITE) ?
MDL_SHARED_WRITE : MDL_SHARED_READ); MDL_SHARED_WRITE : MDL_SHARED_READ);
} }
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
@ -9687,7 +9687,7 @@ bool multi_delete_set_locks_and_link_aux_tables(LEX *lex)
walk->updating= target_tbl->updating; walk->updating= target_tbl->updating;
walk->lock_type= target_tbl->lock_type; walk->lock_type= target_tbl->lock_type;
/* We can assume that tables to be deleted from are locked for write. */ /* We can assume that tables to be deleted from are locked for write. */
DBUG_ASSERT(walk->lock_type >= TL_WRITE_ALLOW_WRITE); DBUG_ASSERT(walk->lock_type >= TL_FIRST_WRITE);
walk->mdl_request.set_type(MDL_SHARED_WRITE); walk->mdl_request.set_type(MDL_SHARED_WRITE);
target_tbl->correspondent_table= walk; // Remember corresponding table target_tbl->correspondent_table= walk; // Remember corresponding table
} }

2
sql/sql_select.cc
View File

@ -1049,7 +1049,7 @@ int SELECT_LEX::vers_setup_conds(THD *thd, TABLE_LIST *tables)
if (vers_conditions.is_set()) if (vers_conditions.is_set())
{ {
if (vers_conditions.was_set() && if (vers_conditions.was_set() &&
table->lock_type > TL_READ_NO_INSERT && table->lock_type >= TL_FIRST_WRITE &&
!vers_conditions.delete_history) !vers_conditions.delete_history)
{ {
my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), table->alias.str); my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), table->alias.str);

2
sql/sql_trigger.cc
View File

@ -2270,7 +2270,7 @@ add_tables_and_routines_for_triggers(THD *thd,
TABLE_LIST *table_list) TABLE_LIST *table_list)
{ {
DBUG_ASSERT(static_cast<int>(table_list->lock_type) >= DBUG_ASSERT(static_cast<int>(table_list->lock_type) >=
static_cast<int>(TL_WRITE_ALLOW_WRITE)); static_cast<int>(TL_FIRST_WRITE));
for (int i= 0; i < (int)TRG_EVENT_MAX; i++) for (int i= 0; i < (int)TRG_EVENT_MAX; i++)
{ {

2
sql/sql_yacc.yy
View File

@ -16704,7 +16704,7 @@ table_lock:
table_ident opt_table_alias_clause lock_option table_ident opt_table_alias_clause lock_option
{ {
thr_lock_type lock_type= (thr_lock_type) $3; thr_lock_type lock_type= (thr_lock_type) $3;
bool lock_for_write= (lock_type >= TL_WRITE_ALLOW_WRITE); bool lock_for_write= (lock_type >= TL_FIRST_WRITE);
ulong table_options= lock_for_write ? TL_OPTION_UPDATING : 0; ulong table_options= lock_for_write ? TL_OPTION_UPDATING : 0;
enum_mdl_type mdl_type= !lock_for_write enum_mdl_type mdl_type= !lock_for_write
? MDL_SHARED_READ ? MDL_SHARED_READ

4
sql/table.cc
View File

@ -3616,7 +3616,7 @@ bool fix_session_vcol_expr_for_read(THD *thd, Field *field,
{ {
DBUG_ENTER("fix_session_vcol_expr_for_read"); DBUG_ENTER("fix_session_vcol_expr_for_read");
TABLE_LIST *tl= field->table->pos_in_table_list; TABLE_LIST *tl= field->table->pos_in_table_list;
if (!tl || tl->lock_type >= TL_WRITE_ALLOW_WRITE) if (!tl || tl->lock_type >= TL_FIRST_WRITE)
DBUG_RETURN(0); DBUG_RETURN(0);
Security_context *save_security_ctx= thd->security_ctx; Security_context *save_security_ctx= thd->security_ctx;
if (tl->security_ctx) if (tl->security_ctx)
@ -8494,7 +8494,7 @@ void init_mdl_requests(TABLE_LIST *table_list)
for ( ; table_list ; table_list= table_list->next_global) for ( ; table_list ; table_list= table_list->next_global)
MDL_REQUEST_INIT(&table_list->mdl_request, MDL_key::TABLE, MDL_REQUEST_INIT(&table_list->mdl_request, MDL_key::TABLE,
table_list->db.str, table_list->table_name.str, table_list->db.str, table_list->table_name.str,
table_list->lock_type >= TL_WRITE_ALLOW_WRITE table_list->lock_type >= TL_FIRST_WRITE
? MDL_SHARED_WRITE : MDL_SHARED_READ, MDL_TRANSACTION); ? MDL_SHARED_WRITE : MDL_SHARED_READ, MDL_TRANSACTION);
} }

6
sql/table.h
View File

@ -2135,7 +2135,7 @@ struct TABLE_LIST
enum thr_lock_type lock_type_arg) enum thr_lock_type lock_type_arg)
{ {
enum enum_mdl_type mdl_type; enum enum_mdl_type mdl_type;
if (lock_type_arg >= TL_WRITE_ALLOW_WRITE) if (lock_type_arg >= TL_FIRST_WRITE)
mdl_type= MDL_SHARED_WRITE; mdl_type= MDL_SHARED_WRITE;
else if (lock_type_arg == TL_READ_NO_INSERT) else if (lock_type_arg == TL_READ_NO_INSERT)
mdl_type= MDL_SHARED_NO_WRITE; mdl_type= MDL_SHARED_NO_WRITE;
@ -2150,7 +2150,7 @@ struct TABLE_LIST
table_name= *table_name_arg; table_name= *table_name_arg;
alias= (alias_arg ? *alias_arg : *table_name_arg); alias= (alias_arg ? *alias_arg : *table_name_arg);
lock_type= lock_type_arg; lock_type= lock_type_arg;
updating= lock_type >= TL_WRITE_ALLOW_WRITE; updating= lock_type >= TL_FIRST_WRITE;
MDL_REQUEST_INIT(&mdl_request, MDL_key::TABLE, db.str, table_name.str, MDL_REQUEST_INIT(&mdl_request, MDL_key::TABLE, db.str, table_name.str,
mdl_type, MDL_TRANSACTION); mdl_type, MDL_TRANSACTION);
} }
@ -2184,7 +2184,7 @@ struct TABLE_LIST
belong_to_view= belong_to_view_arg; belong_to_view= belong_to_view_arg;
trg_event_map= trg_event_map_arg; trg_event_map= trg_event_map_arg;
/* MDL is enough for read-only FK checks, we don't need the table */ /* MDL is enough for read-only FK checks, we don't need the table */
if (prelocking_type == PRELOCK_FK && lock_type < TL_WRITE_ALLOW_WRITE) if (prelocking_type == PRELOCK_FK && lock_type < TL_FIRST_WRITE)
open_strategy= OPEN_STUB; open_strategy= OPEN_STUB;
**last_ptr= this; **last_ptr= this;