/**

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

*/

#ifndef OCEANBASE_SQL_PLAN_CACHE_OB_PLAN_CACHE_STRUCT_

#define OCEANBASE_SQL_PLAN_CACHE_OB_PLAN_CACHE_STRUCT_

#include "lib/container/ob_iarray.h"

#include "lib/container/ob_se_array.h"

#include "lib/hash/ob_hashmap.h"

#include "lib/hash_func/murmur_hash.h"

#include "lib/time/ob_time_utility.h"

#include "lib/allocator/ob_allocator.h"

#include "lib/string/ob_string.h"

#include "lib/utility/serialization.h"

#include "sql/plan_cache/ob_lib_cache_register.h"

#include "sql/plan_cache/ob_i_lib_cache_key.h"

#include "sql/plan_cache/ob_i_lib_cache_context.h"

#include "sql/ob_sql_utils.h"

#include "sql/plan_cache/ob_plan_cache_util.h"

#include "sql/udr/ob_udr_struct.h"

namespace oceanbase

{

namespace common

{

class ObString;

}

namespace sql

{

typedef common::ObSEArray<ObString, 1, common::ModulePageAllocator, true> TmpTableNameArray;

enum PlanCacheMode

{

PC_INVALID_MODE = -1,

PC_TEXT_MODE = 0,

PC_PS_MODE = 1,

PC_PL_MODE = 2,

PC_MAX_MODE = 3

};

struct ObPlanCacheKey : public ObILibCacheKey

{

ObPlanCacheKey()

: key_id_(common::OB_INVALID_ID),

db_id_(common::OB_INVALID_ID),

sessid_(0),

mode_(PC_TEXT_MODE),

is_weak_read_(false) {}

inline void reset()

{

name_.reset();

key_id_ = common::OB_INVALID_ID;

db_id_ = common::OB_INVALID_ID;

sessid_ = 0;

mode_ = PC_TEXT_MODE;

sys_vars_str_.reset();

config_str_.reset();

is_weak_read_ = false;

namespace_ = NS_INVALID;

}

virtual inline int deep_copy(common::ObIAllocator &allocator,

const ObILibCacheKey &other)

{

int ret = common::OB_SUCCESS;

const ObPlanCacheKey &pc_key = static_cast<const ObPlanCacheKey&>(other);

if (OB_FAIL(common::ob_write_string(allocator, pc_key.name_, name_))) {

SQL_PC_LOG(WARN, "write string failed", K(ret), K(pc_key.name_));

} else if (OB_FAIL(common::ob_write_string(allocator, pc_key.sys_vars_str_,

sys_vars_str_))) {

SQL_PC_LOG(WARN, "write sys vars str failed", K(ret),

K(pc_key.sys_vars_str_));

} else if (OB_FAIL(common::ob_write_string(allocator, pc_key.config_str_,

config_str_))) {

SQL_PC_LOG(WARN, "write config str failed", K(ret),

K(pc_key.config_str_));

} else {

db_id_ = pc_key.db_id_;

key_id_ = pc_key.key_id_;

sessid_ = pc_key.sessid_;

mode_ = pc_key.mode_;

namespace_ = pc_key.namespace_;

is_weak_read_ = pc_key.is_weak_read_;

}

return ret;

}

inline void destory(common::ObIAllocator &allocator)

{

if (NULL != name_.ptr()) {

allocator.free(name_.ptr());

}

if (NULL != sys_vars_str_.ptr()) {

allocator.free(sys_vars_str_.ptr());

}

if (NULL != config_str_.ptr()) {

allocator.free(config_str_.ptr());

}

}

virtual inline uint64_t hash() const

{

uint64_t hash_ret = name_.hash();

hash_ret = common::murmurhash(&key_id_, sizeof(uint64_t), hash_ret);

hash_ret = common::murmurhash(&db_id_, sizeof(uint64_t), hash_ret);

hash_ret = common::murmurhash(&sessid_, sizeof(uint32_t), hash_ret);

hash_ret = common::murmurhash(&mode_, sizeof(PlanCacheMode), hash_ret);

hash_ret = sys_vars_str_.hash(hash_ret);

hash_ret = config_str_.hash(hash_ret);

hash_ret = common::murmurhash(&namespace_, sizeof(ObLibCacheNameSpace), hash_ret);

return hash_ret;

}

virtual inline bool is_equal(const ObILibCacheKey &other) const

{

const ObPlanCacheKey &pc_key = static_cast<const ObPlanCacheKey&>(other);

bool cmp_ret = name_ == pc_key.name_ &&

db_id_ == pc_key.db_id_ &&

key_id_ == pc_key.key_id_ &&

sessid_ == pc_key.sessid_ &&

mode_ == pc_key.mode_ &&

sys_vars_str_ == pc_key.sys_vars_str_ &&

config_str_ == pc_key.config_str_ &&

is_weak_read_ == pc_key.is_weak_read_ &&

namespace_ == pc_key.namespace_;

return cmp_ret;

}

TO_STRING_KV(K_(name),

K_(key_id),

K_(db_id),

K_(sessid),

K_(mode),

K_(sys_vars_str),

K_(config_str),

K_(is_weak_read),

K_(namespace));

//通过name来进行查找，一般是shared sql/procedure

//cursor用这种方式，对应的namespace是CRSR

common::ObString name_;

//通过schema id来进行查找，这种方式一般是直接的schema obj需要缓存到plan

//cache中，例如store procedure, package, function

uint64_t key_id_; //在ps中key_id_的含有为statement id

uint64_t db_id_;

uint32_t sessid_;

PlanCacheMode mode_;

common::ObString sys_vars_str_;

common::ObString config_str_;

bool is_weak_read_;

};

//记录快速化参数后不需要扣参数的原始字符串及相关信息

struct NotParamInfo

{

int64_t idx_;

common::ObString raw_text_;

NotParamInfo()

:idx_(common::OB_INVALID_ID)

{}

void reset()

{

idx_ = common::OB_INVALID_ID;

raw_text_.reset();

}

TO_STRING_KV(K_(idx), K_(raw_text));

};

typedef common::ObSEArray<NotParamInfo, 4> NotParamInfoList;

// Template SQL Constant Constraints

typedef common::ObSEArray<NotParamInfoList, 4> TplSqlConstCons;

struct PsNotParamInfo

{

int64_t idx_;

common::ObObjParam ps_param_;

TO_STRING_KV(K_(idx), K_(ps_param));

};

struct ObValuesTokenPos {

ObValuesTokenPos() : no_param_sql_pos_(0), param_idx_(0) {}

ObValuesTokenPos(const int64_t no_param_pos, const int64_t param_idx)

: no_param_sql_pos_(no_param_pos), param_idx_(param_idx) {}

int64_t no_param_sql_pos_;

int64_t param_idx_;

TO_STRING_KV(K(no_param_sql_pos_), K(param_idx_));

};

typedef common::ObFixedArray<ObPCParam *, common::ObIAllocator> ObArrayPCParam;

struct ObFastParserResult

{

private:

common::ModulePageAllocator inner_alloc_;

public:

ObFastParserResult()

: inner_alloc_("FastParserRes"),

raw_params_(&inner_alloc_),

parameterized_params_(&inner_alloc_),

cache_params_(NULL),

values_token_pos_(0),

values_tokens_(&inner_alloc_)

{

reset_question_mark_ctx();

}

ObPlanCacheKey pc_key_; //plan cache key, parameterized by fast parser

common::ObFixedArray<ObPCParam *, common::ObIAllocator> raw_params_;

common::ObFixedArray<const common::ObObjParam *, common::ObIAllocator> parameterized_params_;

ParamStore *cache_params_;

ObQuestionMarkCtx question_mark_ctx_;

int64_t values_token_pos_; // for insert values

common::ObFixedArray<ObValuesTokenPos, common::ObIAllocator> values_tokens_; // for values table

common::ObSEArray<ObArrayPCParam *, 4, common::ModulePageAllocator, true> array_params_;

void reset() {

pc_key_.reset();

raw_params_.reuse();

parameterized_params_.reuse();

cache_params_ = NULL;

values_token_pos_ = 0;

values_tokens_.reuse();

array_params_.reuse();

}

void reset_question_mark_ctx()

{

question_mark_ctx_.name_ = NULL;

question_mark_ctx_.count_ = 0;

question_mark_ctx_.capacity_ = 0;

question_mark_ctx_.by_ordinal_ = false;

question_mark_ctx_.by_name_ = false;

question_mark_ctx_.by_defined_name_ = false;

}

int assign(const ObFastParserResult &other)

{

int ret = OB_SUCCESS;

pc_key_ = other.pc_key_;

raw_params_.set_allocator(&inner_alloc_);

parameterized_params_.set_allocator(&inner_alloc_);

cache_params_ = other.cache_params_;

question_mark_ctx_ = other.question_mark_ctx_;

values_tokens_.set_allocator(&inner_alloc_);

if (OB_FAIL(raw_params_.assign(other.raw_params_))) {

SQL_PC_LOG(WARN, "failed to assign fix array", K(ret));

} else if (OB_FAIL(parameterized_params_.assign(other.parameterized_params_))) {

SQL_PC_LOG(WARN, "failed to assign fix array", K(ret));

} else if (OB_FAIL(values_tokens_.assign(other.values_tokens_))) {

SQL_PC_LOG(WARN, "failed to assign fix array", K(ret));

} else if (OB_FAIL(array_params_.assign(other.array_params_))) {

SQL_PC_LOG(WARN, "failed to assign array", K(ret));

}

return ret;

}

TO_STRING_KV(K(pc_key_), K(raw_params_), K(parameterized_params_), K(cache_params_), K(values_token_pos_),

K(values_tokens_), K(array_params_));

};

enum WayToGenPlan {

WAY_DEPENDENCE_ENVIRONMENT,

WAY_ACS,

WAY_PLAN_BASELINE,

WAY_OPTIMIZER,

};

struct SelectItemParamInfo

{

// 比最大长度的column名多一倍的buffer

static const int64_t PARAMED_FIELD_BUF_LEN = MAX_COLUMN_CHAR_LENGTH;

// 对于 select -1 + a + 1 + b + 2 from dual，参数化后的sql为select ? + a + ? b + ? from dual

// questions_pos_记录每一个?相对于column表达式的偏移，即[0, 4, 9]

// params_idx_记录每一个?在raw_params中的下标，即[0, 1, 2]

// neg_params_idx_记录哪一个常量是负号，即[0]

// paramed_field_name_记录参数化后的column模板，即'? + a + ? + b + ?'

// esc_str_flag_标记z这一个column是不是字符串常量，比如 select 'abc' from dual，'abc'对应的标记为true

common::ObSEArray<int64_t, 16> questions_pos_;

common::ObSEArray<int64_t, 16> params_idx_;

common::ObBitSet<> neg_params_idx_;

char paramed_field_name_[PARAMED_FIELD_BUF_LEN];

int64_t name_len_;

bool esc_str_flag_;

SelectItemParamInfo()

: questions_pos_(),

params_idx_(),

neg_params_idx_(),

name_len_(0),

esc_str_flag_(false) {}

void reset()

{

questions_pos_.reset();

params_idx_.reset();

neg_params_idx_.reset();

esc_str_flag_ = false;

name_len_ = 0;

}

TO_STRING_KV(K_(questions_pos),

K_(params_idx),

K_(neg_params_idx),

K_(name_len),

K_(esc_str_flag),

K(common::ObString(name_len_, paramed_field_name_)));

};

typedef common::ObFixedArray<SelectItemParamInfo, common::ObIAllocator> SelectItemParamInfoArray;

typedef common::ObFixedArray<ObPCParam *, common::ObIAllocator> ObRawParams;

typedef common::ObFixedArray<ObRawParams *, common::ObIAllocator> ObRawParams2DArray;

struct ObInsertBatchOptInfo

{

ObInsertBatchOptInfo(common::ObIAllocator &allocator)

: insert_params_count_(0),

update_params_count_(0),

sql_delta_length_(0),

multi_raw_params_(allocator),

new_reconstruct_sql_()

{}

TO_STRING_KV(K_(insert_params_count), K_(update_params_count),

K_(sql_delta_length), K_(new_reconstruct_sql));

int64_t insert_params_count_;

int64_t update_params_count_;

int64_t sql_delta_length_;

ObRawParams2DArray multi_raw_params_;

ObString new_reconstruct_sql_;

};

struct ObPlanCacheCtx : public ObILibCacheCtx

{

ObPlanCacheCtx(const common::ObString &sql,

const PlanCacheMode mode,

common::ObIAllocator &allocator,

ObSqlCtx &sql_ctx,

ObExecContext &exec_ctx,

uint64_t tenant_id)

: mode_(mode),

raw_sql_(sql),

allocator_(allocator),

sql_ctx_(sql_ctx),

exec_ctx_(exec_ctx),

fp_result_(),

not_param_info_(allocator),

not_param_var_(allocator),

param_charset_type_(allocator),

normal_parse_const_cnt_(0),

need_evolution_(false),

select_item_param_infos_(allocator),

should_add_plan_(true),

begin_commit_stmt_(false),

must_be_positive_index_(),

multi_stmt_fp_results_(allocator),

handle_id_(MAX_HANDLE),

is_remote_executor_(false),

is_parameterized_execute_(false),

ps_need_parameterized_(false),

fixed_param_idx_(allocator),

need_add_obj_stat_(true),

is_inner_sql_(false),

is_original_ps_mode_(false),

ab_params_(NULL),

new_raw_sql_(),

is_rewrite_sql_(false),

rule_name_(),

def_name_ctx_(NULL),

fixed_param_info_list_(allocator),

dynamic_param_info_list_(allocator),

tpl_sql_const_cons_(allocator),

need_retry_add_plan_(true),

insert_batch_opt_info_(allocator)

{

fp_result_.pc_key_.mode_ = mode_;

}

int get_not_param_info_str(common::ObIAllocator &allocator, common::ObString &str)

{

int ret = common::OB_SUCCESS;

if (not_param_info_.count() > 0) {

int64_t size = 0;

int64_t not_param_num = not_param_info_.count();

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

size += not_param_info_.at(i).raw_text_.length() + 2;

}

char *buf = (char *)allocator.alloc(size);

if (OB_ISNULL(buf)) {

ret = common::OB_ALLOCATE_MEMORY_FAILED;

SQL_PC_LOG(WARN, "fail to alloc memory for special param info", K(ret));

} else {

int64_t pos = 0;

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

pos += not_param_info_.at(i).raw_text_.to_string(buf + pos, size - pos);

if (i != not_param_num - 1) {

pos += snprintf(buf + pos, size - pos, ",");

}

}

str = common::ObString::make_string(buf);

}

} else {

/*do nothing*/

}

return ret;

}

int is_retry(bool &v) const; //是否在重试之中

int is_retry_for_dup_tbl(bool &v) const; //仅复制表原因的重试才会设置为true

void set_begin_commit_stmt() { begin_commit_stmt_ = true; }

bool is_begin_commit_stmt() const { return begin_commit_stmt_; }

void set_is_parameterized_execute() { is_parameterized_execute_ = true; }

bool is_parameterized_execute() { return is_parameterized_execute_; }

void set_is_inner_sql(bool v) { is_inner_sql_ = v; };

bool is_inner_sql() const { return is_inner_sql_; }

void set_is_rewrite_sql(bool v) { is_rewrite_sql_ = v; }

bool is_rewrite_sql() const { return is_rewrite_sql_; }

void set_need_retry_add_plan(bool v) { need_retry_add_plan_ = v; }

bool need_retry_add_plan() const { return need_retry_add_plan_; }

void set_pc_key_mode() { fp_result_.pc_key_.mode_ = mode_; }

TO_STRING_KV(

K(mode_),

K(raw_sql_),

K(not_param_info_),

K(not_param_var_),

K(not_param_index_),

K(neg_param_index_),

K(param_charset_type_),

K(should_add_plan_),

K(begin_commit_stmt_),

K(is_remote_executor_),

K(is_parameterized_execute_),

K(ps_need_parameterized_),

K(fixed_param_idx_),

K(need_add_obj_stat_),

K(is_inner_sql_),

K(is_rewrite_sql_),

K(rule_name_),

K(def_name_ctx_),

K(fixed_param_info_list_),

K(dynamic_param_info_list_),

K(tpl_sql_const_cons_),

K(is_original_ps_mode_),

K(new_raw_sql_),

K(need_retry_add_plan_),

K(insert_batch_opt_info_)

);

PlanCacheMode mode_; //control use which variables to do match

const common::ObString &raw_sql_; //query sql

common::ObIAllocator &allocator_; //result mem_pool

ObSqlCtx &sql_ctx_;

ObExecContext &exec_ctx_;

ObFastParserResult fp_result_; //result after fast parser

common::ObFixedArray<NotParamInfo, common::ObIAllocator> not_param_info_; //used for match pcv in pcv_set, gen when add plan

common::ObFixedArray<PsNotParamInfo, common::ObIAllocator> not_param_var_; //used for ps mode not param

common::ObBitSet<common::OB_DEFAULT_BITSET_SIZE, common::ModulePageAllocator, true> not_param_index_;

//记录负数信息，在get plan时将fast parser的负数添加负号，现在是为了兼容outline中signature的生成,

//以前为解决负数问题引入正常parser时识别负数，然后将fast parser中?sql负号去掉，并将参数化的参数原

//始串前加'-', 从而生成的plan cache key中无负号,现在plan cache对负号的处理没有依赖这个方案，

//但outline的signature生成依赖了plan cache key, 导致对负号的处理还需保留。

common::ObBitSet<common::OB_DEFAULT_BITSET_SIZE, common::ModulePageAllocator, true> neg_param_index_;

common::ObFixedArray<common::ObCharsetType, common::ObIAllocator> param_charset_type_;

// 用于存储临时表计划所包含的临时表名

TmpTableNameArray tmp_table_names_;

ObSqlTraits sql_traits_;

int64_t normal_parse_const_cnt_;

// ***** for spm ****

bool need_evolution_;

//****** for spm end *****

// select item参数化信息

SelectItemParamInfoArray select_item_param_infos_;

// 根据get plan时的一些信息(get plan失败)，判断新生成的计划是否加入plan cache

bool should_add_plan_;

// 记录是否为begin/commit的语句，用于优化部分路径的调用

bool begin_commit_stmt_;

// record which const param must be positive

common::ObBitSet<common::OB_DEFAULT_BITSET_SIZE,

common::ModulePageAllocator, true> must_be_positive_index_;

// used for store fp results for multi_stmt optimization

common::ObFixedArray<ObFastParserResult, common::ObIAllocator> multi_stmt_fp_results_;

CacheRefHandleID handle_id_;

bool is_remote_executor_;

bool is_parameterized_execute_;

bool ps_need_parameterized_;

common::ObFixedArray<int64_t, common::ObIAllocator> fixed_param_idx_;

bool need_add_obj_stat_;

bool is_inner_sql_;

bool is_original_ps_mode_;

ParamStore *ab_params_; // arraybinding batch parameters,

ObString new_raw_sql_; // values clause rebuild raw sql

// ********** for rewrite rule **********

bool is_rewrite_sql_;

common::ObString rule_name_;

QuestionMarkDefNameCtx *def_name_ctx_;

common::ObFixedArray<FixedParamValue, common::ObIAllocator> fixed_param_info_list_;

common::ObFixedArray<DynamicParamInfo, common::ObIAllocator> dynamic_param_info_list_;

common::ObFixedArray<NotParamInfoList, common::ObIAllocator> tpl_sql_const_cons_;

// ********** for rewrite end **********

// when schema version of cache node is old, whether remove this node and retry add cache obj.

bool need_retry_add_plan_;

ObInsertBatchOptInfo insert_batch_opt_info_;

};

struct ObPlanCacheStat

{

uint64_t access_count_;

uint64_t hit_count_;

ObPlanCacheStat()

: access_count_(0),

hit_count_(0)

{}

TO_STRING_KV("access_count", access_count_,

"hit_count", hit_count_);

};

}

}

#endif //OCEANBASE_SQL_PLAN_CACHE_OB_PLAN_CACHE_STRUCT_