359 lines
12 KiB
C++
359 lines
12 KiB
C++
/**
|
|
* Copyright (c) 2021 OceanBase
|
|
* OceanBase CE is licensed under Mulan PubL v2.
|
|
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
|
* You may obtain a copy of Mulan PubL v2 at:
|
|
* http://license.coscl.org.cn/MulanPubL-2.0
|
|
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
|
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
* See the Mulan PubL v2 for more details.
|
|
*/
|
|
|
|
#define USING_LOG_PREFIX SERVER
|
|
|
|
#include "ob_plan_cache_plan_explain.h"
|
|
#include "observer/ob_server_utils.h"
|
|
#include "observer/ob_server_struct.h"
|
|
#include "observer/ob_req_time_service.h"
|
|
#include "share/schema/ob_schema_getter_guard.h"
|
|
#include "common/ob_range.h"
|
|
#include "sql/plan_cache/ob_plan_cache.h"
|
|
#include "sql/ob_sql.h"
|
|
#include "sql/plan_cache/ob_cache_object_factory.h"
|
|
#include "sql/engine/table/ob_table_scan_op.h"
|
|
using namespace oceanbase;
|
|
using namespace oceanbase::observer;
|
|
using namespace oceanbase::sql;
|
|
using namespace oceanbase::common;
|
|
using namespace oceanbase::share::schema;
|
|
|
|
namespace oceanbase
|
|
{
|
|
namespace observer
|
|
{
|
|
template<class Op>
|
|
int ObExpVisitor::add_row(const Op &cur_op)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObObj *cells = NULL;
|
|
const int64_t col_count = output_column_ids_.count();
|
|
if (OB_ISNULL(cells = cur_row_.cells_)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
SERVER_LOG(WARN, "cur row cell is NULL", K(ret));
|
|
} else if (OB_UNLIKELY(col_count < 1)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
SERVER_LOG(WARN, "column count error ", K(ret), K(col_count));
|
|
} else {
|
|
ObString ipstr;
|
|
common::ObAddr addr;
|
|
ObQueryFlag scan_flag;
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < col_count; ++i) {
|
|
uint64_t col_id = output_column_ids_.at(i);
|
|
switch(col_id) {
|
|
case ObPlanCachePlanExplain::TENANT_ID_COL : {
|
|
cells[i].set_int(tenant_id_);
|
|
break;
|
|
}
|
|
case ObPlanCachePlanExplain::IP_COL: {
|
|
ipstr.reset();
|
|
if (OB_FAIL(ObServerUtils::get_server_ip(allocator_, ipstr))) {
|
|
SERVER_LOG(ERROR, "get server ip failed", K(ret));
|
|
} else {
|
|
cells[i].set_varchar(ipstr);
|
|
cells[i].set_collation_type(ObCharset::get_default_collation(
|
|
ObCharset::get_default_charset()));
|
|
}
|
|
break;
|
|
}
|
|
case ObPlanCachePlanExplain::PORT_COL: {
|
|
addr.reset();
|
|
addr = GCTX.self_addr();
|
|
cells[i].set_int(addr.get_port());
|
|
break;
|
|
}
|
|
case ObPlanCachePlanExplain::PLAN_ID_COL: {
|
|
cells[i].set_int(plan_id_);
|
|
break;
|
|
}
|
|
case ObPlanCachePlanExplain::OP_NAME_COL: {
|
|
char *buf = NULL;
|
|
int64_t buf_len = cur_op.get_plan_depth() + strlen(cur_op.get_name()) + 1;
|
|
int64_t pos = 0;
|
|
if (OB_ISNULL(buf = static_cast<char *> (allocator_->alloc(buf_len)))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
} else {
|
|
int64_t j = cur_op.get_plan_depth();
|
|
while (j > 0 && pos < buf_len) {
|
|
BUF_PRINTF(" ");
|
|
--j;
|
|
}
|
|
if (OB_UNLIKELY(0 > snprintf(buf + pos, buf_len - pos, "%s", cur_op.get_name()))) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
SERVER_LOG(WARN, "fail to gen operator name");
|
|
} else {
|
|
cells[i].set_varchar(buf);
|
|
cells[i].set_collation_type(ObCharset::get_default_collation(
|
|
ObCharset::get_default_charset()));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case ObPlanCachePlanExplain::TBL_NAME_COL: {
|
|
ObString tbl_name;
|
|
ret = get_table_name(cur_op, tbl_name);
|
|
if (OB_SUCC(ret)) {
|
|
cells[i].set_varchar(tbl_name);
|
|
cells[i].set_collation_type(ObCharset::get_default_collation(
|
|
ObCharset::get_default_charset()));
|
|
}
|
|
break;
|
|
}
|
|
case ObPlanCachePlanExplain::ROWS_COL: {
|
|
cells[i].set_int(cur_op.get_rows());
|
|
break;
|
|
}
|
|
case ObPlanCachePlanExplain::COST_COL: {
|
|
cells[i].set_int(cur_op.get_cost());
|
|
break;
|
|
}
|
|
case ObPlanCachePlanExplain::PROPERTY_COL: {
|
|
ObString property;
|
|
ret = get_property(cur_op, property);
|
|
if (OB_SUCC(ret)) {
|
|
cells[i].set_varchar(property);
|
|
cells[i].set_collation_type(ObCharset::get_default_collation(
|
|
ObCharset::get_default_charset()));
|
|
}
|
|
break;
|
|
}
|
|
case ObPlanCachePlanExplain::PLAN_DEPTH_COL: {
|
|
cells[i].set_int(cur_op.get_plan_depth());
|
|
break;
|
|
}
|
|
case ObPlanCachePlanExplain::PLAN_LINE_ID_COL: {
|
|
cells[i].set_int(cur_op.get_id());
|
|
break;
|
|
}
|
|
default: {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
SERVER_LOG(WARN,
|
|
"invalid column id",
|
|
K(ret),
|
|
K(i),
|
|
K(output_column_ids_),
|
|
K(col_id));
|
|
break;
|
|
}
|
|
}
|
|
} // end for
|
|
if (OB_SUCC(ret)) {
|
|
if (OB_FAIL(scanner_.add_row(cur_row_))) {
|
|
SERVER_LOG(WARN, "fail to add row", K(ret), K(cur_row_));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObOpSpecExpVisitor::add_row(const sql::ObOpSpec &op)
|
|
{
|
|
return ObExpVisitor::add_row(op);
|
|
}
|
|
|
|
template<>
|
|
int ObExpVisitor::get_table_name<ObOpSpec>(const ObOpSpec &cur_op, ObString &table_name)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
char *buffer = NULL;
|
|
ObString index_name;
|
|
ObString tmp_table_name;
|
|
if (OB_ISNULL(buffer = static_cast<char *>(allocator_->alloc(OB_MAX_PLAN_EXPLAIN_NAME_LENGTH)))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
SERVER_LOG(WARN, "failed to allocate memory", K(ret));
|
|
} else if (PHY_TABLE_SCAN == cur_op.get_type()) {
|
|
const ObTableScanSpec &tsc_spec = static_cast<const ObTableScanSpec &>(cur_op);
|
|
ObQueryFlag scan_flag;
|
|
scan_flag.flag_ = tsc_spec.flags_;
|
|
tmp_table_name = tsc_spec.table_name_;
|
|
index_name = tsc_spec.index_name_;
|
|
if (OB_FAIL(get_table_access_desc(tsc_spec.should_scan_index(), scan_flag,
|
|
tmp_table_name, index_name, table_name))) {
|
|
SERVER_LOG(WARN, "failed to get table name", K(ret));
|
|
}
|
|
} else {
|
|
table_name = ObString::make_string("NULL");
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObExpVisitor::get_table_access_desc(bool is_idx_access, const ObQueryFlag &scan_flag, ObString &tab_name,
|
|
const ObString &index_name, ObString &ret_name)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
char *buffer = NULL;
|
|
int64_t tmp_pos = 0;
|
|
|
|
if (OB_ISNULL(buffer = static_cast<char *>(allocator_->alloc(OB_MAX_PLAN_EXPLAIN_NAME_LENGTH)))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
SERVER_LOG(WARN, "failed to allocate memory", K(ret));
|
|
} else {
|
|
tmp_pos = tab_name.to_string(buffer, OB_MAX_PLAN_EXPLAIN_NAME_LENGTH);
|
|
if (is_idx_access) {
|
|
IGNORE_RETURN snprintf(buffer+tmp_pos,
|
|
OB_MAX_PLAN_EXPLAIN_NAME_LENGTH-tmp_pos,
|
|
LEFT_BRACKET);
|
|
tmp_pos += strlen(LEFT_BRACKET);
|
|
tmp_pos += index_name.to_string(buffer+tmp_pos,
|
|
OB_MAX_PLAN_EXPLAIN_NAME_LENGTH - tmp_pos);
|
|
if (scan_flag.is_reverse_scan()) {
|
|
IGNORE_RETURN snprintf(buffer + tmp_pos,
|
|
OB_MAX_PLAN_EXPLAIN_NAME_LENGTH - tmp_pos,
|
|
COMMA_REVERSE);
|
|
tmp_pos += strlen(COMMA_REVERSE);
|
|
} else {
|
|
// do nothing
|
|
}
|
|
IGNORE_RETURN snprintf(buffer + tmp_pos,
|
|
OB_MAX_PLAN_EXPLAIN_NAME_LENGTH - tmp_pos,
|
|
RIGHT_BRACKET);
|
|
tmp_pos += strlen(RIGHT_BRACKET);
|
|
} else {
|
|
if (scan_flag.is_reverse_scan()) {
|
|
IGNORE_RETURN snprintf(buffer + tmp_pos,
|
|
OB_MAX_PLAN_EXPLAIN_NAME_LENGTH - tmp_pos,
|
|
BRACKET_REVERSE);
|
|
tmp_pos += strlen(BRACKET_REVERSE);
|
|
} else { /* Do nothing */ }
|
|
}
|
|
|
|
if (OB_SUCC(ret)) {
|
|
ret_name.assign_ptr(buffer, tmp_pos);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
template<>
|
|
int ObExpVisitor::get_property<ObOpSpec>(const ObOpSpec &cur_op,
|
|
common::ObString &property)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
char *buf = NULL;
|
|
int64_t pos = 0;
|
|
if (OB_ISNULL(buf = static_cast<char *> (allocator_->alloc(OB_MAX_OPERATOR_PROPERTY_LENGTH)))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
SERVER_LOG(WARN, "failed to allocate memory", K(ret));
|
|
} else {
|
|
switch (cur_op.get_type()) {
|
|
case PHY_TABLE_SCAN: {
|
|
if (OB_FAIL(static_cast<const ObTableScanSpec &>(cur_op).explain_index_selection_info(
|
|
buf, OB_MAX_OPERATOR_PROPERTY_LENGTH, pos))) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
SERVER_LOG(WARN, "fail to gen property", K(ret));
|
|
} else {
|
|
property.assign_ptr(buf, pos);
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
property = ObString::make_string("NULL");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObPlanCachePlanExplain::set_tenant_plan_id(const common::ObIArray<common::ObNewRange> &ranges)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
// display only one plan
|
|
if (ranges.count() == 1 && ranges.at(0).is_single_rowkey()) {
|
|
ObRowkey start_key = ranges.at(0).start_key_;
|
|
const ObObj *start_key_obj_ptr = start_key.get_obj_ptr();
|
|
if (OB_ISNULL(start_key_obj_ptr)
|
|
|| start_key.get_obj_cnt() != 4) /* (tenant_id, svr_ip, svr_port, plan_id) */ {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
SERVER_LOG(WARN,
|
|
"fail to init plan visitor",
|
|
K(ret),
|
|
K(start_key_obj_ptr),
|
|
"count", start_key.get_obj_cnt());
|
|
} else {
|
|
tenant_id_ = start_key_obj_ptr[0].get_int();
|
|
plan_id_ = start_key_obj_ptr[3].get_int();
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObPlanCachePlanExplain::inner_open()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObPhysicalPlan *plan = NULL;
|
|
// !!!引用plan cache资源之前必须加ObReqTimeGuard
|
|
ObReqTimeGuard req_timeinfo_guard;
|
|
if (OB_FAIL(set_tenant_plan_id(key_ranges_))) {
|
|
LOG_WARN("set tenant id and plan id failed", K(ret));
|
|
} else if (!is_sys_tenant(effective_tenant_id_) && tenant_id_ != effective_tenant_id_) {
|
|
// user tenant can only show self tenant infos
|
|
// return nothing
|
|
LOG_INFO("non-sys tenant can only show self tenant plan cache plan explain infos",
|
|
K(effective_tenant_id_), K(tenant_id_), K(plan_id_));
|
|
} else if (OB_INVALID_INDEX != tenant_id_ && OB_INVALID_INDEX != plan_id_) {
|
|
ObPlanCache *plan_cache = NULL;
|
|
ObCacheObjGuard guard(PLAN_EXPLAIN_HANDLE);
|
|
int tmp_ret = OB_SUCCESS;
|
|
|
|
MTL_SWITCH(tenant_id_) {
|
|
plan_cache = MTL(ObPlanCache*);
|
|
if (OB_SUCCESS != (tmp_ret = plan_cache->ref_plan(plan_id_, guard))) {
|
|
// should not panic
|
|
} else if (FALSE_IT(plan = static_cast<ObPhysicalPlan*>(guard.get_cache_obj()))) {
|
|
// do nothing
|
|
} else if (OB_ISNULL(plan)) {
|
|
// maybe pl object, do nothing
|
|
} else if (OB_NOT_NULL(plan->get_root_op_spec())) {
|
|
if (OB_FAIL(static_engine_exp_visitor_.init(tenant_id_, plan_id_, allocator_))) {
|
|
SERVER_LOG(WARN, "failed to init visitor", K(ret));
|
|
} else if (OB_FAIL(plan->get_root_op_spec()->accept(static_engine_exp_visitor_))) {
|
|
SERVER_LOG(WARN, "fail to traverse physical plan", K(ret));
|
|
}
|
|
} else {
|
|
// done
|
|
}
|
|
} // mtl switch ends
|
|
} else {
|
|
SERVER_LOG(DEBUG, "invalid tenant_id or plan_id", K_(tenant_id), K_(plan_id));
|
|
}
|
|
|
|
// data is ready
|
|
if (OB_SUCC(ret)) {
|
|
scanner_it_ = scanner_.begin();
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ObPlanCachePlanExplain::inner_get_next_row(common::ObNewRow *&row)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (OB_FAIL(scanner_it_.get_next_row(cur_row_))) {
|
|
if (OB_ITER_END != ret) {
|
|
SERVER_LOG(WARN, "fail to get next row", K(ret));
|
|
}
|
|
} else {
|
|
row = &cur_row_;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
ObPlanCachePlanExplain::~ObPlanCachePlanExplain()
|
|
{
|
|
}
|
|
|
|
} // end namespace observr
|
|
} // end namespace oceanbase
|