561 lines
20 KiB
C++
561 lines
20 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 SQL_PC
|
|
#include "sql/plan_cache/ob_pcv_set.h"
|
|
#include "sql/ob_sql_context.h"
|
|
#include "sql/plan_cache/ob_pc_ref_handle.h"
|
|
#include "share/schema/ob_table_schema.h"
|
|
#include "share/ob_cluster_version.h"
|
|
#include "share/config/ob_server_config.h"
|
|
#include "lib/container/ob_bit_set.h"
|
|
#include "lib/charset/ob_charset.h"
|
|
|
|
using namespace oceanbase::common;
|
|
using namespace oceanbase::share::schema;
|
|
|
|
namespace oceanbase
|
|
{
|
|
namespace sql
|
|
{
|
|
|
|
int ObPCVSet::init(ObILibCacheCtx &ctx, const ObILibCacheObject *obj)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObSQLSessionInfo* sess;
|
|
#ifdef OB_BUILD_SPM
|
|
bool is_spm_on = false;
|
|
#endif
|
|
ObPlanCacheCtx &pc_ctx = static_cast<ObPlanCacheCtx&>(ctx);
|
|
const ObPlanCacheObject *cache_obj = static_cast<const ObPlanCacheObject*>(obj);
|
|
if (is_inited_) {
|
|
ret = OB_INIT_TWICE;
|
|
LOG_WARN("init twice", K(ret));
|
|
} else if (OB_ISNULL(lib_cache_) || OB_ISNULL(cache_obj)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("invalid argument", K(ret));
|
|
} else if (NULL == (sess = pc_ctx.sql_ctx_.session_info_)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
SQL_PC_LOG(WARN, "session info is null", K(ret));
|
|
#ifdef OB_BUILD_SPM
|
|
} else if (OB_FAIL(sess->get_use_plan_baseline(is_spm_on))) {
|
|
LOG_WARN("fail to get spm config");
|
|
} else if (FALSE_IT(is_spm_closed_ = (!is_spm_on))) {
|
|
// do nothing
|
|
#endif
|
|
} else if (NULL == (pc_alloc_ = lib_cache_->get_pc_allocator())) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("invalid plan cache allocator", K_(pc_alloc), K(ret));
|
|
} else {
|
|
if (OB_FAIL(pc_key_.deep_copy(allocator_, pc_ctx.fp_result_.pc_key_))) {
|
|
LOG_WARN("fail to init plan cache key in pcv set", K(ret));
|
|
} else if (OB_FAIL(deep_copy_sql(pc_ctx.raw_sql_))) {
|
|
LOG_WARN("fail to deep_copy_sql", K(ret), K(pc_ctx.raw_sql_));
|
|
} else {
|
|
is_inited_ = true;
|
|
if (pc_ctx.exec_ctx_.get_min_cluster_version() != GET_MIN_CLUSTER_VERSION()) {
|
|
LOG_TRACE("Lob Debug, using remote min cluster version",
|
|
K(pc_ctx.exec_ctx_.get_min_cluster_version()),
|
|
K(GET_MIN_CLUSTER_VERSION()));
|
|
}
|
|
min_cluster_version_ = pc_ctx.exec_ctx_.get_min_cluster_version();
|
|
normal_parse_const_cnt_ = pc_ctx.normal_parse_const_cnt_;
|
|
LOG_TRACE("inited pcv set", K(pc_key_), K(ObTimeUtility::current_time()));
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void ObPCVSet::destroy()
|
|
{
|
|
if (is_inited_) {
|
|
while (!pcv_list_.is_empty()) {
|
|
ObPlanCacheValue *pcv= pcv_list_.get_first();
|
|
if (OB_ISNULL(pcv)) {
|
|
//do nothing;
|
|
} else {
|
|
pcv_list_.remove(pcv);
|
|
free_pcv(pcv);
|
|
pcv = NULL;
|
|
}
|
|
}
|
|
pc_key_.destory(allocator_);
|
|
pc_key_.reset();
|
|
if (NULL != sql_.ptr()) {
|
|
allocator_.free(sql_.ptr());
|
|
}
|
|
|
|
// free sql_id list
|
|
for (int64_t i = 0; i < sql_ids_.count(); i++) {
|
|
if (NULL != sql_ids_[i].ptr()) {
|
|
allocator_.free(sql_ids_[i].ptr());
|
|
}
|
|
}
|
|
sql_ids_.reset();
|
|
sql_.reset();
|
|
normal_parse_const_cnt_ = 0;
|
|
min_cluster_version_ = 0;
|
|
plan_num_ = 0;
|
|
need_check_gen_tbl_col_ = false;
|
|
is_inited_ = false;
|
|
}
|
|
}
|
|
|
|
//1.检查fast parser识别常量个数是否与正常parser识别常量个数一致
|
|
//2.通过match 每个pcv中db_id, sys_vars, not params找到对应的pcv
|
|
//3.在pcv中get plan
|
|
int ObPCVSet::inner_get_cache_obj(ObILibCacheCtx &ctx,
|
|
ObILibCacheKey *key,
|
|
ObILibCacheObject *&cache_obj)
|
|
{
|
|
UNUSED(key);
|
|
int ret = OB_SUCCESS;
|
|
#ifdef OB_BUILD_SPM
|
|
bool is_spm_on = false;
|
|
#endif
|
|
ObPlanCacheObject *plan = NULL;
|
|
ObPlanCacheCtx &pc_ctx = static_cast<ObPlanCacheCtx&>(ctx);
|
|
if (PC_PS_MODE == pc_ctx.mode_ || PC_PL_MODE == pc_ctx.mode_) {
|
|
if (normal_parse_const_cnt_ != pc_ctx.fp_result_.parameterized_params_.count()) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("param num is not equal", K_(normal_parse_const_cnt),
|
|
"parameterized_params_count", pc_ctx.fp_result_.parameterized_params_.count());
|
|
}
|
|
} else {
|
|
if (normal_parse_const_cnt_ != pc_ctx.fp_result_.raw_params_.count()) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
SQL_PC_LOG(TRACE, "const number of fast parse and normal parse is different",
|
|
"fast_parse_const_num", pc_ctx.fp_result_.raw_params_.count(),
|
|
K_(normal_parse_const_cnt),
|
|
K(pc_ctx.fp_result_.raw_params_));
|
|
}
|
|
}
|
|
if (pc_ctx.exec_ctx_.get_min_cluster_version() != GET_MIN_CLUSTER_VERSION()) {
|
|
LOG_TRACE("Lob Debug, using remote min cluster version",
|
|
K(pc_ctx.exec_ctx_.get_min_cluster_version()),
|
|
K(GET_MIN_CLUSTER_VERSION()));
|
|
}
|
|
if (OB_FAIL(ret)) {
|
|
} else if (min_cluster_version_ != pc_ctx.exec_ctx_.get_min_cluster_version()) {
|
|
ret = OB_OLD_SCHEMA_VERSION;
|
|
} else if (need_check_gen_tbl_col_) {
|
|
// 检查是否有generated table投影列同名的可能
|
|
bool contain_dup_col = false;
|
|
if (OB_FAIL(check_raw_param_for_dup_col(pc_ctx, contain_dup_col))) {
|
|
LOG_WARN("failed to check raw param for dup col", K(ret));
|
|
} else if (contain_dup_col) {
|
|
ret = OB_SQL_PC_NOT_EXIST;
|
|
}
|
|
}
|
|
if (OB_FAIL(ret)) {
|
|
} else if (OB_ISNULL(pc_ctx.sql_ctx_.schema_guard_) ||
|
|
OB_ISNULL(pc_ctx.sql_ctx_.session_info_)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("unexpected null schema guard",
|
|
K(ret), K(pc_ctx.sql_ctx_.schema_guard_), K(pc_ctx.sql_ctx_.session_info_));
|
|
#ifdef OB_BUILD_SPM
|
|
} else if (OB_FAIL(pc_ctx.sql_ctx_.session_info_->get_use_plan_baseline(is_spm_on))) {
|
|
LOG_WARN("failed to get spm status", K(ret));
|
|
} else if (is_spm_closed_ != (!is_spm_on)) {
|
|
// spm param is altered
|
|
ret = OB_OLD_SCHEMA_VERSION;
|
|
#endif
|
|
} else {
|
|
ObSEArray<PCVSchemaObj, 4> schema_array;
|
|
//plan cache匹配临时表应该始终使用用户创建的session才能保证语义的正确性
|
|
//远端执行的时候会创建临时的session对象，其session_id也是临时的，
|
|
//所以这里必须使用get_sessid_for_table()规则去判断
|
|
pc_ctx.sql_ctx_.schema_guard_->set_session_id(
|
|
pc_ctx.sql_ctx_.session_info_->get_sessid_for_table());
|
|
ObPlanCacheValue *matched_pcv = NULL;
|
|
int64_t new_tenant_schema_version = OB_INVALID_VERSION;
|
|
bool need_check_schema = true;
|
|
DLIST_FOREACH(pcv, pcv_list_) {
|
|
bool is_same = false;
|
|
LOG_TRACE("get plan, pcv", K(pcv));
|
|
if (OB_FAIL(pcv->get_all_dep_schema(pc_ctx,
|
|
pc_ctx.sql_ctx_.session_info_->get_database_id(),
|
|
new_tenant_schema_version,
|
|
need_check_schema,
|
|
schema_array))) {
|
|
if (OB_OLD_SCHEMA_VERSION == ret) {
|
|
LOG_TRACE("failed to get all table schema", K(ret));
|
|
} else {
|
|
LOG_WARN("failed to get all table schema", K(ret));
|
|
}
|
|
} else if (OB_FAIL(pcv->match(pc_ctx, schema_array, is_same))) {
|
|
LOG_WARN("fail to match pcv when get plan", K(ret));
|
|
} else if (false == is_same) {
|
|
LOG_TRACE("failed to match param");
|
|
/*do nothing*/
|
|
} else {
|
|
matched_pcv = pcv;
|
|
if (OB_FAIL(pcv->choose_plan(pc_ctx, schema_array, plan))) {
|
|
LOG_TRACE("failed to get plan in plan cache value", K(ret));
|
|
}
|
|
break;
|
|
}
|
|
} //end foreach
|
|
// 如果tenant schema变化了, 但table schema没有过期, 则更新tenant schema
|
|
// plan必须不为NULL，因为下层可能会有覆盖错误码的行为，即使计划没有匹配上，
|
|
// ret仍然为success，此时tenant schema version又会被推高，可能有正确性问题
|
|
// bug link：
|
|
if (OB_SUCC(ret) && NULL != matched_pcv && NULL != plan) {
|
|
if (OB_FAIL(matched_pcv->lift_tenant_schema_version(new_tenant_schema_version))) {
|
|
LOG_WARN("failed to lift pcv's tenant schema version", K(ret));
|
|
} else if (!need_check_schema && OB_NOT_NULL(pc_ctx.exec_ctx_.get_physical_plan_ctx())) {
|
|
pc_ctx.exec_ctx_.get_physical_plan_ctx()->set_tenant_schema_version(new_tenant_schema_version);
|
|
}
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
cache_obj = plan;
|
|
if (NULL == plan) {
|
|
ret = OB_SQL_PC_NOT_EXIST;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
//1.通过match 每个pcv中db_id, sys_vars, not params找到对应的pcv
|
|
//2.如果匹配的pcv则在pcv中add plan， 否则重新生成pcv并add plan
|
|
int ObPCVSet::inner_add_cache_obj(ObILibCacheCtx &ctx,
|
|
ObILibCacheKey *key,
|
|
ObILibCacheObject *cache_obj)
|
|
{
|
|
UNUSED(key);
|
|
int ret = OB_SUCCESS;
|
|
bool is_new = true;
|
|
ObPlanCacheObject *plan = static_cast<ObPlanCacheObject*>(cache_obj);
|
|
ObPlanCacheCtx &pc_ctx = static_cast<ObPlanCacheCtx&>(ctx);
|
|
ObSEArray<PCVSchemaObj, 4> schema_array;
|
|
if (OB_ISNULL(plan) ||
|
|
OB_ISNULL(pc_ctx.sql_ctx_.schema_guard_) ||
|
|
OB_ISNULL(pc_ctx.sql_ctx_.session_info_)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("invalid argument", K(ret), K(plan),
|
|
K(pc_ctx.sql_ctx_.schema_guard_),
|
|
K(pc_ctx.sql_ctx_.session_info_));
|
|
} else if (get_plan_num() >= MAX_PCV_SET_PLAN_NUM) {
|
|
static const int64_t PRINT_PLAN_EXCEEDS_LOG_INTERVAL = 20 * 1000 * 1000; // 20s
|
|
ret = OB_REACH_MEMORY_LIMIT;
|
|
if (REACH_TIME_INTERVAL(PRINT_PLAN_EXCEEDS_LOG_INTERVAL)) {
|
|
LOG_INFO("number of plans in a single pcv_set reach limit", K(ret), K(get_plan_num()), K(pc_ctx));
|
|
}
|
|
} else if (OB_FAIL(ObPlanCacheValue::get_all_dep_schema(*pc_ctx.sql_ctx_.schema_guard_,
|
|
plan->get_dependency_table(),
|
|
schema_array))) {
|
|
LOG_WARN("failed to get all dep schema", K(ret));
|
|
} else {
|
|
DLIST_FOREACH(pcv, pcv_list_) {
|
|
bool is_same = false;
|
|
LOG_DEBUG("add plan, pcv", K(pcv));
|
|
if (OB_FAIL(pcv->match(pc_ctx, schema_array, is_same))) {
|
|
LOG_WARN("fail to match pcv in pcv_set", K(ret));
|
|
} else if (is_same) {
|
|
is_new = false;
|
|
LOG_INFO("has identical pcv", K(is_same), K(pcv));
|
|
if (OB_FAIL(pcv->add_plan(*plan, schema_array, pc_ctx))) {
|
|
if (OB_SQL_PC_PLAN_DUPLICATE == ret
|
|
|| is_not_supported_err(ret)) {
|
|
LOG_TRACE("fail to add plan to pcv", K(ret));
|
|
} else {
|
|
LOG_WARN("fail to add plan to pcv", K(ret));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
} //for end
|
|
}
|
|
if (OB_SUCC(ret) && is_new) {
|
|
ObPlanCacheValue *pcv = NULL;
|
|
if (OB_FAIL(create_pcv_and_add_plan(plan,
|
|
pc_ctx,
|
|
schema_array,
|
|
pcv))) {
|
|
if (!is_not_supported_err(ret)) {
|
|
LOG_WARN("fail to create and add pcv", K(ret));
|
|
}
|
|
} else if (NULL == pcv) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
} else if (!pcv_list_.add_last(pcv)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("fail to add pcv to pcv_list", K(ret));
|
|
free_pcv(pcv);
|
|
pcv = NULL;
|
|
} else {
|
|
// do nothing
|
|
}
|
|
}
|
|
|
|
//在add plan时维护一个最小的merged version, 用于后台在淘汰时进行检查;
|
|
if (OB_SUCC(ret)) {
|
|
if (OB_FAIL(set_raw_param_info_if_needed(plan))) {
|
|
LOG_WARN("failed to set raw param info", K(ret));
|
|
} else {
|
|
// inc plan num if succeeds
|
|
plan_num_ += 1;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
//生成pcv并add plan
|
|
int ObPCVSet::create_pcv_and_add_plan(ObPlanCacheObject *cache_obj,
|
|
ObPlanCacheCtx &pc_ctx,
|
|
const ObIArray<PCVSchemaObj> &schema_array,
|
|
ObPlanCacheValue *&new_pcv)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
new_pcv = nullptr;
|
|
common::ObString sql_id;
|
|
common::ObString sql_id_org(common::OB_MAX_SQL_ID_LENGTH, (const char*)&pc_ctx.sql_ctx_.sql_id_);
|
|
//create pcv and init
|
|
if (OB_ISNULL(cache_obj) ||
|
|
OB_ISNULL(pc_ctx.sql_ctx_.schema_guard_)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
SQL_PC_LOG(WARN, "invalid argument", K(ret));
|
|
} else if (OB_FAIL(create_new_pcv(new_pcv))) {
|
|
SQL_PC_LOG(WARN, "failed to create new plan cache value", K(ret));
|
|
} else if (OB_UNLIKELY(nullptr == new_pcv)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected null for new_pcv", K(new_pcv));
|
|
} else if (OB_FAIL(new_pcv->init(this, cache_obj, pc_ctx))) {
|
|
SQL_PC_LOG(WARN, "failed to init plan cache value");
|
|
} else if (OB_FAIL(ob_write_string(allocator_, sql_id_org, sql_id))) {
|
|
SQL_PC_LOG(WARN, "failed to deep copy sql_id_", K(sql_id_org), K(ret));
|
|
} else if (OB_FAIL(push_sql_id(sql_id))) {
|
|
SQL_PC_LOG(WARN, "failed to push sql_id_", K(ret));
|
|
} else {
|
|
// do nothing
|
|
}
|
|
|
|
//add plan
|
|
if (OB_SUCC(ret)) {
|
|
if (OB_FAIL(new_pcv->add_plan(*cache_obj, schema_array, pc_ctx))) {
|
|
if (!is_not_supported_err(ret)) {
|
|
SQL_PC_LOG(WARN, "failed to add plan to plan cache value", K(ret));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (OB_FAIL(ret) && nullptr != new_pcv) {
|
|
free_pcv(new_pcv);
|
|
new_pcv = nullptr;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObPCVSet::deep_copy_sql(const ObString &sql)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (OB_ISNULL(sql.ptr())) {
|
|
SQL_PC_LOG(TRACE, "sql is empty, ignore copy sql", K(ret), K(lbt()));
|
|
} else if (OB_FAIL(ob_write_string(allocator_, sql, sql_))) {
|
|
SQL_PC_LOG(WARN, "deep copy sql into pcv_set failed", K(ret), K(sql));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObPCVSet::create_new_pcv(ObPlanCacheValue *&new_pcv)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
void *buff = nullptr;
|
|
new_pcv = nullptr;
|
|
|
|
if (nullptr == (buff = allocator_.alloc(sizeof(ObPlanCacheValue)))) {
|
|
ret = OB_ALLOCATE_MEMORY_FAILED;
|
|
LOG_WARN("failed to allocate memory for ObPlanCacheValue", K(ret));
|
|
} else if (nullptr == (new_pcv = new(buff)ObPlanCacheValue())) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("failed to construct ObPlanCacheValue", K(ret));
|
|
} else {
|
|
// do nothing
|
|
}
|
|
|
|
if (OB_SUCC(ret)) {
|
|
// do nothing
|
|
} else if (nullptr != new_pcv) { // cleanup
|
|
new_pcv->~ObPlanCacheValue();
|
|
allocator_.free(new_pcv);
|
|
new_pcv = nullptr;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void ObPCVSet::free_pcv(ObPlanCacheValue *pcv)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (OB_ISNULL(pcv)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("invalid argument", K(pcv), K(ret));
|
|
} else {
|
|
pcv->~ObPlanCacheValue();
|
|
allocator_.free(pcv);
|
|
pcv = nullptr;
|
|
}
|
|
}
|
|
|
|
int ObPCVSet::set_raw_param_info_if_needed(ObPlanCacheObject *cache_obj)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObPhysicalPlan *plan = NULL;
|
|
col_field_arr_.reset();
|
|
col_field_arr_.set_allocator(&allocator_);
|
|
ObBitSet<> visited_idx;
|
|
PCColStruct col_item;
|
|
if (need_check_gen_tbl_col_) {
|
|
// do nothing
|
|
} else if (OB_ISNULL(cache_obj)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("invalid argument", K(cache_obj));
|
|
} else if (OB_ISNULL(plan = dynamic_cast<ObPhysicalPlan *>(cache_obj))) {
|
|
// do nothing
|
|
} else if (!plan->contain_paramed_column_field()) {
|
|
// do nothing
|
|
} else if (OB_FAIL(col_field_arr_.reserve(plan->get_field_columns().count()))) {
|
|
LOG_WARN("failed to init fixed array",
|
|
K(ret), K(plan->get_field_columns().count()));
|
|
} else {
|
|
for (int64_t i = 0; i < plan->get_field_columns().count(); i++) {
|
|
const ObField &cur_field = plan->get_field_columns().at(i);
|
|
if (!cur_field.is_paramed_select_item_ || OB_ISNULL(cur_field.paramed_ctx_)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("Invalid argument", K(ret), K(cur_field.is_paramed_select_item_), K(cur_field.paramed_ctx_));
|
|
} else if (visited_idx.has_member(i) || !cur_field.paramed_ctx_->need_check_dup_name_) {
|
|
// do nothing
|
|
} else {
|
|
if (OB_FAIL(visited_idx.add_member(i))) {
|
|
LOG_WARN("failed to add member", K(ret), K(i));
|
|
} else if (OB_FAIL(col_item.param_idxs_.assign(cur_field.paramed_ctx_->param_idxs_))) {
|
|
LOG_WARN("failed to assign array", K(ret));
|
|
} else if (OB_FAIL(col_field_arr_.push_back(col_item))) {
|
|
LOG_WARN("failed to push back element", K(ret));
|
|
} else {
|
|
// do nothing
|
|
}
|
|
col_item.reset();
|
|
for (int64_t j = i + 1; OB_SUCC(ret) && j < plan->get_field_columns().count(); j++) {
|
|
const ObField &next_field = plan->get_field_columns().at(j);
|
|
if (!next_field.is_paramed_select_item_ || OB_ISNULL(next_field.paramed_ctx_)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("Invalid argument", K(ret), K(next_field.is_paramed_select_item_), K(next_field.paramed_ctx_));
|
|
} else if (visited_idx.has_member(j) || !next_field.paramed_ctx_->need_check_dup_name_) {
|
|
// do nothing
|
|
} else if (ObCharset::case_compat_mode_equal(cur_field.paramed_ctx_->paramed_cname_,
|
|
next_field.paramed_ctx_->paramed_cname_)) {
|
|
if (OB_FAIL(visited_idx.add_member(j))) {
|
|
LOG_WARN("failed to add member", K(ret));
|
|
} else if (OB_FAIL(col_item.param_idxs_.assign(next_field.paramed_ctx_->param_idxs_))) {
|
|
LOG_WARN("failed to assign array", K(ret));
|
|
} else if (OB_FAIL(col_field_arr_.push_back(col_item))) {
|
|
LOG_WARN("failed to push back element");
|
|
} else {
|
|
col_item.reset();
|
|
}
|
|
} else {
|
|
// do nothing
|
|
}
|
|
} // for end
|
|
if (OB_SUCC(ret)) {
|
|
col_field_arr_.at(col_field_arr_.count() - 1).is_last_ = true;
|
|
}
|
|
}
|
|
}
|
|
if (OB_SUCC(ret)) {
|
|
need_check_gen_tbl_col_ = true;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObPCVSet::check_raw_param_for_dup_col(ObPlanCacheCtx &pc_ctx, bool &contain_dup_col)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
contain_dup_col = false;
|
|
if (!need_check_gen_tbl_col_) {
|
|
// do nothing
|
|
} else {
|
|
for (int64_t cur_idx = 0; OB_SUCC(ret) && !contain_dup_col && cur_idx < col_field_arr_.count();
|
|
cur_idx++) {
|
|
if (col_field_arr_.at(cur_idx).is_last_) {
|
|
// do nothing
|
|
} else {
|
|
PCColStruct &left_col_item = col_field_arr_.at(cur_idx);
|
|
PCColStruct &right_col_item = col_field_arr_.at(cur_idx + 1);
|
|
bool all_same = true;
|
|
ObIArray<ObPCParam *> &raw_params = pc_ctx.fp_result_.raw_params_;
|
|
for (int64_t i = 0; OB_SUCC(ret) && all_same && i < left_col_item.param_idxs_.count(); i++) {
|
|
int64_t l_idx = left_col_item.param_idxs_.at(i);
|
|
int64_t r_idx = right_col_item.param_idxs_.at(i);
|
|
if (OB_ISNULL(raw_params.at(l_idx)) ||
|
|
OB_ISNULL(raw_params.at(r_idx)) ||
|
|
OB_ISNULL(raw_params.at(l_idx)->node_) ||
|
|
OB_ISNULL(raw_params.at(r_idx)->node_)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("invalid argument", K(ret));
|
|
} else {
|
|
ObString l_tmp_str(raw_params.at(l_idx)->node_->text_len_,
|
|
raw_params.at(l_idx)->node_->raw_text_);
|
|
ObString r_tmp_str(raw_params.at(r_idx)->node_->text_len_,
|
|
raw_params.at(r_idx)->node_->raw_text_);
|
|
|
|
if (0 != l_tmp_str.compare(r_tmp_str)) {
|
|
all_same = false;
|
|
LOG_TRACE("raw text not matched", K(l_tmp_str), K(r_tmp_str));
|
|
}
|
|
}
|
|
} // for end
|
|
contain_dup_col = all_same;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
int ObPCVSet::check_contains_table(uint64_t db_id, common::ObString tab_name, bool &contains)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
DLIST_FOREACH(pcv, pcv_list_) {
|
|
if (OB_ISNULL(pcv)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("invalid argument", K(pcv), K(ret));
|
|
} else if (OB_FAIL(pcv->check_contains_table(db_id, tab_name, contains))) {
|
|
LOG_WARN("fail to check table name", K(ret), K(db_id), K(tab_name));
|
|
} else if (!contains) {
|
|
// continue find
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
#ifdef OB_BUILD_SPM
|
|
int ObPCVSet::get_evolving_evolution_task(EvolutionPlanList &evo_task_list)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
DLIST_FOREACH(pcv, pcv_list_) {
|
|
if (OB_ISNULL(pcv)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_WARN("invalid argument", K(pcv), K(ret));
|
|
} else if (OB_FAIL(pcv->get_evolving_evolution_task(evo_task_list))) {
|
|
LOG_WARN("fail to get evolving evolution task", K(ret));
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
}
|
|
}
|