hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Fix the core caused by plan cache double free

Browse Source
This commit is contained in:
obdev
2023-04-20 11:15:53 +00:00
committed by ob-robot
parent 0dbff9d9b9
commit 2657770e7f
5 changed files with 89 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/sql/plan_cache/ob_lib_cache_object_manager.cpp
View File

@ -76,6 +76,7 @@ int ObLCObjectManager::alloc(ObCacheObjGuard& guard,
if (OB_FAIL(alloc_cache_obj_map_.set_refactored(obj_id, cache_obj))) { if (OB_FAIL(alloc_cache_obj_map_.set_refactored(obj_id, cache_obj))) {
LOG_WARN("failed to add element to hashmap", K(ret)); LOG_WARN("failed to add element to hashmap", K(ret));
inner_free(cache_obj); inner_free(cache_obj);
entity = NULL;
cache_obj = NULL; cache_obj = NULL;
} }
} }

22
src/sql/plan_cache/ob_pcv_set.cpp
View File

@ -54,13 +54,13 @@ int ObPCVSet::init(ObILibCacheCtx &ctx, const ObILibCacheObject *obj)
} else { } else {
is_inited_ = true; is_inited_ = true;
if (pc_ctx.exec_ctx_.get_min_cluster_version() != GET_MIN_CLUSTER_VERSION()) { if (pc_ctx.exec_ctx_.get_min_cluster_version() != GET_MIN_CLUSTER_VERSION()) {
LOG_DEBUG("Lob Debug, using remote min cluster version", LOG_TRACE("Lob Debug, using remote min cluster version",
K(pc_ctx.exec_ctx_.get_min_cluster_version()), K(pc_ctx.exec_ctx_.get_min_cluster_version()),
K(GET_MIN_CLUSTER_VERSION())); K(GET_MIN_CLUSTER_VERSION()));
} }
min_cluster_version_ = pc_ctx.exec_ctx_.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_; normal_parse_const_cnt_ = pc_ctx.normal_parse_const_cnt_;
LOG_DEBUG("inited pcv set", K(pc_key_), K(ObTimeUtility::current_time())); LOG_TRACE("inited pcv set", K(pc_key_), K(ObTimeUtility::current_time()));
} }
} }
return ret; return ret;
@ -121,14 +121,14 @@ int ObPCVSet::inner_get_cache_obj(ObILibCacheCtx &ctx,
} else { } else {
if (normal_parse_const_cnt_ != pc_ctx.fp_result_.raw_params_.count()) { if (normal_parse_const_cnt_ != pc_ctx.fp_result_.raw_params_.count()) {
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
SQL_PC_LOG(DEBUG, "const number of fast parse and normal parse is different", 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(), "fast_parse_const_num", pc_ctx.fp_result_.raw_params_.count(),
K_(normal_parse_const_cnt), K_(normal_parse_const_cnt),
K(pc_ctx.fp_result_.raw_params_)); K(pc_ctx.fp_result_.raw_params_));
} }
} }
if (pc_ctx.exec_ctx_.get_min_cluster_version() != GET_MIN_CLUSTER_VERSION()) { if (pc_ctx.exec_ctx_.get_min_cluster_version() != GET_MIN_CLUSTER_VERSION()) {
LOG_DEBUG("Lob Debug, using remote min cluster version", LOG_TRACE("Lob Debug, using remote min cluster version",
K(pc_ctx.exec_ctx_.get_min_cluster_version()), K(pc_ctx.exec_ctx_.get_min_cluster_version()),
K(GET_MIN_CLUSTER_VERSION())); K(GET_MIN_CLUSTER_VERSION()));
} }
@ -162,26 +162,26 @@ int ObPCVSet::inner_get_cache_obj(ObILibCacheCtx &ctx,
bool need_check_schema = true; bool need_check_schema = true;
DLIST_FOREACH(pcv, pcv_list_) { DLIST_FOREACH(pcv, pcv_list_) {
bool is_same = false; bool is_same = false;
LOG_DEBUG("get plan, pcv", K(pcv)); LOG_TRACE("get plan, pcv", K(pcv));
if (OB_FAIL(pcv->get_all_dep_schema(pc_ctx, if (OB_FAIL(pcv->get_all_dep_schema(pc_ctx,
pc_ctx.sql_ctx_.session_info_->get_database_id(), pc_ctx.sql_ctx_.session_info_->get_database_id(),
new_tenant_schema_version, new_tenant_schema_version,
need_check_schema, need_check_schema,
schema_array))) { schema_array))) {
if (OB_OLD_SCHEMA_VERSION == ret) { if (OB_OLD_SCHEMA_VERSION == ret) {
LOG_DEBUG("failed to get all table schema", K(ret)); LOG_TRACE("failed to get all table schema", K(ret));
} else { } else {
LOG_WARN("failed to get all table schema", K(ret)); LOG_WARN("failed to get all table schema", K(ret));
} }
} else if (OB_FAIL(pcv->match(pc_ctx, schema_array, is_same))) { } else if (OB_FAIL(pcv->match(pc_ctx, schema_array, is_same))) {
LOG_WARN("fail to match pcv when get plan", K(ret)); LOG_WARN("fail to match pcv when get plan", K(ret));
} else if (false == is_same) { } else if (false == is_same) {
LOG_DEBUG("failed to match param"); LOG_TRACE("failed to match param");
/*do nothing*/ /*do nothing*/
} else { } else {
matched_pcv = pcv; matched_pcv = pcv;
if (OB_FAIL(pcv->choose_plan(pc_ctx, schema_array, plan))) { if (OB_FAIL(pcv->choose_plan(pc_ctx, schema_array, plan))) {
LOG_DEBUG("failed to get plan in plan cache value", K(ret)); LOG_TRACE("failed to get plan in plan cache value", K(ret));
} }
break; break;
} }
@ -248,7 +248,7 @@ int ObPCVSet::inner_add_cache_obj(ObILibCacheCtx &ctx,
if (OB_FAIL(pcv->add_plan(*plan, schema_array, pc_ctx))) { if (OB_FAIL(pcv->add_plan(*plan, schema_array, pc_ctx))) {
if (OB_SQL_PC_PLAN_DUPLICATE == ret if (OB_SQL_PC_PLAN_DUPLICATE == ret
|| is_not_supported_err(ret)) { || is_not_supported_err(ret)) {
LOG_DEBUG("fail to add plan to pcv", K(ret)); LOG_TRACE("fail to add plan to pcv", K(ret));
} else { } else {
LOG_WARN("fail to add plan to pcv", K(ret)); LOG_WARN("fail to add plan to pcv", K(ret));
} }
@ -340,7 +340,7 @@ int ObPCVSet::deep_copy_sql(const ObString &sql)
{ {
int ret = OB_SUCCESS; int ret = OB_SUCCESS;
if (OB_ISNULL(sql.ptr())) { if (OB_ISNULL(sql.ptr())) {
SQL_PC_LOG(DEBUG, "sql is empty, ignore copy sql", K(ret), K(lbt())); SQL_PC_LOG(TRACE, "sql is empty, ignore copy sql", K(ret), K(lbt()));
} else if (OB_FAIL(ob_write_string(allocator_, sql, sql_))) { } 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)); SQL_PC_LOG(WARN, "deep copy sql into pcv_set failed", K(ret), K(sql));
} }
@ -493,7 +493,7 @@ int ObPCVSet::check_raw_param_for_dup_col(ObPlanCacheCtx &pc_ctx, bool &contain_
if (0 != l_tmp_str.compare(r_tmp_str)) { if (0 != l_tmp_str.compare(r_tmp_str)) {
all_same = false; all_same = false;
LOG_DEBUG("raw text not matched", K(l_tmp_str), K(r_tmp_str)); LOG_TRACE("raw text not matched", K(l_tmp_str), K(r_tmp_str));
} }
} }
} // for end } // for end

68
src/sql/plan_cache/ob_plan_cache.cpp
View File

@ -469,7 +469,7 @@ int ObPlanCache::get_plan(common::ObIAllocator &allocator,
} }
if (OB_SUCC(ret)) { if (OB_SUCC(ret)) {
if (OB_FAIL(get_plan_cache(pc_ctx, guard))) { if (OB_FAIL(get_plan_cache(pc_ctx, guard))) {
SQL_PC_LOG(DEBUG, "failed to get plan", K(ret)); SQL_PC_LOG(TRACE, "failed to get plan", K(ret), K(pc_ctx.fp_result_.pc_key_));
} else if (OB_ISNULL(guard.cache_obj_) } else if (OB_ISNULL(guard.cache_obj_)
|| ObLibCacheNameSpace::NS_CRSR != guard.cache_obj_->get_ns()) { || ObLibCacheNameSpace::NS_CRSR != guard.cache_obj_->get_ns()) {
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
@ -671,11 +671,11 @@ int ObPlanCache::get_plan_cache(ObILibCacheCtx &ctx,
ObPlanCacheCtx &pc_ctx = static_cast<ObPlanCacheCtx&>(ctx); ObPlanCacheCtx &pc_ctx = static_cast<ObPlanCacheCtx&>(ctx);
pc_ctx.key_ = &(pc_ctx.fp_result_.pc_key_); pc_ctx.key_ = &(pc_ctx.fp_result_.pc_key_);
if (OB_FAIL(get_cache_obj(ctx, pc_ctx.key_, guard))) { if (OB_FAIL(get_cache_obj(ctx, pc_ctx.key_, guard))) {
SQL_PC_LOG(DEBUG, "failed to get plan", K(ret)); SQL_PC_LOG(TRACE, "failed to get plan", K(ret), K(pc_ctx.key_));
} }
// check the returned error code and whether the plan has expired // check the returned error code and whether the plan has expired
if (OB_FAIL(check_after_get_plan(ret, ctx, guard.cache_obj_))) { if (OB_FAIL(check_after_get_plan(ret, ctx, guard.cache_obj_))) {
SQL_PC_LOG(DEBUG, "failed to check after get plan", K(ret)); SQL_PC_LOG(TRACE, "failed to check after get plan", K(ret));
} }
if (OB_FAIL(ret) && OB_NOT_NULL(guard.cache_obj_)) { if (OB_FAIL(ret) && OB_NOT_NULL(guard.cache_obj_)) {
co_mgr_.free(guard.cache_obj_, guard.ref_handle_); co_mgr_.free(guard.cache_obj_, guard.ref_handle_);
@ -699,7 +699,7 @@ int ObPlanCache::add_cache_obj(ObILibCacheCtx &ctx,
SQL_PC_LOG(ERROR, "unmatched tenant_id", K(ret), K(get_tenant_id()), K(cache_obj->get_tenant_id())); SQL_PC_LOG(ERROR, "unmatched tenant_id", K(ret), K(get_tenant_id()), K(cache_obj->get_tenant_id()));
} else if (OB_FAIL(get_value(key, cache_node, w_ref_lock /*write locked*/))) { } else if (OB_FAIL(get_value(key, cache_node, w_ref_lock /*write locked*/))) {
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
SQL_PC_LOG(DEBUG, "failed to get cache node from lib cache by key", K(ret)); SQL_PC_LOG(TRACE, "failed to get cache node from lib cache by key", K(ret));
} else if (NULL == cache_node) { } else if (NULL == cache_node) {
ObILibCacheKey *cache_key = NULL; ObILibCacheKey *cache_key = NULL;
//create node, init node, and add cache obj //create node, init node, and add cache obj
@ -730,7 +730,7 @@ int ObPlanCache::add_cache_obj(ObILibCacheCtx &ctx,
SQL_PC_LOG(TRACE, "fail to add cache obj", K(ret), K(cache_obj)); SQL_PC_LOG(TRACE, "fail to add cache obj", K(ret), K(cache_obj));
} }
} else if (OB_SUCCESS == hash_err) { } else if (OB_SUCCESS == hash_err) {
SQL_PC_LOG(DEBUG, "succeed to set node to key_node_map"); SQL_PC_LOG(TRACE, "succeed to set node to key_node_map");
/* stat must be added after set_refactored is successful, otherwise the following may occur: /* stat must be added after set_refactored is successful, otherwise the following may occur:
* Thread A Thread B * Thread A Thread B
* create_node_and_add_cache_obj * create_node_and_add_cache_obj
@ -780,7 +780,7 @@ int ObPlanCache::add_cache_obj(ObILibCacheCtx &ctx,
} else { /* node exist, add cache obj to it */ } else { /* node exist, add cache obj to it */
LOG_TRACE("inner add cache obj", K(key), K(cache_node)); LOG_TRACE("inner add cache obj", K(key), K(cache_node));
if (OB_FAIL(cache_node->add_cache_obj(ctx, key, cache_obj))) { if (OB_FAIL(cache_node->add_cache_obj(ctx, key, cache_obj))) {
SQL_PC_LOG(DEBUG, "failed to add cache obj to lib cache node", K(ret)); SQL_PC_LOG(TRACE, "failed to add cache obj to lib cache node", K(ret));
} else if (OB_FAIL(cache_node->update_node_stat(ctx))) { } else if (OB_FAIL(cache_node->update_node_stat(ctx))) {
SQL_PC_LOG(WARN, "failed to update node stat", K(ret)); SQL_PC_LOG(WARN, "failed to update node stat", K(ret));
} else if (OB_FAIL(add_stat_for_cache_obj(ctx, cache_obj))) { } else if (OB_FAIL(add_stat_for_cache_obj(ctx, cache_obj))) {
@ -807,21 +807,21 @@ int ObPlanCache::get_cache_obj(ObILibCacheCtx &ctx,
SQL_PC_LOG(WARN, "invalid null argument", K(ret), K(key)); SQL_PC_LOG(WARN, "invalid null argument", K(ret), K(key));
} else if (OB_FAIL(get_value(key, cache_node, r_ref_lock /*read locked*/))) { } else if (OB_FAIL(get_value(key, cache_node, r_ref_lock /*read locked*/))) {
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
SQL_PC_LOG(DEBUG, "failed to get cache node from lib cache by key", K(ret)); SQL_PC_LOG(TRACE, "failed to get cache node from lib cache by key", K(ret));
} else if (OB_UNLIKELY(NULL == cache_node)) { } else if (OB_UNLIKELY(NULL == cache_node)) {
ret = OB_SQL_PC_NOT_EXIST; ret = OB_SQL_PC_NOT_EXIST;
SQL_PC_LOG(DEBUG, "cache obj does not exist!", K(key)); SQL_PC_LOG(TRACE, "cache obj does not exist!", K(key));
} else { } else {
LOG_DEBUG("inner_get_cache_obj", K(key), K(cache_node)); LOG_TRACE("inner_get_cache_obj", K(key), K(cache_node));
if (OB_FAIL(cache_node->update_node_stat(ctx))) { if (OB_FAIL(cache_node->update_node_stat(ctx))) {
SQL_PC_LOG(WARN, "failed to update node stat", K(ret)); SQL_PC_LOG(WARN, "failed to update node stat", K(ret));
} else if (OB_FAIL(cache_node->get_cache_obj(ctx, key, cache_obj))) { } else if (OB_FAIL(cache_node->get_cache_obj(ctx, key, cache_obj))) {
if (OB_SQL_PC_NOT_EXIST != ret) { if (OB_SQL_PC_NOT_EXIST != ret) {
LOG_DEBUG("cache_node fail to get cache obj", K(ret)); LOG_TRACE("cache_node fail to get cache obj", K(ret));
} }
} else { } else {
guard.cache_obj_ = cache_obj; guard.cache_obj_ = cache_obj;
LOG_DEBUG("succ to get cache obj", KPC(key)); LOG_TRACE("succ to get cache obj", KPC(key));
} }
// release lock whatever // release lock whatever
(void)cache_node->unlock(); (void)cache_node->unlock();
@ -845,7 +845,7 @@ int ObPlanCache::cache_node_exists(ObILibCacheKey* key,
SQL_PC_LOG(WARN, "invalid null argument", K(ret), K(key)); SQL_PC_LOG(WARN, "invalid null argument", K(ret), K(key));
} else if (OB_FAIL(get_value(key, cache_node, r_ref_lock /*read locked*/))) { } else if (OB_FAIL(get_value(key, cache_node, r_ref_lock /*read locked*/))) {
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
SQL_PC_LOG(DEBUG, "failed to get cache node from lib cache by key", K(ret)); SQL_PC_LOG(TRACE, "failed to get cache node from lib cache by key", K(ret));
} else if (OB_UNLIKELY(NULL == cache_node)) { } else if (OB_UNLIKELY(NULL == cache_node)) {
is_exists = false; is_exists = false;
} else { } else {
@ -869,12 +869,12 @@ int ObPlanCache::get_value(ObILibCacheKey *key,
case OB_SUCCESS: { case OB_SUCCESS: {
//get node and lock //get node and lock
if (OB_FAIL(op.get_value(node))) { if (OB_FAIL(op.get_value(node))) {
SQL_PC_LOG(DEBUG, "failed to lock cache node", K(ret), KPC(key)); SQL_PC_LOG(TRACE, "failed to lock cache node", K(ret), KPC(key));
} }
break; break;
} }
case OB_HASH_NOT_EXIST: { //返回时 node = NULL; ret = OB_SUCCESS; case OB_HASH_NOT_EXIST: { //返回时 node = NULL; ret = OB_SUCCESS;
SQL_PC_LOG(DEBUG, "entry does not exist.", KPC(key)); SQL_PC_LOG(TRACE, "entry does not exist.", KPC(key));
break; break;
} }
default: { default: {
@ -910,6 +910,7 @@ int ObPlanCache::foreach_cache_evict(CallBack &cb)
} else if (OB_FAIL(batch_remove_cache_node(*to_evict_list))) { } else if (OB_FAIL(batch_remove_cache_node(*to_evict_list))) {
SQL_PC_LOG(WARN, "failed to remove lib cache node", K(ret)); SQL_PC_LOG(WARN, "failed to remove lib cache node", K(ret));
} }
if (OB_NOT_NULL(to_evict_list)) {
//decrement reference count //decrement reference count
int64_t N = to_evict_list->count(); int64_t N = to_evict_list->count();
for (int64_t i = 0; OB_SUCC(ret) && i < N; i++) { for (int64_t i = 0; OB_SUCC(ret) && i < N; i++) {
@ -917,6 +918,7 @@ int ObPlanCache::foreach_cache_evict(CallBack &cb)
to_evict_list->at(i).node_->dec_ref_count(cb.get_ref_handle()); to_evict_list->at(i).node_->dec_ref_count(cb.get_ref_handle());
} }
} }
}
return ret; return ret;
} }
@ -926,26 +928,26 @@ template int ObPlanCache::foreach_cache_evict<pl::ObGetPLKVEntryOp>(pl::ObGetPLK
int ObPlanCache::cache_evict_all_obj() int ObPlanCache::cache_evict_all_obj()
{ {
int ret = OB_SUCCESS; int ret = OB_SUCCESS;
SQL_PC_LOG(DEBUG, "cache evict all plan start"); SQL_PC_LOG(TRACE, "cache evict all plan start");
LCKeyValueArray to_evict_keys; LCKeyValueArray to_evict_keys;
ObKVEntryTraverseOp get_ids_op(&to_evict_keys, PCV_GET_PLAN_KEY_HANDLE); ObKVEntryTraverseOp get_ids_op(&to_evict_keys, PCV_GET_PLAN_KEY_HANDLE);
if (OB_FAIL(foreach_cache_evict(get_ids_op))) { if (OB_FAIL(foreach_cache_evict(get_ids_op))) {
SQL_PC_LOG(WARN, "failed to foreach cache evict", K(ret)); SQL_PC_LOG(WARN, "failed to foreach cache evict", K(ret));
} }
SQL_PC_LOG(DEBUG, "cache evict all plan end"); SQL_PC_LOG(TRACE, "cache evict all plan end");
return ret; return ret;
} }
int ObPlanCache::cache_evict_by_ns(ObLibCacheNameSpace ns) int ObPlanCache::cache_evict_by_ns(ObLibCacheNameSpace ns)
{ {
int ret = OB_SUCCESS; int ret = OB_SUCCESS;
SQL_PC_LOG(DEBUG, "cache evict all obj by ns start"); SQL_PC_LOG(TRACE, "cache evict all obj by ns start");
LCKeyValueArray to_evict_keys; LCKeyValueArray to_evict_keys;
ObGetKVEntryByNsOp get_ids_op(ns, &to_evict_keys, PCV_GET_PLAN_KEY_HANDLE); ObGetKVEntryByNsOp get_ids_op(ns, &to_evict_keys, PCV_GET_PLAN_KEY_HANDLE);
if (OB_FAIL(foreach_cache_evict(get_ids_op))) { if (OB_FAIL(foreach_cache_evict(get_ids_op))) {
SQL_PC_LOG(WARN, "failed to foreach cache evict", K(ret)); SQL_PC_LOG(WARN, "failed to foreach cache evict", K(ret));
} }
SQL_PC_LOG(DEBUG, "cache evict all obj by ns end"); SQL_PC_LOG(TRACE, "cache evict all obj by ns end");
return ret; return ret;
} }
@ -963,13 +965,13 @@ int ObPlanCache::cache_evict_all_plan()
int ObPlanCache::cache_evict_plan_by_sql_id(uint64_t db_id, common::ObString sql_id) int ObPlanCache::cache_evict_plan_by_sql_id(uint64_t db_id, common::ObString sql_id)
{ {
int ret = OB_SUCCESS; int ret = OB_SUCCESS;
SQL_PC_LOG(DEBUG, "cache evict plan by sql id start"); SQL_PC_LOG(TRACE, "cache evict plan by sql id start");
LCKeyValueArray to_evict_keys; LCKeyValueArray to_evict_keys;
ObGetKVEntryBySQLIDOp get_ids_op(db_id, sql_id, &to_evict_keys, PCV_GET_PLAN_KEY_HANDLE); ObGetKVEntryBySQLIDOp get_ids_op(db_id, sql_id, &to_evict_keys, PCV_GET_PLAN_KEY_HANDLE);
if (OB_FAIL(foreach_cache_evict(get_ids_op))) { if (OB_FAIL(foreach_cache_evict(get_ids_op))) {
SQL_PC_LOG(WARN, "failed to foreach cache evict", K(ret)); SQL_PC_LOG(WARN, "failed to foreach cache evict", K(ret));
} }
SQL_PC_LOG(DEBUG, "cache evict plan by sql id end"); SQL_PC_LOG(TRACE, "cache evict plan by sql id end");
return ret; return ret;
} }
@ -979,13 +981,13 @@ int ObPlanCache::evict_plan_by_table_name(uint64_t database_id, ObString tab_nam
int ret = OB_SUCCESS; int ret = OB_SUCCESS;
observer::ObReqTimeGuard req_timeinfo_guard; observer::ObReqTimeGuard req_timeinfo_guard;
ObGlobalReqTimeService::check_req_timeinfo(); ObGlobalReqTimeService::check_req_timeinfo();
SQL_PC_LOG(DEBUG, "cache evict plan by table name start"); SQL_PC_LOG(TRACE, "cache evict plan by table name start");
LCKeyValueArray to_evict_keys; LCKeyValueArray to_evict_keys;
ObGetPcvSetByTabNameOp get_ids_op(database_id, tab_name, &to_evict_keys, PCV_GET_PLAN_KEY_HANDLE); ObGetPcvSetByTabNameOp get_ids_op(database_id, tab_name, &to_evict_keys, PCV_GET_PLAN_KEY_HANDLE);
if (OB_FAIL(foreach_cache_evict(get_ids_op))) { if (OB_FAIL(foreach_cache_evict(get_ids_op))) {
SQL_PC_LOG(WARN, "failed to foreach cache evict", K(ret)); SQL_PC_LOG(WARN, "failed to foreach cache evict", K(ret));
} }
SQL_PC_LOG(DEBUG, "cache evict plan baseline by sql id end"); SQL_PC_LOG(TRACE, "cache evict plan baseline by sql id end");
return ret; return ret;
} }
@ -1253,7 +1255,7 @@ int ObPlanCache::add_cache_obj_stat(ObILibCacheCtx &ctx, ObILibCacheObject *cach
co_mgr_.free(cache_obj, LC_REF_CACHE_OBJ_STAT_HANDLE); co_mgr_.free(cache_obj, LC_REF_CACHE_OBJ_STAT_HANDLE);
cache_obj = NULL; cache_obj = NULL;
} else { } else {
LOG_DEBUG("succeeded to add cache object stat", K(cache_obj->get_object_id()), K(cache_obj)); LOG_TRACE("succeeded to add cache object stat", K(cache_obj->get_object_id()), K(cache_obj));
} }
} }
return ret; return ret;
@ -1453,7 +1455,7 @@ int ObPlanCache::add_ps_plan(T *plan, ObPlanCacheCtx &pc_ctx)
SQL_PC_LOG(WARN, "invalid physical plan", K(ret)); SQL_PC_LOG(WARN, "invalid physical plan", K(ret));
} else if (is_reach_memory_limit()) { } else if (is_reach_memory_limit()) {
ret = OB_REACH_MEMORY_LIMIT; ret = OB_REACH_MEMORY_LIMIT;
SQL_PC_LOG(DEBUG, "plan cache memory used reach the high water mark", SQL_PC_LOG(TRACE, "plan cache memory used reach the high water mark",
K(mem_used_), K(get_mem_limit()), K(ret)); K(mem_used_), K(get_mem_limit()), K(ret));
} else if (plan->get_mem_size() >= get_mem_high()) { } else if (plan->get_mem_size() >= get_mem_high()) {
// plan mem is too big to reach memory highwater, do not add plan // plan mem is too big to reach memory highwater, do not add plan
@ -1493,7 +1495,7 @@ int ObPlanCache::add_exists_cache_obj_by_sql(ObILibCacheCtx &ctx,
pc_ctx.need_add_obj_stat_ = false; pc_ctx.need_add_obj_stat_ = false;
uint64_t old_stmt_id = pc_ctx.fp_result_.pc_key_.key_id_; uint64_t old_stmt_id = pc_ctx.fp_result_.pc_key_.key_id_;
pc_ctx.fp_result_.pc_key_.key_id_ = OB_INVALID_ID; pc_ctx.fp_result_.pc_key_.key_id_ = OB_INVALID_ID;
SQL_PC_LOG(DEBUG, "start to add ps plan by sql", K(pc_ctx.fp_result_.pc_key_)); SQL_PC_LOG(TRACE, "start to add ps plan by sql", K(pc_ctx.fp_result_.pc_key_));
if (OB_FAIL(add_plan_cache(pc_ctx, cache_obj))) { if (OB_FAIL(add_plan_cache(pc_ctx, cache_obj))) {
if (OB_FAIL(deal_add_ps_plan_result(ret, pc_ctx, *cache_obj))) { if (OB_FAIL(deal_add_ps_plan_result(ret, pc_ctx, *cache_obj))) {
LOG_WARN("fail to deal result code", K(ret)); LOG_WARN("fail to deal result code", K(ret));
@ -1515,7 +1517,7 @@ int ObPlanCache::deal_add_ps_plan_result(int add_plan_ret,
int ret = add_plan_ret; int ret = add_plan_ret;
if (OB_SQL_PC_PLAN_DUPLICATE == ret) { if (OB_SQL_PC_PLAN_DUPLICATE == ret) {
ret = OB_SUCCESS; ret = OB_SUCCESS;
LOG_DEBUG("this plan has been added by others, need not add again", K(cache_object)); LOG_TRACE("this plan has been added by others, need not add again", K(cache_object));
} else if (OB_REACH_MEMORY_LIMIT == ret || OB_SQL_PC_PLAN_SIZE_LIMIT == ret) { } else if (OB_REACH_MEMORY_LIMIT == ret || OB_SQL_PC_PLAN_SIZE_LIMIT == ret) {
if (REACH_TIME_INTERVAL(1000000)) { //1s, 当内存达到上限时, 该日志打印会比较频繁, 所以以1s为间隔打印 if (REACH_TIME_INTERVAL(1000000)) { //1s, 当内存达到上限时, 该日志打印会比较频繁, 所以以1s为间隔打印
ObTruncatedString trunc_sql(pc_ctx.raw_sql_); ObTruncatedString trunc_sql(pc_ctx.raw_sql_);
@ -1526,7 +1528,7 @@ int ObPlanCache::deal_add_ps_plan_result(int add_plan_ret,
ret = OB_SUCCESS; ret = OB_SUCCESS;
} else if (is_not_supported_err(ret)) { } else if (is_not_supported_err(ret)) {
ret = OB_SUCCESS; ret = OB_SUCCESS;
LOG_DEBUG("plan cache don't support add this kind of plan now", K(cache_object)); LOG_TRACE("plan cache don't support add this kind of plan now", K(cache_object));
} else if (OB_FAIL(ret)) { } else if (OB_FAIL(ret)) {
if (OB_REACH_MAX_CONCURRENT_NUM != ret) { //如果是达到限流上限, 则将错误码抛出去 if (OB_REACH_MAX_CONCURRENT_NUM != ret) { //如果是达到限流上限, 则将错误码抛出去
ret = OB_SUCCESS; //add plan出错, 覆盖错误码, 确保因plan cache失败不影响正常执行路径 ret = OB_SUCCESS; //add plan出错, 覆盖错误码, 确保因plan cache失败不影响正常执行路径
@ -1534,7 +1536,7 @@ int ObPlanCache::deal_add_ps_plan_result(int add_plan_ret,
} }
} else { } else {
pc_ctx.sql_ctx_.self_add_plan_ = true; pc_ctx.sql_ctx_.self_add_plan_ = true;
LOG_DEBUG("Successed to add plan to ObPlanCache", K(cache_object)); LOG_TRACE("Successed to add plan to ObPlanCache", K(cache_object));
} }
return ret; return ret;
@ -1559,7 +1561,7 @@ int ObPlanCache::add_exists_cache_obj_by_stmt_id(ObILibCacheCtx &ctx,
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
SQL_PC_LOG(WARN, "convert cache_obj to ObPhysicalPlan failed", K(ret)); SQL_PC_LOG(WARN, "convert cache_obj to ObPhysicalPlan failed", K(ret));
} else { } else {
SQL_PC_LOG(DEBUG, "ps_stmt_id changed", K(plan->stat_.ps_stmt_id_), K(new_stmt_id)); SQL_PC_LOG(TRACE, "ps_stmt_id changed", K(plan->stat_.ps_stmt_id_), K(new_stmt_id));
plan->stat_.ps_stmt_id_ = new_stmt_id; plan->stat_.ps_stmt_id_ = new_stmt_id;
} }
} else { } else {
@ -1708,13 +1710,13 @@ int ObPlanCache::get_ps_plan(ObCacheObjGuard& guard,
pc_ctx.fp_result_.pc_key_.name_ = pc_ctx.raw_sql_; pc_ctx.fp_result_.pc_key_.name_ = pc_ctx.raw_sql_;
if (OB_FAIL(get_plan_cache(pc_ctx, guard))) { if (OB_FAIL(get_plan_cache(pc_ctx, guard))) {
if (OB_OLD_SCHEMA_VERSION == ret) { if (OB_OLD_SCHEMA_VERSION == ret) {
SQL_PC_LOG(DEBUG, "get cache obj by sql failed because of old_schema_version", SQL_PC_LOG(TRACE, "get cache obj by sql failed because of old_schema_version",
K(ret), K(pc_ctx.raw_sql_), K(new_stmt_id), K(cache_key_node_map_.size())); K(ret), K(pc_ctx.raw_sql_), K(new_stmt_id), K(cache_key_node_map_.size()));
} else { } else {
SQL_PC_LOG(DEBUG, "get cache obj by sql failed", SQL_PC_LOG(TRACE, "get cache obj by sql failed",
K(ret), K(pc_ctx.raw_sql_), K(new_stmt_id), K(cache_key_node_map_.size())); K(ret), K(pc_ctx.raw_sql_), K(new_stmt_id), K(cache_key_node_map_.size()));
} }
SQL_PC_LOG(DEBUG, "fail to get plan", K(ret)); SQL_PC_LOG(TRACE, "fail to get plan", K(ret));
} else if (OB_ISNULL(guard.cache_obj_) || OB_UNLIKELY(!guard.cache_obj_->is_valid_cache_obj())) { } else if (OB_ISNULL(guard.cache_obj_) || OB_UNLIKELY(!guard.cache_obj_->is_valid_cache_obj())) {
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
LOG_WARN("cache obj is invalid", K(ret), KPC(guard.cache_obj_)); LOG_WARN("cache obj is invalid", K(ret), KPC(guard.cache_obj_));
@ -1797,7 +1799,7 @@ int ObPlanCache::need_late_compile(ObPhysicalPlan *plan,
need_late_compilation = false; need_late_compilation = false;
} }
} }
LOG_DEBUG("will use late compilation", K(need_late_compilation)); LOG_TRACE("will use late compilation", K(need_late_compilation));
return ret; return ret;
} }

34
src/sql/plan_cache/ob_plan_cache_value.cpp
View File

@ -452,7 +452,7 @@ int ObPlanCacheValue::choose_plan(ObPlanCacheCtx &pc_ctx,
SQL_PC_LOG(WARN, "fail to check table version", K(ret)); SQL_PC_LOG(WARN, "fail to check table version", K(ret));
} else if (true == is_old_version) { } else if (true == is_old_version) {
ret = OB_OLD_SCHEMA_VERSION; ret = OB_OLD_SCHEMA_VERSION;
SQL_PC_LOG(DEBUG, "view or table is old version", K(ret)); SQL_PC_LOG(TRACE, "view or table is old version", K(ret));
} }
if (OB_FAIL(ret)) { if (OB_FAIL(ret)) {
//do nothing //do nothing
@ -703,28 +703,28 @@ int ObPlanCacheValue::resolver_params(ObPlanCacheCtx &pc_ctx,
&& (value.is_negative_number() && (value.is_negative_number()
|| (value.is_zero_number() && '-' == raw_param->str_value_[0]))) { // -0 is also counted as negative || (value.is_zero_number() && '-' == raw_param->str_value_[0]))) { // -0 is also counted as negative
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
LOG_DEBUG("param must be positive", K(ret), K(i), K(value)); LOG_TRACE("param must be positive", K(ret), K(i), K(value));
pc_ctx.should_add_plan_ = false; // 内部主动抛出not supported时候需要设置这个标志，以免新计划add plan导致锁冲突 pc_ctx.should_add_plan_ = false; // 内部主动抛出not supported时候需要设置这个标志，以免新计划add plan导致锁冲突
} else if (lib::is_mysql_mode() } else if (lib::is_mysql_mode()
&& value.is_integer_type() && value.is_integer_type()
&& (value.get_int() < 0 && (value.get_int() < 0
|| (0 == value.get_int() && '-' == raw_param->str_value_[0]))) { || (0 == value.get_int() && '-' == raw_param->str_value_[0]))) {
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
LOG_DEBUG("param must be positive", K(ret), K(i), K(value)); LOG_TRACE("param must be positive", K(ret), K(i), K(value));
pc_ctx.should_add_plan_ = false; // 内部主动抛出not supported时候需要设置这个标志，以免新计划add plan导致锁冲突 pc_ctx.should_add_plan_ = false; // 内部主动抛出not supported时候需要设置这个标志，以免新计划add plan导致锁冲突
} else { } else {
// do nothing // do nothing
} }
} }
} }
SQL_PC_LOG(DEBUG, "is_param", SQL_PC_LOG(TRACE, "is_param",
K(i), K(i),
K(value), K(value),
K(raw_param->type_), K(raw_param->type_),
K(raw_param->value_), K(raw_param->value_),
"str_value", ObString(raw_param->str_len_, raw_param->str_value_)); "str_value", ObString(raw_param->str_len_, raw_param->str_value_));
} else { } else {
SQL_PC_LOG(DEBUG, "not_param", SQL_PC_LOG(TRACE, "not_param",
K(i), K(i),
K(value), K(value),
K(raw_param->type_), K(raw_param->type_),
@ -888,11 +888,11 @@ int ObPlanCacheValue::check_not_param_value(const ObFastParserResult &fp_result
} else if (0 != not_param_info.at(i).raw_text_.compare( } else if (0 != not_param_info.at(i).raw_text_.compare(
ObString(raw_param->text_len_, raw_param->raw_text_))) { ObString(raw_param->text_len_, raw_param->raw_text_))) {
is_same = false; is_same = false;
LOG_DEBUG("match not param info", LOG_TRACE("match not param info",
"raw value", ObString(raw_param->text_len_, raw_param->raw_text_), "raw value", ObString(raw_param->text_len_, raw_param->raw_text_),
"cached special value", not_param_info.at(i).raw_text_); "cached special value", not_param_info.at(i).raw_text_);
} else { } else {
LOG_DEBUG("match param info", LOG_TRACE("match param info",
"raw value", ObString(raw_param->text_len_, raw_param->raw_text_), "raw value", ObString(raw_param->text_len_, raw_param->raw_text_),
"cached special value", not_param_info.at(i).raw_text_); "cached special value", not_param_info.at(i).raw_text_);
} }
@ -914,10 +914,10 @@ int ObPlanCacheValue::cmp_not_param_info(const NotParamInfoList &l_param_info_li
const NotParamInfo &r_param_info = r_param_info_list.at(i); const NotParamInfo &r_param_info = r_param_info_list.at(i);
if (l_param_info.idx_ != r_param_info.idx_) { if (l_param_info.idx_ != r_param_info.idx_) {
is_equal = false; is_equal = false;
LOG_DEBUG("compare not param info", K(l_param_info), K(r_param_info)); LOG_TRACE("compare not param info", K(l_param_info), K(r_param_info));
} else if (0 != l_param_info.raw_text_.compare(r_param_info.raw_text_)) { } else if (0 != l_param_info.raw_text_.compare(r_param_info.raw_text_)) {
is_equal = false; is_equal = false;
LOG_DEBUG("compare not param info", K(l_param_info), K(r_param_info)); LOG_TRACE("compare not param info", K(l_param_info), K(r_param_info));
} }
} }
} }
@ -1001,7 +1001,7 @@ int ObPlanCacheValue::get_one_group_params(int64_t pos, const ParamStore &src_pa
} else if (OB_FAIL(dst_params.push_back(array_obj->data_[pos]))) { } else if (OB_FAIL(dst_params.push_back(array_obj->data_[pos]))) {
LOG_WARN("fail to push param_obj to param_store", K(i), K(pos), K(array_obj->data_[pos]), K(ret)); LOG_WARN("fail to push param_obj to param_store", K(i), K(pos), K(array_obj->data_[pos]), K(ret));
} else { } else {
LOG_DEBUG("get one batch obj", K(pos), K(i), K(array_obj->data_[pos])); LOG_TRACE("get one batch obj", K(pos), K(i), K(array_obj->data_[pos]));
} }
} }
return ret; return ret;
@ -1085,7 +1085,7 @@ int ObPlanCacheValue::add_plan(ObPlanCacheObject &plan,
SQL_PC_LOG(WARN, "fail to check table version", K(ret)); SQL_PC_LOG(WARN, "fail to check table version", K(ret));
} else if (is_old_version) { } else if (is_old_version) {
ret = OB_OLD_SCHEMA_VERSION; ret = OB_OLD_SCHEMA_VERSION;
SQL_PC_LOG(DEBUG, "view or table is old version", K(ret)); SQL_PC_LOG(TRACE, "view or table is old version", K(ret));
/* Consider this concurrent scene: /* Consider this concurrent scene:
1. No mapping is defined on t.c1 at first. 1. No mapping is defined on t.c1 at first.
2. Thread1 resolve select * from t where c1 = 1; and generate a plan with rule_id = INVALID 2. Thread1 resolve select * from t where c1 = 1; and generate a plan with rule_id = INVALID
@ -1130,7 +1130,7 @@ int ObPlanCacheValue::add_plan(ObPlanCacheObject &plan,
need_new_planset = false; need_new_planset = false;
batch_plan_set = cur_plan_set; batch_plan_set = cur_plan_set;
if (OB_FAIL(cur_plan_set->add_cache_obj(plan, pc_ctx, outline_param_idx, add_plan_ret))) { if (OB_FAIL(cur_plan_set->add_cache_obj(plan, pc_ctx, outline_param_idx, add_plan_ret))) {
SQL_PC_LOG(DEBUG, "failed to add plan", K(ret)); SQL_PC_LOG(TRACE, "failed to add plan", K(ret));
} }
break; break;
} }
@ -1155,7 +1155,7 @@ int ObPlanCacheValue::add_plan(ObPlanCacheObject &plan,
get_pc_malloc()))) { get_pc_malloc()))) {
LOG_WARN("init new plan set failed", K(ret)); LOG_WARN("init new plan set failed", K(ret));
} else if (OB_FAIL(plan_set->add_cache_obj(plan, pc_ctx, outline_param_idx, add_plan_ret))) { } else if (OB_FAIL(plan_set->add_cache_obj(plan, pc_ctx, outline_param_idx, add_plan_ret))) {
SQL_PC_LOG(DEBUG, "failed to add plan to plan set", K(ret)); SQL_PC_LOG(TRACE, "failed to add plan to plan set", K(ret));
} else if (!plan_sets_.add_last(plan_set)) { } else if (!plan_sets_.add_last(plan_set)) {
ret = OB_ERROR; ret = OB_ERROR;
SQL_PC_LOG(WARN, "failed to add plan set to plan cache value", K(ret)); SQL_PC_LOG(WARN, "failed to add plan set to plan cache value", K(ret));
@ -1233,7 +1233,7 @@ void ObPlanCacheValue::reset()
plan_sets_.clear(); plan_sets_.clear();
// free plan_cache_key // free plan_cache_key
if (NULL == pc_alloc_) { if (NULL == pc_alloc_) {
SQL_PC_LOG(DEBUG, "pc alloc not init, may be reset before", K(pc_alloc_)); SQL_PC_LOG(TRACE, "pc alloc not init, may be reset before", K(pc_alloc_));
} else { } else {
for (int64_t i = 0; i < not_param_info_.count(); i++) { for (int64_t i = 0; i < not_param_info_.count(); i++) {
if (NULL != not_param_info_.at(i).raw_text_.ptr()) { if (NULL != not_param_info_.at(i).raw_text_.ptr()) {
@ -1410,7 +1410,7 @@ int ObPlanCacheValue::check_dep_schema_version(const ObIArray<PCVSchemaObj> &sch
LOG_DEBUG("matched schema objs", K(*schema_obj1), K(schema_obj2), K(i)); LOG_DEBUG("matched schema objs", K(*schema_obj1), K(schema_obj2), K(i));
// do nothing // do nothing
} else { } else {
LOG_DEBUG("mismatched schema objs", K(*schema_obj1), K(schema_obj2), K(i)); LOG_TRACE("mismatched schema objs", K(*schema_obj1), K(schema_obj2), K(i));
is_old_version = true; is_old_version = true;
} }
} }
@ -1747,7 +1747,7 @@ int ObPlanCacheValue::set_stored_schema_objs(const DependenyTableStore &dep_tabl
} else { } else {
// do nothing // do nothing
} }
LOG_DEBUG("check sys table", K(table_schema->get_table_name()), K(contain_sys_name_table_)); LOG_TRACE("check sys table", K(table_schema->get_table_name()), K(contain_sys_name_table_));
} else { } else {
// do nothing // do nothing
} }
@ -1881,7 +1881,7 @@ int ObPlanCacheValue::get_all_dep_schema(ObPlanCacheCtx &pc_ctx,
tmp_schema_obj.reset(); tmp_schema_obj.reset();
} else if (nullptr == table_schema) { } else if (nullptr == table_schema) {
ret = OB_OLD_SCHEMA_VERSION; ret = OB_OLD_SCHEMA_VERSION;
LOG_DEBUG("table not exist", K(ret), K(*pcv_schema), K(table_schema)); LOG_TRACE("table not exist", K(ret), K(*pcv_schema), K(table_schema));
} else if (OB_FAIL(tmp_schema_obj.init_without_copy_name(table_schema))) { } else if (OB_FAIL(tmp_schema_obj.init_without_copy_name(table_schema))) {
LOG_WARN("failed to init pcv schema obj", K(ret)); LOG_WARN("failed to init pcv schema obj", K(ret));
} else if (OB_FAIL(schema_array.push_back(tmp_schema_obj))) { } else if (OB_FAIL(schema_array.push_back(tmp_schema_obj))) {

38
src/sql/plan_cache/ob_plan_set.cpp
View File

@ -83,7 +83,7 @@ int ObPlanSet::match_params_info(const ParamStore *params,
} else { } else {
//匹配原始的参数 //匹配原始的参数
int64_t N = params->count(); int64_t N = params->count();
LOG_DEBUG("params info", K(params_info_), K(*params), K(this)); LOG_TRACE("params info", K(params_info_), K(*params), K(this));
for (int64_t i = 0; OB_SUCC(ret) && is_same && i < N; ++i) { for (int64_t i = 0; OB_SUCC(ret) && is_same && i < N; ++i) {
if (OB_FAIL(match_param_info(params_info_.at(i), if (OB_FAIL(match_param_info(params_info_.at(i),
params->at(i), params->at(i),
@ -196,6 +196,7 @@ int ObPlanSet::match_params_info(const ParamStore *params,
} }
if (OB_FAIL(ret)) { if (OB_FAIL(ret)) {
is_same = false; is_same = false;
LOG_TRACE("after match param result", K(ret), K(is_same), K(params_info_));
} }
} }
LOG_DEBUG("after match param result", K(ret), K(is_same), K(params_info_)); LOG_DEBUG("after match param result", K(ret), K(is_same), K(params_info_));
@ -261,6 +262,7 @@ int ObPlanSet::match_param_info(const ObParamInfo &param_info,
is_same = true; is_same = true;
} else { } else {
is_same = false; is_same = false;
LOG_TRACE("ext match param info", K(data_type), K(param_info), K(is_same), K(ret));
} }
LOG_DEBUG("ext match param info", K(data_type), K(param_info), K(is_same), K(ret)); LOG_DEBUG("ext match param info", K(data_type), K(param_info), K(is_same), K(ret));
} else if (param_info.is_oracle_empty_string_ && !param.is_null()) { //普通字符串不匹配空串的计划 } else if (param_info.is_oracle_empty_string_ && !param.is_null()) { //普通字符串不匹配空串的计划
@ -934,7 +936,7 @@ int ObPlanSet::match_constraint(const ParamStore &params, bool &is_matched)
K(ret), K(const_param.get_type()), K(params.at(param_idx).get_type())); K(ret), K(const_param.get_type()), K(params.at(param_idx).get_type()));
} else if (!const_param.can_compare(params.at(param_idx)) || } else if (!const_param.can_compare(params.at(param_idx)) ||
0 != const_param.compare(params.at(param_idx))) { 0 != const_param.compare(params.at(param_idx))) {
LOG_DEBUG("not matched const param", K(const_param), K(params.at(param_idx))); LOG_TRACE("not matched const param", K(const_param), K(params.at(param_idx)));
is_matched = false; is_matched = false;
} else { } else {
// do nothing // do nothing
@ -968,7 +970,7 @@ int ObPlanSet::match_constraint(const ParamStore &params, bool &is_matched)
} }
} }
if (match_const) { if (match_const) {
LOG_DEBUG("matched const param constraint", K(params), K(all_possible_const_param_constraints_.at(i))); LOG_TRACE("matched const param constraint", K(params), K(all_possible_const_param_constraints_.at(i)));
is_matched = false; // matching one of the constraint, need to generated new plan is_matched = false; // matching one of the constraint, need to generated new plan
} }
} }
@ -1016,7 +1018,7 @@ int ObPlanSet::match_constraint(const ParamStore &params, bool &is_matched)
} }
if (OB_SUCC(ret) && !is_matched) { if (OB_SUCC(ret) && !is_matched) {
is_matched = false; is_matched = false;
LOG_DEBUG("not match equal param constraint", K(params), K(first_idx), K(second_idx)); LOG_TRACE("not match equal param constraint", K(params), K(first_idx), K(second_idx));
} }
} }
@ -1174,7 +1176,7 @@ int ObSqlPlanSet::add_plan(ObPhysicalPlan &plan,
if (OB_SUCC(ret)) { if (OB_SUCC(ret)) {
switch(plan_type) { switch(plan_type) {
case OB_PHY_PLAN_LOCAL:{ case OB_PHY_PLAN_LOCAL:{
SQL_PC_LOG(DEBUG, "plan set add plan, local plan", K(ret)); SQL_PC_LOG(TRACE, "plan set add plan, local plan", K(ret));
if (is_multi_stmt_plan()) { if (is_multi_stmt_plan()) {
if (NULL != array_binding_plan_) { if (NULL != array_binding_plan_) {
ret = OB_SQL_PC_PLAN_DUPLICATE; ret = OB_SQL_PC_PLAN_DUPLICATE;
@ -1183,7 +1185,7 @@ int ObSqlPlanSet::add_plan(ObPhysicalPlan &plan,
} }
} else { } else {
if (OB_FAIL(add_physical_plan(OB_PHY_PLAN_LOCAL, pc_ctx, plan))) { if (OB_FAIL(add_physical_plan(OB_PHY_PLAN_LOCAL, pc_ctx, plan))) {
SQL_PC_LOG(DEBUG, "fail to add local plan", K(ret)); SQL_PC_LOG(TRACE, "fail to add local plan", K(ret));
} else if (OB_SUCC(ret) } else if (OB_SUCC(ret)
&& FALSE_IT(direct_local_plan_ = &plan)) { && FALSE_IT(direct_local_plan_ = &plan)) {
// do nothing // do nothing
@ -1207,7 +1209,7 @@ int ObSqlPlanSet::add_plan(ObPhysicalPlan &plan,
} }
} break; } break;
case OB_PHY_PLAN_DISTRIBUTED: { case OB_PHY_PLAN_DISTRIBUTED: {
SQL_PC_LOG(DEBUG, "plan set add plan, distr plan", K(ret)); SQL_PC_LOG(TRACE, "plan set add plan, distr plan", K(ret));
if (OB_FAIL(add_physical_plan(OB_PHY_PLAN_DISTRIBUTED, pc_ctx, plan))) { if (OB_FAIL(add_physical_plan(OB_PHY_PLAN_DISTRIBUTED, pc_ctx, plan))) {
LOG_WARN("failed to add dist plan", K(ret), K(plan)); LOG_WARN("failed to add dist plan", K(ret), K(plan));
} else { } else {
@ -1230,7 +1232,7 @@ int ObSqlPlanSet::add_plan(ObPhysicalPlan &plan,
} }
} }
} }
SQL_PC_LOG(DEBUG, "plan set add plan", K(ret), K(&plan), "plan type ", plan_type, SQL_PC_LOG(TRACE, "plan set add plan", K(ret), K(&plan), "plan type ", plan_type,
K(has_duplicate_table_), K(stmt_type_)); K(has_duplicate_table_), K(stmt_type_));
// increase plan ref_count, // increase plan ref_count,
// if plan doesn't add in plan cache,don't increase ref_count; // if plan doesn't add in plan cache,don't increase ref_count;
@ -1319,7 +1321,7 @@ int ObSqlPlanSet::init_new_set(const ObPlanCacheCtx &pc_ctx,
for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) { for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
if (NULL == partition_infos.at(i)) { if (NULL == partition_infos.at(i)) {
ret = OB_ERR_UNEXPECTED; ret = OB_ERR_UNEXPECTED;
SQL_PC_LOG(DEBUG, "invalid partition info"); SQL_PC_LOG(TRACE, "invalid partition info");
} else if (OB_FAIL(table_locations_.push_back(partition_infos.at(i)->get_table_location()))) { } else if (OB_FAIL(table_locations_.push_back(partition_infos.at(i)->get_table_location()))) {
SQL_PC_LOG(WARN, "fail to push table location", K(ret)); SQL_PC_LOG(WARN, "fail to push table location", K(ret));
} else if (is_all_non_partition_ } else if (is_all_non_partition_
@ -1342,7 +1344,7 @@ int ObSqlPlanSet::select_plan(ObPlanCacheCtx &pc_ctx, ObPlanCacheObject *&cache_
} else if (0 == need_try_plan_ || is_multi_stmt_plan()) { } else if (0 == need_try_plan_ || is_multi_stmt_plan()) {
if (OB_FAIL(get_plan_normal(pc_ctx, plan))) { if (OB_FAIL(get_plan_normal(pc_ctx, plan))) {
if (OB_SQL_PC_NOT_EXIST == ret) { if (OB_SQL_PC_NOT_EXIST == ret) {
LOG_DEBUG("fail to get plan normal", K(ret)); LOG_TRACE("fail to get plan normal", K(ret));
} else { } else {
LOG_WARN("fail to get plan normal", K(ret)); LOG_WARN("fail to get plan normal", K(ret));
} }
@ -1350,7 +1352,7 @@ int ObSqlPlanSet::select_plan(ObPlanCacheCtx &pc_ctx, ObPlanCacheObject *&cache_
} else { } else {
if (OB_FAIL(get_plan_special(pc_ctx, plan))) { if (OB_FAIL(get_plan_special(pc_ctx, plan))) {
if (OB_SQL_PC_NOT_EXIST == ret) { if (OB_SQL_PC_NOT_EXIST == ret) {
LOG_DEBUG("fail to get plan special", K(ret)); LOG_TRACE("fail to get plan special", K(ret));
} else { } else {
LOG_WARN("fail to get plan special", K(ret)); LOG_WARN("fail to get plan special", K(ret));
} }
@ -1591,7 +1593,7 @@ int ObSqlPlanSet::get_plan_normal(ObPlanCacheCtx &pc_ctx,
SMART_VAR(PLS, candi_table_locs) { SMART_VAR(PLS, candi_table_locs) {
if (enable_inner_part_parallel_exec_) { if (enable_inner_part_parallel_exec_) {
if (OB_FAIL(get_physical_plan(OB_PHY_PLAN_DISTRIBUTED, pc_ctx, plan))) { if (OB_FAIL(get_physical_plan(OB_PHY_PLAN_DISTRIBUTED, pc_ctx, plan))) {
LOG_DEBUG("failed to get px plan", K(ret)); LOG_TRACE("failed to get px plan", K(ret));
} }
} else if (OB_FAIL(get_plan_type(table_locations_, } else if (OB_FAIL(get_plan_type(table_locations_,
false, false,
@ -1599,7 +1601,7 @@ int ObSqlPlanSet::get_plan_normal(ObPlanCacheCtx &pc_ctx,
candi_table_locs, candi_table_locs,
plan_type))) { plan_type))) {
// ret = OB_SQL_PC_NOT_EXIST; // ret = OB_SQL_PC_NOT_EXIST;
SQL_PC_LOG(DEBUG, "failed to get plan type", K(ret)); SQL_PC_LOG(TRACE, "failed to get plan type", K(ret));
} }
if (OB_SUCC(ret) && !enable_inner_part_parallel_exec_) { if (OB_SUCC(ret) && !enable_inner_part_parallel_exec_) {
@ -1613,7 +1615,7 @@ int ObSqlPlanSet::get_plan_normal(ObPlanCacheCtx &pc_ctx,
plan = array_binding_plan_; plan = array_binding_plan_;
} }
} else if (OB_FAIL(get_physical_plan(OB_PHY_PLAN_LOCAL, pc_ctx, plan))) { } else if (OB_FAIL(get_physical_plan(OB_PHY_PLAN_LOCAL, pc_ctx, plan))) {
LOG_DEBUG("failed to get local plan", K(ret)); LOG_TRACE("failed to get local plan", K(ret));
} }
} break; } break;
case OB_PHY_PLAN_REMOTE: { case OB_PHY_PLAN_REMOTE: {
@ -1625,7 +1627,7 @@ int ObSqlPlanSet::get_plan_normal(ObPlanCacheCtx &pc_ctx,
case OB_PHY_PLAN_DISTRIBUTED: { case OB_PHY_PLAN_DISTRIBUTED: {
if (OB_FAIL(get_physical_plan(OB_PHY_PLAN_DISTRIBUTED, pc_ctx, plan))) { if (OB_FAIL(get_physical_plan(OB_PHY_PLAN_DISTRIBUTED, pc_ctx, plan))) {
if (OB_SQL_PC_NOT_EXIST == ret) { if (OB_SQL_PC_NOT_EXIST == ret) {
LOG_DEBUG("fail to get dist plan", K(ret)); LOG_TRACE("fail to get dist plan", K(ret));
} else { } else {
LOG_WARN("fail to get dist plan", K(ret)); LOG_WARN("fail to get dist plan", K(ret));
} }
@ -1713,9 +1715,9 @@ int ObSqlPlanSet::try_get_dist_plan(ObPlanCacheCtx &pc_ctx,
int ret = OB_SUCCESS; int ret = OB_SUCCESS;
plan = NULL; plan = NULL;
if (OB_FAIL(dist_plans_.get_plan(pc_ctx, plan))) { if (OB_FAIL(dist_plans_.get_plan(pc_ctx, plan))) {
LOG_DEBUG("failed to get dist plan", K(ret)); LOG_TRACE("failed to get dist plan", K(ret));
} else if (plan != NULL) { } else if (plan != NULL) {
LOG_DEBUG("succeed to get dist plan", K(*plan)); LOG_TRACE("succeed to get dist plan", K(*plan));
} }
if (OB_SQL_PC_NOT_EXIST == ret) { if (OB_SQL_PC_NOT_EXIST == ret) {
ret = OB_SUCCESS; ret = OB_SUCCESS;
@ -1748,7 +1750,7 @@ int ObSqlPlanSet::get_plan_special(ObPlanCacheCtx &pc_ctx,
//try dist plan //try dist plan
if (OB_SUCC(ret) && get_next) { if (OB_SUCC(ret) && get_next) {
if (OB_FAIL(try_get_dist_plan(pc_ctx, plan))) { if (OB_FAIL(try_get_dist_plan(pc_ctx, plan))) {
LOG_DEBUG("failed to try get dist plan", K(ret)); LOG_TRACE("failed to try get dist plan", K(ret));
} }
} }
if (OB_SUCC(ret) && nullptr == plan) { if (OB_SUCC(ret) && nullptr == plan) {