/**

* 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 SQL_RESV

#include "sql/resolver/dml/ob_hint.h"

#include "lib/utility/ob_unify_serialize.h"

#include "sql/optimizer/ob_log_plan.h"

#include "common/ob_smart_call.h"

#include "sql/monitor/ob_sql_plan.h"

namespace oceanbase

{

using namespace common;

namespace sql

{

void ObPhyPlanHint::reset()

{

read_consistency_ = INVALID_CONSISTENCY;

query_timeout_ = -1;

plan_cache_policy_ = OB_USE_PLAN_CACHE_INVALID;

force_trace_log_ = false;

log_level_.reset();

parallel_ = -1;

monitor_ = false;

}

OB_SERIALIZE_MEMBER(ObPhyPlanHint,

read_consistency_,

query_timeout_,

plan_cache_policy_,

force_trace_log_,

log_level_,

parallel_,

monitor_);

int ObPhyPlanHint::deep_copy(const ObPhyPlanHint &other, ObIAllocator &allocator)

{

int ret = OB_SUCCESS;

read_consistency_ = other.read_consistency_;

query_timeout_ = other.query_timeout_;

plan_cache_policy_ = other.plan_cache_policy_;

force_trace_log_ = other.force_trace_log_;

parallel_ = other.parallel_;

monitor_ = other.monitor_;

if (OB_FAIL(ob_write_string(allocator, other.log_level_, log_level_))) {

LOG_WARN("Failed to deep copy log level", K(ret));

}

return ret;

}

int ObGlobalHint::merge_monitor_hints(const ObIArray<ObMonitorHint> &monitoring_ids)

{

int ret = OB_SUCCESS;

bool find = false;

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

find = false;

for (int64_t j = 0; j < monitoring_ids_.count(); ++j) {

if (monitoring_ids.at(i).id_ == monitoring_ids_.at(j).id_) {

monitoring_ids_.at(j).flags_ |= monitoring_ids.at(i).flags_;

find = true;

}

}

if (!find) {

if (OB_FAIL(monitoring_ids_.push_back(monitoring_ids.at(i)))) {

LOG_WARN("Failed to push back tracing", K(ret));

}

}

}

return ret;

}

int ObGlobalHint::merge_dop_hint(uint64_t dfo, uint64_t dop)

{

int ret = OB_SUCCESS;

bool find = false;

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

if (dfo == dops_.at(i).dfo_) {

find = true;

if (dop > dops_.at(i).dop_) {

dops_.at(i).dop_ = dop;

}

}

}

if (!find) {

ObDopHint hint;

hint.dfo_ = dfo;

hint.dop_ = dop;

if (OB_FAIL(dops_.push_back(hint))) {

LOG_WARN("Failed to push back dop", K(ret));

}

}

LOG_DEBUG("add dop hint", K(dops_));

return ret;

}

int ObGlobalHint::merge_dop_hint(const ObIArray<ObDopHint> &dop_hints)

{

int ret = OB_SUCCESS;

bool find = false;

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

if (OB_FAIL(merge_dop_hint(dop_hints.at(i).dfo_, dop_hints.at(i).dop_))) {

LOG_WARN("failed to add dop hint", K(dops_));

}

}

return ret;

}

void ObGlobalHint::merge_query_timeout_hint(int64_t hint_time)

{

if (hint_time > 0) {

if (OB_UNLIKELY(hint_time > OB_MAX_USER_SPECIFIED_TIMEOUT)) {

LOG_USER_WARN(OB_ERR_TIMEOUT_TRUNCATED);

hint_time = std::min(OB_MAX_USER_SPECIFIED_TIMEOUT, hint_time);

}

if (query_timeout_ < 0) {

query_timeout_ = hint_time;

} else {

query_timeout_ = std::min(hint_time, query_timeout_);

}

}

}

void ObGlobalHint::merge_dblink_info_hint(int64_t tx_id, int64_t tm_sessid)

{

if (-1 != tx_id && -1 != tm_sessid) {

tx_id_ = tx_id;

tm_sessid_ = tm_sessid;

LOG_DEBUG("merge dblink info hint", K(tx_id_), K(tm_sessid_));

}

}

void ObGlobalHint::reset_dblink_info_hint()

{

tx_id_ = -1;

tm_sessid_ = -1;

}

void ObGlobalHint::merge_max_concurrent_hint(int64_t max_concurrent)

{

if (max_concurrent >= 0) {

if (UNSET_MAX_CONCURRENT == max_concurrent_) {

max_concurrent_ = max_concurrent;

} else {

max_concurrent_ = std::min(max_concurrent_, max_concurrent);

}

}

}

/* global parallel hint priority:

1. with paralle degree: parallel(8)

2. enable auto dop: parallel(auto)

3. disable auto dop: parallel(manual)

*/

void ObGlobalHint::merge_parallel_hint(int64_t parallel)

{

if (SET_ENABLE_MANUAL_DOP == parallel) {

parallel_ = UNSET_PARALLEL == parallel_ ? SET_ENABLE_MANUAL_DOP : parallel_;

} else if (SET_ENABLE_AUTO_DOP == parallel) {

parallel_ = (UNSET_PARALLEL == parallel_ || SET_ENABLE_MANUAL_DOP == parallel_)

? SET_ENABLE_AUTO_DOP : parallel_;

} else if (UNSET_PARALLEL < parallel) {

if (UNSET_PARALLEL >= parallel_) {

parallel_ = parallel;

} else {

parallel_ = std::min(parallel, parallel_);

}

}

}

void ObGlobalHint::merge_dynamic_sampling_hint(int64_t dynamic_sampling)

{

if (dynamic_sampling != UNSET_DYNAMIC_SAMPLING) {

if (UNSET_DYNAMIC_SAMPLING == dynamic_sampling_ || dynamic_sampling == dynamic_sampling_) {

dynamic_sampling_ = dynamic_sampling;

} else {//conflict will cause reset origin state compatible Oracle.

dynamic_sampling_ = UNSET_DYNAMIC_SAMPLING;

}

}

}

void ObGlobalHint::merge_parallel_dml_hint(ObPDMLOption pdml_option)

{

if (ObPDMLOption::DISABLE != pdml_option_ && ObPDMLOption::ENABLE != pdml_option_) {

if (ObPDMLOption::DISABLE == pdml_option || ObPDMLOption::ENABLE == pdml_option) {

pdml_option_ = pdml_option;

}

} else if (ObPDMLOption::ENABLE == pdml_option_ || ObPDMLOption::ENABLE == pdml_option) {

pdml_option_ = ObPDMLOption::ENABLE;

} else {

pdml_option_ = ObPDMLOption::DISABLE;

}

}

void ObGlobalHint::merge_param_option_hint(ObParamOption opt)

{

if (ObParamOption::FORCE != param_option_ && ObParamOption::EXACT != param_option_) {

if (ObParamOption::FORCE == opt || ObParamOption::EXACT == opt) {

param_option_ = opt;

}

} else if (ObParamOption::EXACT == param_option_ || ObParamOption::EXACT == opt) {

param_option_ = ObParamOption::EXACT;

} else {

param_option_ = ObParamOption::FORCE;

}

}

void ObGlobalHint::merge_topk_hint(int64_t precision, int64_t sharding_minimum_row_count)

{

topk_precision_ = std::max(topk_precision_, precision);

sharding_minimum_row_count_ = std::max(sharding_minimum_row_count_, sharding_minimum_row_count);

}

void ObGlobalHint::merge_plan_cache_hint(ObPlanCachePolicy policy)

{

if (ObPlanCachePolicy::OB_USE_PLAN_CACHE_NONE == policy ||

ObPlanCachePolicy::OB_USE_PLAN_CACHE_NONE == plan_cache_policy_) {

plan_cache_policy_ = ObPlanCachePolicy::OB_USE_PLAN_CACHE_NONE;

} else if (ObPlanCachePolicy::OB_USE_PLAN_CACHE_DEFAULT == policy ||

ObPlanCachePolicy::OB_USE_PLAN_CACHE_DEFAULT == plan_cache_policy_) {

plan_cache_policy_ = ObPlanCachePolicy::OB_USE_PLAN_CACHE_DEFAULT;

}

}

// use the first log level hint now.

void ObGlobalHint::merge_log_level_hint(const ObString &log_level)

{

int tmp_ret = OB_SUCCESS;

if (!log_level_.empty() || log_level.empty()) {

// do nothing

} else if (0 == log_level.case_compare("disabled")) {

//allowed for variables

LOG_WARN_RET(tmp_ret, "Log level parse check error", K(tmp_ret));

} else if (OB_UNLIKELY(tmp_ret = OB_LOGGER.parse_check(log_level.ptr(), log_level.length()))) {

LOG_WARN_RET(tmp_ret, "Log level parse check error", K(tmp_ret));

} else {

log_level_.assign_ptr(log_level.ptr(), log_level.length());

}

}

void ObGlobalHint::merge_read_consistency_hint(ObConsistencyLevel read_consistency,

int64_t frozen_version)

{

if (INVALID_CONSISTENCY == read_consistency_) {

read_consistency_ = read_consistency;

frozen_version_ = frozen_version;

} else if (FROZEN == read_consistency_ || FROZEN == read_consistency) {

read_consistency_ = FROZEN;

frozen_version_ = std::max(frozen_version_, frozen_version);

} else if (WEAK == read_consistency_ || WEAK == read_consistency) {

read_consistency_ = WEAK;

frozen_version_ = -1;

} else if (STRONG == read_consistency_ || STRONG == read_consistency) {

read_consistency_ = STRONG;

frozen_version_ = -1;

}

}

void ObGlobalHint::merge_opt_features_version_hint(uint64_t opt_features_version)

{

if (is_valid_opt_features_version(opt_features_version)) {

opt_features_version_ = std::max(opt_features_version_, opt_features_version);

}

}

// zhanyue todo: try remove this later

bool ObGlobalHint::has_hint_exclude_concurrent() const

{

bool bret = false;

return -1 != frozen_version_

|| -1 != topk_precision_

|| 0 != sharding_minimum_row_count_

|| UNSET_QUERY_TIMEOUT != query_timeout_

|| (-1 != tx_id_ && -1 != tm_sessid_)

|| common::INVALID_CONSISTENCY != read_consistency_

|| OB_USE_PLAN_CACHE_INVALID != plan_cache_policy_

|| false != force_trace_log_

|| false != enable_lock_early_release_

|| false != force_refresh_lc_

|| !log_level_.empty()

|| has_parallel_hint()

|| false != monitor_

|| ObPDMLOption::NOT_SPECIFIED != pdml_option_

|| ObParamOption::NOT_SPECIFIED != param_option_

|| !monitoring_ids_.empty()

|| !dops_.empty()

|| !opt_params_.empty()

|| !ob_ddl_schema_versions_.empty()

|| flashback_read_tx_uncommitted_;

}

void ObGlobalHint::reset()

{

frozen_version_ = -1;

topk_precision_ = -1;

sharding_minimum_row_count_ = 0;

query_timeout_ = UNSET_QUERY_TIMEOUT;

tx_id_ = -1;

tm_sessid_ = -1;

read_consistency_ = common::INVALID_CONSISTENCY;

plan_cache_policy_ = OB_USE_PLAN_CACHE_INVALID;

force_trace_log_ = false;

max_concurrent_ = UNSET_MAX_CONCURRENT;

enable_lock_early_release_ = false;

force_refresh_lc_ = false;

log_level_.reset();

parallel_ = UNSET_PARALLEL;

monitor_ = false;

pdml_option_ = ObPDMLOption::NOT_SPECIFIED;

param_option_ = ObParamOption::NOT_SPECIFIED;

monitoring_ids_.reuse();

dops_.reuse();

opt_features_version_ = UNSET_OPT_FEATURES_VERSION;

disable_transform_ = false;

disable_cost_based_transform_ = false;

opt_params_.reset();

ob_ddl_schema_versions_.reuse();

enable_append_ = false;

osg_hint_.flags_ = 0;

has_dbms_stats_hint_ = false;

flashback_read_tx_uncommitted_ = false;

dynamic_sampling_ = ObGlobalHint::UNSET_DYNAMIC_SAMPLING;

}

int ObGlobalHint::merge_global_hint(const ObGlobalHint &other)

{

int ret = OB_SUCCESS;

merge_read_consistency_hint(other.read_consistency_, other.frozen_version_);

merge_topk_hint(other.topk_precision_, other.sharding_minimum_row_count_);

merge_query_timeout_hint(other.query_timeout_);

merge_dblink_info_hint(other.tx_id_, other.tm_sessid_);

enable_lock_early_release_ |= other.enable_lock_early_release_;

merge_log_level_hint(other.log_level_);

enable_lock_early_release_ |= other.enable_lock_early_release_;

force_refresh_lc_ |= other.force_refresh_lc_;

merge_plan_cache_hint(other.plan_cache_policy_);

merge_parallel_dml_hint(other.pdml_option_);

force_trace_log_ |= other.force_trace_log_;

merge_max_concurrent_hint(other.max_concurrent_);

merge_parallel_hint(other.parallel_);

monitor_ |= other.monitor_;

merge_param_option_hint(other.param_option_);

merge_opt_features_version_hint(other.opt_features_version_);

disable_transform_ |= other.disable_transform_;

disable_cost_based_transform_ |= other.disable_cost_based_transform_;

enable_append_ |= other.enable_append_;

osg_hint_.flags_ |= other.osg_hint_.flags_;

has_dbms_stats_hint_ |= other.has_dbms_stats_hint_;

flashback_read_tx_uncommitted_ |= other.flashback_read_tx_uncommitted_;

merge_dynamic_sampling_hint(other.dynamic_sampling_);

if (OB_FAIL(merge_monitor_hints(other.monitoring_ids_))) {

LOG_WARN("failed to merge monitor hints", K(ret));

} else if (OB_FAIL(merge_dop_hint(other.dops_))) {

LOG_WARN("failed to merge dop hints", K(ret));

} else if (OB_FAIL(opt_params_.merge_opt_param_hint(other.opt_params_))) {

LOG_WARN("failed to merge opt param hint", K(ret));

} else if (OB_FAIL(append(ob_ddl_schema_versions_, other.ob_ddl_schema_versions_))) {

LOG_WARN("failed to append ddl_schema_version", K(ret));

}

return ret;

}

int ObGlobalHint::assign(const ObGlobalHint &other)

{

reset();

return merge_global_hint(other);

}

// hints below not print

// MAX_CONCURRENT

// ObDDLSchemaVersionHint

int ObGlobalHint::print_global_hint(PlanText &plan_text) const

{

int ret = OB_SUCCESS;

char *buf = plan_text.buf_;

int64_t &buf_len = plan_text.buf_len_;

int64_t &pos = plan_text.pos_;

const char* outline_indent = ObQueryHint::get_outline_indent(plan_text.is_oneline_);

const bool ignore_parallel_for_dblink = EXPLAIN_DBLINK_STMT == plan_text.type_;

#define PRINT_GLOBAL_HINT_STR(hint_str) \

if (OB_FAIL(BUF_PRINTF("%s%s", outline_indent, hint_str))) { \

LOG_WARN("failed to print hint", K(ret), K(hint_str)); } \

#define PRINT_GLOBAL_HINT_NUM(hint_name, num) \

if (OB_FAIL(BUF_PRINTF("%s%s(%ld)", outline_indent, hint_name, num))) { \

LOG_WARN("failed to print hint", K(ret), K(hint_name)); } \

//TOPK

if (OB_SUCC(ret) && (-1 < topk_precision_ || 0 < sharding_minimum_row_count_)) {

if (OB_FAIL(BUF_PRINTF("%sTOPK(%ld %ld)", outline_indent, topk_precision_,

sharding_minimum_row_count_))) {

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

}

}

// TRACING & STAT

if (OB_SUCC(ret) && !monitoring_ids_.empty()) {

if (OB_FAIL(print_monitoring_hints(plan_text))) {

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

}

}

//DOP

if (OB_SUCC(ret) && !dops_.empty() && !ignore_parallel_for_dblink) {

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

if (OB_FAIL(BUF_PRINTF("%sDOP(%lu, %lu)", outline_indent, dops_.at(i).dfo_, dops_.at(i).dop_))) {

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

}

}

}

//READ_CONSISTENCY && FROZEN_VERSION

if (OB_SUCC(ret) && (read_consistency_ != UNSET_CONSISTENCY)) {

if (FROZEN == read_consistency_ && frozen_version_ != -1) {

PRINT_GLOBAL_HINT_NUM("FROZEN_VERSION", frozen_version_);

} else if (FROZEN == read_consistency_) {

PRINT_GLOBAL_HINT_STR("READ_CONSISTENCY( FROZEN )");

} else if (WEAK == read_consistency_) {

PRINT_GLOBAL_HINT_STR("READ_CONSISTENCY( WEAK )");

} else if (STRONG == read_consistency_) {

PRINT_GLOBAL_HINT_STR("READ_CONSISTENCY( STRONG )");

} else {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected READ_CONSISTENCY", K(ret), K_(read_consistency));

}

}

if (OB_SUCC(ret) && UNSET_QUERY_TIMEOUT != query_timeout_) { //QUERY_TIMEOUT

PRINT_GLOBAL_HINT_NUM("QUERY_TIMEOUT", query_timeout_);

}

if (OB_SUCC(ret) && -1 != tx_id_ && -1 != tm_sessid_) { //DBLINK_INFO

if (OB_FAIL(BUF_PRINTF("%s%s(%ld , %ld)", outline_indent, "DBLINK_INFO", tx_id_, tm_sessid_))) {

LOG_WARN("failed to print hint", K(ret), K("DBLINK_INFO(%lld , %lld)"));

}

}

if (OB_SUCC(ret) && plan_cache_policy_ != OB_USE_PLAN_CACHE_INVALID) { //USE_PLAN_CACHE

const char *plan_cache_policy = "INVALID";

if (OB_USE_PLAN_CACHE_NONE == plan_cache_policy_) {

PRINT_GLOBAL_HINT_STR("USE_PLAN_CACHE( NONE )");

} else if (OB_USE_PLAN_CACHE_DEFAULT == plan_cache_policy_) {

PRINT_GLOBAL_HINT_STR("USE_PLAN_CACHE( DEFAULT )");

} else { }

}

if (OB_SUCC(ret) && force_trace_log_) { //TRACE_LOG

PRINT_GLOBAL_HINT_STR("TRACE_LOG");

}

if (OB_SUCC(ret) && enable_lock_early_release_) { //TRANS_PARAM

if (OB_FAIL(BUF_PRINTF("%sTRANS_PARAM(\'ENABLE_EARLY_LOCK_RELEASE\' \'true\')", outline_indent))) {

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

}

}

if (OB_SUCC(ret) && force_refresh_lc_) { //FORCE_REFRESH_LOCATION_CACHE

PRINT_GLOBAL_HINT_STR("FORCE_REFRESH_LOCATION_CACHE");

}

if (OB_SUCC(ret) && !log_level_.empty()) { //LOG_LEVEL

if (OB_FAIL(BUF_PRINTF("%sLOG_LEVEL(\"%.*s\")", outline_indent,

log_level_.length(), log_level_.ptr() ))) {

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

}

}

if (OB_SUCC(ret) && has_parallel_hint() && !ignore_parallel_for_dblink) { //PARALLEL

if (has_parallel_degree()) {

PRINT_GLOBAL_HINT_NUM("PARALLEL", parallel_);

} else if (enable_auto_dop()) {

PRINT_GLOBAL_HINT_STR("PARALLEL( AUTO )");

} else if (enable_manual_dop()) {

PRINT_GLOBAL_HINT_STR("PARALLEL( MANUAL )");

}

}

if (OB_SUCC(ret) && monitor_) { //MONITOR

PRINT_GLOBAL_HINT_STR("MONITOR");

}

if (OB_SUCC(ret) && ObPDMLOption::NOT_SPECIFIED != pdml_option_) { //PDML

if (ObPDMLOption::ENABLE == pdml_option_) {

if (!ignore_parallel_for_dblink) {

PRINT_GLOBAL_HINT_STR("ENABLE_PARALLEL_DML");

}

} else if (ObPDMLOption::DISABLE == pdml_option_) {

PRINT_GLOBAL_HINT_STR("DISABLE_PARALLEL_DML");

} else {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected pdml hint value", K(ret), K_(pdml_option));

}

}

if (OB_SUCC(ret) && ObParamOption::NOT_SPECIFIED != param_option_) { // PARAM

if (OB_UNLIKELY(ObParamOption::EXACT != param_option_)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected param hint value", K(ret), K_(param_option));

} else {

PRINT_GLOBAL_HINT_STR("CURSOR_SHARING_EXACT");

}

}

// OPTIMIZER_FEATURES_ENABLE

if (OB_SUCC(ret) && (has_valid_opt_features_version())) {

int64_t cur_pos = 0;

const uint64_t version = has_valid_opt_features_version()

? opt_features_version_ : CURRENT_OUTLINE_ENABLE_VERSION;

if (OB_FAIL(BUF_PRINTF("%s%s(\'", outline_indent, "OPTIMIZER_FEATURES_ENABLE"))) {

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

} else if (OB_UNLIKELY(0 == (cur_pos = ObClusterVersion::print_version_str(buf + pos,

buf_len - pos,

version)))) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("failed to print version str", K(ret), K(version));

} else if (OB_FALSE_IT(pos += cur_pos)) {

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

}

}

if (OB_SUCC(ret) && disable_query_transform()) {

PRINT_GLOBAL_HINT_STR("NO_QUERY_TRANSFORMATION");

}

if (OB_SUCC(ret) && disable_cost_based_transform()) {

PRINT_GLOBAL_HINT_STR("NO_COST_BASED_QUERY_TRANSFORMATION");

}

if (OB_SUCC(ret) && has_append()) { // APPEND

PRINT_GLOBAL_HINT_STR("APPEND");

}

if (OB_SUCC(ret) && UNSET_DYNAMIC_SAMPLING != dynamic_sampling_) { //DYNAMIC SAMPLING

PRINT_GLOBAL_HINT_NUM("DYNAMIC_SAMPLING", dynamic_sampling_);

}

if (OB_SUCC(ret) && OB_FAIL(opt_params_.print_opt_param_hint(plan_text))) {

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

}

if (OB_SUCC(ret) && OB_FAIL(osg_hint_.print_osg_hint(plan_text))) {

LOG_WARN("failed to print optimizer statistics gathering hint", K(ret));

}

if (OB_SUCC(ret) && has_dbms_stats_hint()) {

PRINT_GLOBAL_HINT_STR("DBMS_STATS");

}

if (OB_SUCC(ret) && get_flashback_read_tx_uncommitted()) {

PRINT_GLOBAL_HINT_STR("FLASHBACK_READ_TX_UNCOMMITTED");

}

return ret;

}

void ObGlobalHint::merge_osg_hint(int8_t flag) {

osg_hint_.flags_ |= flag;

}

int ObOptimizerStatisticsGatheringHint::print_osg_hint(PlanText &plan_text) const

{

int ret = OB_SUCCESS;

const char* outline_indent = ObQueryHint::get_outline_indent(plan_text.is_oneline_);

char *buf = plan_text.buf_;

int64_t &buf_len = plan_text.buf_len_;

int64_t &pos = plan_text.pos_;

if ((flags_ & OB_NO_OPT_STATS_GATHER)) {

PRINT_GLOBAL_HINT_STR("NO_GATHER_OPTIMIZER_STATISTICS");

}

if (OB_SUCC(ret) && (flags_ & OB_OPT_STATS_GATHER)) {

PRINT_GLOBAL_HINT_STR("GATHER_OPTIMIZER_STATISTICS");

}

if (OB_SUCC(ret) && (flags_ & OB_APPEND_HINT)) {

PRINT_GLOBAL_HINT_STR("APPEND");

}

return ret;

}

int ObGlobalHint::print_monitoring_hints(PlanText &plan_text) const

{

int ret = OB_SUCCESS;

if (!monitoring_ids_.empty()) {

char *buf = plan_text.buf_;

int64_t &buf_len = plan_text.buf_len_;

int64_t &pos = plan_text.pos_;

const char* outline_indent = ObQueryHint::get_outline_indent(plan_text.is_oneline_);

ObSEArray<uint64_t, 4> tracing_ids;

ObSEArray<uint64_t, 4> stat_ids;

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

if ((monitoring_ids_.at(i).flags_ & ObMonitorHint::OB_MONITOR_TRACING)

&& OB_FAIL(tracing_ids.push_back(monitoring_ids_.at(i).id_))) {

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

} else if ((monitoring_ids_.at(i).flags_ & ObMonitorHint::OB_MONITOR_STAT)

&& OB_FAIL(stat_ids.push_back(monitoring_ids_.at(i).id_))) {

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

}

}

if (OB_SUCC(ret) && !tracing_ids.empty()) {

if (OB_FAIL(BUF_PRINTF("%sTRACING(%lu", outline_indent, tracing_ids.at(0)))) {

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

}

for (int64_t i = 1; OB_SUCC(ret) && i < tracing_ids.count(); ++i) {

if (OB_FAIL(BUF_PRINTF(" %lu", tracing_ids.at(i)))) {

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

}

}

if (OB_FAIL(BUF_PRINTF(")"))) {

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

}

}

if (OB_SUCC(ret) && !stat_ids.empty()) {

if (OB_FAIL(BUF_PRINTF("%sSTAT(%lu", outline_indent, stat_ids.at(0)))) {

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

}

for (int64_t i = 1; OB_SUCC(ret) && i < stat_ids.count(); ++i) {

if (OB_FAIL(BUF_PRINTF(" %lu", stat_ids.at(i)))) {

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

}

}

if (OB_FAIL(BUF_PRINTF(")"))) {

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

}

}

}

return ret;

}

DEFINE_ENUM_FUNC(ObOptParamHint::OptParamType, opt_param, OPT_PARAM_TYPE_DEF, ObOptParamHint::);

int ObOptParamHint::print_opt_param_hint(PlanText &plan_text) const

{

int ret = OB_SUCCESS;

if (OB_UNLIKELY(param_types_.count() != param_vals_.count())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected opt param hint", K(ret), K(*this));

} else if (param_types_.empty()) {

/* do nothing*/

} else {

char *buf = plan_text.buf_;

int64_t &buf_len = plan_text.buf_len_;

int64_t &pos = plan_text.pos_;

const char* outline_indent = ObQueryHint::get_outline_indent(plan_text.is_oneline_);

const char* param_name = NULL;

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

if (OB_UNLIKELY(OptParamType::INVALID_OPT_PARAM_TYPE == param_types_.at(i))

|| OB_ISNULL(param_name = get_opt_param_string(param_types_.at(i)))) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected param type in opt param hint", K(ret), K(param_types_.at(i)));

} else if (OB_UNLIKELY(!param_vals_.at(i).is_int() && !param_vals_.at(i).is_varchar())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected param value type", K(ret), K(param_vals_.at(i)));

} else if (OB_FAIL(BUF_PRINTF("%sOPT_PARAM(\'%s\'", outline_indent, param_name))) {

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

} else if (param_vals_.at(i).is_int() &&

OB_FAIL(BUF_PRINTF(" %ld)", param_vals_.at(i).get_int()))) {

LOG_WARN("failed to opt param hint value", K(ret), K(param_vals_.at(i)));

} else if (param_vals_.at(i).is_varchar() &&

OB_FAIL(BUF_PRINTF(" \'%.*s\')", param_vals_.at(i).get_varchar().length(),

param_vals_.at(i).get_varchar().ptr()))) {

LOG_WARN("failed to opt param hint value", K(ret), K(param_vals_.at(i)));

}

}

}

return ret;

}

int ObOptParamHint::merge_opt_param_hint(const ObOptParamHint &other)

{

int ret = OB_SUCCESS;

if (OB_UNLIKELY(param_types_.count() != param_vals_.count()

|| other.param_types_.count() != other.param_vals_.count())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected opt param hint", K(ret), K(other));

}

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

if (OB_FAIL(add_opt_param_hint(other.param_types_.at(i), other.param_vals_.at(i)))) {

LOG_WARN("failed to add opt param hint", K(ret), K(i), K(other));

}

}

return ret;

}

int ObOptParamHint::add_opt_param_hint(const OptParamType param_type, const ObObj &val)

{

int ret = OB_SUCCESS;

ObObj cur_value;

if (!is_param_val_valid(param_type, val)) {

/* do nothing */

} else if (OB_FAIL(get_opt_param(param_type, cur_value))) {

LOG_WARN("failed to get opt param", K(ret), K(param_type));

} else if (!cur_value.is_nop_value()) {

/* exists opt param hint for this type, use the first opt param hint */

} else if (OB_FAIL(param_types_.push_back(param_type))

|| OB_FAIL(param_vals_.push_back(val))) {

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

}

return ret;

}

bool ObOptParamHint::is_param_val_valid(const OptParamType param_type, const ObObj &val)

{

bool is_valid = false;

switch (param_type) {

case HIDDEN_COLUMN_VISIBLE: {

is_valid = val.is_varchar() && (0 == val.get_varchar().case_compare("true")

|| 0 == val.get_varchar().case_compare("false"));

break;

}

case ROWSETS_ENABLED: {

is_valid = val.is_varchar() && (0 == val.get_varchar().case_compare("true")

|| 0 == val.get_varchar().case_compare("false"));

break;

}

case ROWSETS_MAX_ROWS: {

is_valid = val.is_int() && (0 <= val.get_int() && 65535 >= val.get_int());

break;

}

case DDL_EXECUTION_ID: {

is_valid = val.is_int() && (0 <= val.get_int());

break;

}

case DDL_TASK_ID: {

is_valid = val.is_int() && (0 < val.get_int());

break;

}

case ENABLE_NEWSORT: {

is_valid = val.is_varchar() && (0 == val.get_varchar().case_compare("true")

|| 0 == val.get_varchar().case_compare("false"));

break;

}

case USE_PART_SORT_MGB: {

is_valid = val.is_varchar() && (0 == val.get_varchar().case_compare("true")

|| 0 == val.get_varchar().case_compare("false"));

break;

}

case USE_DEFAULT_OPT_STAT: {

is_valid = val.is_varchar() && (0 == val.get_varchar().case_compare("true")

|| 0 == val.get_varchar().case_compare("false"));

break;

}

case ENABLE_IN_RANGE_OPTIMIZATION: {

is_valid = val.is_varchar() && (0 == val.get_varchar().case_compare("true")

|| 0 == val.get_varchar().case_compare("false"));

break;

}

case XSOLAPI_GENERATE_WITH_CLAUSE: {

is_valid = val.is_varchar() && (0 == val.get_varchar().case_compare("true")

|| 0 == val.get_varchar().case_compare("false"));

break;

}

default:

LOG_TRACE("invalid opt param val", K(param_type), K(val));

break;

}

return is_valid;

}

int ObOptParamHint::get_opt_param(const OptParamType param_type, ObObj &val) const

{

int ret = OB_SUCCESS;

int64_t idx = OB_INVALID_INDEX;

val.set_nop_value();

for (int64_t i = 0; OB_INVALID_INDEX == idx && i < param_types_.count(); ++i) {

if (param_type == param_types_.at(i)) {

idx = i;

}

}

if (OB_INVALID_INDEX == idx) {

/* do nothing */

} else if (OB_UNLIKELY(idx < 0 || idx >= param_vals_.count())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected idx in opt param hint", K(ret));

} else {

val = param_vals_.at(idx);

}

return ret;

}

// check opt params with 'true'/'false' value

int ObOptParamHint::has_enable_opt_param(const OptParamType param_type, bool &enabled) const

{

int ret = OB_SUCCESS;

ObObj val;

enabled = false;

if (OB_FAIL(get_opt_param(param_type, val))) {

LOG_WARN("failed to get opt param", K(ret), K(param_type));

} else if (val.is_varchar() && 0 == val.get_varchar().case_compare("true")) {

enabled = true;

}

return ret;

}

int ObOptParamHint::get_bool_opt_param(const OptParamType param_type, bool &val, bool &is_exists) const

{

int ret = OB_SUCCESS;

is_exists = false;

ObObj obj;

if (OB_FAIL(get_opt_param(param_type, obj))) {

LOG_WARN("fail to get rowsets_enabled opt_param", K(ret));

} else if (obj.is_nop_value()) {

// do nothing

} else if (!obj.is_varchar()) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("param obj is invalid", K(ret), K(obj));

} else {

val = (0 == obj.get_varchar().case_compare("true"));

is_exists = true;

}

return ret;

}

int ObOptParamHint::get_bool_opt_param(const OptParamType param_type, bool &val) const

{

bool is_exists = false;

return get_bool_opt_param(param_type, val, is_exists);

}

int ObOptParamHint::get_integer_opt_param(const OptParamType param_type, int64_t &val) const

{

int ret = OB_SUCCESS;

ObObj obj;

if (OB_FAIL(get_opt_param(param_type, obj))) {

LOG_WARN("fail to get rowsets_enabled opt_param", K(ret));

} else if (obj.is_nop_value()) {

// do nothing

} else if (!obj.is_int()) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("param obj is invalid", K(ret), K(obj));

} else {

val = obj.get_int();

}

return ret;

}

int ObOptParamHint::has_opt_param(const OptParamType param_type, bool &has_hint) const

{

int ret = OB_SUCCESS;

has_hint = false;

ObObj obj;

if (OB_FAIL(get_opt_param(param_type, obj))) {

LOG_WARN("fail to get rowsets_enabled opt_param", K(ret));

} else {

has_hint = !obj.is_nop_value();

}

return ret;

}

void ObOptParamHint::reset()

{

param_types_.reuse();

param_vals_.reuse();

}

ObItemType ObHint::get_hint_type(ObItemType type)

{

switch(type) {

// transform hint

case T_NO_EXPAND: return T_USE_CONCAT;

case T_NO_MERGE_HINT: return T_MERGE_HINT;

case T_NO_UNNEST: return T_UNNEST;

case T_NO_PLACE_GROUP_BY: return T_PLACE_GROUP_BY;

case T_INLINE: return T_MATERIALIZE;

case T_NO_SEMI_TO_INNER: return T_SEMI_TO_INNER;

case T_NO_REPLACE_CONST: return T_REPLACE_CONST;

case T_NO_SIMPLIFY_ORDER_BY: return T_SIMPLIFY_ORDER_BY;

case T_NO_SIMPLIFY_GROUP_BY: return T_SIMPLIFY_GROUP_BY;

case T_NO_SIMPLIFY_DISTINCT: return T_SIMPLIFY_DISTINCT;

case T_NO_SIMPLIFY_WINFUNC: return T_SIMPLIFY_WINFUNC;

case T_NO_SIMPLIFY_EXPR: return T_SIMPLIFY_EXPR;

case T_NO_SIMPLIFY_LIMIT: return T_SIMPLIFY_LIMIT;

case T_NO_SIMPLIFY_SUBQUERY: return T_SIMPLIFY_SUBQUERY;

case T_NO_FAST_MINMAX: return T_FAST_MINMAX;

case T_NO_PROJECT_PRUNE: return T_PROJECT_PRUNE;

case T_NO_SIMPLIFY_SET: return T_SIMPLIFY_SET;

case T_NO_OUTER_TO_INNER: return T_OUTER_TO_INNER;

case T_NO_COALESCE_SQ: return T_COALESCE_SQ;

case T_NO_COUNT_TO_EXISTS : return T_COUNT_TO_EXISTS;

case T_NO_LEFT_TO_ANTI : return T_LEFT_TO_ANTI;

case T_NO_PUSH_LIMIT : return T_PUSH_LIMIT;

case T_NO_ELIMINATE_JOIN : return T_ELIMINATE_JOIN;

case T_NO_WIN_MAGIC : return T_WIN_MAGIC;

case T_NO_PRED_DEDUCE: return T_PRED_DEDUCE;

case T_NO_PUSH_PRED_CTE: return T_PUSH_PRED_CTE;

case T_NO_PULLUP_EXPR : return T_PULLUP_EXPR;

case T_NO_AGGR_FIRST_UNNEST: return T_AGGR_FIRST_UNNEST;

case T_NO_JOIN_FIRST_UNNEST: return T_JOIN_FIRST_UNNEST;

// optimize hint

case T_NO_USE_DAS_HINT: return T_USE_DAS_HINT;

case T_NO_USE_COLUMN_STORE_HINT: return T_USE_COLUMN_STORE_HINT;

case T_ORDERED: return T_LEADING;

case T_NO_USE_MERGE: return T_USE_MERGE;

case T_NO_USE_HASH: return T_USE_HASH;

case T_NO_USE_NL: return T_USE_NL;

case T_NO_USE_NL_MATERIALIZATION: return T_USE_NL_MATERIALIZATION;

case T_NO_PX_JOIN_FILTER: return T_PX_JOIN_FILTER;

case T_NO_PX_PART_JOIN_FILTER: return T_PX_PART_JOIN_FILTER;

case T_NO_USE_LATE_MATERIALIZATION: return T_USE_LATE_MATERIALIZATION;

case T_NO_USE_HASH_AGGREGATE: return T_USE_HASH_AGGREGATE;

case T_NO_GBY_PUSHDOWN: return T_GBY_PUSHDOWN;

case T_NO_USE_HASH_DISTINCT: return T_USE_HASH_DISTINCT;

case T_NO_DISTINCT_PUSHDOWN: return T_DISTINCT_PUSHDOWN;

case T_NO_USE_HASH_SET: return T_USE_HASH_SET;

case T_NO_USE_DISTRIBUTED_DML: return T_USE_DISTRIBUTED_DML;

case T_DYNAMIC_SAMPLING: return T_DYNAMIC_SAMPLING;

default: return type;

}

}

const char* ObHint::get_hint_name(ObItemType type, bool is_enable_hint /* default true*/ )

{

switch(type) {

// transform hint

case T_NO_REWRITE: return "NO_REWRITE";

case T_USE_CONCAT: return is_enable_hint ? "USE_CONCAT" : "NO_EXPAND";

case T_MERGE_HINT: return is_enable_hint ? "MERGE" : "NO_MERGE";

case T_UNNEST: return is_enable_hint ? "UNNEST" : "NO_UNNEST";

case T_PLACE_GROUP_BY: return is_enable_hint ? "PLACE_GROUP_BY" : "NO_PLACE_GROUP_BY";

case T_PRED_DEDUCE: return is_enable_hint ? "PRED_DEDUCE" : "NO_PRED_DEDUCE";

case T_PUSH_PRED_CTE: return is_enable_hint ? "PUSH_PRED_CTE" : "NO_PUSH_PRED_CTE";

case T_MATERIALIZE: return is_enable_hint ? "MATERIALIZE" : "INLINE";

case T_SEMI_TO_INNER: return is_enable_hint ? "SEMI_TO_INNER" : "NO_SEMI_TO_INNER";

case T_REPLACE_CONST: return is_enable_hint ? "REPLACE_CONST" :"NO_REPLACE_CONST";

case T_SIMPLIFY_ORDER_BY: return is_enable_hint ? "SIMPLIFY_ORDER_BY" : "NO_SIMPLIFY_ORDER_BY";

case T_SIMPLIFY_GROUP_BY: return is_enable_hint ? "SIMPLIFY_GROUP_BY" : "NO_SIMPLIFY_GROUP_BY";

case T_SIMPLIFY_DISTINCT: return is_enable_hint ? "SIMPLIFY_DISTINCT" : "NO_SIMPLIFY_DISTINCT";

case T_SIMPLIFY_WINFUNC: return is_enable_hint ? "SIMPLIFY_WINFUNC" : "NO_SIMPLIFY_WINFUNC";

case T_SIMPLIFY_EXPR: return is_enable_hint ? "SIMPLIFY_EXPR" : "NO_SIMPLIFY_EXPR";

case T_SIMPLIFY_LIMIT: return is_enable_hint ? "SIMPLIFY_LIMIT" : "NO_SIMPLIFY_LIMIT";

case T_SIMPLIFY_SUBQUERY: return is_enable_hint ? "SIMPLIFY_SUBQUERY" : "NO_SIMPLIFY_SUBQUERY";

case T_FAST_MINMAX: return is_enable_hint ? "FAST_MINMAX" : "NO_FAST_MINMAX";

case T_PROJECT_PRUNE: return is_enable_hint ? "PROJECT_PRUNE" : "NO_PROJECT_PRUNE";

case T_SIMPLIFY_SET: return is_enable_hint ? "SIMPLIFY_SET" : "NO_SIMPLIFY_SET";

case T_OUTER_TO_INNER: return is_enable_hint ? "OUTER_TO_INNER" : "NO_OUTER_TO_INNER";

case T_COALESCE_SQ: return is_enable_hint ? "COALESCE_SQ" : "NO_COALESCE_SQ";

case T_COUNT_TO_EXISTS : return is_enable_hint ? "COUNT_TO_EXISTS" : "NO_COUNT_TO_EXISTS";

case T_LEFT_TO_ANTI : return is_enable_hint ? "LEFT_TO_ANTI" : "NO_LEFT_TO_ANTI";

case T_ELIMINATE_JOIN : return is_enable_hint ? "ELIMINATE_JOIN" : "NO_ELIMINATE_JOIN";

case T_WIN_MAGIC : return is_enable_hint ? "WIN_MAGIC" : "NO_WIN_MAGIC";

case T_PUSH_LIMIT : return is_enable_hint ? "PUSH_LIMIT" : "NO_PUSH_LIMIT";

case T_PULLUP_EXPR : return is_enable_hint ? "PULLUP_EXPR" : "NO_PULLUP_EXPR";

case T_AGGR_FIRST_UNNEST: return is_enable_hint ? "AGGR_FIRST_UNNEST" : "NO_AGGR_FIRST_UNNEST";

case T_JOIN_FIRST_UNNEST: return is_enable_hint ? "JOIN_FIRST_UNNEST" : "NO_JOIN_FIRST_UNNEST";

// optimize hint

case T_INDEX_HINT: return "INDEX";

case T_FULL_HINT: return "FULL";

case T_NO_INDEX_HINT: return "NO_INDEX";

case T_USE_DAS_HINT: return is_enable_hint ? "USE_DAS" : "NO_USE_DAS";

case T_USE_COLUMN_STORE_HINT: return is_enable_hint ? "USE_COLUMN_TABLE" : "NO_USE_COLUMN_TABLE";

case T_INDEX_SS_HINT: return "INDEX_SS";

case T_INDEX_SS_ASC_HINT: return "INDEX_SS_ASC";

case T_INDEX_SS_DESC_HINT: return "INDEX_SS_DESC";

case T_LEADING: return is_enable_hint ? "LEADING" : "ORDERED";

case T_USE_MERGE: return is_enable_hint ? "USE_MERGE" : "NO_USE_MERGE";

case T_USE_HASH: return is_enable_hint ? "USE_HASH" : "NO_USE_HASH";

case T_USE_NL: return is_enable_hint ? "USE_NL" : "NO_USE_NL";

case T_USE_NL_MATERIALIZATION: return is_enable_hint ? "USE_NL_MATERIALIZATION"

: "NO_USE_NL_MATERIALIZATION";

case T_PX_JOIN_FILTER: return is_enable_hint ? "PX_JOIN_FILTER" : "NO_PX_JOIN_FILTER";

case T_PX_PART_JOIN_FILTER: return is_enable_hint ? "PX_PART_JOIN_FILTER" : "NO_PX_PART_JOIN_FILTER";

case T_PQ_DISTRIBUTE: return "PQ_DISTRIBUTE";

case T_PQ_MAP: return "PQ_MAP";

case T_PQ_SET: return "PQ_SET";

case T_USE_LATE_MATERIALIZATION: return is_enable_hint ? "USE_LATE_MATERIALIZATION"

: "NO_USE_LATE_MATERIALIZATION";

case T_USE_HASH_AGGREGATE: return is_enable_hint ? "USE_HASH_AGGREGATION"

: "NO_USE_HASH_AGGREGATION";

case T_TABLE_PARALLEL: return "PARALLEL";

case T_PQ_DISTRIBUTE_WINDOW: return "PQ_DISTRIBUTE_WINDOW";

case T_GBY_PUSHDOWN: return is_enable_hint ? "GBY_PUSHDOWN" : "NO_GBY_PUSHDOWN";

case T_USE_HASH_DISTINCT: return is_enable_hint ? "USE_HASH_DISTINCT" : "NO_USE_HASH_DISTINCT";

case T_DISTINCT_PUSHDOWN: return is_enable_hint ? "DISTINCT_PUSHDOWN" : "NO_DISTINCT_PUSHDOWN";

case T_USE_HASH_SET: return is_enable_hint ? "USE_HASH_SET" : "NO_USE_HASH_SET";

case T_USE_DISTRIBUTED_DML: return is_enable_hint ? "USE_DISTRIBUTED_DML" : "NO_USE_DISTRIBUTED_DML";

case T_TABLE_DYNAMIC_SAMPLING: return "DYNAMIC_SAMPLING";

default: return NULL;

}

}

int ObHint::print_hint(PlanText &plan_text) const

{

int ret = OB_SUCCESS;

const ObHint *hint = plan_text.is_used_hint_ ? get_orig_hint() : this;

char *buf = plan_text.buf_;

int64_t &buf_len = plan_text.buf_len_;

int64_t &pos = plan_text.pos_;

int64_t old_pos1 = -1;

int64_t old_pos2 = -1;

if (OB_FAIL(BUF_PRINTF("%s%s(", ObQueryHint::get_outline_indent(plan_text.is_oneline_),

get_hint_name()))) {

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

} else if (OB_FALSE_IT(old_pos1 = pos)) {

} else if (!hint->qb_name_.empty() &&

OB_FAIL(BUF_PRINTF("@\"%.*s\" ", hint->qb_name_.length(), hint->qb_name_.ptr()))) {

LOG_WARN("failed to print qb_name", K(ret));

} else if (!hint->qb_name_.empty() && OB_FALSE_IT(old_pos2 = pos)) {

} else if (OB_FAIL(hint->print_hint_desc(plan_text))) {

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

} else if (old_pos1 == pos) {

pos = old_pos1 - 1; // delete "(" print before

} else if (old_pos2 == pos && OB_FALSE_IT(pos = old_pos2 - 1)) { // delete " " after qb_name

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

} else { /* do nothing */ }

return ret;

}

int ObHint::print_hint_desc(PlanText &plan_text) const

{

UNUSED(plan_text);

return OB_SUCCESS;