/**

* Copyright (c) 2023 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 SQL

#include "sql/optimizer/ob_logical_operator.h"

#include "sql/engine/ob_physical_plan.h"

#include "observer/ob_inner_sql_connection_pool.h"

#include "observer/ob_inner_sql_connection.h"

#include "sql/resolver/ddl/ob_explain_stmt.h"

#include "sql/optimizer/ob_log_values.h"

#include "sql/optimizer/ob_log_plan.h"

#include "sql/optimizer/ob_del_upd_log_plan.h"

#include "lib/time/Time.h"

#include "pl/sys_package/ob_dbms_xplan.h"

#include "lib/json/ob_json.h"

#include "ob_plan_info_manager.h"

#include "lib/rc/ob_rc.h"

#include "ob_sql_plan.h"

using namespace oceanbase::common;

using namespace oceanbase::json;

using namespace oceanbase::observer;

#define NEW_PLAN_STR(plan_strs) \

do { \

if (OB_FAIL(ret)) { \

} else if ((OB_FAIL(plan_strs.push_back(ObString(plan_text.pos_ - last_pos, \

plan_text.buf_ + last_pos))))) { \

LOG_WARN("failed to push back obstring", K(ret)); \

} else { \

last_pos = plan_text.pos_; \

} \

} while (0); \

static const char *ExplainColumnName[] =

{

"ID",

"OPERATOR",

"NAME",

"EST.ROWS",

"EST.TIME(us)",

"REAL.ROWS",

"REAL.TIME(us)",

"IO TIME(us)",

"CPU TIME(us)"

};

enum ExplainColumnEnumType{

Id=0,

Operator,

Name,

EstRows,

EstCost,

RealRows,

RealCost,

IoTime,

CpuTime,

MaxPlanColumn

};

namespace oceanbase

{

namespace sql

{

ObSqlPlan::ObSqlPlan(common::ObIAllocator &allocator)

:allocator_(allocator),

session_(NULL)

{

}

ObSqlPlan::~ObSqlPlan()

{

}

int ObSqlPlan::store_sql_plan(ObLogPlan* log_plan, ObPhysicalPlan* phy_plan)

{

int ret = OB_SUCCESS;

PlanText plan_text;

ObSEArray<ObSqlPlanItem*, 16> sql_plan_infos;

ObLogicalPlanRawData compress_plan;

if (OB_ISNULL(phy_plan)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected null phy plan", K(ret));

} else if (OB_FAIL(init_buffer(plan_text))) {

LOG_WARN("failed to init buffer", K(ret));

} else if (OB_FAIL(get_sql_plan_infos(plan_text,

log_plan,

sql_plan_infos))) {

LOG_WARN("failed to get sql plan infos", K(ret));

} else if (OB_FAIL(compress_plan.compress_logical_plan(allocator_, sql_plan_infos))) {

LOG_WARN("failed to compress logical plan", K(ret));

} else if (phy_plan->set_logical_plan(compress_plan)) {

LOG_WARN("failed to set logical plan", K(ret));

}

if (OB_FAIL(ret)) {

LOG_WARN("failed to store sql plan", K(ret));

ret = OB_SUCCESS;

}

destroy_buffer(plan_text);

return ret;

}

int ObSqlPlan::store_sql_plan_for_explain(ObExecContext *ctx,

ObLogPlan* plan,

ExplainType type,

const ObString& plan_table,

const ObString& statement_id,

const ObExplainDisplayOpt& option,

ObIArray<common::ObString> &plan_strs)

{

int ret = OB_SUCCESS;

PlanText plan_text;

PlanText out_plan_text;

plan_text.type_ = type;

ObSEArray<ObSqlPlanItem*, 16> sql_plan_infos;

bool allocate_mem_failed = false;

if (OB_FAIL(init_buffer(plan_text))) {

LOG_WARN("failed to init buffer", K(ret));

} else if (OB_FAIL(get_sql_plan_infos(plan_text,

plan,

sql_plan_infos))) {

LOG_WARN("failed to get sql plan infos", K(ret));

}

allocate_mem_failed |= OB_ALLOCATE_MEMORY_FAILED == ret;

if (OB_FAIL(format_sql_plan(sql_plan_infos,

type,

option,

out_plan_text))) {

LOG_WARN("failed to format sql plan", K(ret));

}

allocate_mem_failed |= OB_ALLOCATE_MEMORY_FAILED == ret;

if (OB_FAIL(plan_text_to_strings(out_plan_text, plan_strs))) {

LOG_WARN("failed to convert plan text to strings", K(ret));

} else if (OB_FAIL(inner_store_sql_plan_for_explain(ctx,

plan_table,

statement_id,

sql_plan_infos))) {

LOG_WARN("failed to store explain plan", K(ret));

if (plan_table.compare("PLAN_TABLE") == 0) {

//ignore error for default

ret = OB_SUCCESS;

}

}

if (OB_SUCC(ret)) {

if (allocate_mem_failed || plan_strs.empty()) {

if (OB_FAIL(plan_strs.push_back("Plan truncated due to insufficient memory!"))) {

LOG_WARN("failed to push back string", K(ret));

}

}

}

destroy_buffer(plan_text);

return ret;

}

int ObSqlPlan::print_sql_plan(ObLogPlan* plan,

ExplainType type,

const ObExplainDisplayOpt& option,

ObIArray<common::ObString> &plan_strs)

{

int ret = OB_SUCCESS;

PlanText plan_text;

PlanText out_plan_text;

plan_text.type_ = type;

ObSEArray<ObSqlPlanItem*, 16> sql_plan_infos;

if (OB_FAIL(init_buffer(plan_text))) {

LOG_WARN("failed to init buffer", K(ret));

} else if (OB_FAIL(get_sql_plan_infos(plan_text,

plan,

sql_plan_infos))) {

LOG_WARN("failed to get sql plan infos", K(ret));

} else if (OB_FAIL(format_sql_plan(sql_plan_infos,

type,

option,

out_plan_text))) {

LOG_WARN("failed to format sql plan", K(ret));

} else if (OB_FAIL(plan_text_to_strings(out_plan_text, plan_strs))) {

LOG_WARN("failed to convert plan text to strings", K(ret));

}

if (OB_FAIL(ret)) {

LOG_WARN("failed to store sql plan", K(ret));

ret = OB_SUCCESS;

}

destroy_buffer(plan_text);

return ret;

}

int ObSqlPlan::get_plan_outline_info_one_line(PlanText &plan_text,

ObLogPlan* plan)

{

int ret = OB_SUCCESS;

const ObQueryCtx *query_ctx = NULL;

if (OB_ISNULL(plan) || OB_ISNULL(query_ctx = plan->get_optimizer_context().get_query_ctx())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected NULL", K(ret), K(plan), K(query_ctx));

} else {

plan_text.is_used_hint_ = false;

plan_text.is_oneline_ = true;

plan_text.is_outline_data_ = true;

BUF_PRINT_CONST_STR("/*+BEGIN_OUTLINE_DATA", plan_text);

const ObQueryHint &query_hint = query_ctx->get_query_hint();

if (OB_FAIL(reset_plan_tree_outline_flag(plan->get_plan_root()))) {

LOG_WARN("failed to reset plan tree outline flag", K(ret));

} else if (OB_FAIL(get_plan_tree_outline(plan_text, plan->get_plan_root()))) {

LOG_WARN("failed to get plan tree outline", K(ret));

} else if (OB_FAIL(query_hint.print_transform_hints(plan_text))) {

LOG_WARN("failed to print all transform hints", K(ret));

} else if (OB_FAIL(get_global_hint_outline(plan_text, *plan))) {

LOG_WARN("failed to get plan global hint outline", K(ret));

} else {

BUF_PRINT_CONST_STR(" END_OUTLINE_DATA*/", plan_text);

plan_text.is_outline_data_ = false;

}

if (OB_SIZE_OVERFLOW == ret) {

ret = OB_SUCCESS;

}

}

return ret;

}

int ObSqlPlan::get_plan_used_hint_info_one_line(PlanText &plan_text,

ObLogPlan* plan)

{

int ret = OB_SUCCESS;

const ObQueryCtx *query_ctx = NULL;

if (OB_ISNULL(plan) ||

OB_ISNULL(query_ctx = plan->get_optimizer_context().get_query_ctx())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected NULL", K(ret), K(plan), K(query_ctx));

} else {

const ObQueryHint &query_hint = query_ctx->get_query_hint();

plan_text.is_used_hint_ = true;

plan_text.is_oneline_ = true;

plan_text.pos_ = 0;

BUF_PRINT_CONST_STR("/*+ ", plan_text);

if (OB_FAIL(get_plan_tree_used_hint(plan_text, plan->get_plan_root()))) {

LOG_WARN("failed to get plan tree used hint", K(ret));

} else if (OB_FAIL(query_hint.print_qb_name_hints(plan_text))) {

LOG_WARN("failed to print qb name hints", K(ret));

} else if (OB_FAIL(query_hint.print_transform_hints(plan_text))) {

LOG_WARN("failed to print all transform hints", K(ret));

} else if (OB_FAIL(query_hint.get_global_hint().print_global_hint(plan_text))) {

LOG_WARN("failed to print global hint", K(ret));

} else {

BUF_PRINT_CONST_STR(" */", plan_text);

}

if (OB_SIZE_OVERFLOW == ret) {

ret = OB_SUCCESS;

}

}

return ret;

}

int ObSqlPlan::get_global_hint_outline(PlanText &plan_text, ObLogPlan &plan)

{

int ret = OB_SUCCESS;

ObGlobalHint outline_global_hint;

if (OB_FAIL(outline_global_hint.assign(plan.get_optimizer_context().get_global_hint()))) {

LOG_WARN("failed to assign global hint", K(ret));

} else if (OB_FAIL(construct_outline_global_hint(plan, outline_global_hint))) {

LOG_WARN("failed to construct outline global hint", K(ret));

} else if (OB_FAIL(outline_global_hint.print_global_hint(plan_text))) {

LOG_WARN("failed to print global hint", K(ret));

}

return ret;

}

int ObSqlPlan::construct_outline_global_hint(ObLogPlan &plan, ObGlobalHint &outline_global_hint)

{

int ret = OB_SUCCESS;

ObDelUpdLogPlan *del_upd_plan = NULL;

outline_global_hint.opt_features_version_ = ObGlobalHint::CURRENT_OUTLINE_ENABLE_VERSION;

outline_global_hint.pdml_option_ = ObPDMLOption::NOT_SPECIFIED;

if (OB_SUCC(ret) && NULL != (del_upd_plan = dynamic_cast<ObDelUpdLogPlan*>(&plan))

&& del_upd_plan->use_pdml()) {

outline_global_hint.pdml_option_ = ObPDMLOption::ENABLE;

}

if (OB_SUCC(ret)) {

outline_global_hint.parallel_ = ObGlobalHint::UNSET_PARALLEL;

if (plan.get_optimizer_context().is_use_auto_dop()) {

outline_global_hint.merge_parallel_hint(ObGlobalHint::SET_ENABLE_AUTO_DOP);

} else if (plan.get_optimizer_context().get_max_parallel() > ObGlobalHint::DEFAULT_PARALLEL) {

outline_global_hint.merge_parallel_hint(plan.get_optimizer_context().get_max_parallel());

}

}

return ret;

}

int ObSqlPlan::inner_store_sql_plan_for_explain(ObExecContext *ctx,

const ObString& plan_table,

const ObString& statement_id,

ObIArray<ObSqlPlanItem*> &sql_plan_infos)

{

int ret = OB_SUCCESS;

obutil::ObSysTime current_time = obutil::ObSysTime::now();

std::string time_str = current_time.toDateTime();

ObInnerSQLConnectionPool *pool = NULL;

sql::ObSQLSessionInfo *session = NULL;

ObInnerSQLConnection *conn = NULL;

ObSQLSessionInfo::StmtSavedValue *saved_session = NULL;

transaction::ObTxDesc *save_tx_desc = NULL;

int64_t save_nested_count = 0;

int64_t affected_rows = 0;

ObSqlString sql;

if (OB_ISNULL(ctx) ||

OB_ISNULL(ctx->get_sql_proxy()) ||

OB_ISNULL(session = ctx->get_my_session()) ||

OB_ISNULL((pool = static_cast<ObInnerSQLConnectionPool *>

(ctx->get_sql_proxy()->get_pool())))) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpect null sql proxy", K(ret));

} else if (OB_FAIL(pool->acquire_spi_conn(session, conn))) {

LOG_WARN("failed to get sql connection", K(ret));

} else if (OB_ISNULL(conn)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpect null sql connection", K(ret));

} else if (OB_FAIL(prepare_and_store_session(session,

saved_session,

save_tx_desc,

save_nested_count))) {

LOG_WARN("failed to begin nested session", K(ret));

}

for (int64_t i = 0; OB_SUCC(ret) && i < sql_plan_infos.count(); ++i) {

ObSqlPlanItem *plan_item = sql_plan_infos.at(i);

if (OB_ISNULL(plan_item)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpect null plan item", K(ret));

} else if (OB_FAIL(escape_quotes(*plan_item))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(sql.assign_fmt("INSERT INTO %.*s VALUES( \

'%.*s', \

CASE WHEN (SELECT MAX(PLAN_ID) FROM %.*s) IS NULL\

THEN 0\

ELSE (SELECT MAX(PLAN_ID) FROM %.*s)\

END + %ld, \

'%.*s', \

'%.*s', \

'%.*s', \

'%.*s', \

'%.*s', \

'%.*s', \

'%.*s', \

'%.*s', \

%ld, \

'%.*s', \

'%.*s', \

%d, \

%d, \

%d, \

%d, \

%d, \

%d, \

%ld, \

%ld, \

%ld, \

%ld, \

'%.*s', \

'%.*s', \

'%.*s', \

%ld, \

'%.*s', \

'%.*s', \

%ld, \

%ld, \

%ld, \

'%.*s', \

'%.*s', \

'%.*s', \

'%.*s', \

'%.*s', \

%ld, \

'%.*s', \

'%.*s' \

)",

plan_table.length(),

plan_table.ptr(),

statement_id.length(),

statement_id.ptr(),

plan_table.length(),

plan_table.ptr(),

plan_table.length(),

plan_table.ptr(),

(int64_t)(i > 0 ? 0 : 1),

(int)time_str.length(),

time_str.c_str(),

(int)plan_item->remarks_len_,

plan_item->remarks_,

(int)plan_item->operation_len_,

plan_item->operation_,

(int)plan_item->options_len_,

plan_item->options_,

(int)plan_item->object_node_len_,

plan_item->object_node_,

(int)plan_item->object_owner_len_,

plan_item->object_owner_,

(int)plan_item->object_name_len_,

plan_item->object_name_,

(int)plan_item->object_alias_len_,

plan_item->object_alias_,

plan_item->object_id_,

(int)plan_item->object_type_len_,

plan_item->object_type_,

(int)plan_item->optimizer_len_,

plan_item->optimizer_,

plan_item->search_columns_,

plan_item->id_,

plan_item->parent_id_,

plan_item->depth_,

plan_item->position_,

(int)plan_item->is_last_child_,

plan_item->cost_,

plan_item->cardinality_,

plan_item->bytes_,

plan_item->rowset_,

(int)plan_item->other_tag_len_,

plan_item->other_tag_,

(int)plan_item->partition_start_len_,

plan_item->partition_start_,

(int)plan_item->partition_stop_len_,

plan_item->partition_stop_,

plan_item->partition_id_,

(int)plan_item->other_len_,

plan_item->other_,

(int)plan_item->distribution_len_,

plan_item->distribution_,

plan_item->cpu_cost_,

plan_item->io_cost_,

plan_item->temp_space_,

(int)plan_item->access_predicates_len_,

plan_item->access_predicates_,

(int)plan_item->filter_predicates_len_,

plan_item->filter_predicates_,

(int)plan_item->startup_predicates_len_,

plan_item->startup_predicates_,

(int)plan_item->projection_len_,

plan_item->projection_,

(int)plan_item->special_predicates_len_,

plan_item->special_predicates_,

plan_item->time_,

(int)plan_item->qblock_name_len_,

plan_item->qblock_name_,

(int)plan_item->other_xml_len_,

plan_item->other_xml_

))) {

LOG_WARN("failed to assign sql string", K(ret));

} else if (OB_FAIL(conn->execute_write(session->get_effective_tenant_id(),

sql.ptr(),

affected_rows))) {

LOG_WARN("failed to exec inner sql", K(ret));

}

}

if (OB_NOT_NULL(conn) &&

OB_NOT_NULL(ctx) &&

OB_NOT_NULL(ctx->get_sql_proxy())) {

ctx->get_sql_proxy()->close(conn, ret);

}

if (OB_NOT_NULL(session)) {

int end_ret = restore_session(session,

saved_session,

save_tx_desc,

save_nested_count);

if (OB_SUCCESS != end_ret) {

LOG_WARN("failed to restore session", K(end_ret), K(ret));

if (OB_SUCCESS == ret) {

ret = end_ret;

}

}

}

return ret;

}

int ObSqlPlan::escape_quotes(ObSqlPlanItem &plan_item)

{

int ret = OB_SUCCESS;

if (OB_FAIL(inner_escape_quotes(plan_item.operation_,

plan_item.operation_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.options_,

plan_item.options_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.object_node_,

plan_item.object_node_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.object_owner_,

plan_item.object_owner_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.object_name_,

plan_item.object_name_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.object_alias_,

plan_item.object_alias_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.object_type_,

plan_item.object_type_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.optimizer_,

plan_item.optimizer_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.other_tag_,

plan_item.other_tag_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.partition_start_,

plan_item.partition_start_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.partition_stop_,

plan_item.partition_stop_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.other_,

plan_item.other_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.distribution_,

plan_item.distribution_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.access_predicates_,

plan_item.access_predicates_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.filter_predicates_,

plan_item.filter_predicates_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.startup_predicates_,

plan_item.startup_predicates_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.projection_,

plan_item.projection_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.special_predicates_,

plan_item.special_predicates_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.qblock_name_,

plan_item.qblock_name_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.remarks_,

plan_item.remarks_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

} else if (OB_FAIL(inner_escape_quotes(plan_item.other_xml_,

plan_item.other_xml_len_))) {

LOG_WARN("failed to escape quotes", K(ret));

}

return ret;

}

/**

* escape quotes for string value

* oracle: ' => ''

* mysql: ' => \'

*/

int ObSqlPlan::inner_escape_quotes(char* &ptr, int64_t &length)

{

int ret = OB_SUCCESS;

int64_t num_quotes = 0;

for (int64_t i = 0; i < length; ++i) {

if (ptr[i] == '\'') {

++num_quotes;

}

}

if (num_quotes > 0) {

char *buf = NULL;

int64_t buf_len = length + num_quotes;

int64_t pos = 0;

if (OB_ISNULL(buf=(char*)allocator_.alloc(buf_len))) {

ret = OB_ALLOCATE_MEMORY_FAILED;

LOG_WARN("failed to allocate memory", K(ret));

} else {

for (int64_t i = 0; i < length; ++i) {

if (ptr[i] == '\'') {

if (lib::is_mysql_mode()) {

buf[pos++] = '\\';

} else {

buf[pos++] = '\'';

}

}

buf[pos++] = ptr[i];

}

length = buf_len;

ptr = buf;

}

}

return ret;

}

int ObSqlPlan::get_sql_plan_infos(PlanText &plan_text,

ObLogPlan* plan,

ObIArray<ObSqlPlanItem*> &sql_plan_infos)

{

int ret = OB_SUCCESS;

if (OB_ISNULL(plan)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpect null plan", K(ret));

//get operator tree info

} else if (OB_FAIL(get_plan_tree_infos(plan_text,

plan->get_plan_root(),

sql_plan_infos,

0,

1,

false))) {

LOG_WARN("failed to get plan tree infos", K(ret));

} else if (sql_plan_infos.empty()) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpect null plan", K(ret));

//get used hint、outline info

} else if (OB_FAIL(get_plan_used_hint_info(plan_text,

plan,

sql_plan_infos.at(0)))) {

LOG_WARN("failed to get plan outline info", K(ret));

} else if (OB_FAIL(get_qb_name_trace(plan_text,

plan,

sql_plan_infos.at(0)))) {

LOG_WARN("failed to get qb name trace", K(ret));

} else if (OB_FAIL(get_plan_outline_info(plan_text,

plan,

sql_plan_infos.at(0)))) {

LOG_WARN("failed to get plan outline info", K(ret));

} else if (OB_FAIL(get_plan_other_info(plan_text,

plan,

sql_plan_infos.at(0)))) {

LOG_WARN("failed to get plan other info", K(ret));

}

return ret;

}

int ObSqlPlan::get_plan_tree_infos(PlanText &plan_text,

ObLogicalOperator* op,

ObIArray<ObSqlPlanItem*> &sql_plan_infos,

int depth,

int position,

bool is_last_child)

{

int ret = OB_SUCCESS;

if (OB_ISNULL(plan_text.buf_) || OB_ISNULL(op)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpect null op", K(ret));

} else if (plan_text.buf_len_ - plan_text.pos_ < sizeof(ObSqlPlanItem)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("buffer size is not enough", K(ret));

} else {

ObSqlPlanItem *plan_item = new(plan_text.buf_ + plan_text.pos_)ObSqlPlanItem();

plan_text.pos_ += sizeof(ObSqlPlanItem);

plan_item->depth_ = depth;

plan_item->position_ = position;

plan_item->is_last_child_ = is_last_child;

if (OB_FAIL(op->get_plan_item_info(plan_text,

*plan_item))) {

LOG_WARN("failed to get plan item info", K(ret));

} else if (OB_FAIL(sql_plan_infos.push_back(plan_item))) {

LOG_WARN("failed to push back sql plan item", K(ret));

}

for (int i = 0; OB_SUCC(ret) && i < op->get_num_of_child(); ++i) {

if (OB_FAIL(SMART_CALL(get_plan_tree_infos(plan_text,

op->get_child(i),

sql_plan_infos,

depth + 1,

i+1,

i+1 == op->get_num_of_child())))) {

LOG_WARN("failed to get child plan tree infos", K(ret));

}

}

}

return ret;

}

int ObSqlPlan::get_plan_used_hint_info(PlanText &plan_text,

ObLogPlan* plan,

ObSqlPlanItem* sql_plan_item)

{

int ret = OB_SUCCESS;

const ObQueryCtx *query_ctx = NULL;

//print_plan_tree:print_used_hint

if (OB_ISNULL(plan) || OB_ISNULL(sql_plan_item) ||

OB_ISNULL(query_ctx = plan->get_optimizer_context().get_query_ctx())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected NULL", K(ret), K(plan), K(query_ctx));

} else {

const ObQueryHint &query_hint = query_ctx->get_query_hint();

PlanText temp_text;

temp_text.is_used_hint_ = true;

temp_text.buf_ = plan_text.buf_ + plan_text.pos_;

temp_text.buf_len_ = plan_text.buf_len_ - plan_text.pos_;

temp_text.pos_ = 0;

BUF_PRINT_CONST_STR(" /*+", temp_text);

BUF_PRINT_CONST_STR(NEW_LINE, temp_text);

BUF_PRINT_CONST_STR(OUTPUT_PREFIX, temp_text);

if (OB_FAIL(get_plan_tree_used_hint(temp_text, plan->get_plan_root()))) {

LOG_WARN("failed to get plan tree used hint", K(ret));

} else if (OB_FAIL(query_hint.print_qb_name_hints(temp_text))) {

LOG_WARN("failed to print qb name hints", K(ret));

} else if (OB_FAIL(query_hint.print_transform_hints(temp_text))) {

LOG_WARN("failed to print all transform hints", K(ret));

} else if (OB_FAIL(query_hint.get_global_hint().print_global_hint(temp_text))) {

LOG_WARN("failed to print global hint", K(ret));

} else {

BUF_PRINT_CONST_STR(NEW_LINE, temp_text);

BUF_PRINT_CONST_STR(" */", temp_text);

sql_plan_item->other_tag_ = temp_text.buf_;

sql_plan_item->other_tag_len_ = temp_text.pos_;

plan_text.pos_ += temp_text.pos_;

}

}

return ret;

}

int ObSqlPlan::get_plan_tree_used_hint(PlanText &plan_text,

ObLogicalOperator* op)

{

int ret = OB_SUCCESS;

if (OB_ISNULL(op)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpect null op", K(ret));

} else if (OB_FAIL(op->print_used_hint(plan_text))) {

LOG_WARN("failed to get plan used hint", K(ret));

}

for (int i = 0; OB_SUCC(ret) && i < op->get_num_of_child(); ++i) {

if (OB_FAIL(SMART_CALL(get_plan_tree_used_hint(plan_text,

op->get_child(i))))) {

LOG_WARN("failed to get child plan tree used hint", K(ret));

}

}

return ret;

}

int ObSqlPlan::get_qb_name_trace(PlanText &plan_text,

ObLogPlan* plan,

ObSqlPlanItem* sql_plan_item)

{

int ret = OB_SUCCESS;

const ObQueryCtx *query_ctx = NULL;

if (OB_ISNULL(plan) || OB_ISNULL(sql_plan_item) ||

OB_ISNULL(query_ctx = plan->get_optimizer_context().get_query_ctx())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected NULL", K(ret), K(plan), K(query_ctx));

} else {

PlanText temp_text;

temp_text.buf_ = plan_text.buf_ + plan_text.pos_;

temp_text.buf_len_ = plan_text.buf_len_ - plan_text.pos_;

temp_text.pos_ = 0;

char *buf = temp_text.buf_;

int64_t &buf_len = temp_text.buf_len_;

int64_t &pos = temp_text.pos_;

const ObIArray<QbNames> &stmt_id_map = query_ctx->get_query_hint().stmt_id_map_;

for (int64_t i = 0; OB_SUCC(ret) && i < stmt_id_map.count(); ++i) {

if (OB_FAIL(BUF_PRINTF(" stmt_id:%ld, ", i))) {

} else if (OB_FAIL(stmt_id_map.at(i).print_qb_names(temp_text))) {

LOG_WARN("failed to print qb names", K(ret));

} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {

/* Do nothing */

}

}

if (OB_SUCC(ret)) {

sql_plan_item->remarks_ = temp_text.buf_;

sql_plan_item->remarks_len_ = temp_text.pos_;

plan_text.pos_ += temp_text.pos_;

}

}

return ret;

}

int ObSqlPlan::get_plan_outline_info(PlanText &plan_text,

ObLogPlan* plan,

ObSqlPlanItem* sql_plan_item)

{

int ret = OB_SUCCESS;

const ObQueryCtx *query_ctx = NULL;

if (OB_ISNULL(plan) || OB_ISNULL(sql_plan_item) ||

OB_ISNULL(query_ctx = plan->get_optimizer_context().get_query_ctx())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected NULL", K(ret), K(plan), K(query_ctx));

} else {

PlanText temp_text;

temp_text.is_used_hint_ = false;

temp_text.is_outline_data_ = true;

temp_text.buf_ = plan_text.buf_ + plan_text.pos_;

temp_text.buf_len_ = plan_text.buf_len_ - plan_text.pos_;

temp_text.pos_ = 0;

BUF_PRINT_CONST_STR(" /*+", temp_text);

BUF_PRINT_CONST_STR(NEW_LINE, temp_text);

BUF_PRINT_CONST_STR(OUTPUT_PREFIX, temp_text);

BUF_PRINT_CONST_STR("BEGIN_OUTLINE_DATA", temp_text);

const ObQueryHint &query_hint = query_ctx->get_query_hint();

if (OB_FAIL(reset_plan_tree_outline_flag(plan->get_plan_root()))) {

LOG_WARN("failed to reset plan tree outline flag", K(ret));

} else if (OB_FAIL(get_plan_tree_outline(temp_text, plan->get_plan_root()))) {

LOG_WARN("failed to get plan tree outline", K(ret));

} else if (OB_FAIL(query_hint.print_transform_hints(temp_text))) {

LOG_WARN("failed to print all transform hints", K(ret));

} else if (OB_FAIL(get_global_hint_outline(temp_text, *plan))) {

LOG_WARN("failed to get plan global hint outline", K(ret));

} else {

BUF_PRINT_CONST_STR(NEW_LINE, temp_text);

BUF_PRINT_CONST_STR(OUTPUT_PREFIX, temp_text);

BUF_PRINT_CONST_STR("END_OUTLINE_DATA", temp_text);

BUF_PRINT_CONST_STR(NEW_LINE, temp_text);

BUF_PRINT_CONST_STR(" */", temp_text);

sql_plan_item->other_xml_ = temp_text.buf_;

sql_plan_item->other_xml_len_ = temp_text.pos_;

plan_text.pos_ += temp_text.pos_;

}

}

return ret;

}

int ObSqlPlan::reset_plan_tree_outline_flag(ObLogicalOperator* op)

{

int ret = OB_SUCCESS;

if (OB_ISNULL(op) || OB_ISNULL(op->get_plan())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpect null op", K(ret));

} else {

op->get_plan()->reset_outline_print_flags();

}

for (int i = 0; OB_SUCC(ret) && i < op->get_num_of_child(); ++i) {

if (OB_FAIL(SMART_CALL(reset_plan_tree_outline_flag(op->get_child(i))))) {

LOG_WARN("failed to reset child plan tree outline flag", K(ret));

}

}

return ret;

}

int ObSqlPlan::get_plan_tree_outline(PlanText &plan_text,

ObLogicalOperator* op)

{

int ret = OB_SUCCESS;

if (OB_ISNULL(op)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpect null op", K(ret));

} else if (OB_FAIL(op->print_outline_data(plan_text))) {

LOG_WARN("failed to get plan outline", K(ret));

}

for (int i = 0; OB_SUCC(ret) && i < op->get_num_of_child(); ++i) {

if (OB_FAIL(SMART_CALL(get_plan_tree_outline(plan_text,

op->get_child(i))))) {

LOG_WARN("failed to get child plan tree outline", K(ret));

}

}

return ret;

}

int ObSqlPlan::get_plan_other_info(PlanText &plan_text,

ObLogPlan* plan,

ObSqlPlanItem* sql_plan_item)

{

int ret = OB_SUCCESS;

const ObDMLStmt *stmt = NULL;

const ObQueryCtx *query_ctx = NULL;

if (OB_ISNULL(plan) || OB_ISNULL(sql_plan_item) ||

OB_ISNULL(stmt=plan->get_stmt()) || OB_ISNULL(query_ctx=stmt->get_query_ctx())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpect null param", K(ret));

} else {

ObObjPrintParams print_params(query_ctx->get_timezone_info());

BEGIN_BUF_PRINT

ObPhyPlanType plan_type = plan->get_optimizer_context().get_phy_plan_type();

if (OB_FAIL(BUF_PRINTF(" Plan Type:"))) {

} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {

} else if (OB_FAIL(BUF_PRINTF(OUTPUT_PREFIX))) {

} else if (OB_FAIL(BUF_PRINTF("%.*s",

ob_plan_type_str(plan_type).length(),

ob_plan_type_str(plan_type).ptr()))) {

} else {

ret = BUF_PRINTF(NEW_LINE);

}

const ParamStore *params = NULL;

if (OB_FAIL(ret)) {

} else if (OB_ISNULL(params = plan->get_optimizer_context().get_params())) {

ret = OB_ERR_UNEXPECTED;

} else if (params->count() <= 0) {

//do nothing

} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {

} else if (OB_FAIL(BUF_PRINTF(" Parameters:"))) {

} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {

} else { /* Do nothing */ }

for (int64_t i = 0; OB_SUCC(ret) && NULL != params && i < params->count(); i++) {

if (OB_FAIL(BUF_PRINTF(OUTPUT_PREFIX))) {

} else if (OB_FAIL(BUF_PRINTF(":%ld => ", i))) {

} else {

int64_t save_pos = pos;

if (OB_FAIL(params->at(i).print_sql_literal(buf,

buf_len,

pos,

print_params))) {

//ignore size overflow error

pos = save_pos;

}

if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {

} else { /* Do nothing */ }

}

}

const ObPlanNotes &notes = plan->get_optimizer_context().get_plan_notes();

if (notes.count() <= 0 || OB_FAIL(ret)) {

} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */

} else if (OB_FAIL(BUF_PRINTF(" Note:"))) { /* Do nothing */

} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) { /* Do nothing */

}

for (int64_t i = 0; OB_SUCC(ret) && i < notes.count(); i++) {

if (OB_FAIL(BUF_PRINTF(OUTPUT_PREFIX))) {

} else {

pos += notes.at(i).to_string(buf + pos, buf_len - pos);

ret = BUF_PRINTF(NEW_LINE);

}

}

if (OB_SUCC(ret)) {

if (OB_FAIL(get_constraint_info(buf, buf_len, pos, *query_ctx))) {

LOG_WARN("failed to get constraint info", K(ret));

}

}

END_BUF_PRINT(sql_plan_item->other_, sql_plan_item->other_len_);

}

// statis version

// constraint

return ret;

}

int ObSqlPlan::get_constraint_info(char *buf,

int64_t buf_len,

int64_t &pos,

const ObQueryCtx &ctx)

{

int ret = OB_SUCCESS;

if (!ctx.all_plan_const_param_constraints_.empty()) {

if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {

} else if (OB_FAIL(BUF_PRINTF(" "))) {

} else if (OB_FAIL(BUF_PRINTF("Const Parameter Constraints:"))) {

} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {

}

for (int64_t i = 0; OB_SUCC(ret) && i < ctx.all_plan_const_param_constraints_.count(); ++i) {

if (OB_FAIL(print_constraint_info(buf,

buf_len,

pos,

ctx.all_plan_const_param_constraints_.at(i)))) {

LOG_WARN("failed to print constraint info", K(ret));

}

}

}

if (OB_SUCC(ret) && !ctx.all_possible_const_param_constraints_.empty()) {

if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {

} else if (OB_FAIL(BUF_PRINTF(" "))) {

} else if (OB_FAIL(BUF_PRINTF("Possible Const Parameter Constraints:"))) {

} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {

}

for (int64_t i = 0; OB_SUCC(ret) && i < ctx.all_possible_const_param_constraints_.count(); ++i) {

if (OB_FAIL(print_constraint_info(buf,

buf_len,

pos,

ctx.all_possible_const_param_constraints_.at(i)))) {

LOG_WARN("failed to print constraint info", K(ret));

}

}

}

if (OB_SUCC(ret) && !ctx.all_equal_param_constraints_.empty()) {

if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {

} else if (OB_FAIL(BUF_PRINTF(" "))) {

} else if (OB_FAIL(BUF_PRINTF("Equal Parameter Constraints:"))) {

} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {

}

for (int64_t i = 0; OB_SUCC(ret) && i < ctx.all_equal_param_constraints_.count(); ++i) {

if (OB_FAIL(print_constraint_info(buf,

buf_len,

pos,

ctx.all_equal_param_constraints_.at(i)))) {

LOG_WARN("failed to print constraint info", K(ret));

}

}

}

if (OB_SUCC(ret) && !ctx.all_expr_constraints_.empty()) {

if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {

} else if (OB_FAIL(BUF_PRINTF(" "))) {

} else if (OB_FAIL(BUF_PRINTF("Expr Constraints:"))) {

} else if (OB_FAIL(BUF_PRINTF(NEW_LINE))) {

}

for (int64_t i = 0; OB_SUCC(ret) && i < ctx.all_expr_constraints_.count(); ++i) {

if (OB_FAIL(print_constraint_info(buf,

buf_len,

pos,

ctx.all_expr_constraints_.at(i)))) {

LOG_WARN("failed to print constraint info", K(ret));

}

}

}

return ret;

}

int ObSqlPlan::print_constraint_info(char *buf,

int64_t buf_len,

int64_t &pos,

const ObPCConstParamInfo &info)

{

int ret = OB_SUCCESS;

if (info.const_idx_.count() != info.const_params_.count()) {

ret = OB_ERR_UNEXPECTED;