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

Change THD->transaction to a pointer to enable multiple transactions

Browse Source 
All changes (except one) is of type
thd->transaction.  -> thd->transaction->

thd->transaction points by default to 'thd->default_transaction'
This allows us to 'easily' have multiple active transactions for a
THD object, like when reading data from the mysql.proc table
This commit is contained in:
Monty 2020-05-04 14:20:14 +03:00
parent 7ae812cf2c
commit d1d472646d
32 changed files with 317 additions and 311 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
sql/handler.cc
View File

@ -1244,14 +1244,14 @@ void trans_register_ha(THD *thd, bool all, handlerton *ht_arg, ulonglong trxid)
if (all) if (all)
{ {
trans= &thd->transaction.all; trans= &thd->transaction->all;
thd->server_status|= SERVER_STATUS_IN_TRANS; thd->server_status|= SERVER_STATUS_IN_TRANS;
if (thd->tx_read_only) if (thd->tx_read_only)
thd->server_status|= SERVER_STATUS_IN_TRANS_READONLY; thd->server_status|= SERVER_STATUS_IN_TRANS_READONLY;
DBUG_PRINT("info", ("setting SERVER_STATUS_IN_TRANS")); DBUG_PRINT("info", ("setting SERVER_STATUS_IN_TRANS"));
} }
else else
trans= &thd->transaction.stmt; trans= &thd->transaction->stmt;
ha_info= thd->ha_data[ht_arg->slot].ha_info + (all ? 1 : 0); ha_info= thd->ha_data[ht_arg->slot].ha_info + (all ? 1 : 0);
@ -1263,8 +1263,8 @@ void trans_register_ha(THD *thd, bool all, handlerton *ht_arg, ulonglong trxid)
trans->no_2pc|=(ht_arg->prepare==0); trans->no_2pc|=(ht_arg->prepare==0);
/* Set implicit xid even if there's explicit XA, it will be ignored anyway. */ /* Set implicit xid even if there's explicit XA, it will be ignored anyway. */
if (thd->transaction.implicit_xid.is_null()) if (thd->transaction->implicit_xid.is_null())
thd->transaction.implicit_xid.set(thd->query_id); thd->transaction->implicit_xid.set(thd->query_id);
/* /*
Register transaction start in performance schema if not done already. Register transaction start in performance schema if not done already.
@ -1327,7 +1327,7 @@ static int prepare_or_error(handlerton *ht, THD *thd, bool all)
int ha_prepare(THD *thd) int ha_prepare(THD *thd)
{ {
int error=0, all=1; int error=0, all=1;
THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt; THD_TRANS *trans=all ? &thd->transaction->all : &thd->transaction->stmt;
Ha_trx_info *ha_info= trans->ha_list; Ha_trx_info *ha_info= trans->ha_list;
DBUG_ENTER("ha_prepare"); DBUG_ENTER("ha_prepare");
@ -1377,7 +1377,7 @@ uint ha_count_rw_all(THD *thd, Ha_trx_info **ptr_ha_info)
{ {
unsigned rw_ha_count= 0; unsigned rw_ha_count= 0;
for (auto ha_info= thd->transaction.all.ha_list; ha_info; for (auto ha_info= thd->transaction->all.ha_list; ha_info;
ha_info= ha_info->next()) ha_info= ha_info->next())
{ {
if (ha_info->is_trx_read_write()) if (ha_info->is_trx_read_write())
@ -1472,7 +1472,7 @@ int ha_commit_trans(THD *thd, bool all)
'all' means that this is either an explicit commit issued by 'all' means that this is either an explicit commit issued by
user, or an implicit commit issued by a DDL. user, or an implicit commit issued by a DDL.
*/ */
THD_TRANS *trans= all ? &thd->transaction.all : &thd->transaction.stmt; THD_TRANS *trans= all ? &thd->transaction->all : &thd->transaction->stmt;
/* /*
"real" is a nick name for a transaction for which a commit will "real" is a nick name for a transaction for which a commit will
make persistent changes. E.g. a 'stmt' transaction inside a 'all' make persistent changes. E.g. a 'stmt' transaction inside a 'all'
@ -1480,7 +1480,7 @@ int ha_commit_trans(THD *thd, bool all)
the changes are not durable as they might be rolled back if the the changes are not durable as they might be rolled back if the
enclosing 'all' transaction is rolled back. enclosing 'all' transaction is rolled back.
*/ */
bool is_real_trans= ((all || thd->transaction.all.ha_list == 0) && bool is_real_trans= ((all || thd->transaction->all.ha_list == 0) &&
!(thd->variables.option_bits & OPTION_GTID_BEGIN)); !(thd->variables.option_bits & OPTION_GTID_BEGIN));
Ha_trx_info *ha_info= trans->ha_list; Ha_trx_info *ha_info= trans->ha_list;
bool need_prepare_ordered, need_commit_ordered; bool need_prepare_ordered, need_commit_ordered;
@ -1507,8 +1507,8 @@ int ha_commit_trans(THD *thd, bool all)
flags will not get propagated to its normal transaction's flags will not get propagated to its normal transaction's
counterpart. counterpart.
*/ */
DBUG_ASSERT(thd->transaction.stmt.ha_list == NULL || DBUG_ASSERT(thd->transaction->stmt.ha_list == NULL ||
trans == &thd->transaction.stmt); trans == &thd->transaction->stmt);
if (thd->in_sub_stmt) if (thd->in_sub_stmt)
{ {
@ -1538,7 +1538,7 @@ int ha_commit_trans(THD *thd, bool all)
*/ */
if (is_real_trans) if (is_real_trans)
{ {
thd->transaction.cleanup(); thd->transaction->cleanup();
MYSQL_COMMIT_TRANSACTION(thd->m_transaction_psi); MYSQL_COMMIT_TRANSACTION(thd->m_transaction_psi);
thd->m_transaction_psi= NULL; thd->m_transaction_psi= NULL;
} }
@ -1649,7 +1649,7 @@ int ha_commit_trans(THD *thd, bool all)
// Here, the call will not commit inside InnoDB. It is only working // Here, the call will not commit inside InnoDB. It is only working
// around closing thd->transaction.stmt open by TR_table::open(). // around closing thd->transaction.stmt open by TR_table::open().
if (all) if (all)
commit_one_phase_2(thd, false, &thd->transaction.stmt, false); commit_one_phase_2(thd, false, &thd->transaction->stmt, false);
} }
} }
#endif #endif
@ -1710,11 +1710,11 @@ int ha_commit_trans(THD *thd, bool all)
goto done; goto done;
} }
DBUG_ASSERT(thd->transaction.implicit_xid.get_my_xid() == DBUG_ASSERT(thd->transaction->implicit_xid.get_my_xid() ==
thd->transaction.implicit_xid.quick_get_my_xid()); thd->transaction->implicit_xid.quick_get_my_xid());
DBUG_ASSERT(!thd->transaction.xid_state.is_explicit_XA() || DBUG_ASSERT(!thd->transaction->xid_state.is_explicit_XA() ||
thd->lex->xa_opt == XA_ONE_PHASE); thd->lex->xa_opt == XA_ONE_PHASE);
xid= thd->transaction.implicit_xid.quick_get_my_xid(); xid= thd->transaction->implicit_xid.quick_get_my_xid();
#ifdef WITH_WSREP #ifdef WITH_WSREP
if (run_wsrep_hooks && !error) if (run_wsrep_hooks && !error)
@ -1845,7 +1845,7 @@ end:
int ha_commit_one_phase(THD *thd, bool all) int ha_commit_one_phase(THD *thd, bool all)
{ {
THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt; THD_TRANS *trans=all ? &thd->transaction->all : &thd->transaction->stmt;
/* /*
"real" is a nick name for a transaction for which a commit will "real" is a nick name for a transaction for which a commit will
make persistent changes. E.g. a 'stmt' transaction inside a 'all' make persistent changes. E.g. a 'stmt' transaction inside a 'all'
@ -1859,7 +1859,7 @@ int ha_commit_one_phase(THD *thd, bool all)
ha_commit_one_phase() can be called with an empty ha_commit_one_phase() can be called with an empty
transaction.all.ha_list, see why in trans_register_ha()). transaction.all.ha_list, see why in trans_register_ha()).
*/ */
bool is_real_trans= ((all || thd->transaction.all.ha_list == 0) && bool is_real_trans= ((all || thd->transaction->all.ha_list == 0) &&
!(thd->variables.option_bits & OPTION_GTID_BEGIN)); !(thd->variables.option_bits & OPTION_GTID_BEGIN));
int res; int res;
DBUG_ENTER("ha_commit_one_phase"); DBUG_ENTER("ha_commit_one_phase");
@ -1906,8 +1906,8 @@ commit_one_phase_2(THD *thd, bool all, THD_TRANS *trans, bool is_real_trans)
if (all) if (all)
{ {
#ifdef HAVE_QUERY_CACHE #ifdef HAVE_QUERY_CACHE
if (thd->transaction.changed_tables) if (thd->transaction->changed_tables)
query_cache.invalidate(thd, thd->transaction.changed_tables); query_cache.invalidate(thd, thd->transaction->changed_tables);
#endif #endif
} }
} }
@ -1915,7 +1915,7 @@ commit_one_phase_2(THD *thd, bool all, THD_TRANS *trans, bool is_real_trans)
if (is_real_trans) if (is_real_trans)
{ {
thd->has_waiter= false; thd->has_waiter= false;
thd->transaction.cleanup(); thd->transaction->cleanup();
if (count >= 2) if (count >= 2)
statistic_increment(transactions_multi_engine, LOCK_status); statistic_increment(transactions_multi_engine, LOCK_status);
} }
@ -1927,7 +1927,7 @@ commit_one_phase_2(THD *thd, bool all, THD_TRANS *trans, bool is_real_trans)
int ha_rollback_trans(THD *thd, bool all) int ha_rollback_trans(THD *thd, bool all)
{ {
int error=0; int error=0;
THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt; THD_TRANS *trans=all ? &thd->transaction->all : &thd->transaction->stmt;
Ha_trx_info *ha_info= trans->ha_list, *ha_info_next; Ha_trx_info *ha_info= trans->ha_list, *ha_info_next;
/* /*
"real" is a nick name for a transaction for which a commit will "real" is a nick name for a transaction for which a commit will
@ -1942,15 +1942,15 @@ int ha_rollback_trans(THD *thd, bool all)
ha_commit_one_phase() is called with an empty ha_commit_one_phase() is called with an empty
transaction.all.ha_list, see why in trans_register_ha()). transaction.all.ha_list, see why in trans_register_ha()).
*/ */
bool is_real_trans=all || thd->transaction.all.ha_list == 0; bool is_real_trans=all || thd->transaction->all.ha_list == 0;
DBUG_ENTER("ha_rollback_trans"); DBUG_ENTER("ha_rollback_trans");
/* /*
We must not rollback the normal transaction if a statement We must not rollback the normal transaction if a statement
transaction is pending. transaction is pending.
*/ */
DBUG_ASSERT(thd->transaction.stmt.ha_list == NULL || DBUG_ASSERT(thd->transaction->stmt.ha_list == NULL ||
trans == &thd->transaction.stmt); trans == &thd->transaction->stmt);
#ifdef HAVE_REPLICATION #ifdef HAVE_REPLICATION
if (is_real_trans) if (is_real_trans)
@ -1967,7 +1967,7 @@ int ha_rollback_trans(THD *thd, bool all)
builds, we explicitly do the signalling before rolling back. builds, we explicitly do the signalling before rolling back.
*/ */
DBUG_ASSERT(!(thd->rgi_slave && thd->rgi_slave->did_mark_start_commit) || DBUG_ASSERT(!(thd->rgi_slave && thd->rgi_slave->did_mark_start_commit) ||
thd->transaction.xid_state.is_explicit_XA()); thd->transaction->xid_state.is_explicit_XA());
if (thd->rgi_slave && thd->rgi_slave->did_mark_start_commit) if (thd->rgi_slave && thd->rgi_slave->did_mark_start_commit)
thd->rgi_slave->unmark_start_commit(); thd->rgi_slave->unmark_start_commit();
} }
@ -2042,10 +2042,10 @@ int ha_rollback_trans(THD *thd, bool all)
transaction hasn't been started in any transactional storage engine. transaction hasn't been started in any transactional storage engine.
*/ */
if (thd->transaction_rollback_request) if (thd->transaction_rollback_request)
thd->transaction.xid_state.set_error(thd->get_stmt_da()->sql_errno()); thd->transaction->xid_state.set_error(thd->get_stmt_da()->sql_errno());
thd->has_waiter= false; thd->has_waiter= false;
thd->transaction.cleanup(); thd->transaction->cleanup();
} }
if (all) if (all)
thd->transaction_rollback_request= FALSE; thd->transaction_rollback_request= FALSE;
@ -2063,7 +2063,7 @@ int ha_rollback_trans(THD *thd, bool all)
it doesn't matter if a warning is pushed to a system thread or not: it doesn't matter if a warning is pushed to a system thread or not:
No one will see it... No one will see it...
*/ */
if (is_real_trans && thd->transaction.all.modified_non_trans_table && if (is_real_trans && thd->transaction->all.modified_non_trans_table &&
!thd->slave_thread && thd->killed < KILL_CONNECTION) !thd->slave_thread && thd->killed < KILL_CONNECTION)
push_warning(thd, Sql_condition::WARN_LEVEL_WARN, push_warning(thd, Sql_condition::WARN_LEVEL_WARN,
ER_WARNING_NOT_COMPLETE_ROLLBACK, ER_WARNING_NOT_COMPLETE_ROLLBACK,
@ -2405,8 +2405,8 @@ commit_checkpoint_notify_ha(handlerton *hton, void *cookie)
bool ha_rollback_to_savepoint_can_release_mdl(THD *thd) bool ha_rollback_to_savepoint_can_release_mdl(THD *thd)
{ {
Ha_trx_info *ha_info; Ha_trx_info *ha_info;
THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt : THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction->stmt :
&thd->transaction.all); &thd->transaction->all);
DBUG_ENTER("ha_rollback_to_savepoint_can_release_mdl"); DBUG_ENTER("ha_rollback_to_savepoint_can_release_mdl");
@ -2430,8 +2430,8 @@ bool ha_rollback_to_savepoint_can_release_mdl(THD *thd)
int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv) int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv)
{ {
int error=0; int error=0;
THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt : THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction->stmt :
&thd->transaction.all); &thd->transaction->all);
Ha_trx_info *ha_info, *ha_info_next; Ha_trx_info *ha_info, *ha_info_next;
DBUG_ENTER("ha_rollback_to_savepoint"); DBUG_ENTER("ha_rollback_to_savepoint");
@ -2516,8 +2516,8 @@ int ha_savepoint(THD *thd, SAVEPOINT *sv)
} }
#endif /* WITH_WSREP */ #endif /* WITH_WSREP */
int error=0; int error=0;
THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt : THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction->stmt :
&thd->transaction.all); &thd->transaction->all);
Ha_trx_info *ha_info= trans->ha_list; Ha_trx_info *ha_info= trans->ha_list;
DBUG_ENTER("ha_savepoint"); DBUG_ENTER("ha_savepoint");
@ -5021,7 +5021,7 @@ int ha_enable_transaction(THD *thd, bool on)
DBUG_ENTER("ha_enable_transaction"); DBUG_ENTER("ha_enable_transaction");
DBUG_PRINT("enter", ("on: %d", (int) on)); DBUG_PRINT("enter", ("on: %d", (int) on));
if ((thd->transaction.on= on)) if ((thd->transaction->on= on))
{ {
/* /*
Now all storage engines should have transaction handling enabled. Now all storage engines should have transaction handling enabled.

54
sql/log.cc
View File

@ -1774,7 +1774,7 @@ binlog_flush_cache(THD *thd, binlog_cache_mngr *cache_mngr,
if ((using_stmt && !cache_mngr->stmt_cache.empty()) || if ((using_stmt && !cache_mngr->stmt_cache.empty()) ||
(using_trx && !cache_mngr->trx_cache.empty()) || (using_trx && !cache_mngr->trx_cache.empty()) ||
thd->transaction.xid_state.is_explicit_XA()) thd->transaction->xid_state.is_explicit_XA())
{ {
if (using_stmt && thd->binlog_flush_pending_rows_event(TRUE, FALSE)) if (using_stmt && thd->binlog_flush_pending_rows_event(TRUE, FALSE))
DBUG_RETURN(1); DBUG_RETURN(1);
@ -1879,11 +1879,11 @@ binlog_commit_flush_trx_cache(THD *thd, bool all, binlog_cache_mngr *cache_mngr)
if (thd->lex->sql_command == SQLCOM_XA_COMMIT && if (thd->lex->sql_command == SQLCOM_XA_COMMIT &&
thd->lex->xa_opt != XA_ONE_PHASE) thd->lex->xa_opt != XA_ONE_PHASE)
{ {
DBUG_ASSERT(thd->transaction.xid_state.is_explicit_XA()); DBUG_ASSERT(thd->transaction->xid_state.is_explicit_XA());
DBUG_ASSERT(thd->transaction.xid_state.get_state_code() == DBUG_ASSERT(thd->transaction->xid_state.get_state_code() ==
XA_PREPARED); XA_PREPARED);
buflen= serialize_with_xid(thd->transaction.xid_state.get_xid(), buflen= serialize_with_xid(thd->transaction->xid_state.get_xid(),
buf, query, q_len); buf, query, q_len);
} }
Query_log_event end_evt(thd, buf, buflen, TRUE, TRUE, TRUE, 0); Query_log_event end_evt(thd, buf, buflen, TRUE, TRUE, TRUE, 0);
@ -1910,11 +1910,11 @@ binlog_rollback_flush_trx_cache(THD *thd, bool all,
char buf[q_len + ser_buf_size]= "ROLLBACK"; char buf[q_len + ser_buf_size]= "ROLLBACK";
size_t buflen= sizeof("ROLLBACK") - 1; size_t buflen= sizeof("ROLLBACK") - 1;
if (thd->transaction.xid_state.is_explicit_XA()) if (thd->transaction->xid_state.is_explicit_XA())
{ {
/* for not prepared use plain ROLLBACK */ /* for not prepared use plain ROLLBACK */
if (thd->transaction.xid_state.get_state_code() == XA_PREPARED) if (thd->transaction->xid_state.get_state_code() == XA_PREPARED)
buflen= serialize_with_xid(thd->transaction.xid_state.get_xid(), buflen= serialize_with_xid(thd->transaction->xid_state.get_xid(),
buf, query, q_len); buf, query, q_len);
} }
Query_log_event end_evt(thd, buf, buflen, TRUE, TRUE, TRUE, 0); Query_log_event end_evt(thd, buf, buflen, TRUE, TRUE, TRUE, 0);
@ -1999,7 +1999,7 @@ binlog_truncate_trx_cache(THD *thd, binlog_cache_mngr *cache_mngr, bool all)
inline bool is_preparing_xa(THD *thd) inline bool is_preparing_xa(THD *thd)
{ {
return return
thd->transaction.xid_state.is_explicit_XA() && thd->transaction->xid_state.is_explicit_XA() &&
thd->lex->sql_command == SQLCOM_XA_PREPARE; thd->lex->sql_command == SQLCOM_XA_PREPARE;
} }
@ -2039,15 +2039,15 @@ static int binlog_rollback_by_xid(handlerton *hton, XID *xid)
(void) thd->binlog_setup_trx_data(); (void) thd->binlog_setup_trx_data();
DBUG_ASSERT(thd->lex->sql_command == SQLCOM_XA_ROLLBACK || DBUG_ASSERT(thd->lex->sql_command == SQLCOM_XA_ROLLBACK ||
(thd->transaction.xid_state.get_state_code() == XA_ROLLBACK_ONLY)); (thd->transaction->xid_state.get_state_code() == XA_ROLLBACK_ONLY));
return binlog_rollback(hton, thd, TRUE); return binlog_rollback(hton, thd, TRUE);
} }
inline bool is_prepared_xa(THD *thd) inline bool is_prepared_xa(THD *thd)
{ {
return thd->transaction.xid_state.is_explicit_XA() && return thd->transaction->xid_state.is_explicit_XA() &&
thd->transaction.xid_state.get_state_code() == XA_PREPARED; thd->transaction->xid_state.get_state_code() == XA_PREPARED;
} }
@ -2084,7 +2084,7 @@ static bool trans_cannot_safely_rollback(THD *thd, bool all)
static int binlog_commit_flush_xa_prepare(THD *thd, bool all, static int binlog_commit_flush_xa_prepare(THD *thd, bool all,
binlog_cache_mngr *cache_mngr) binlog_cache_mngr *cache_mngr)
{ {
XID *xid= thd->transaction.xid_state.get_xid(); XID *xid= thd->transaction->xid_state.get_xid();
{ {
// todo assert wsrep_simulate || is_open() // todo assert wsrep_simulate || is_open()
@ -2155,8 +2155,8 @@ static int binlog_commit(handlerton *hton, THD *thd, bool all)
("all: %d, in_transaction: %s, all.modified_non_trans_table: %s, stmt.modified_non_trans_table: %s", ("all: %d, in_transaction: %s, all.modified_non_trans_table: %s, stmt.modified_non_trans_table: %s",
all, all,
YESNO(thd->in_multi_stmt_transaction_mode()), YESNO(thd->in_multi_stmt_transaction_mode()),
YESNO(thd->transaction.all.modified_non_trans_table), YESNO(thd->transaction->all.modified_non_trans_table),
YESNO(thd->transaction.stmt.modified_non_trans_table))); YESNO(thd->transaction->stmt.modified_non_trans_table)));
thd->backup_stage(&org_stage); thd->backup_stage(&org_stage);
@ -2167,7 +2167,7 @@ static int binlog_commit(handlerton *hton, THD *thd, bool all)
} }
if (cache_mngr->trx_cache.empty() && if (cache_mngr->trx_cache.empty() &&
thd->transaction.xid_state.get_state_code() != XA_PREPARED) thd->transaction->xid_state.get_state_code() != XA_PREPARED)
{ {
/* /*
we're here because cache_log was flushed in MYSQL_BIN_LOG::log_xid() we're here because cache_log was flushed in MYSQL_BIN_LOG::log_xid()
@ -2227,8 +2227,8 @@ static int binlog_rollback(handlerton *hton, THD *thd, bool all)
DBUG_PRINT("debug", ("all: %s, all.modified_non_trans_table: %s, stmt.modified_non_trans_table: %s", DBUG_PRINT("debug", ("all: %s, all.modified_non_trans_table: %s, stmt.modified_non_trans_table: %s",
YESNO(all), YESNO(all),
YESNO(thd->transaction.all.modified_non_trans_table), YESNO(thd->transaction->all.modified_non_trans_table),
YESNO(thd->transaction.stmt.modified_non_trans_table))); YESNO(thd->transaction->stmt.modified_non_trans_table)));
/* /*
If an incident event is set we do not flush the content of the statement If an incident event is set we do not flush the content of the statement
@ -2245,7 +2245,7 @@ static int binlog_rollback(handlerton *hton, THD *thd, bool all)
} }
if (cache_mngr->trx_cache.empty() && if (cache_mngr->trx_cache.empty() &&
thd->transaction.xid_state.get_state_code() != XA_PREPARED) thd->transaction->xid_state.get_state_code() != XA_PREPARED)
{ {
/* /*
we're here because cache_log was flushed in MYSQL_BIN_LOG::log_xid() we're here because cache_log was flushed in MYSQL_BIN_LOG::log_xid()
@ -5618,7 +5618,7 @@ stmt_has_updated_trans_table(const THD *thd)
{ {
Ha_trx_info *ha_info; Ha_trx_info *ha_info;
for (ha_info= thd->transaction.stmt.ha_list; ha_info; for (ha_info= thd->transaction->stmt.ha_list; ha_info;
ha_info= ha_info->next()) ha_info= ha_info->next())
{ {
if (ha_info->is_trx_read_write() && ha_info->ht() != binlog_hton) if (ha_info->is_trx_read_write() && ha_info->ht() != binlog_hton)
@ -5697,8 +5697,8 @@ bool ending_single_stmt_trans(THD* thd, const bool all)
*/ */
bool trans_has_updated_non_trans_table(const THD* thd) bool trans_has_updated_non_trans_table(const THD* thd)
{ {
return (thd->transaction.all.modified_non_trans_table || return (thd->transaction->all.modified_non_trans_table ||
thd->transaction.stmt.modified_non_trans_table); thd->transaction->stmt.modified_non_trans_table);
} }
/** /**
@ -5711,7 +5711,7 @@ bool trans_has_updated_non_trans_table(const THD* thd)
*/ */
bool stmt_has_updated_non_trans_table(const THD* thd) bool stmt_has_updated_non_trans_table(const THD* thd)
{ {
return (thd->transaction.stmt.modified_non_trans_table); return (thd->transaction->stmt.modified_non_trans_table);
} }
/* /*
@ -7581,7 +7581,7 @@ MYSQL_BIN_LOG::write_transaction_to_binlog(THD *thd,
entry.using_stmt_cache= using_stmt_cache; entry.using_stmt_cache= using_stmt_cache;
entry.using_trx_cache= using_trx_cache; entry.using_trx_cache= using_trx_cache;
entry.need_unlog= is_preparing_xa(thd); entry.need_unlog= is_preparing_xa(thd);
ha_info= all ? thd->transaction.all.ha_list : thd->transaction.stmt.ha_list; ha_info= all ? thd->transaction->all.ha_list : thd->transaction->stmt.ha_list;
for (; !entry.need_unlog && ha_info; ha_info= ha_info->next()) for (; !entry.need_unlog && ha_info; ha_info= ha_info->next())
{ {
@ -8158,7 +8158,7 @@ MYSQL_BIN_LOG::trx_group_commit_leader(group_commit_entry *leader)
*/ */
DBUG_ASSERT(!cache_mngr->stmt_cache.empty() || DBUG_ASSERT(!cache_mngr->stmt_cache.empty() ||
!cache_mngr->trx_cache.empty() || !cache_mngr->trx_cache.empty() ||
current->thd->transaction.xid_state.is_explicit_XA()); current->thd->transaction->xid_state.is_explicit_XA());
if (unlikely((current->error= write_transaction_or_stmt(current, if (unlikely((current->error= write_transaction_or_stmt(current,
commit_id)))) commit_id))))
@ -9108,7 +9108,7 @@ void
TC_LOG::run_prepare_ordered(THD *thd, bool all) TC_LOG::run_prepare_ordered(THD *thd, bool all)
{ {
Ha_trx_info *ha_info= Ha_trx_info *ha_info=
all ? thd->transaction.all.ha_list : thd->transaction.stmt.ha_list; all ? thd->transaction->all.ha_list : thd->transaction->stmt.ha_list;
mysql_mutex_assert_owner(&LOCK_prepare_ordered); mysql_mutex_assert_owner(&LOCK_prepare_ordered);
for (; ha_info; ha_info= ha_info->next()) for (; ha_info; ha_info= ha_info->next())
@ -9125,7 +9125,7 @@ void
TC_LOG::run_commit_ordered(THD *thd, bool all) TC_LOG::run_commit_ordered(THD *thd, bool all)
{ {
Ha_trx_info *ha_info= Ha_trx_info *ha_info=
all ? thd->transaction.all.ha_list : thd->transaction.stmt.ha_list; all ? thd->transaction->all.ha_list : thd->transaction->stmt.ha_list;
mysql_mutex_assert_owner(&LOCK_commit_ordered); mysql_mutex_assert_owner(&LOCK_commit_ordered);
for (; ha_info; ha_info= ha_info->next()) for (; ha_info; ha_info= ha_info->next())
@ -10129,7 +10129,7 @@ int TC_LOG_BINLOG::unlog_xa_prepare(THD *thd, bool all)
{ {
/* an empty XA-prepare event group is logged */ /* an empty XA-prepare event group is logged */
#ifndef DBUG_OFF #ifndef DBUG_OFF
for (ha_info= thd->transaction.all.ha_list; rw_count > 1 && ha_info; for (ha_info= thd->transaction->all.ha_list; rw_count > 1 && ha_info;
ha_info= ha_info->next()) ha_info= ha_info->next())
DBUG_ASSERT(ha_info->ht() != binlog_hton); DBUG_ASSERT(ha_info->ht() != binlog_hton);
#endif #endif

38
sql/log_event_server.cc
View File

@ -2045,7 +2045,7 @@ compare_errors:
DBUG_EXECUTE_IF("stop_slave_middle_group", DBUG_EXECUTE_IF("stop_slave_middle_group",
if (!current_stmt_is_commit && is_begin() == 0) if (!current_stmt_is_commit && is_begin() == 0)
{ {
if (thd->transaction.all.modified_non_trans_table) if (thd->transaction->all.modified_non_trans_table)
const_cast<Relay_log_info*>(rli)->abort_slave= 1; const_cast<Relay_log_info*>(rli)->abort_slave= 1;
};); };);
} }
@ -2366,7 +2366,7 @@ int Format_description_log_event::do_apply_event(rpl_group_info *rgi)
original place when it comes to us; we'll know this by checking original place when it comes to us; we'll know this by checking
log_pos ("artificial" events have log_pos == 0). log_pos ("artificial" events have log_pos == 0).
*/ */
if (!is_artificial_event() && created && thd->transaction.all.ha_list) if (!is_artificial_event() && created && thd->transaction->all.ha_list)
{ {
/* This is not an error (XA is safe), just an information */ /* This is not an error (XA is safe), just an information */
rli->report(INFORMATION_LEVEL, 0, NULL, rli->report(INFORMATION_LEVEL, 0, NULL,
@ -3238,13 +3238,13 @@ Gtid_log_event::Gtid_log_event(THD *thd_arg, uint64 seq_no_arg,
{ {
cache_type= Log_event::EVENT_NO_CACHE; cache_type= Log_event::EVENT_NO_CACHE;
bool is_tmp_table= thd_arg->lex->stmt_accessed_temp_table(); bool is_tmp_table= thd_arg->lex->stmt_accessed_temp_table();
if (thd_arg->transaction.stmt.trans_did_wait() || if (thd_arg->transaction->stmt.trans_did_wait() ||
thd_arg->transaction.all.trans_did_wait()) thd_arg->transaction->all.trans_did_wait())
flags2|= FL_WAITED; flags2|= FL_WAITED;
if (thd_arg->transaction.stmt.trans_did_ddl() || if (thd_arg->transaction->stmt.trans_did_ddl() ||
thd_arg->transaction.stmt.has_created_dropped_temp_table() || thd_arg->transaction->stmt.has_created_dropped_temp_table() ||
thd_arg->transaction.all.trans_did_ddl() || thd_arg->transaction->all.trans_did_ddl() ||
thd_arg->transaction.all.has_created_dropped_temp_table()) thd_arg->transaction->all.has_created_dropped_temp_table())
flags2|= FL_DDL; flags2|= FL_DDL;
else if (is_transactional && !is_tmp_table) else if (is_transactional && !is_tmp_table)
flags2|= FL_TRANSACTIONAL; flags2|= FL_TRANSACTIONAL;
@ -3254,7 +3254,7 @@ Gtid_log_event::Gtid_log_event(THD *thd_arg, uint64 seq_no_arg,
if (thd_arg->rgi_slave) if (thd_arg->rgi_slave)
flags2|= (thd_arg->rgi_slave->gtid_ev_flags2 & (FL_DDL|FL_WAITED)); flags2|= (thd_arg->rgi_slave->gtid_ev_flags2 & (FL_DDL|FL_WAITED));
XID_STATE &xid_state= thd->transaction.xid_state; XID_STATE &xid_state= thd->transaction->xid_state;
if (is_transactional && xid_state.is_explicit_XA() && if (is_transactional && xid_state.is_explicit_XA() &&
(thd->lex->sql_command == SQLCOM_XA_PREPARE || (thd->lex->sql_command == SQLCOM_XA_PREPARE ||
xid_state.get_state_code() == XA_PREPARED)) xid_state.get_state_code() == XA_PREPARED))
@ -3925,7 +3925,7 @@ int Xid_apply_log_event::do_apply_event(rpl_group_info *rgi)
sub_id= rgi->gtid_sub_id; sub_id= rgi->gtid_sub_id;
gtid= rgi->current_gtid; gtid= rgi->current_gtid;
if (!thd->transaction.xid_state.is_explicit_XA()) if (!thd->transaction->xid_state.is_explicit_XA())
{ {
if ((err= do_record_gtid(thd, rgi, true /* in_trans */, &hton))) if ((err= do_record_gtid(thd, rgi, true /* in_trans */, &hton)))
return err; return err;
@ -3945,7 +3945,7 @@ int Xid_apply_log_event::do_apply_event(rpl_group_info *rgi)
res= do_commit(); res= do_commit();
if (!res && rgi->gtid_pending) if (!res && rgi->gtid_pending)
{ {
DBUG_ASSERT(!thd->transaction.xid_state.is_explicit_XA()); DBUG_ASSERT(!thd->transaction->xid_state.is_explicit_XA());
if ((err= do_record_gtid(thd, rgi, false, &hton))) if ((err= do_record_gtid(thd, rgi, false, &hton)))
return err; return err;
@ -3964,7 +3964,7 @@ int Xid_apply_log_event::do_apply_event(rpl_group_info *rgi)
/* /*
Increment the global status commit count variable Increment the global status commit count variable
*/ */
enum enum_sql_command cmd= !thd->transaction.xid_state.is_explicit_XA() ? enum enum_sql_command cmd= !thd->transaction->xid_state.is_explicit_XA() ?
SQLCOM_COMMIT : SQLCOM_XA_PREPARE; SQLCOM_COMMIT : SQLCOM_XA_PREPARE;
status_var_increment(thd->status_var.com_stat[cmd]); status_var_increment(thd->status_var.com_stat[cmd]);
@ -5337,8 +5337,8 @@ int Rows_log_event::do_apply_event(rpl_group_info *rgi)
has not yet modified anything. Note, all.modified is reset has not yet modified anything. Note, all.modified is reset
by THD::reset_for_next_command(). by THD::reset_for_next_command().
*/ */
thd->transaction.stmt.modified_non_trans_table= FALSE; thd->transaction->stmt.modified_non_trans_table= FALSE;
thd->transaction.stmt.m_unsafe_rollback_flags&= ~THD_TRANS::DID_WAIT; thd->transaction->stmt.m_unsafe_rollback_flags&= ~THD_TRANS::DID_WAIT;
/* /*
This is a row injection, so we flag the "statement" as This is a row injection, so we flag the "statement" as
such. Note that this code is called both when the slave does row such. Note that this code is called both when the slave does row
@ -5699,8 +5699,8 @@ int Rows_log_event::do_apply_event(rpl_group_info *rgi)
m_curr_row= m_curr_row_end; m_curr_row= m_curr_row_end;
if (likely(error == 0) && !transactional_table) if (likely(error == 0) && !transactional_table)
thd->transaction.all.modified_non_trans_table= thd->transaction->all.modified_non_trans_table=
thd->transaction.stmt.modified_non_trans_table= TRUE; thd->transaction->stmt.modified_non_trans_table= TRUE;
} // row processing loop } // row processing loop
while (error == 0 && (m_curr_row != m_rows_end)); while (error == 0 && (m_curr_row != m_rows_end));
@ -5716,7 +5716,7 @@ int Rows_log_event::do_apply_event(rpl_group_info *rgi)
to shutdown trying to finish incomplete events group. to shutdown trying to finish incomplete events group.
*/ */
DBUG_EXECUTE_IF("stop_slave_middle_group", DBUG_EXECUTE_IF("stop_slave_middle_group",
if (thd->transaction.all.modified_non_trans_table) if (thd->transaction->all.modified_non_trans_table)
const_cast<Relay_log_info*>(rli)->abort_slave= 1;); const_cast<Relay_log_info*>(rli)->abort_slave= 1;);
} }
@ -5869,8 +5869,8 @@ static int rows_event_stmt_cleanup(rpl_group_info *rgi, THD * thd)
*/ */
if (!thd->in_multi_stmt_transaction_mode()) if (!thd->in_multi_stmt_transaction_mode())
{ {
thd->transaction.all.modified_non_trans_table= 0; thd->transaction->all.modified_non_trans_table= 0;
thd->transaction.all.m_unsafe_rollback_flags&= ~THD_TRANS::DID_WAIT; thd->transaction->all.m_unsafe_rollback_flags&= ~THD_TRANS::DID_WAIT;
} }
rgi->cleanup_context(thd, 0); rgi->cleanup_context(thd, 0);

2
sql/rpl_gtid.cc
View File

@ -507,7 +507,7 @@ rpl_slave_state::select_gtid_pos_table(THD *thd, LEX_CSTRING *out_tablename)
Ha_trx_info *ha_info; Ha_trx_info *ha_info;
uint count = 0; uint count = 0;
for (ha_info= thd->transaction.all.ha_list; ha_info; ha_info= ha_info->next()) for (ha_info= thd->transaction->all.ha_list; ha_info; ha_info= ha_info->next())
{ {
void *trx_hton= ha_info->ht(); void *trx_hton= ha_info->ht();
auto table_entry= list; auto table_entry= list;

2
sql/rpl_rli.cc
View File

@ -2232,7 +2232,7 @@ void rpl_group_info::cleanup_context(THD *thd, bool error)
trans_rollback above does not rollback XA transactions trans_rollback above does not rollback XA transactions
(todo/fixme consider to do so. (todo/fixme consider to do so.
*/ */
if (thd->transaction.xid_state.is_explicit_XA()) if (thd->transaction->xid_state.is_explicit_XA())
xa_trans_force_rollback(thd); xa_trans_force_rollback(thd);
thd->mdl_context.release_transactional_locks(); thd->mdl_context.release_transactional_locks();

2
sql/semisync_master.cc
View File

@ -682,7 +682,7 @@ int Repl_semi_sync_master::wait_after_commit(THD* thd, bool all)
my_off_t log_pos; my_off_t log_pos;
bool is_real_trans= bool is_real_trans=
(all || thd->transaction.all.ha_list == 0); (all || thd->transaction->all.ha_list == 0);
/* /*
The coordinates are propagated to this point having been computed The coordinates are propagated to this point having been computed
in report_binlog_update in report_binlog_update

4
sql/session_tracker.cc
View File

@ -741,7 +741,7 @@ bool Transaction_state_tracker::store(THD *thd, String *buf)
if ((thd->variables.session_track_transaction_info == TX_TRACK_CHISTICS) && if ((thd->variables.session_track_transaction_info == TX_TRACK_CHISTICS) &&
(tx_changed & TX_CHG_CHISTICS)) (tx_changed & TX_CHG_CHISTICS))
{ {
bool is_xa= thd->transaction.xid_state.is_explicit_XA(); bool is_xa= thd->transaction->xid_state.is_explicit_XA();
size_t start; size_t start;
/* 2 length by 1 byte and code */ /* 2 length by 1 byte and code */
@ -918,7 +918,7 @@ bool Transaction_state_tracker::store(THD *thd, String *buf)
if ((tx_curr_state & TX_EXPLICIT) && is_xa) if ((tx_curr_state & TX_EXPLICIT) && is_xa)
{ {
XID *xid= thd->transaction.xid_state.get_xid(); XID *xid= thd->transaction->xid_state.get_xid();
long glen, blen; long glen, blen;
buf->append(STRING_WITH_LEN("XA START")); buf->append(STRING_WITH_LEN("XA START"));

6
sql/slave.cc
View File

@ -1535,7 +1535,7 @@ static bool sql_slave_killed(rpl_group_info *rgi)
rli->is_in_group(). rli->is_in_group().
*/ */
if ((thd->transaction.all.modified_non_trans_table || if ((thd->transaction->all.modified_non_trans_table ||
(thd->variables.option_bits & OPTION_KEEP_LOG)) && (thd->variables.option_bits & OPTION_KEEP_LOG)) &&
rli->is_in_group()) rli->is_in_group())
{ {
@ -1549,7 +1549,7 @@ static bool sql_slave_killed(rpl_group_info *rgi)
DBUG_PRINT("info", ("modified_non_trans_table: %d OPTION_BEGIN: %d " DBUG_PRINT("info", ("modified_non_trans_table: %d OPTION_BEGIN: %d "
"OPTION_KEEP_LOG: %d is_in_group: %d", "OPTION_KEEP_LOG: %d is_in_group: %d",
thd->transaction.all.modified_non_trans_table, thd->transaction->all.modified_non_trans_table,
MY_TEST(thd->variables.option_bits & OPTION_BEGIN), MY_TEST(thd->variables.option_bits & OPTION_BEGIN),
MY_TEST(thd->variables.option_bits & OPTION_KEEP_LOG), MY_TEST(thd->variables.option_bits & OPTION_KEEP_LOG),
rli->is_in_group())); rli->is_in_group()));
@ -4386,7 +4386,7 @@ static int exec_relay_log_event(THD* thd, Relay_log_info* rli,
(LOG_EVENT_IS_QUERY(typ) && (LOG_EVENT_IS_QUERY(typ) &&
strcmp("COMMIT", ((Query_log_event *) ev)->query) == 0)) strcmp("COMMIT", ((Query_log_event *) ev)->query) == 0))
{ {
DBUG_ASSERT(thd->transaction.all.modified_non_trans_table); DBUG_ASSERT(thd->transaction->all.modified_non_trans_table);
rli->abort_slave= 1; rli->abort_slave= 1;
mysql_mutex_unlock(&rli->data_lock); mysql_mutex_unlock(&rli->data_lock);
delete ev; delete ev;

6
sql/sp_head.cc
View File

@ -3426,8 +3426,8 @@ sp_lex_keeper::reset_lex_and_exec_core(THD *thd, uint *nextp,
It's reset further in the common code part. It's reset further in the common code part.
It's merged with the saved parent's value at the exit of this func. It's merged with the saved parent's value at the exit of this func.
*/ */
bool parent_modified_non_trans_table= thd->transaction.stmt.modified_non_trans_table; bool parent_modified_non_trans_table= thd->transaction->stmt.modified_non_trans_table;
thd->transaction.stmt.modified_non_trans_table= FALSE; thd->transaction->stmt.modified_non_trans_table= FALSE;
DBUG_ASSERT(!thd->derived_tables); DBUG_ASSERT(!thd->derived_tables);
DBUG_ASSERT(thd->Item_change_list::is_empty()); DBUG_ASSERT(thd->Item_change_list::is_empty());
/* /*
@ -3550,7 +3550,7 @@ sp_lex_keeper::reset_lex_and_exec_core(THD *thd, uint *nextp,
Merge here with the saved parent's values Merge here with the saved parent's values
what is needed from the substatement gained what is needed from the substatement gained
*/ */
thd->transaction.stmt.modified_non_trans_table |= parent_modified_non_trans_table; thd->transaction->stmt.modified_non_trans_table |= parent_modified_non_trans_table;
TRANSACT_TRACKER(add_trx_state_from_thd(thd)); TRANSACT_TRACKER(add_trx_state_from_thd(thd));

10
sql/sql_base.cc
View File

@ -793,7 +793,7 @@ int close_thread_tables(THD *thd)
DEBUG_SYNC(thd, "before_close_thread_tables"); DEBUG_SYNC(thd, "before_close_thread_tables");
#endif #endif
DBUG_ASSERT(thd->transaction.stmt.is_empty() || thd->in_sub_stmt || DBUG_ASSERT(thd->transaction->stmt.is_empty() || thd->in_sub_stmt ||
(thd->state_flags & Open_tables_state::BACKUPS_AVAIL)); (thd->state_flags & Open_tables_state::BACKUPS_AVAIL));
for (table= thd->open_tables; table; table= table->next) for (table= thd->open_tables; table; table= table->next)
@ -2351,7 +2351,7 @@ Locked_tables_list::unlock_locked_tables(THD *thd)
TRANSACT_TRACKER(clear_trx_state(thd, TX_LOCKED_TABLES)); TRANSACT_TRACKER(clear_trx_state(thd, TX_LOCKED_TABLES));
DBUG_ASSERT(thd->transaction.stmt.is_empty()); DBUG_ASSERT(thd->transaction->stmt.is_empty());
error= close_thread_tables(thd); error= close_thread_tables(thd);
/* /*
@ -4117,7 +4117,7 @@ bool open_tables(THD *thd, const DDL_options_st &options,
DBUG_ENTER("open_tables"); DBUG_ENTER("open_tables");
/* Data access in XA transaction is only allowed when it is active. */ /* Data access in XA transaction is only allowed when it is active. */
if (*start && thd->transaction.xid_state.check_has_uncommitted_xa()) if (*start && thd->transaction->xid_state.check_has_uncommitted_xa())
DBUG_RETURN(true); DBUG_RETURN(true);
thd->current_tablenr= 0; thd->current_tablenr= 0;
@ -5186,7 +5186,7 @@ end:
table on the fly, and thus mustn't manipulate with the table on the fly, and thus mustn't manipulate with the
transaction of the enclosing statement. transaction of the enclosing statement.
*/ */
DBUG_ASSERT(thd->transaction.stmt.is_empty() || DBUG_ASSERT(thd->transaction->stmt.is_empty() ||
(thd->state_flags & Open_tables_state::BACKUPS_AVAIL)); (thd->state_flags & Open_tables_state::BACKUPS_AVAIL));
close_thread_tables(thd); close_thread_tables(thd);
/* Don't keep locks for a failed statement. */ /* Don't keep locks for a failed statement. */
@ -5583,7 +5583,7 @@ void close_tables_for_reopen(THD *thd, TABLE_LIST **tables,
table on the fly, and thus mustn't manipulate with the table on the fly, and thus mustn't manipulate with the
transaction of the enclosing statement. transaction of the enclosing statement.
*/ */
DBUG_ASSERT(thd->transaction.stmt.is_empty() || DBUG_ASSERT(thd->transaction->stmt.is_empty() ||
(thd->state_flags & Open_tables_state::BACKUPS_AVAIL)); (thd->state_flags & Open_tables_state::BACKUPS_AVAIL));
close_thread_tables(thd); close_thread_tables(thd);
thd->mdl_context.rollback_to_savepoint(start_of_statement_svp); thd->mdl_context.rollback_to_savepoint(start_of_statement_svp);

52
sql/sql_class.cc
View File

@ -813,12 +813,14 @@ THD::THD(my_thread_id id, bool is_wsrep_applier)
system_thread= NON_SYSTEM_THREAD; system_thread= NON_SYSTEM_THREAD;
cleanup_done= free_connection_done= abort_on_warning= 0; cleanup_done= free_connection_done= abort_on_warning= 0;
peer_port= 0; // For SHOW PROCESSLIST peer_port= 0; // For SHOW PROCESSLIST
transaction.m_pending_rows_event= 0; transaction= &default_transaction;
transaction.on= 1; transaction->m_pending_rows_event= 0;
wt_thd_lazy_init(&transaction.wt, &variables.wt_deadlock_search_depth_short, transaction->on= 1;
&variables.wt_timeout_short, wt_thd_lazy_init(&transaction->wt,
&variables.wt_deadlock_search_depth_long, &variables.wt_deadlock_search_depth_short,
&variables.wt_timeout_long); &variables.wt_timeout_short,
&variables.wt_deadlock_search_depth_long,
&variables.wt_timeout_long);
#ifdef SIGNAL_WITH_VIO_CLOSE #ifdef SIGNAL_WITH_VIO_CLOSE
active_vio = 0; active_vio = 0;
#endif #endif
@ -1262,10 +1264,10 @@ void THD::init()
if (variables.sql_mode & MODE_ANSI_QUOTES) if (variables.sql_mode & MODE_ANSI_QUOTES)
server_status|= SERVER_STATUS_ANSI_QUOTES; server_status|= SERVER_STATUS_ANSI_QUOTES;
transaction.all.modified_non_trans_table= transaction->all.modified_non_trans_table=
transaction.stmt.modified_non_trans_table= FALSE; transaction->stmt.modified_non_trans_table= FALSE;
transaction.all.m_unsafe_rollback_flags= transaction->all.m_unsafe_rollback_flags=
transaction.stmt.m_unsafe_rollback_flags= 0; transaction->stmt.m_unsafe_rollback_flags= 0;
open_options=ha_open_options; open_options=ha_open_options;
update_lock_default= (variables.low_priority_updates ? update_lock_default= (variables.low_priority_updates ?
@ -1396,11 +1398,11 @@ void THD::init_for_queries()
reset_root_defaults(mem_root, variables.query_alloc_block_size, reset_root_defaults(mem_root, variables.query_alloc_block_size,
variables.query_prealloc_size); variables.query_prealloc_size);
reset_root_defaults(&transaction.mem_root, reset_root_defaults(&transaction->mem_root,
variables.trans_alloc_block_size, variables.trans_alloc_block_size,
variables.trans_prealloc_size); variables.trans_prealloc_size);
DBUG_ASSERT(!transaction.xid_state.is_explicit_XA()); DBUG_ASSERT(!transaction->xid_state.is_explicit_XA());
DBUG_ASSERT(transaction.implicit_xid.is_null()); DBUG_ASSERT(transaction->implicit_xid.is_null());
} }
@ -1539,7 +1541,7 @@ void THD::cleanup(void)
delete_dynamic(&user_var_events); delete_dynamic(&user_var_events);
close_temporary_tables(); close_temporary_tables();
if (transaction.xid_state.is_explicit_XA()) if (transaction->xid_state.is_explicit_XA())
trans_xa_detach(this); trans_xa_detach(this);
else else
trans_rollback(this); trans_rollback(this);
@ -1565,7 +1567,7 @@ void THD::cleanup(void)
decrease_user_connections(user_connect); decrease_user_connections(user_connect);
user_connect= 0; // Safety user_connect= 0; // Safety
} }
wt_thd_destroy(&transaction.wt); wt_thd_destroy(&transaction->wt);
my_hash_free(&user_vars); my_hash_free(&user_vars);
my_hash_free(&sequences); my_hash_free(&sequences);
@ -1697,7 +1699,7 @@ THD::~THD()
#endif #endif
mdl_context.destroy(); mdl_context.destroy();
free_root(&transaction.mem_root,MYF(0)); transaction->free();
mysql_cond_destroy(&COND_wakeup_ready); mysql_cond_destroy(&COND_wakeup_ready);
mysql_mutex_destroy(&LOCK_wakeup_ready); mysql_mutex_destroy(&LOCK_wakeup_ready);
mysql_mutex_destroy(&LOCK_thd_data); mysql_mutex_destroy(&LOCK_thd_data);
@ -2597,8 +2599,8 @@ void THD::add_changed_table(TABLE *table)
void THD::add_changed_table(const char *key, size_t key_length) void THD::add_changed_table(const char *key, size_t key_length)
{ {
DBUG_ENTER("THD::add_changed_table(key)"); DBUG_ENTER("THD::add_changed_table(key)");
CHANGED_TABLE_LIST **prev_changed = &transaction.changed_tables; CHANGED_TABLE_LIST **prev_changed = &transaction->changed_tables;
CHANGED_TABLE_LIST *curr = transaction.changed_tables; CHANGED_TABLE_LIST *curr = transaction->changed_tables;
for (; curr; prev_changed = &(curr->next), curr = curr->next) for (; curr; prev_changed = &(curr->next), curr = curr->next)
{ {
@ -5050,7 +5052,7 @@ thd_rpl_deadlock_check(MYSQL_THD thd, MYSQL_THD other_thd)
if (!thd) if (!thd)
return 0; return 0;
DEBUG_SYNC(thd, "thd_report_wait_for"); DEBUG_SYNC(thd, "thd_report_wait_for");
thd->transaction.stmt.mark_trans_did_wait(); thd->transaction->stmt.mark_trans_did_wait();
if (!other_thd) if (!other_thd)
return 0; return 0;
binlog_report_wait_for(thd, other_thd); binlog_report_wait_for(thd, other_thd);
@ -5153,7 +5155,7 @@ thd_need_ordering_with(const MYSQL_THD thd, const MYSQL_THD other_thd)
extern "C" int thd_non_transactional_update(const MYSQL_THD thd) extern "C" int thd_non_transactional_update(const MYSQL_THD thd)
{ {
return(thd->transaction.all.modified_non_trans_table); return(thd->transaction->all.modified_non_trans_table);
} }
extern "C" int thd_binlog_format(const MYSQL_THD thd) extern "C" int thd_binlog_format(const MYSQL_THD thd)
@ -5362,7 +5364,7 @@ void THD::reset_sub_statement_state(Sub_statement_state *backup,
backup->limit_found_rows= limit_found_rows; backup->limit_found_rows= limit_found_rows;
backup->cuted_fields= cuted_fields; backup->cuted_fields= cuted_fields;
backup->client_capabilities= client_capabilities; backup->client_capabilities= client_capabilities;
backup->savepoints= transaction.savepoints; backup->savepoints= transaction->savepoints;
backup->first_successful_insert_id_in_prev_stmt= backup->first_successful_insert_id_in_prev_stmt=
first_successful_insert_id_in_prev_stmt; first_successful_insert_id_in_prev_stmt;
backup->first_successful_insert_id_in_cur_stmt= backup->first_successful_insert_id_in_cur_stmt=
@ -5384,7 +5386,7 @@ void THD::reset_sub_statement_state(Sub_statement_state *backup,
client_capabilities &= ~CLIENT_MULTI_RESULTS; client_capabilities &= ~CLIENT_MULTI_RESULTS;
in_sub_stmt|= new_state; in_sub_stmt|= new_state;
cuted_fields= 0; cuted_fields= 0;
transaction.savepoints= 0; transaction->savepoints= 0;
first_successful_insert_id_in_cur_stmt= 0; first_successful_insert_id_in_cur_stmt= 0;
reset_slow_query_state(); reset_slow_query_state();
} }
@ -5410,16 +5412,16 @@ void THD::restore_sub_statement_state(Sub_statement_state *backup)
level. It is enough to release first savepoint set on this level since level. It is enough to release first savepoint set on this level since
all later savepoints will be released automatically. all later savepoints will be released automatically.
*/ */
if (transaction.savepoints) if (transaction->savepoints)
{ {
SAVEPOINT *sv; SAVEPOINT *sv;
for (sv= transaction.savepoints; sv->prev; sv= sv->prev) for (sv= transaction->savepoints; sv->prev; sv= sv->prev)
{} {}
/* ha_release_savepoint() never returns error. */ /* ha_release_savepoint() never returns error. */
(void)ha_release_savepoint(this, sv); (void)ha_release_savepoint(this, sv);
} }
count_cuted_fields= backup->count_cuted_fields; count_cuted_fields= backup->count_cuted_fields;
transaction.savepoints= backup->savepoints; transaction->savepoints= backup->savepoints;
variables.option_bits= backup->option_bits; variables.option_bits= backup->option_bits;
in_sub_stmt= backup->in_sub_stmt; in_sub_stmt= backup->in_sub_stmt;
enable_slow_log= backup->enable_slow_log; enable_slow_log= backup->enable_slow_log;

36
sql/sql_class.h
View File

@ -2733,6 +2733,10 @@ public:
free_root(&mem_root,MYF(MY_KEEP_PREALLOC)); free_root(&mem_root,MYF(MY_KEEP_PREALLOC));
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
void free()
{
free_root(&mem_root,MYF(0));
}
my_bool is_active() my_bool is_active()
{ {
return (all.ha_list != NULL); return (all.ha_list != NULL);
@ -2744,7 +2748,7 @@ public:
init_sql_alloc(key_memory_thd_transactions, &mem_root, init_sql_alloc(key_memory_thd_transactions, &mem_root,
ALLOC_ROOT_MIN_BLOCK_SIZE, 0, MYF(MY_THREAD_SPECIFIC)); ALLOC_ROOT_MIN_BLOCK_SIZE, 0, MYF(MY_THREAD_SPECIFIC));
} }
} transaction; } default_transaction, *transaction;
Global_read_lock global_read_lock; Global_read_lock global_read_lock;
Field *dup_field; Field *dup_field;
#ifndef __WIN__ #ifndef __WIN__
@ -3582,8 +3586,8 @@ public:
timeval transaction_time() timeval transaction_time()
{ {
if (!in_multi_stmt_transaction_mode()) if (!in_multi_stmt_transaction_mode())
transaction.start_time.reset(this); transaction->start_time.reset(this);
return transaction.start_time; return transaction->start_time;
} }
inline void set_start_time() inline void set_start_time()
@ -3756,7 +3760,7 @@ public:
} }
inline void* trans_alloc(size_t size) inline void* trans_alloc(size_t size)
{ {
return alloc_root(&transaction.mem_root,size); return alloc_root(&transaction->mem_root,size);
} }
LEX_CSTRING strmake_lex_cstring(const char *str, size_t length) LEX_CSTRING strmake_lex_cstring(const char *str, size_t length)
@ -4172,7 +4176,7 @@ public:
inline bool really_abort_on_warning() inline bool really_abort_on_warning()
{ {
return (abort_on_warning && return (abort_on_warning &&
(!transaction.stmt.modified_non_trans_table || (!transaction->stmt.modified_non_trans_table ||
(variables.sql_mode & MODE_STRICT_ALL_TABLES))); (variables.sql_mode & MODE_STRICT_ALL_TABLES)));
} }
void set_status_var_init(); void set_status_var_init();
@ -4838,9 +4842,9 @@ public:
if (!wsrep_xid.is_null()) if (!wsrep_xid.is_null())
return &wsrep_xid; return &wsrep_xid;
#endif /* WITH_WSREP */ #endif /* WITH_WSREP */
return transaction.xid_state.is_explicit_XA() ? return (transaction->xid_state.is_explicit_XA() ?
transaction.xid_state.get_xid() : transaction->xid_state.get_xid() :
&transaction.implicit_xid; &transaction->implicit_xid);
} }
/* Members related to temporary tables. */ /* Members related to temporary tables. */
@ -5084,10 +5088,10 @@ public:
/* Copy relevant `stmt` transaction flags to `all` transaction. */ /* Copy relevant `stmt` transaction flags to `all` transaction. */
void merge_unsafe_rollback_flags() void merge_unsafe_rollback_flags()
{ {
if (transaction.stmt.modified_non_trans_table) if (transaction->stmt.modified_non_trans_table)
transaction.all.modified_non_trans_table= TRUE; transaction->all.modified_non_trans_table= TRUE;
transaction.all.m_unsafe_rollback_flags|= transaction->all.m_unsafe_rollback_flags|=
(transaction.stmt.m_unsafe_rollback_flags & (transaction->stmt.m_unsafe_rollback_flags &
(THD_TRANS::DID_WAIT | THD_TRANS::CREATED_TEMP_TABLE | (THD_TRANS::DID_WAIT | THD_TRANS::CREATED_TEMP_TABLE |
THD_TRANS::DROPPED_TEMP_TABLE | THD_TRANS::DID_DDL)); THD_TRANS::DROPPED_TEMP_TABLE | THD_TRANS::DID_DDL));
} }
@ -5097,7 +5101,7 @@ public:
{ {
if (in_active_multi_stmt_transaction()) if (in_active_multi_stmt_transaction())
{ {
if (transaction.all.is_trx_read_write()) if (transaction->all.is_trx_read_write())
{ {
if (variables.idle_write_transaction_timeout > 0) if (variables.idle_write_transaction_timeout > 0)
return variables.idle_write_transaction_timeout; return variables.idle_write_transaction_timeout;
@ -7284,13 +7288,13 @@ class Sp_eval_expr_state
{ {
m_thd->count_cuted_fields= CHECK_FIELD_ERROR_FOR_NULL; m_thd->count_cuted_fields= CHECK_FIELD_ERROR_FOR_NULL;
m_thd->abort_on_warning= m_thd->is_strict_mode(); m_thd->abort_on_warning= m_thd->is_strict_mode();
m_thd->transaction.stmt.modified_non_trans_table= false; m_thd->transaction->stmt.modified_non_trans_table= false;
} }
void stop() void stop()
{ {
m_thd->count_cuted_fields= m_count_cuted_fields; m_thd->count_cuted_fields= m_count_cuted_fields;
m_thd->abort_on_warning= m_abort_on_warning; m_thd->abort_on_warning= m_abort_on_warning;
m_thd->transaction.stmt.modified_non_trans_table= m_thd->transaction->stmt.modified_non_trans_table=
m_stmt_modified_non_trans_table; m_stmt_modified_non_trans_table;
} }
public: public:
@ -7298,7 +7302,7 @@ public:
:m_thd(thd), :m_thd(thd),
m_count_cuted_fields(thd->count_cuted_fields), m_count_cuted_fields(thd->count_cuted_fields),
m_abort_on_warning(thd->abort_on_warning), m_abort_on_warning(thd->abort_on_warning),
m_stmt_modified_non_trans_table(thd->transaction.stmt. m_stmt_modified_non_trans_table(thd->transaction->stmt.
modified_non_trans_table) modified_non_trans_table)
{ {
start(); start();

34
sql/sql_delete.cc
View File

@ -878,11 +878,11 @@ cleanup:
transactional_table= table->file->has_transactions(); transactional_table= table->file->has_transactions();
if (!transactional_table && deleted > 0) if (!transactional_table && deleted > 0)
thd->transaction.stmt.modified_non_trans_table= thd->transaction->stmt.modified_non_trans_table=
thd->transaction.all.modified_non_trans_table= TRUE; thd->transaction->all.modified_non_trans_table= TRUE;
/* See similar binlogging code in sql_update.cc, for comments */ /* See similar binlogging code in sql_update.cc, for comments */
if (likely((error < 0) || thd->transaction.stmt.modified_non_trans_table)) if (likely((error < 0) || thd->transaction->stmt.modified_non_trans_table))
{ {
if (WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open()) if (WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open())
{ {
@ -911,7 +911,7 @@ cleanup:
} }
} }
} }
DBUG_ASSERT(transactional_table || !deleted || thd->transaction.stmt.modified_non_trans_table); DBUG_ASSERT(transactional_table || !deleted || thd->transaction->stmt.modified_non_trans_table);
if (likely(error < 0) || if (likely(error < 0) ||
(thd->lex->ignore && !thd->is_error() && !thd->is_fatal_error)) (thd->lex->ignore && !thd->is_error() && !thd->is_fatal_error))
@ -1332,7 +1332,7 @@ int multi_delete::send_data(List<Item> &values)
{ {
deleted++; deleted++;
if (!table->file->has_transactions()) if (!table->file->has_transactions())
thd->transaction.stmt.modified_non_trans_table= TRUE; thd->transaction->stmt.modified_non_trans_table= TRUE;
if (table->triggers && if (table->triggers &&
table->triggers->process_triggers(thd, TRG_EVENT_DELETE, table->triggers->process_triggers(thd, TRG_EVENT_DELETE,
TRG_ACTION_AFTER, FALSE)) TRG_ACTION_AFTER, FALSE))
@ -1368,17 +1368,17 @@ void multi_delete::abort_result_set()
/* the error was handled or nothing deleted and no side effects return */ /* the error was handled or nothing deleted and no side effects return */
if (error_handled || if (error_handled ||
(!thd->transaction.stmt.modified_non_trans_table && !deleted)) (!thd->transaction->stmt.modified_non_trans_table && !deleted))
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
/* Something already deleted so we have to invalidate cache */ /* Something already deleted so we have to invalidate cache */
if (deleted) if (deleted)
query_cache_invalidate3(thd, delete_tables, 1); query_cache_invalidate3(thd, delete_tables, 1);
if (thd->transaction.stmt.modified_non_trans_table) if (thd->transaction->stmt.modified_non_trans_table)
thd->transaction.all.modified_non_trans_table= TRUE; thd->transaction->all.modified_non_trans_table= TRUE;
thd->transaction.all.m_unsafe_rollback_flags|= thd->transaction->all.m_unsafe_rollback_flags|=
(thd->transaction.stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT); (thd->transaction->stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT);
/* /*
If rows from the first table only has been deleted and it is If rows from the first table only has been deleted and it is
@ -1400,7 +1400,7 @@ void multi_delete::abort_result_set()
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
if (thd->transaction.stmt.modified_non_trans_table) if (thd->transaction->stmt.modified_non_trans_table)
{ {
/* /*
there is only side effects; to binlog with the error there is only side effects; to binlog with the error
@ -1538,7 +1538,7 @@ int multi_delete::do_table_deletes(TABLE *table, SORT_INFO *sort_info,
} }
} }
if (last_deleted != deleted && !table->file->has_transactions()) if (last_deleted != deleted && !table->file->has_transactions())
thd->transaction.stmt.modified_non_trans_table= TRUE; thd->transaction->stmt.modified_non_trans_table= TRUE;
end_read_record(&info); end_read_record(&info);
@ -1566,10 +1566,10 @@ bool multi_delete::send_eof()
/* reset used flags */ /* reset used flags */
THD_STAGE_INFO(thd, stage_end); THD_STAGE_INFO(thd, stage_end);
if (thd->transaction.stmt.modified_non_trans_table) if (thd->transaction->stmt.modified_non_trans_table)
thd->transaction.all.modified_non_trans_table= TRUE; thd->transaction->all.modified_non_trans_table= TRUE;
thd->transaction.all.m_unsafe_rollback_flags|= thd->transaction->all.m_unsafe_rollback_flags|=
(thd->transaction.stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT); (thd->transaction->stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT);
/* /*
We must invalidate the query cache before binlog writing and We must invalidate the query cache before binlog writing and
@ -1580,7 +1580,7 @@ bool multi_delete::send_eof()
query_cache_invalidate3(thd, delete_tables, 1); query_cache_invalidate3(thd, delete_tables, 1);
} }
if (likely((local_error == 0) || if (likely((local_error == 0) ||
thd->transaction.stmt.modified_non_trans_table)) thd->transaction->stmt.modified_non_trans_table))
{ {
if(WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open()) if(WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open())
{ {

2
sql/sql_handler.cc
View File

@ -480,7 +480,7 @@ err:
If called with reopen flag, no need to rollback either, If called with reopen flag, no need to rollback either,
it will be done at statement end. it will be done at statement end.
*/ */
DBUG_ASSERT(thd->transaction.stmt.is_empty()); DBUG_ASSERT(thd->transaction->stmt.is_empty());
close_thread_tables(thd); close_thread_tables(thd);
thd->mdl_context.rollback_to_savepoint(mdl_savepoint); thd->mdl_context.rollback_to_savepoint(mdl_savepoint);
thd->set_open_tables(backup_open_tables); thd->set_open_tables(backup_open_tables);

38
sql/sql_insert.cc
View File

@ -1156,13 +1156,13 @@ values_loop_end:
query_cache_invalidate3(thd, table_list, 1); query_cache_invalidate3(thd, table_list, 1);
} }
if (thd->transaction.stmt.modified_non_trans_table) if (thd->transaction->stmt.modified_non_trans_table)
thd->transaction.all.modified_non_trans_table= TRUE; thd->transaction->all.modified_non_trans_table= TRUE;
thd->transaction.all.m_unsafe_rollback_flags|= thd->transaction->all.m_unsafe_rollback_flags|=
(thd->transaction.stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT); (thd->transaction->stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT);
if (error <= 0 || if (error <= 0 ||
thd->transaction.stmt.modified_non_trans_table || thd->transaction->stmt.modified_non_trans_table ||
was_insert_delayed) was_insert_delayed)
{ {
if(WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open()) if(WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open())
@ -1225,7 +1225,7 @@ values_loop_end:
} }
} }
DBUG_ASSERT(transactional_table || !changed || DBUG_ASSERT(transactional_table || !changed ||
thd->transaction.stmt.modified_non_trans_table); thd->transaction->stmt.modified_non_trans_table);
} }
THD_STAGE_INFO(thd, stage_end); THD_STAGE_INFO(thd, stage_end);
/* /*
@ -2056,7 +2056,7 @@ int write_record(THD *thd, TABLE *table, COPY_INFO *info, select_result *sink)
else else
info->updated++; info->updated++;
if (!table->file->has_transactions()) if (!table->file->has_transactions())
thd->transaction.stmt.modified_non_trans_table= TRUE; thd->transaction->stmt.modified_non_trans_table= TRUE;
if (table->triggers && if (table->triggers &&
table->triggers->process_triggers(thd, TRG_EVENT_DELETE, table->triggers->process_triggers(thd, TRG_EVENT_DELETE,
TRG_ACTION_AFTER, TRUE)) TRG_ACTION_AFTER, TRUE))
@ -2122,7 +2122,7 @@ after_trg_or_ignored_err:
if (key) if (key)
my_safe_afree(key,table->s->max_unique_length); my_safe_afree(key,table->s->max_unique_length);
if (!table->file->has_transactions()) if (!table->file->has_transactions())
thd->transaction.stmt.modified_non_trans_table= TRUE; thd->transaction->stmt.modified_non_trans_table= TRUE;
DBUG_RETURN(trg_error); DBUG_RETURN(trg_error);
err: err:
@ -4139,13 +4139,13 @@ bool select_insert::prepare_eof()
query_cache_invalidate3(thd, table, 1); query_cache_invalidate3(thd, table, 1);
} }
if (thd->transaction.stmt.modified_non_trans_table) if (thd->transaction->stmt.modified_non_trans_table)
thd->transaction.all.modified_non_trans_table= TRUE; thd->transaction->all.modified_non_trans_table= TRUE;
thd->transaction.all.m_unsafe_rollback_flags|= thd->transaction->all.m_unsafe_rollback_flags|=
(thd->transaction.stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT); (thd->transaction->stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT);
DBUG_ASSERT(trans_table || !changed || DBUG_ASSERT(trans_table || !changed ||
thd->transaction.stmt.modified_non_trans_table); thd->transaction->stmt.modified_non_trans_table);
/* /*
Write to binlog before commiting transaction. No statement will Write to binlog before commiting transaction. No statement will
@ -4154,7 +4154,7 @@ bool select_insert::prepare_eof()
ha_autocommit_or_rollback() is issued below. ha_autocommit_or_rollback() is issued below.
*/ */
if ((WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open()) && if ((WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open()) &&
(likely(!error) || thd->transaction.stmt.modified_non_trans_table)) (likely(!error) || thd->transaction->stmt.modified_non_trans_table))
{ {
int errcode= 0; int errcode= 0;
int res; int res;
@ -4274,11 +4274,11 @@ void select_insert::abort_result_set()
*/ */
changed= (info.copied || info.deleted || info.updated); changed= (info.copied || info.deleted || info.updated);
transactional_table= table->file->has_transactions(); transactional_table= table->file->has_transactions();
if (thd->transaction.stmt.modified_non_trans_table || if (thd->transaction->stmt.modified_non_trans_table ||
thd->log_current_statement) thd->log_current_statement)
{ {
if (!can_rollback_data()) if (!can_rollback_data())
thd->transaction.all.modified_non_trans_table= TRUE; thd->transaction->all.modified_non_trans_table= TRUE;
if(WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open()) if(WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open())
{ {
@ -4294,7 +4294,7 @@ void select_insert::abort_result_set()
query_cache_invalidate3(thd, table, 1); query_cache_invalidate3(thd, table, 1);
} }
DBUG_ASSERT(transactional_table || !changed || DBUG_ASSERT(transactional_table || !changed ||
thd->transaction.stmt.modified_non_trans_table); thd->transaction->stmt.modified_non_trans_table);
table->s->table_creation_was_logged|= binary_logged; table->s->table_creation_was_logged|= binary_logged;
table->file->ha_release_auto_increment(); table->file->ha_release_auto_increment();
@ -4874,7 +4874,7 @@ bool select_create::send_eof()
mark the flag at this point. mark the flag at this point.
*/ */
if (table->s->tmp_table) if (table->s->tmp_table)
thd->transaction.stmt.mark_created_temp_table(); thd->transaction->stmt.mark_created_temp_table();
if (thd->slave_thread) if (thd->slave_thread)
thd->variables.binlog_annotate_row_events= 0; thd->variables.binlog_annotate_row_events= 0;
@ -5039,7 +5039,7 @@ void select_create::abort_result_set()
save_option_bits= thd->variables.option_bits; save_option_bits= thd->variables.option_bits;
thd->variables.option_bits&= ~OPTION_BIN_LOG; thd->variables.option_bits&= ~OPTION_BIN_LOG;
select_insert::abort_result_set(); select_insert::abort_result_set();
thd->transaction.stmt.modified_non_trans_table= FALSE; thd->transaction->stmt.modified_non_trans_table= FALSE;
thd->variables.option_bits= save_option_bits; thd->variables.option_bits= save_option_bits;
/* possible error of writing binary log is ignored deliberately */ /* possible error of writing binary log is ignored deliberately */

14
sql/sql_load.cc
View File

@ -739,7 +739,7 @@ int mysql_load(THD *thd, const sql_exchange *ex, TABLE_LIST *table_list,
/* since there is already an error, the possible error of /* since there is already an error, the possible error of
writing binary log will be ignored */ writing binary log will be ignored */
if (thd->transaction.stmt.modified_non_trans_table) if (thd->transaction->stmt.modified_non_trans_table)
(void) write_execute_load_query_log_event(thd, ex, (void) write_execute_load_query_log_event(thd, ex,
table_list->db.str, table_list->db.str,
table_list->table_name.str, table_list->table_name.str,
@ -764,10 +764,10 @@ int mysql_load(THD *thd, const sql_exchange *ex, TABLE_LIST *table_list,
(ulong) (info.records - info.copied), (ulong) (info.records - info.copied),
(long) thd->get_stmt_da()->current_statement_warn_count()); (long) thd->get_stmt_da()->current_statement_warn_count());
if (thd->transaction.stmt.modified_non_trans_table) if (thd->transaction->stmt.modified_non_trans_table)
thd->transaction.all.modified_non_trans_table= TRUE; thd->transaction->all.modified_non_trans_table= TRUE;
thd->transaction.all.m_unsafe_rollback_flags|= thd->transaction->all.m_unsafe_rollback_flags|=
(thd->transaction.stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT); (thd->transaction->stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT);
#ifndef EMBEDDED_LIBRARY #ifndef EMBEDDED_LIBRARY
if (mysql_bin_log.is_open()) if (mysql_bin_log.is_open())
{ {
@ -816,7 +816,7 @@ int mysql_load(THD *thd, const sql_exchange *ex, TABLE_LIST *table_list,
my_ok(thd, info.copied + info.deleted, 0L, name); my_ok(thd, info.copied + info.deleted, 0L, name);
err: err:
DBUG_ASSERT(transactional_table || !(info.copied || info.deleted) || DBUG_ASSERT(transactional_table || !(info.copied || info.deleted) ||
thd->transaction.stmt.modified_non_trans_table); thd->transaction->stmt.modified_non_trans_table);
table->file->ha_release_auto_increment(); table->file->ha_release_auto_increment();
table->auto_increment_field_not_null= FALSE; table->auto_increment_field_not_null= FALSE;
thd->abort_on_warning= 0; thd->abort_on_warning= 0;
@ -1300,7 +1300,7 @@ read_xml_field(THD *thd, COPY_INFO &info, TABLE_LIST *table_list,
We don't need to reset auto-increment field since we are restoring We don't need to reset auto-increment field since we are restoring
its default value at the beginning of each loop iteration. its default value at the beginning of each loop iteration.
*/ */
thd->transaction.stmt.modified_non_trans_table= no_trans_update_stmt; thd->transaction->stmt.modified_non_trans_table= no_trans_update_stmt;
thd->get_stmt_da()->inc_current_row_for_warning(); thd->get_stmt_da()->inc_current_row_for_warning();
continue_loop:; continue_loop:;
} }

18
sql/sql_parse.cc
View File

@ -1104,7 +1104,7 @@ int bootstrap(MYSQL_FILE *file)
thd->reset_kill_query(); /* Ensure that killed_errmsg is released */ thd->reset_kill_query(); /* Ensure that killed_errmsg is released */
free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC)); free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC)); thd->transaction->free();
thd->lex->restore_set_statement_var(); thd->lex->restore_set_statement_var();
} }
delete thd; delete thd;
@ -2118,7 +2118,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
mysqld_list_fields(thd,&table_list,fields); mysqld_list_fields(thd,&table_list,fields);
thd->lex->unit.cleanup(); thd->lex->unit.cleanup();
/* No need to rollback statement transaction, it's not started. */ /* No need to rollback statement transaction, it's not started. */
DBUG_ASSERT(thd->transaction.stmt.is_empty()); DBUG_ASSERT(thd->transaction->stmt.is_empty());
close_thread_tables(thd); close_thread_tables(thd);
thd->mdl_context.rollback_to_savepoint(mdl_savepoint); thd->mdl_context.rollback_to_savepoint(mdl_savepoint);
@ -3177,7 +3177,7 @@ mysql_create_routine(THD *thd, LEX *lex)
creation of routine and implicit GRANT parts of one fully atomic creation of routine and implicit GRANT parts of one fully atomic
statement. statement.
*/ */
DBUG_ASSERT(thd->transaction.stmt.is_empty()); DBUG_ASSERT(thd->transaction->stmt.is_empty());
close_thread_tables(thd); close_thread_tables(thd);
/* /*
Check if the definer exists on slave, Check if the definer exists on slave,
@ -3398,7 +3398,7 @@ mysql_execute_command(THD *thd)
DBUG_RETURN(1); DBUG_RETURN(1);
} }
DBUG_ASSERT(thd->transaction.stmt.is_empty() || thd->in_sub_stmt); DBUG_ASSERT(thd->transaction->stmt.is_empty() || thd->in_sub_stmt);
/* /*
Each statement or replication event which might produce deadlock Each statement or replication event which might produce deadlock
should handle transaction rollback on its own. So by the start of should handle transaction rollback on its own. So by the start of
@ -3625,7 +3625,7 @@ mysql_execute_command(THD *thd)
thd->progress.report_to_client= MY_TEST(sql_command_flags[lex->sql_command] & thd->progress.report_to_client= MY_TEST(sql_command_flags[lex->sql_command] &
CF_REPORT_PROGRESS); CF_REPORT_PROGRESS);
DBUG_ASSERT(thd->transaction.stmt.modified_non_trans_table == FALSE); DBUG_ASSERT(thd->transaction->stmt.modified_non_trans_table == FALSE);
/* store old value of binlog format */ /* store old value of binlog format */
enum_binlog_format orig_binlog_format,orig_current_stmt_binlog_format; enum_binlog_format orig_binlog_format,orig_current_stmt_binlog_format;
@ -3782,7 +3782,7 @@ mysql_execute_command(THD *thd)
*/ */
DBUG_ASSERT(! thd->in_sub_stmt); DBUG_ASSERT(! thd->in_sub_stmt);
/* Statement transaction still should not be started. */ /* Statement transaction still should not be started. */
DBUG_ASSERT(thd->transaction.stmt.is_empty()); DBUG_ASSERT(thd->transaction->stmt.is_empty());
if (!(thd->variables.option_bits & OPTION_GTID_BEGIN)) if (!(thd->variables.option_bits & OPTION_GTID_BEGIN))
{ {
/* Commit the normal transaction if one is active. */ /* Commit the normal transaction if one is active. */
@ -3796,7 +3796,7 @@ mysql_execute_command(THD *thd)
goto error; goto error;
} }
} }
thd->transaction.stmt.mark_trans_did_ddl(); thd->transaction->stmt.mark_trans_did_ddl();
#ifdef WITH_WSREP #ifdef WITH_WSREP
/* Clean up the previous transaction on implicit commit */ /* Clean up the previous transaction on implicit commit */
if (wsrep_thd_is_local(thd) && wsrep_after_statement(thd)) if (wsrep_thd_is_local(thd) && wsrep_after_statement(thd))
@ -6578,7 +6578,7 @@ drop_routine(THD *thd, LEX *lex)
dropping of routine and implicit REVOKE parts of one fully atomic dropping of routine and implicit REVOKE parts of one fully atomic
statement. statement.
*/ */
DBUG_ASSERT(thd->transaction.stmt.is_empty()); DBUG_ASSERT(thd->transaction->stmt.is_empty());
close_thread_tables(thd); close_thread_tables(thd);
if (sp_result != SP_KEY_NOT_FOUND && if (sp_result != SP_KEY_NOT_FOUND &&
@ -7581,7 +7581,7 @@ void THD::reset_for_next_command(bool do_clear_error)
if (!in_multi_stmt_transaction_mode()) if (!in_multi_stmt_transaction_mode())
{ {
variables.option_bits&= ~OPTION_KEEP_LOG; variables.option_bits&= ~OPTION_KEEP_LOG;
transaction.all.reset(); transaction->all.reset();
} }
DBUG_ASSERT(security_ctx== &main_security_ctx); DBUG_ASSERT(security_ctx== &main_security_ctx);
thread_specific_used= FALSE; thread_specific_used= FALSE;

2
sql/sql_prepare.cc
View File

@ -4087,7 +4087,7 @@ bool Prepared_statement::prepare(const char *packet, uint packet_len)
lex->unit.cleanup(); lex->unit.cleanup();
/* No need to commit statement transaction, it's not started. */ /* No need to commit statement transaction, it's not started. */
DBUG_ASSERT(thd->transaction.stmt.is_empty()); DBUG_ASSERT(thd->transaction->stmt.is_empty());
close_thread_tables(thd); close_thread_tables(thd);
thd->mdl_context.rollback_to_savepoint(mdl_savepoint); thd->mdl_context.rollback_to_savepoint(mdl_savepoint);

4
sql/sql_sequence.cc
View File

@ -437,7 +437,7 @@ int SEQUENCE::read_initial_values(TABLE *table)
MYSQL_LOCK *lock; MYSQL_LOCK *lock;
bool mdl_lock_used= 0; bool mdl_lock_used= 0;
THD *thd= table->in_use; THD *thd= table->in_use;
bool has_active_transaction= !thd->transaction.stmt.is_empty(); bool has_active_transaction= !thd->transaction->stmt.is_empty();
/* /*
There is already a mdl_ticket for this table. However, for list_fields There is already a mdl_ticket for this table. However, for list_fields
the MDL lock is of type MDL_SHARED_HIGH_PRIO which is not usable the MDL lock is of type MDL_SHARED_HIGH_PRIO which is not usable
@ -490,7 +490,7 @@ int SEQUENCE::read_initial_values(TABLE *table)
But we also don't want to commit the stmt transaction while in a But we also don't want to commit the stmt transaction while in a
substatement, see MDEV-15977. substatement, see MDEV-15977.
*/ */
if (!has_active_transaction && !thd->transaction.stmt.is_empty() && if (!has_active_transaction && !thd->transaction->stmt.is_empty() &&
!thd->in_sub_stmt) !thd->in_sub_stmt)
trans_commit_stmt(thd); trans_commit_stmt(thd);
} }

10
sql/sql_table.cc
View File

@ -2616,7 +2616,7 @@ err:
trans_tmp_table_deleted || non_tmp_table_deleted) trans_tmp_table_deleted || non_tmp_table_deleted)
{ {
if (non_trans_tmp_table_deleted || trans_tmp_table_deleted) if (non_trans_tmp_table_deleted || trans_tmp_table_deleted)
thd->transaction.stmt.mark_dropped_temp_table(); thd->transaction->stmt.mark_dropped_temp_table();
query_cache_invalidate3(thd, tables, 0); query_cache_invalidate3(thd, tables, 0);
if (!dont_log_query && mysql_bin_log.is_open()) if (!dont_log_query && mysql_bin_log.is_open())
@ -5391,7 +5391,7 @@ err:
} }
if (create_info->tmp_table()) if (create_info->tmp_table())
thd->transaction.stmt.mark_created_temp_table(); thd->transaction->stmt.mark_created_temp_table();
/* Write log if no error or if we already deleted a table */ /* Write log if no error or if we already deleted a table */
if (likely(!result) || thd->log_current_statement) if (likely(!result) || thd->log_current_statement)
@ -6009,7 +6009,7 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table,
res, create_info->tmp_table(), local_create_info.table)); res, create_info->tmp_table(), local_create_info.table));
if (create_info->tmp_table()) if (create_info->tmp_table())
{ {
thd->transaction.stmt.mark_created_temp_table(); thd->transaction->stmt.mark_created_temp_table();
if (!res && local_create_info.table) if (!res && local_create_info.table)
{ {
/* /*
@ -10931,7 +10931,7 @@ bool mysql_trans_commit_alter_copy_data(THD *thd)
DBUG_ENTER("mysql_trans_commit_alter_copy_data"); DBUG_ENTER("mysql_trans_commit_alter_copy_data");
/* Save flags as trans_commit_implicit are deleting them */ /* Save flags as trans_commit_implicit are deleting them */
save_unsafe_rollback_flags= thd->transaction.stmt.m_unsafe_rollback_flags; save_unsafe_rollback_flags= thd->transaction->stmt.m_unsafe_rollback_flags;
DEBUG_SYNC(thd, "alter_table_copy_trans_commit"); DEBUG_SYNC(thd, "alter_table_copy_trans_commit");
@ -10949,7 +10949,7 @@ bool mysql_trans_commit_alter_copy_data(THD *thd)
if (trans_commit_implicit(thd)) if (trans_commit_implicit(thd))
error= TRUE; error= TRUE;
thd->transaction.stmt.m_unsafe_rollback_flags= save_unsafe_rollback_flags; thd->transaction->stmt.m_unsafe_rollback_flags= save_unsafe_rollback_flags;
DBUG_RETURN(error); DBUG_RETURN(error);
} }

48
sql/sql_update.cc
View File

@ -1227,7 +1227,7 @@ update_end:
table->file->try_semi_consistent_read(0); table->file->try_semi_consistent_read(0);
if (!transactional_table && updated > 0) if (!transactional_table && updated > 0)
thd->transaction.stmt.modified_non_trans_table= TRUE; thd->transaction->stmt.modified_non_trans_table= TRUE;
end_read_record(&info); end_read_record(&info);
delete select; delete select;
@ -1246,10 +1246,10 @@ update_end:
query_cache_invalidate3(thd, table_list, 1); query_cache_invalidate3(thd, table_list, 1);
} }
if (thd->transaction.stmt.modified_non_trans_table) if (thd->transaction->stmt.modified_non_trans_table)
thd->transaction.all.modified_non_trans_table= TRUE; thd->transaction->all.modified_non_trans_table= TRUE;
thd->transaction.all.m_unsafe_rollback_flags|= thd->transaction->all.m_unsafe_rollback_flags|=
(thd->transaction.stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT); (thd->transaction->stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT);
/* /*
error < 0 means really no error at all: we processed all rows until the error < 0 means really no error at all: we processed all rows until the
@ -1260,7 +1260,7 @@ update_end:
Sometimes we want to binlog even if we updated no rows, in case user used Sometimes we want to binlog even if we updated no rows, in case user used
it to be sure master and slave are in same state. it to be sure master and slave are in same state.
*/ */
if (likely(error < 0) || thd->transaction.stmt.modified_non_trans_table) if (likely(error < 0) || thd->transaction->stmt.modified_non_trans_table)
{ {
if (WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open()) if (WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open())
{ {
@ -1281,7 +1281,7 @@ update_end:
} }
} }
} }
DBUG_ASSERT(transactional_table || !updated || thd->transaction.stmt.modified_non_trans_table); DBUG_ASSERT(transactional_table || !updated || thd->transaction->stmt.modified_non_trans_table);
free_underlaid_joins(thd, select_lex); free_underlaid_joins(thd, select_lex);
delete file_sort; delete file_sort;
if (table->file->pushed_cond) if (table->file->pushed_cond)
@ -2452,7 +2452,7 @@ multi_update::~multi_update()
delete [] copy_field; delete [] copy_field;
thd->count_cuted_fields= CHECK_FIELD_IGNORE; // Restore this setting thd->count_cuted_fields= CHECK_FIELD_IGNORE; // Restore this setting
DBUG_ASSERT(trans_safe || !updated || DBUG_ASSERT(trans_safe || !updated ||
thd->transaction.all.modified_non_trans_table); thd->transaction->all.modified_non_trans_table);
} }
@ -2577,7 +2577,7 @@ int multi_update::send_data(List<Item> &not_used_values)
else else
{ {
trans_safe= FALSE; trans_safe= FALSE;
thd->transaction.stmt.modified_non_trans_table= TRUE; thd->transaction->stmt.modified_non_trans_table= TRUE;
} }
} }
} }
@ -2632,7 +2632,7 @@ void multi_update::abort_result_set()
{ {
/* the error was handled or nothing deleted and no side effects return */ /* the error was handled or nothing deleted and no side effects return */
if (unlikely(error_handled || if (unlikely(error_handled ||
(!thd->transaction.stmt.modified_non_trans_table && !updated))) (!thd->transaction->stmt.modified_non_trans_table && !updated)))
return; return;
/* Something already updated so we have to invalidate cache */ /* Something already updated so we have to invalidate cache */
@ -2645,14 +2645,14 @@ void multi_update::abort_result_set()
if (! trans_safe) if (! trans_safe)
{ {
DBUG_ASSERT(thd->transaction.stmt.modified_non_trans_table); DBUG_ASSERT(thd->transaction->stmt.modified_non_trans_table);
if (do_update && table_count > 1) if (do_update && table_count > 1)
{ {
/* Add warning here */ /* Add warning here */
(void) do_updates(); (void) do_updates();
} }
} }
if (thd->transaction.stmt.modified_non_trans_table) if (thd->transaction->stmt.modified_non_trans_table)
{ {
/* /*
The query has to binlog because there's a modified non-transactional table The query has to binlog because there's a modified non-transactional table
@ -2671,11 +2671,11 @@ void multi_update::abort_result_set()
thd->query(), thd->query_length(), thd->query(), thd->query_length(),
transactional_tables, FALSE, FALSE, errcode); transactional_tables, FALSE, FALSE, errcode);
} }
thd->transaction.all.modified_non_trans_table= TRUE; thd->transaction->all.modified_non_trans_table= TRUE;
} }
thd->transaction.all.m_unsafe_rollback_flags|= thd->transaction->all.m_unsafe_rollback_flags|=
(thd->transaction.stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT); (thd->transaction->stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT);
DBUG_ASSERT(trans_safe || !updated || thd->transaction.stmt.modified_non_trans_table); DBUG_ASSERT(trans_safe || !updated || thd->transaction->stmt.modified_non_trans_table);
} }
@ -2896,7 +2896,7 @@ int multi_update::do_updates()
else else
{ {
trans_safe= FALSE; // Can't do safe rollback trans_safe= FALSE; // Can't do safe rollback
thd->transaction.stmt.modified_non_trans_table= TRUE; thd->transaction->stmt.modified_non_trans_table= TRUE;
} }
} }
(void) table->file->ha_rnd_end(); (void) table->file->ha_rnd_end();
@ -2933,7 +2933,7 @@ err2:
else else
{ {
trans_safe= FALSE; trans_safe= FALSE;
thd->transaction.stmt.modified_non_trans_table= TRUE; thd->transaction->stmt.modified_non_trans_table= TRUE;
} }
} }
DBUG_RETURN(1); DBUG_RETURN(1);
@ -2980,13 +2980,13 @@ bool multi_update::send_eof()
either from the query's list or via a stored routine: bug#13270,23333 either from the query's list or via a stored routine: bug#13270,23333
*/ */
if (thd->transaction.stmt.modified_non_trans_table) if (thd->transaction->stmt.modified_non_trans_table)
thd->transaction.all.modified_non_trans_table= TRUE; thd->transaction->all.modified_non_trans_table= TRUE;
thd->transaction.all.m_unsafe_rollback_flags|= thd->transaction->all.m_unsafe_rollback_flags|=
(thd->transaction.stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT); (thd->transaction->stmt.m_unsafe_rollback_flags & THD_TRANS::DID_WAIT);
if (likely(local_error == 0 || if (likely(local_error == 0 ||
thd->transaction.stmt.modified_non_trans_table)) thd->transaction->stmt.modified_non_trans_table))
{ {
if (WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open()) if (WSREP_EMULATE_BINLOG(thd) || mysql_bin_log.is_open())
{ {
@ -3018,7 +3018,7 @@ bool multi_update::send_eof()
} }
} }
DBUG_ASSERT(trans_safe || !updated || DBUG_ASSERT(trans_safe || !updated ||
thd->transaction.stmt.modified_non_trans_table); thd->transaction->stmt.modified_non_trans_table);
if (likely(local_error != 0)) if (likely(local_error != 0))
error_handled= TRUE; // to force early leave from ::abort_result_set() error_handled= TRUE; // to force early leave from ::abort_result_set()

10
sql/sys_vars.cc
View File

@ -2999,7 +2999,7 @@ static Sys_var_charptr_fscs Sys_tmpdir(
static bool fix_trans_mem_root(sys_var *self, THD *thd, enum_var_type type) static bool fix_trans_mem_root(sys_var *self, THD *thd, enum_var_type type)
{ {
if (type != OPT_GLOBAL) if (type != OPT_GLOBAL)
reset_root_defaults(&thd->transaction.mem_root, reset_root_defaults(&thd->transaction->mem_root,
thd->variables.trans_alloc_block_size, thd->variables.trans_alloc_block_size,
thd->variables.trans_prealloc_size); thd->variables.trans_prealloc_size);
return false; return false;
@ -4326,8 +4326,8 @@ static bool fix_autocommit(sys_var *self, THD *thd, enum_var_type type)
thd->variables.option_bits&= thd->variables.option_bits&=
~(OPTION_BEGIN | OPTION_KEEP_LOG | OPTION_NOT_AUTOCOMMIT | ~(OPTION_BEGIN | OPTION_KEEP_LOG | OPTION_NOT_AUTOCOMMIT |
OPTION_GTID_BEGIN); OPTION_GTID_BEGIN);
thd->transaction.all.modified_non_trans_table= false; thd->transaction->all.modified_non_trans_table= false;
thd->transaction.all.m_unsafe_rollback_flags&= ~THD_TRANS::DID_WAIT; thd->transaction->all.m_unsafe_rollback_flags&= ~THD_TRANS::DID_WAIT;
thd->server_status|= SERVER_STATUS_AUTOCOMMIT; thd->server_status|= SERVER_STATUS_AUTOCOMMIT;
return false; return false;
} }
@ -4336,8 +4336,8 @@ static bool fix_autocommit(sys_var *self, THD *thd, enum_var_type type)
(OPTION_AUTOCOMMIT |OPTION_NOT_AUTOCOMMIT)) == 0) (OPTION_AUTOCOMMIT |OPTION_NOT_AUTOCOMMIT)) == 0)
{ {
// disabling autocommit // disabling autocommit
thd->transaction.all.modified_non_trans_table= false; thd->transaction->all.modified_non_trans_table= false;
thd->transaction.all.m_unsafe_rollback_flags&= ~THD_TRANS::DID_WAIT; thd->transaction->all.m_unsafe_rollback_flags&= ~THD_TRANS::DID_WAIT;
thd->server_status&= ~SERVER_STATUS_AUTOCOMMIT; thd->server_status&= ~SERVER_STATUS_AUTOCOMMIT;
thd->variables.option_bits|= OPTION_NOT_AUTOCOMMIT; thd->variables.option_bits|= OPTION_NOT_AUTOCOMMIT;
return false; return false;

2
sql/temporary_tables.cc
View File

@ -1402,7 +1402,7 @@ bool THD::log_events_and_free_tmp_shares()
variables.character_set_client= cs_save; variables.character_set_client= cs_save;
get_stmt_da()->set_overwrite_status(true); get_stmt_da()->set_overwrite_status(true);
transaction.stmt.mark_dropped_temp_table(); transaction->stmt.mark_dropped_temp_table();
bool error2= mysql_bin_log.write(&qinfo); bool error2= mysql_bin_log.write(&qinfo);
if (unlikely(error|= error2)) if (unlikely(error|= error2))
{ {

2
sql/threadpool_common.cc
View File

@ -162,7 +162,7 @@ static TP_PRIORITY get_priority(TP_connection *c)
DBUG_ASSERT(c->thd == current_thd); DBUG_ASSERT(c->thd == current_thd);
TP_PRIORITY prio= (TP_PRIORITY)c->thd->variables.threadpool_priority; TP_PRIORITY prio= (TP_PRIORITY)c->thd->variables.threadpool_priority;
if (prio == TP_PRIORITY_AUTO) if (prio == TP_PRIORITY_AUTO)
prio= c->thd->transaction.is_active() ? TP_PRIORITY_HIGH : TP_PRIORITY_LOW; prio= c->thd->transaction->is_active() ? TP_PRIORITY_HIGH : TP_PRIORITY_LOW;
return prio; return prio;
} }

48
sql/transaction.cc
View File

@ -69,12 +69,12 @@ static bool trans_check(THD *thd)
Always commit statement transaction before manipulating with Always commit statement transaction before manipulating with
the normal one. the normal one.
*/ */
DBUG_ASSERT(thd->transaction.stmt.is_empty()); DBUG_ASSERT(thd->transaction->stmt.is_empty());
if (unlikely(thd->in_sub_stmt)) if (unlikely(thd->in_sub_stmt))
my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0)); my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
if (thd->transaction.xid_state.is_explicit_XA()) if (thd->transaction->xid_state.is_explicit_XA())
thd->transaction.xid_state.er_xaer_rmfail(); thd->transaction->xid_state.er_xaer_rmfail();
else else
DBUG_RETURN(FALSE); DBUG_RETURN(FALSE);
@ -130,10 +130,10 @@ bool trans_begin(THD *thd, uint flags)
The following set should not be needed as transaction state should The following set should not be needed as transaction state should
already be reset. We should at some point change this to an assert. already be reset. We should at some point change this to an assert.
*/ */
thd->transaction.all.reset(); thd->transaction->all.reset();
thd->has_waiter= false; thd->has_waiter= false;
thd->waiting_on_group_commit= false; thd->waiting_on_group_commit= false;
thd->transaction.start_time.reset(thd); thd->transaction->start_time.reset(thd);
if (res) if (res)
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
@ -272,7 +272,7 @@ bool trans_commit(THD *thd)
repl_semisync_master.wait_after_commit(thd, FALSE); repl_semisync_master.wait_after_commit(thd, FALSE);
#endif #endif
thd->variables.option_bits&= ~(OPTION_BEGIN | OPTION_KEEP_LOG); thd->variables.option_bits&= ~(OPTION_BEGIN | OPTION_KEEP_LOG);
thd->transaction.all.reset(); thd->transaction->all.reset();
thd->lex->start_transaction_opt= 0; thd->lex->start_transaction_opt= 0;
/* The transaction should be marked as complete in P_S. */ /* The transaction should be marked as complete in P_S. */
@ -321,7 +321,7 @@ bool trans_commit_implicit(THD *thd)
} }
thd->variables.option_bits&= ~(OPTION_BEGIN | OPTION_KEEP_LOG); thd->variables.option_bits&= ~(OPTION_BEGIN | OPTION_KEEP_LOG);
thd->transaction.all.reset(); thd->transaction->all.reset();
/* The transaction should be marked as complete in P_S. */ /* The transaction should be marked as complete in P_S. */
DBUG_ASSERT(thd->m_transaction_psi == NULL); DBUG_ASSERT(thd->m_transaction_psi == NULL);
@ -367,7 +367,7 @@ bool trans_rollback(THD *thd)
/* Reset the binlog transaction marker */ /* Reset the binlog transaction marker */
thd->variables.option_bits&= ~(OPTION_BEGIN | OPTION_KEEP_LOG | thd->variables.option_bits&= ~(OPTION_BEGIN | OPTION_KEEP_LOG |
OPTION_GTID_BEGIN); OPTION_GTID_BEGIN);
thd->transaction.all.reset(); thd->transaction->all.reset();
thd->lex->start_transaction_opt= 0; thd->lex->start_transaction_opt= 0;
/* The transaction should be marked as complete in P_S. */ /* The transaction should be marked as complete in P_S. */
@ -405,7 +405,7 @@ bool trans_rollback_implicit(THD *thd)
Don't perform rollback in the middle of sub-statement, wait till Don't perform rollback in the middle of sub-statement, wait till
its end. its end.
*/ */
DBUG_ASSERT(thd->transaction.stmt.is_empty() && !thd->in_sub_stmt); DBUG_ASSERT(thd->transaction->stmt.is_empty() && !thd->in_sub_stmt);
thd->server_status&= ~SERVER_STATUS_IN_TRANS; thd->server_status&= ~SERVER_STATUS_IN_TRANS;
DBUG_PRINT("info", ("clearing SERVER_STATUS_IN_TRANS")); DBUG_PRINT("info", ("clearing SERVER_STATUS_IN_TRANS"));
@ -416,7 +416,7 @@ bool trans_rollback_implicit(THD *thd)
preserve backward compatibility. preserve backward compatibility.
*/ */
thd->variables.option_bits&= ~(OPTION_KEEP_LOG); thd->variables.option_bits&= ~(OPTION_KEEP_LOG);
thd->transaction.all.reset(); thd->transaction->all.reset();
/* Rollback should clear transaction_rollback_request flag. */ /* Rollback should clear transaction_rollback_request flag. */
DBUG_ASSERT(!thd->transaction_rollback_request); DBUG_ASSERT(!thd->transaction_rollback_request);
@ -458,7 +458,7 @@ bool trans_commit_stmt(THD *thd)
thd->merge_unsafe_rollback_flags(); thd->merge_unsafe_rollback_flags();
if (thd->transaction.stmt.ha_list) if (thd->transaction->stmt.ha_list)
{ {
res= ha_commit_trans(thd, FALSE); res= ha_commit_trans(thd, FALSE);
if (! thd->in_active_multi_stmt_transaction()) if (! thd->in_active_multi_stmt_transaction())
@ -493,7 +493,7 @@ bool trans_commit_stmt(THD *thd)
DBUG_ASSERT(thd->in_active_multi_stmt_transaction() || DBUG_ASSERT(thd->in_active_multi_stmt_transaction() ||
thd->m_transaction_psi == NULL); thd->m_transaction_psi == NULL);
thd->transaction.stmt.reset(); thd->transaction->stmt.reset();
DBUG_RETURN(MY_TEST(res)); DBUG_RETURN(MY_TEST(res));
} }
@ -521,7 +521,7 @@ bool trans_rollback_stmt(THD *thd)
thd->merge_unsafe_rollback_flags(); thd->merge_unsafe_rollback_flags();
if (thd->transaction.stmt.ha_list) if (thd->transaction->stmt.ha_list)
{ {
ha_rollback_trans(thd, FALSE); ha_rollback_trans(thd, FALSE);
if (! thd->in_active_multi_stmt_transaction()) if (! thd->in_active_multi_stmt_transaction())
@ -536,7 +536,7 @@ bool trans_rollback_stmt(THD *thd)
DBUG_ASSERT(thd->in_active_multi_stmt_transaction() || DBUG_ASSERT(thd->in_active_multi_stmt_transaction() ||
thd->m_transaction_psi == NULL); thd->m_transaction_psi == NULL);
thd->transaction.stmt.reset(); thd->transaction->stmt.reset();
DBUG_RETURN(FALSE); DBUG_RETURN(FALSE);
} }
@ -545,7 +545,7 @@ bool trans_rollback_stmt(THD *thd)
static SAVEPOINT ** static SAVEPOINT **
find_savepoint(THD *thd, LEX_CSTRING name) find_savepoint(THD *thd, LEX_CSTRING name)
{ {
SAVEPOINT **sv= &thd->transaction.savepoints; SAVEPOINT **sv= &thd->transaction->savepoints;
while (*sv) while (*sv)
{ {
@ -579,7 +579,7 @@ bool trans_savepoint(THD *thd, LEX_CSTRING name)
!opt_using_transactions) !opt_using_transactions)
DBUG_RETURN(FALSE); DBUG_RETURN(FALSE);
if (thd->transaction.xid_state.check_has_uncommitted_xa()) if (thd->transaction->xid_state.check_has_uncommitted_xa())
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
sv= find_savepoint(thd, name); sv= find_savepoint(thd, name);
@ -590,14 +590,14 @@ bool trans_savepoint(THD *thd, LEX_CSTRING name)
ha_release_savepoint(thd, *sv); ha_release_savepoint(thd, *sv);
*sv= (*sv)->prev; *sv= (*sv)->prev;
} }
else if ((newsv= (SAVEPOINT *) alloc_root(&thd->transaction.mem_root, else if ((newsv= (SAVEPOINT *) alloc_root(&thd->transaction->mem_root,
savepoint_alloc_size)) == NULL) savepoint_alloc_size)) == NULL)
{ {
my_error(ER_OUT_OF_RESOURCES, MYF(0)); my_error(ER_OUT_OF_RESOURCES, MYF(0));
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
} }
newsv->name= strmake_root(&thd->transaction.mem_root, name.str, name.length); newsv->name= strmake_root(&thd->transaction->mem_root, name.str, name.length);
newsv->length= (uint)name.length; newsv->length= (uint)name.length;
/* /*
@ -608,8 +608,8 @@ bool trans_savepoint(THD *thd, LEX_CSTRING name)
if (unlikely(ha_savepoint(thd, newsv))) if (unlikely(ha_savepoint(thd, newsv)))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
newsv->prev= thd->transaction.savepoints; newsv->prev= thd->transaction->savepoints;
thd->transaction.savepoints= newsv; thd->transaction->savepoints= newsv;
/* /*
Remember locks acquired before the savepoint was set. Remember locks acquired before the savepoint was set.
@ -655,7 +655,7 @@ bool trans_rollback_to_savepoint(THD *thd, LEX_CSTRING name)
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
} }
if (thd->transaction.xid_state.check_has_uncommitted_xa()) if (thd->transaction->xid_state.check_has_uncommitted_xa())
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
/** /**
@ -688,13 +688,13 @@ bool trans_rollback_to_savepoint(THD *thd, LEX_CSTRING name)
if (ha_rollback_to_savepoint(thd, sv)) if (ha_rollback_to_savepoint(thd, sv))
res= TRUE; res= TRUE;
else if (((thd->variables.option_bits & OPTION_KEEP_LOG) || else if (((thd->variables.option_bits & OPTION_KEEP_LOG) ||
thd->transaction.all.modified_non_trans_table) && thd->transaction->all.modified_non_trans_table) &&
!thd->slave_thread) !thd->slave_thread)
push_warning(thd, Sql_condition::WARN_LEVEL_WARN, push_warning(thd, Sql_condition::WARN_LEVEL_WARN,
ER_WARNING_NOT_COMPLETE_ROLLBACK, ER_WARNING_NOT_COMPLETE_ROLLBACK,
ER_THD(thd, ER_WARNING_NOT_COMPLETE_ROLLBACK)); ER_THD(thd, ER_WARNING_NOT_COMPLETE_ROLLBACK));
thd->transaction.savepoints= sv; thd->transaction->savepoints= sv;
if (!res && mdl_can_safely_rollback_to_savepoint) if (!res && mdl_can_safely_rollback_to_savepoint)
thd->mdl_context.rollback_to_savepoint(sv->mdl_savepoint); thd->mdl_context.rollback_to_savepoint(sv->mdl_savepoint);
@ -732,7 +732,7 @@ bool trans_release_savepoint(THD *thd, LEX_CSTRING name)
if (ha_release_savepoint(thd, sv)) if (ha_release_savepoint(thd, sv))
res= TRUE; res= TRUE;
thd->transaction.savepoints= sv->prev; thd->transaction->savepoints= sv->prev;
DBUG_RETURN(MY_TEST(res)); DBUG_RETURN(MY_TEST(res));
} }

2
sql/wsrep_applier.cc
View File

@ -191,7 +191,7 @@ int wsrep_apply_events(THD* thd,
/* Use the original server id for logging. */ /* Use the original server id for logging. */
thd->set_server_id(ev->server_id); thd->set_server_id(ev->server_id);
thd->set_time(); // time the query thd->set_time(); // time the query
thd->transaction.start_time.reset(thd); thd->transaction->start_time.reset(thd);
thd->lex->current_select= 0; thd->lex->current_select= 0;
if (!ev->when) if (!ev->when)
{ {

2
sql/wsrep_trans_observer.h
View File

@ -82,7 +82,7 @@ static inline bool wsrep_not_committed(THD* thd)
*/ */
static inline bool wsrep_is_real(THD* thd, bool all) static inline bool wsrep_is_real(THD* thd, bool all)
{ {
return (all || thd->transaction.all.ha_list == 0); return (all || thd->transaction->all.ha_list == 0);
} }
/* /*

90
sql/xa.cc
View File

@ -397,11 +397,11 @@ bool xa_trans_force_rollback(THD *thd)
} }
thd->variables.option_bits&= thd->variables.option_bits&=
~(OPTION_BEGIN | OPTION_KEEP_LOG | OPTION_GTID_BEGIN); ~(OPTION_BEGIN | OPTION_KEEP_LOG | OPTION_GTID_BEGIN);
thd->transaction.all.reset(); thd->transaction->all.reset();
thd->server_status&= thd->server_status&=
~(SERVER_STATUS_IN_TRANS | SERVER_STATUS_IN_TRANS_READONLY); ~(SERVER_STATUS_IN_TRANS | SERVER_STATUS_IN_TRANS_READONLY);
DBUG_PRINT("info", ("clearing SERVER_STATUS_IN_TRANS")); DBUG_PRINT("info", ("clearing SERVER_STATUS_IN_TRANS"));
xid_cache_delete(thd, &thd->transaction.xid_state); xid_cache_delete(thd, &thd->transaction->xid_state);
trans_track_end_trx(thd); trans_track_end_trx(thd);
@ -422,17 +422,17 @@ bool trans_xa_start(THD *thd)
{ {
DBUG_ENTER("trans_xa_start"); DBUG_ENTER("trans_xa_start");
if (thd->transaction.xid_state.is_explicit_XA() && if (thd->transaction->xid_state.is_explicit_XA() &&
thd->transaction.xid_state.xid_cache_element->xa_state == XA_IDLE && thd->transaction->xid_state.xid_cache_element->xa_state == XA_IDLE &&
thd->lex->xa_opt == XA_RESUME) thd->lex->xa_opt == XA_RESUME)
{ {
bool not_equal= bool not_equal=
!thd->transaction.xid_state.xid_cache_element->xid.eq(thd->lex->xid); !thd->transaction->xid_state.xid_cache_element->xid.eq(thd->lex->xid);
if (not_equal) if (not_equal)
my_error(ER_XAER_NOTA, MYF(0)); my_error(ER_XAER_NOTA, MYF(0));
else else
{ {
thd->transaction.xid_state.xid_cache_element->xa_state= XA_ACTIVE; thd->transaction->xid_state.xid_cache_element->xa_state= XA_ACTIVE;
MYSQL_SET_TRANSACTION_XA_STATE(thd->m_transaction_psi, XA_ACTIVE); MYSQL_SET_TRANSACTION_XA_STATE(thd->m_transaction_psi, XA_ACTIVE);
} }
DBUG_RETURN(not_equal); DBUG_RETURN(not_equal);
@ -443,14 +443,14 @@ bool trans_xa_start(THD *thd)
my_error(ER_XAER_INVAL, MYF(0)); my_error(ER_XAER_INVAL, MYF(0));
else if (!thd->lex->xid->gtrid_length) else if (!thd->lex->xid->gtrid_length)
my_error(ER_XAER_INVAL, MYF(0)); my_error(ER_XAER_INVAL, MYF(0));
else if (thd->transaction.xid_state.is_explicit_XA()) else if (thd->transaction->xid_state.is_explicit_XA())
thd->transaction.xid_state.er_xaer_rmfail(); thd->transaction->xid_state.er_xaer_rmfail();
else if (thd->locked_tables_mode || thd->in_active_multi_stmt_transaction()) else if (thd->locked_tables_mode || thd->in_active_multi_stmt_transaction())
my_error(ER_XAER_OUTSIDE, MYF(0)); my_error(ER_XAER_OUTSIDE, MYF(0));
else if (!trans_begin(thd)) else if (!trans_begin(thd))
{ {
MYSQL_SET_TRANSACTION_XID(thd->m_transaction_psi, thd->lex->xid, XA_ACTIVE); MYSQL_SET_TRANSACTION_XID(thd->m_transaction_psi, thd->lex->xid, XA_ACTIVE);
if (xid_cache_insert(thd, &thd->transaction.xid_state, thd->lex->xid)) if (xid_cache_insert(thd, &thd->transaction->xid_state, thd->lex->xid))
{ {
trans_rollback(thd); trans_rollback(thd);
DBUG_RETURN(true); DBUG_RETURN(true);
@ -478,19 +478,19 @@ bool trans_xa_end(THD *thd)
/* TODO: SUSPEND and FOR MIGRATE are not supported yet. */ /* TODO: SUSPEND and FOR MIGRATE are not supported yet. */
if (thd->lex->xa_opt != XA_NONE) if (thd->lex->xa_opt != XA_NONE)
my_error(ER_XAER_INVAL, MYF(0)); my_error(ER_XAER_INVAL, MYF(0));
else if (!thd->transaction.xid_state.is_explicit_XA() || else if (!thd->transaction->xid_state.is_explicit_XA() ||
thd->transaction.xid_state.xid_cache_element->xa_state != XA_ACTIVE) thd->transaction->xid_state.xid_cache_element->xa_state != XA_ACTIVE)
thd->transaction.xid_state.er_xaer_rmfail(); thd->transaction->xid_state.er_xaer_rmfail();
else if (!thd->transaction.xid_state.xid_cache_element->xid.eq(thd->lex->xid)) else if (!thd->transaction->xid_state.xid_cache_element->xid.eq(thd->lex->xid))
my_error(ER_XAER_NOTA, MYF(0)); my_error(ER_XAER_NOTA, MYF(0));
else if (!xa_trans_rolled_back(thd->transaction.xid_state.xid_cache_element)) else if (!xa_trans_rolled_back(thd->transaction->xid_state.xid_cache_element))
{ {
thd->transaction.xid_state.xid_cache_element->xa_state= XA_IDLE; thd->transaction->xid_state.xid_cache_element->xa_state= XA_IDLE;
MYSQL_SET_TRANSACTION_XA_STATE(thd->m_transaction_psi, XA_IDLE); MYSQL_SET_TRANSACTION_XA_STATE(thd->m_transaction_psi, XA_IDLE);
} }
DBUG_RETURN(thd->is_error() || DBUG_RETURN(thd->is_error() ||
thd->transaction.xid_state.xid_cache_element->xa_state != XA_IDLE); thd->transaction->xid_state.xid_cache_element->xa_state != XA_IDLE);
} }
@ -509,10 +509,10 @@ bool trans_xa_prepare(THD *thd)
DBUG_ENTER("trans_xa_prepare"); DBUG_ENTER("trans_xa_prepare");
if (!thd->transaction.xid_state.is_explicit_XA() || if (!thd->transaction->xid_state.is_explicit_XA() ||
thd->transaction.xid_state.xid_cache_element->xa_state != XA_IDLE) thd->transaction->xid_state.xid_cache_element->xa_state != XA_IDLE)
thd->transaction.xid_state.er_xaer_rmfail(); thd->transaction->xid_state.er_xaer_rmfail();
else if (!thd->transaction.xid_state.xid_cache_element->xid.eq(thd->lex->xid)) else if (!thd->transaction->xid_state.xid_cache_element->xid.eq(thd->lex->xid))
my_error(ER_XAER_NOTA, MYF(0)); my_error(ER_XAER_NOTA, MYF(0));
else else
{ {
@ -533,15 +533,15 @@ bool trans_xa_prepare(THD *thd)
if (!mdl_request.ticket) if (!mdl_request.ticket)
ha_rollback_trans(thd, TRUE); ha_rollback_trans(thd, TRUE);
thd->variables.option_bits&= ~(OPTION_BEGIN | OPTION_KEEP_LOG); thd->variables.option_bits&= ~(OPTION_BEGIN | OPTION_KEEP_LOG);
thd->transaction.all.reset(); thd->transaction->all.reset();
thd->server_status&= thd->server_status&=
~(SERVER_STATUS_IN_TRANS | SERVER_STATUS_IN_TRANS_READONLY); ~(SERVER_STATUS_IN_TRANS | SERVER_STATUS_IN_TRANS_READONLY);
xid_cache_delete(thd, &thd->transaction.xid_state); xid_cache_delete(thd, &thd->transaction->xid_state);
my_error(ER_XA_RBROLLBACK, MYF(0)); my_error(ER_XA_RBROLLBACK, MYF(0));
} }
else else
{ {
thd->transaction.xid_state.xid_cache_element->xa_state= XA_PREPARED; thd->transaction->xid_state.xid_cache_element->xa_state= XA_PREPARED;
MYSQL_SET_TRANSACTION_XA_STATE(thd->m_transaction_psi, XA_PREPARED); MYSQL_SET_TRANSACTION_XA_STATE(thd->m_transaction_psi, XA_PREPARED);
res= thd->variables.pseudo_slave_mode || thd->slave_thread ? res= thd->variables.pseudo_slave_mode || thd->slave_thread ?
slave_applier_reset_xa_trans(thd) : 0; slave_applier_reset_xa_trans(thd) : 0;
@ -564,7 +564,7 @@ bool trans_xa_prepare(THD *thd)
bool trans_xa_commit(THD *thd) bool trans_xa_commit(THD *thd)
{ {
bool res= true; bool res= true;
XID_STATE &xid_state= thd->transaction.xid_state; XID_STATE &xid_state= thd->transaction->xid_state;
DBUG_ENTER("trans_xa_commit"); DBUG_ENTER("trans_xa_commit");
@ -655,7 +655,7 @@ bool trans_xa_commit(THD *thd)
if ((res= MY_TEST(r))) if ((res= MY_TEST(r)))
my_error(r == 1 ? ER_XA_RBROLLBACK : ER_XAER_RMERR, MYF(0)); my_error(r == 1 ? ER_XA_RBROLLBACK : ER_XAER_RMERR, MYF(0));
} }
else if (thd->transaction.xid_state.xid_cache_element->xa_state == XA_PREPARED) else if (thd->transaction->xid_state.xid_cache_element->xa_state == XA_PREPARED)
{ {
MDL_request mdl_request; MDL_request mdl_request;
if (thd->lex->xa_opt != XA_NONE) if (thd->lex->xa_opt != XA_NONE)
@ -710,7 +710,7 @@ bool trans_xa_commit(THD *thd)
} }
thd->variables.option_bits&= ~(OPTION_BEGIN | OPTION_KEEP_LOG); thd->variables.option_bits&= ~(OPTION_BEGIN | OPTION_KEEP_LOG);
thd->transaction.all.reset(); thd->transaction->all.reset();
thd->server_status&= thd->server_status&=
~(SERVER_STATUS_IN_TRANS | SERVER_STATUS_IN_TRANS_READONLY); ~(SERVER_STATUS_IN_TRANS | SERVER_STATUS_IN_TRANS_READONLY);
DBUG_PRINT("info", ("clearing SERVER_STATUS_IN_TRANS")); DBUG_PRINT("info", ("clearing SERVER_STATUS_IN_TRANS"));
@ -734,7 +734,7 @@ bool trans_xa_commit(THD *thd)
bool trans_xa_rollback(THD *thd) bool trans_xa_rollback(THD *thd)
{ {
XID_STATE &xid_state= thd->transaction.xid_state; XID_STATE &xid_state= thd->transaction->xid_state;
DBUG_ENTER("trans_xa_rollback"); DBUG_ENTER("trans_xa_rollback");
@ -817,22 +817,22 @@ bool trans_xa_rollback(THD *thd)
bool trans_xa_detach(THD *thd) bool trans_xa_detach(THD *thd)
{ {
DBUG_ASSERT(thd->transaction.xid_state.is_explicit_XA()); DBUG_ASSERT(thd->transaction->xid_state.is_explicit_XA());
if (thd->transaction.xid_state.xid_cache_element->xa_state != XA_PREPARED) if (thd->transaction->xid_state.xid_cache_element->xa_state != XA_PREPARED)
return xa_trans_force_rollback(thd); return xa_trans_force_rollback(thd);
else if (!thd->transaction.all.is_trx_read_write()) else if (!thd->transaction->all.is_trx_read_write())
{ {
thd->transaction.xid_state.set_error(ER_XA_RBROLLBACK); thd->transaction->xid_state.set_error(ER_XA_RBROLLBACK);
ha_rollback_trans(thd, true); ha_rollback_trans(thd, true);
} }
thd->transaction.xid_state.xid_cache_element->acquired_to_recovered(); thd->transaction->xid_state.xid_cache_element->acquired_to_recovered();
thd->transaction.xid_state.xid_cache_element= 0; thd->transaction->xid_state.xid_cache_element= 0;
thd->transaction.cleanup(); thd->transaction->cleanup();
Ha_trx_info *ha_info, *ha_info_next; Ha_trx_info *ha_info, *ha_info_next;
for (ha_info= thd->transaction.all.ha_list; for (ha_info= thd->transaction->all.ha_list;
ha_info; ha_info;
ha_info= ha_info_next) ha_info= ha_info_next)
{ {
@ -840,8 +840,8 @@ bool trans_xa_detach(THD *thd)
ha_info->reset(); /* keep it conveniently zero-filled */ ha_info->reset(); /* keep it conveniently zero-filled */
} }
thd->transaction.all.ha_list= 0; thd->transaction->all.ha_list= 0;
thd->transaction.all.no_2pc= 0; thd->transaction->all.no_2pc= 0;
return false; return false;
} }
@ -1055,23 +1055,23 @@ static bool slave_applier_reset_xa_trans(THD *thd)
~(SERVER_STATUS_IN_TRANS | SERVER_STATUS_IN_TRANS_READONLY); ~(SERVER_STATUS_IN_TRANS | SERVER_STATUS_IN_TRANS_READONLY);
DBUG_PRINT("info", ("clearing SERVER_STATUS_IN_TRANS")); DBUG_PRINT("info", ("clearing SERVER_STATUS_IN_TRANS"));
thd->transaction.xid_state.xid_cache_element->acquired_to_recovered(); thd->transaction->xid_state.xid_cache_element->acquired_to_recovered();
thd->transaction.xid_state.xid_cache_element= 0; thd->transaction->xid_state.xid_cache_element= 0;
for (Ha_trx_info *ha_info= thd->transaction.all.ha_list, *ha_info_next; for (Ha_trx_info *ha_info= thd->transaction->all.ha_list, *ha_info_next;
ha_info; ha_info= ha_info_next) ha_info; ha_info= ha_info_next)
{ {
ha_info_next= ha_info->next(); ha_info_next= ha_info->next();
ha_info->reset(); ha_info->reset();
} }
thd->transaction.all.ha_list= 0; thd->transaction->all.ha_list= 0;
ha_close_connection(thd); ha_close_connection(thd);
thd->transaction.cleanup(); thd->transaction->cleanup();
thd->transaction.all.reset(); thd->transaction->all.reset();
DBUG_ASSERT(!thd->transaction.all.ha_list); DBUG_ASSERT(!thd->transaction->all.ha_list);
DBUG_ASSERT(!thd->transaction.all.no_2pc); DBUG_ASSERT(!thd->transaction->all.no_2pc);
thd->has_waiter= false; thd->has_waiter= false;
MYSQL_COMMIT_TRANSACTION(thd->m_transaction_psi); // TODO/Fixme: commit? MYSQL_COMMIT_TRANSACTION(thd->m_transaction_psi); // TODO/Fixme: commit?

6
storage/maria/ha_maria.cc
View File

@ -959,7 +959,7 @@ static int maria_create_trn_for_mysql(MARIA_HA *info)
if (!trn) /* no transaction yet - open it now */ if (!trn) /* no transaction yet - open it now */
{ {
trn= trnman_new_trn(& thd->transaction.wt); trn= trnman_new_trn(& thd->transaction->wt);
if (unlikely(!trn)) if (unlikely(!trn))
DBUG_RETURN(HA_ERR_OUT_OF_MEM); DBUG_RETURN(HA_ERR_OUT_OF_MEM);
thd_set_ha_data(thd, maria_hton, trn); thd_set_ha_data(thd, maria_hton, trn);
@ -2772,7 +2772,7 @@ int ha_maria::external_lock(THD *thd, int lock_type)
trnman_increment_locked_tables(file->trn); trnman_increment_locked_tables(file->trn);
} }
if (!thd->transaction.on) if (!thd->transaction->on)
{ {
/* /*
No need to log REDOs/UNDOs. If this is an internal temporary table No need to log REDOs/UNDOs. If this is an internal temporary table
@ -2983,7 +2983,7 @@ int ha_maria::implicit_commit(THD *thd, bool new_trn)
tables may be under LOCK TABLES, and so they will start the next tables may be under LOCK TABLES, and so they will start the next
statement assuming they have a trn (see ha_maria::start_stmt()). statement assuming they have a trn (see ha_maria::start_stmt()).
*/ */
trn= trnman_new_trn(& thd->transaction.wt); trn= trnman_new_trn(& thd->transaction->wt);
thd_set_ha_data(thd, maria_hton, trn); thd_set_ha_data(thd, maria_hton, trn);
if (unlikely(trn == NULL)) if (unlikely(trn == NULL))
{ {

2
storage/spider/spd_db_conn.cc
View File

@ -10219,7 +10219,7 @@ int spider_db_udf_direct_sql(
need_trx_end = TRUE; need_trx_end = TRUE;
} else { } else {
#endif #endif
if (c_thd->transaction.stmt.ha_list) if (c_thd->transaction->stmt.ha_list)
need_trx_end = FALSE; need_trx_end = FALSE;
else else
need_trx_end = TRUE; need_trx_end = TRUE;

8
storage/spider/spd_direct_sql.cc
View File

@ -1813,7 +1813,7 @@ long long spider_direct_sql_body(
if (conn->bg_init) if (conn->bg_init)
pthread_mutex_unlock(&conn->bg_conn_mutex); pthread_mutex_unlock(&conn->bg_conn_mutex);
if (direct_sql->modified_non_trans_table) if (direct_sql->modified_non_trans_table)
thd->transaction.stmt.modified_non_trans_table = TRUE; thd->transaction->stmt.modified_non_trans_table = TRUE;
if (error_num == HA_ERR_OUT_OF_MEM) if (error_num == HA_ERR_OUT_OF_MEM)
my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM); my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
goto error; goto error;
@ -1821,7 +1821,7 @@ long long spider_direct_sql_body(
if (conn->bg_init) if (conn->bg_init)
pthread_mutex_unlock(&conn->bg_conn_mutex); pthread_mutex_unlock(&conn->bg_conn_mutex);
if (direct_sql->modified_non_trans_table) if (direct_sql->modified_non_trans_table)
thd->transaction.stmt.modified_non_trans_table = TRUE; thd->transaction->stmt.modified_non_trans_table = TRUE;
#ifndef WITHOUT_SPIDER_BG_SEARCH #ifndef WITHOUT_SPIDER_BG_SEARCH
} }
if (!bg) if (!bg)
@ -1930,7 +1930,7 @@ void spider_direct_sql_deinit_body(
if (bg_direct_sql->modified_non_trans_table) if (bg_direct_sql->modified_non_trans_table)
{ {
THD *thd = current_thd; THD *thd = current_thd;
thd->transaction.stmt.modified_non_trans_table = TRUE; thd->transaction->stmt.modified_non_trans_table = TRUE;
} }
pthread_cond_destroy(&bg_direct_sql->bg_cond); pthread_cond_destroy(&bg_direct_sql->bg_cond);
pthread_mutex_destroy(&bg_direct_sql->bg_mutex); pthread_mutex_destroy(&bg_direct_sql->bg_mutex);
@ -1961,7 +1961,7 @@ long long spider_direct_sql_bg_end(
pthread_cond_wait(&bg_direct_sql->bg_cond, &bg_direct_sql->bg_mutex); pthread_cond_wait(&bg_direct_sql->bg_cond, &bg_direct_sql->bg_mutex);
pthread_mutex_unlock(&bg_direct_sql->bg_mutex); pthread_mutex_unlock(&bg_direct_sql->bg_mutex);
if (bg_direct_sql->modified_non_trans_table) if (bg_direct_sql->modified_non_trans_table)
thd->transaction.stmt.modified_non_trans_table = TRUE; thd->transaction->stmt.modified_non_trans_table = TRUE;
if (bg_direct_sql->bg_error) if (bg_direct_sql->bg_error)
{ {
my_message(bg_direct_sql->bg_error, bg_direct_sql->bg_error_msg, MYF(0)); my_message(bg_direct_sql->bg_error, bg_direct_sql->bg_error_msg, MYF(0));

2
storage/spider/spd_trx.cc
View File

@ -1939,7 +1939,7 @@ int spider_internal_start_trx(
if (!trx->trx_start) if (!trx->trx_start)
{ {
if ( if (
thd->transaction.xid_state.is_explicit_XA() && thd->transaction->xid_state.is_explicit_XA() &&
spider_param_support_xa() spider_param_support_xa()
) { ) {
trx->trx_xa = TRUE; trx->trx_xa = TRUE;