4493d40a-92aa-4162-9dfc-bfc4ec0996e6
/
polardbxengine
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
polardbxengine/storage/perfschema/table_data_locks.cc

372 lines
11 KiB
C++
Raw Blame History

/* Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is also distributed with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have included with MySQL.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
/**
@file storage/perfschema/table_data_locks.cc
Table DATA_LOCKS (implementation).
*/
#include "storage/perfschema/table_data_locks.h"
#include <stddef.h>
#include "my_compiler.h"
#include "my_dbug.h"
#include "my_inttypes.h"
#include "my_thread.h"
#include "sql/field.h"
#include "sql/plugin_table.h"
#include "sql/table.h"
#include "storage/perfschema/pfs_buffer_container.h"
#include "storage/perfschema/pfs_column_types.h"
#include "storage/perfschema/pfs_column_values.h"
#include "storage/perfschema/pfs_global.h"
#include "storage/perfschema/pfs_instr.h"
THR_LOCK table_data_locks::m_table_lock;
Plugin_table table_data_locks::m_table_def(
/* Schema name */
"performance_schema",
/* Name */
"data_locks",
/* Definition */
" ENGINE VARCHAR(32) not null,\n"
" ENGINE_LOCK_ID VARCHAR(128) not null,\n"
" ENGINE_TRANSACTION_ID BIGINT unsigned,\n"
" THREAD_ID BIGINT unsigned,\n"
" EVENT_ID BIGINT unsigned,\n"
" OBJECT_SCHEMA VARCHAR(64),\n"
" OBJECT_NAME VARCHAR(64),\n"
" PARTITION_NAME VARCHAR(64),\n"
" SUBPARTITION_NAME VARCHAR(64),\n"
" INDEX_NAME VARCHAR(64),\n"
" OBJECT_INSTANCE_BEGIN BIGINT unsigned not null,\n"
" LOCK_TYPE VARCHAR(32) not null,\n"
" LOCK_MODE VARCHAR(32) not null,\n"
" LOCK_STATUS VARCHAR(32) not null,\n"
" LOCK_DATA VARCHAR(8192) CHARACTER SET utf8mb4,\n"
" PRIMARY KEY (ENGINE_LOCK_ID, ENGINE) USING HASH,\n"
" KEY (ENGINE_TRANSACTION_ID, ENGINE) USING HASH,\n"
" KEY (THREAD_ID, EVENT_ID) USING HASH,\n"
" KEY (OBJECT_SCHEMA, OBJECT_NAME, PARTITION_NAME,\n"
" SUBPARTITION_NAME) USING HASH\n",
/* Options */
" ENGINE=PERFORMANCE_SCHEMA",
/* Tablespace */
nullptr);
PFS_engine_table_share table_data_locks::m_share = {
&pfs_readonly_acl,
table_data_locks::create,
NULL, /* write_row */
NULL, /* delete_all_rows */
table_data_locks::get_row_count,
sizeof(pk_pos_t),
&m_table_lock,
&m_table_def,
false, /* perpetual */
PFS_engine_table_proxy(),
{0},
false /* m_in_purgatory */
};
PFS_engine_table *table_data_locks::create(PFS_engine_table_share *) {
return new table_data_locks();
}
ha_rows table_data_locks::get_row_count(void) {
// FIXME
return 99999;
}
table_data_locks::table_data_locks()
: PFS_engine_table(&m_share, &m_pk_pos),
m_row(NULL),
m_pos(),
m_next_pos(),
m_pk_pos() {
for (unsigned int i = 0; i < COUNT_DATA_LOCK_ENGINES; i++) {
m_iterator[i] = NULL;
}
}
void table_data_locks::destroy_iterators() {
for (unsigned int i = 0; i < COUNT_DATA_LOCK_ENGINES; i++) {
if (m_iterator[i] != NULL) {
g_data_lock_inspector[i]->destroy_data_lock_iterator(m_iterator[i]);
m_iterator[i] = NULL;
}
}
}
table_data_locks::~table_data_locks() { destroy_iterators(); }
void table_data_locks::reset_position(void) {
m_pos.reset();
m_next_pos.reset();
m_pk_pos.reset();
m_container.clear();
destroy_iterators();
}
int table_data_locks::rnd_next(void) {
row_data_lock *data;
for (m_pos.set_at(&m_next_pos); m_pos.has_more_engine();
m_pos.next_engine()) {
unsigned int index = m_pos.m_index_1;
if (m_iterator[index] == NULL) {
if (g_data_lock_inspector[index] == NULL) {
continue;
}
m_iterator[index] =
g_data_lock_inspector[index]->create_data_lock_iterator();
if (m_iterator[index] == NULL) {
continue;
}
}
bool iterator_done = false;
PSI_engine_data_lock_iterator *it = m_iterator[index];
for (;;) {
data = m_container.get_row(m_pos.m_index_2);
if (data != NULL) {
m_row = data;
m_next_pos.set_after(&m_pos);
m_pk_pos.set(&m_row->m_hidden_pk);
return 0;
}
if (iterator_done) {
break;
}
m_container.shrink();
/*
TODO: avoid requesting column LOCK_DATA if not used.
*/
/*
PSI_engine_data_lock_iterator::scan() can return an unbounded number
of rows during a scan, depending on the application payload, as some
user sessions may have an unbounded number or records locked.
This can cause severe memory spike, which in turn can take the server
down if not handled properly. Here a select on the table
performance_schema.data_locks will fail with an error, instead of
taking the server down, if out of memory conditions occur.
This is a fail safe only, the implementation of
PSI_engine_data_lock_iterator::scan() in each storage engine
should be constrained to return fewer rows at a time if necessary,
by making more calls to scan(), to handle the load gracefully.
*/
try {
DBUG_EXECUTE_IF("simulate_bad_alloc_exception_1",
throw std::bad_alloc(););
iterator_done = it->scan(&m_container, true);
} catch (const std::bad_alloc &) {
my_error(ER_STD_BAD_ALLOC_ERROR, MYF(0),
"while scanning data_locks table", "rnd_next");
return ER_STD_BAD_ALLOC_ERROR;
}
}
}
return HA_ERR_END_OF_FILE;
}
int table_data_locks::rnd_pos(const void *pos) {
row_data_lock *data;
set_position(pos);
/*
TODO: Multiple engine support.
Find the proper engine based on column ENGINE.
*/
static_assert(COUNT_DATA_LOCK_ENGINES == 1,
"We don't support multiple engines yet.");
unsigned int index = 0;
if (m_iterator[index] == NULL) {
if (g_data_lock_inspector[index] == NULL) {
return HA_ERR_RECORD_DELETED;
}
m_iterator[index] =
g_data_lock_inspector[index]->create_data_lock_iterator();
if (m_iterator[index] == NULL) {
return HA_ERR_RECORD_DELETED;
}
}
PSI_engine_data_lock_iterator *it = m_iterator[index];
m_container.clear();
/*
TODO: avoid requesting column LOCK_DATA if not used.
*/
it->fetch(&m_container, m_pk_pos.m_engine_lock_id,
m_pk_pos.m_engine_lock_id_length, true);
data = m_container.get_row(0);
if (data != NULL) {
m_row = data;
return 0;
}
return HA_ERR_RECORD_DELETED;
}
int table_data_locks::index_init(uint idx, bool) {
PFS_index_data_locks *result = NULL;
switch (idx) {
case 0:
result = PFS_NEW(PFS_index_data_locks_by_lock_id);
break;
case 1:
result = PFS_NEW(PFS_index_data_locks_by_transaction_id);
break;
case 2:
result = PFS_NEW(PFS_index_data_locks_by_thread_id);
break;
case 3:
result = PFS_NEW(PFS_index_data_locks_by_object);
break;
default:
DBUG_ASSERT(false);
break;
}
m_opened_index = result;
m_index = result;
m_container.set_filter(m_opened_index);
return 0;
}
int table_data_locks::index_next() { return rnd_next(); }
int table_data_locks::read_row_values(TABLE *table, unsigned char *buf,
Field **fields, bool read_all) {
Field *f;
if (unlikely(m_row == NULL)) {
return HA_ERR_RECORD_DELETED;
}
/* Set the null bits */
DBUG_ASSERT(table->s->null_bytes == 2);
buf[0] = 0;
buf[1] = 0;
for (; (f = *fields); fields++) {
if (read_all || bitmap_is_set(table->read_set, f->field_index)) {
switch (f->field_index) {
case 0: /* ENGINE */
set_field_varchar_utf8(f, m_row->m_engine);
break;
case 1: /* ENGINE_LOCK_ID */
set_field_varchar_utf8(f, m_row->m_hidden_pk.m_engine_lock_id,
m_row->m_hidden_pk.m_engine_lock_id_length);
break;
case 2: /* ENGINE_TRANSACTION_ID */
if (m_row->m_transaction_id != 0) {
set_field_ulonglong(f, m_row->m_transaction_id);
} else {
f->set_null();
}
break;
case 3: /* THREAD_ID */
if (m_row->m_thread_id != 0) {
set_field_ulonglong(f, m_row->m_thread_id);
} else {
f->set_null();
}
break;
case 4: /* EVENT_ID */
if (m_row->m_event_id != 0) {
set_field_ulonglong(f, m_row->m_event_id);
} else {
f->set_null();
}
break;
case 5: /* OBJECT_SCHEMA */
m_row->m_index_row.set_field(1, f);
break;
case 6: /* OBJECT_NAME */
m_row->m_index_row.set_field(2, f);
break;
case 7: /* PARTITION_NAME */
if (m_row->m_partition_name_length > 0) {
set_field_varchar_utf8(f, m_row->m_partition_name,
m_row->m_partition_name_length);
} else {
f->set_null();
}
break;
case 8: /* SUBPARTITION_NAME */
if (m_row->m_sub_partition_name_length > 0) {
set_field_varchar_utf8(f, m_row->m_sub_partition_name,
m_row->m_sub_partition_name_length);
} else {
f->set_null();
}
break;
case 9: /* INDEX_NAME */
m_row->m_index_row.set_field(3, f);
break;
case 10: /* OBJECT_INSTANCE_BEGIN */
set_field_ulonglong(f, (intptr)m_row->m_identity);
break;
case 11: /* LOCK_TYPE */
set_field_varchar_utf8(f, m_row->m_lock_type);
break;
case 12: /* LOCK_MODE */
set_field_varchar_utf8(f, m_row->m_lock_mode);
break;
case 13: /* LOCK_STATUS */
set_field_varchar_utf8(f, m_row->m_lock_status);
break;
case 14: /* LOCK_DATA */
if (m_row->m_lock_data != NULL) {
set_field_varchar_utf8mb4(f, m_row->m_lock_data);
} else {
f->set_null();
}
break;
default:
DBUG_ASSERT(false);
}
}
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink