/**********************************************************************//**
Prints info about a transaction to the given file. The caller must own the
kernel mutex. */
UNIV_INTERN
void
trx_print(
/*======*/
FILE* f, /*!< in: output stream */
trx_t* trx, /*!< in: transaction */
ulint max_query_len) /*!< in: max query length to print, or 0 to
use the default max length */
{
ibool newline;
fprintf(f, "TRANSACTION " TRX_ID_FMT, TRX_ID_PREP_PRINTF(trx->id));
switch (trx->conc_state) {
case TRX_NOT_STARTED:
fputs(", not started", f);
break;
case TRX_ACTIVE:
fprintf(f, ", ACTIVE %lu sec",
(ulong)difftime(time(NULL), trx->start_time));
break;
case TRX_PREPARED:
fprintf(f, ", ACTIVE (PREPARED) %lu sec",
(ulong)difftime(time(NULL), trx->start_time));
break;
case TRX_COMMITTED_IN_MEMORY:
fputs(", COMMITTED IN MEMORY", f);
break;
default:
fprintf(f, " state %lu", (ulong) trx->conc_state);
}
#ifdef UNIV_LINUX
fprintf(f, ", process no %lu", trx->mysql_process_no);
#endif
fprintf(f, ", OS thread id %lu",
(ulong) os_thread_pf(trx->mysql_thread_id));
if (*trx->op_info) {
putc(' ', f);
fputs(trx->op_info, f);
}
if (trx->is_recovered) {
fputs(" recovered trx", f);
}
if (trx->is_purge) {
fputs(" purge trx", f);
}
if (trx->declared_to_be_inside_innodb) {
fprintf(f, ", thread declared inside InnoDB %lu",
(ulong) trx->n_tickets_to_enter_innodb);
}
putc('\n', f);
if (trx->n_mysql_tables_in_use > 0 || trx->mysql_n_tables_locked > 0) {
fprintf(f, "mysql tables in use %lu, locked %lu\n",
(ulong) trx->n_mysql_tables_in_use,
(ulong) trx->mysql_n_tables_locked);
}
newline = TRUE;
switch (trx->que_state) {
case TRX_QUE_RUNNING:
newline = FALSE; break;
case TRX_QUE_LOCK_WAIT:
fputs("LOCK WAIT ", f); break;
case TRX_QUE_ROLLING_BACK:
fputs("ROLLING BACK ", f); break;
case TRX_QUE_COMMITTING:
fputs("COMMITTING ", f); break;
default:
fprintf(f, "que state %lu ", (ulong) trx->que_state);
}
if (0 < UT_LIST_GET_LEN(trx->trx_locks)
|| mem_heap_get_size(trx->lock_heap) > 400) {
newline = TRUE;
fprintf(f, "%lu lock struct(s), heap size %lu,"
" %lu row lock(s)",
(ulong) UT_LIST_GET_LEN(trx->trx_locks),
(ulong) mem_heap_get_size(trx->lock_heap),
(ulong) lock_number_of_rows_locked(trx));
}
if (trx->has_search_latch) {
newline = TRUE;
fputs(", holds adaptive hash latch", f);
}
if (!ut_dulint_is_zero(trx->undo_no)) {
newline = TRUE;
fprintf(f, ", undo log entries %lu",
(ulong) ut_dulint_get_low(trx->undo_no));
}
if (newline) {
putc('\n', f);
}
if (trx->mysql_thd != NULL) {
innobase_mysql_print_thd(f, trx->mysql_thd, max_query_len);
}
}
/*******************************************************************//**
Fills i_s_trx_row_t object.
If memory can not be allocated then FALSE is returned.
@return FALSE if allocation fails */
static
ibool
fill_trx_row(
/*=========*/
i_s_trx_row_t* row, /*!< out: result object
that's filled */
const trx_t* trx, /*!< in: transaction to
get data from */
const i_s_locks_row_t* requested_lock_row,/*!< in: pointer to the
corresponding row in
innodb_locks if trx is
waiting or NULL if trx
is not waiting */
trx_i_s_cache_t* cache) /*!< in/out: cache into
which to copy volatile
strings */
{
const char* stmt;
size_t stmt_len;
const char* s;
ut_ad(mutex_own(&kernel_mutex));
row->trx_id = trx->id;
row->trx_started = (ib_time_t) trx->start_time;
row->trx_state = trx_get_que_state_str(trx);
row->requested_lock_row = requested_lock_row;
ut_ad(requested_lock_row == NULL
|| i_s_locks_row_validate(requested_lock_row));
if (trx->wait_lock != NULL) {
ut_a(requested_lock_row != NULL);
row->trx_wait_started = (ib_time_t) trx->wait_started;
} else {
ut_a(requested_lock_row == NULL);
row->trx_wait_started = 0;
}
row->trx_weight = (ullint) TRX_WEIGHT(trx);
if (trx->mysql_thd == NULL) {
/* For internal transactions e.g., purge and transactions
being recovered at startup there is no associated MySQL
thread data structure. */
row->trx_mysql_thread_id = 0;
row->trx_query = NULL;
goto thd_done;
}
row->trx_mysql_thread_id = thd_get_thread_id(trx->mysql_thd);
stmt = innobase_get_stmt(trx->mysql_thd, &stmt_len);
if (stmt != NULL) {
char query[TRX_I_S_TRX_QUERY_MAX_LEN + 1];
if (stmt_len > TRX_I_S_TRX_QUERY_MAX_LEN) {
stmt_len = TRX_I_S_TRX_QUERY_MAX_LEN;
}
memcpy(query, stmt, stmt_len);
query[stmt_len] = '\0';
row->trx_query = ha_storage_put_memlim(
cache->storage, query, stmt_len + 1,
MAX_ALLOWED_FOR_STORAGE(cache));
row->trx_query_cs = innobase_get_charset(trx->mysql_thd);
if (row->trx_query == NULL) {
return(FALSE);
}
} else {
row->trx_query = NULL;
}
thd_done:
s = trx->op_info;
if (s != NULL && s[0] != '\0') {
TRX_I_S_STRING_COPY(s, row->trx_operation_state,
TRX_I_S_TRX_OP_STATE_MAX_LEN, cache);
if (row->trx_operation_state == NULL) {
return(FALSE);
}
} else {
row->trx_operation_state = NULL;
}
row->trx_tables_in_use = trx->n_mysql_tables_in_use;
row->trx_tables_locked = trx->mysql_n_tables_locked;
row->trx_lock_structs = UT_LIST_GET_LEN(trx->trx_locks);
row->trx_lock_memory_bytes = mem_heap_get_size(trx->lock_heap);
row->trx_rows_locked = lock_number_of_rows_locked(trx);
row->trx_rows_modified = trx->undo_no;
row->trx_concurrency_tickets = trx->n_tickets_to_enter_innodb;
switch (trx->isolation_level) {
case TRX_ISO_READ_UNCOMMITTED:
row->trx_isolation_level = "READ UNCOMMITTED";
break;
case TRX_ISO_READ_COMMITTED:
row->trx_isolation_level = "READ COMMITTED";
break;
case TRX_ISO_REPEATABLE_READ:
row->trx_isolation_level = "REPEATABLE READ";
break;
case TRX_ISO_SERIALIZABLE:
row->trx_isolation_level = "SERIALIZABLE";
break;
/* Should not happen as TRX_ISO_READ_COMMITTED is default */
default:
row->trx_isolation_level = "UNKNOWN";
}
row->trx_unique_checks = (ibool) trx->check_unique_secondary;
row->trx_foreign_key_checks = (ibool) trx->check_foreigns;
s = trx->detailed_error;
if (s != NULL && s[0] != '\0') {
TRX_I_S_STRING_COPY(s,
row->trx_foreign_key_error,
TRX_I_S_TRX_FK_ERROR_MAX_LEN, cache);
if (row->trx_foreign_key_error == NULL) {
return(FALSE);
}
} else {
row->trx_foreign_key_error = NULL;
}
row->trx_has_search_latch = (ibool) trx->has_search_latch;
row->trx_search_latch_timeout = trx->search_latch_timeout;
return(TRUE);
}
