{

OB_UNIS_VERSION(1);

ObOutlineState() : outline_version_(), is_plan_fixed_(false) {}

~ObOutlineState(){}

void reset()

{

outline_version_.reset();

is_plan_fixed_ = false;

}

TO_STRING_KV(K(outline_version_), K(is_plan_fixed_));

share::schema::ObSchemaObjVersion outline_version_;

bool is_plan_fixed_;//whether the plan will be fixed with outline_content

uint64_t obj_id_;

uint64_t tenant_id_;

int64_t log_del_time_;

int64_t real_del_time_;

int64_t ref_count_;

int64_t mem_used_;

bool added_to_lc_;

AllocCacheObjInfo(uint64_t obj_id, uint64_t tenant_id,

int64_t log_del_time, int64_t real_del_time,

int64_t ref_count, int64_t mem_used, bool added_to_pc)

: obj_id_(obj_id),

tenant_id_(tenant_id),

log_del_time_(log_del_time),

real_del_time_(real_del_time),

ref_count_(ref_count),

mem_used_(mem_used),

added_to_lc_(added_to_pc) {}

AllocCacheObjInfo()

: obj_id_(common::OB_INVALID_ID),

tenant_id_(common::OB_INVALID_ID),

log_del_time_(INT64_MAX),

real_del_time_(INT64_MAX),

ref_count_(0),

mem_used_(0),

added_to_lc_(false) {}

TO_STRING_KV(K_(obj_id), K_(tenant_id), K_(log_del_time),

K_(real_del_time), K_(ref_count), K_(added_to_lc),

K_(mem_used));

{

ObParamInfo()

: scale_(0),

type_(common::ObNullType),

ext_real_type_(common::ObNullType),

is_oracle_null_value_(false),

col_type_(common::CS_TYPE_INVALID),

precision_(PRECISION_UNKNOWN_YET)

{}

virtual ~ObParamInfo() {}

void reset();

TO_STRING_KV(K_(flag),

K_(scale),

K_(type),

K_(ext_real_type),

K_(is_oracle_null_value),

K_(col_type),

K_(precision));

static const int64_t MAX_STR_DES_LEN = 17;

// Store whether to check type and bool value, as well as the expected bool value

common::ParamFlag flag_;

common::ObScale scale_;

common::ObObjType type_;

common::ObObjType ext_real_type_; // use as high 4 bytes of udt id if type is sql udt

// Process Oracle mode type null value matching in plan_cache

bool is_oracle_null_value_;

common::ObCollationType col_type_;

common::ObPrecision precision_;

OB_UNIS_VERSION_V(1);

{

friend class ::test::MockCacheObjectFactory;

ObPlanCacheObject(ObLibCacheNameSpace ns, lib::MemoryContext &mem_context);

virtual ~ObPlanCacheObject() {}

inline int64_t get_dependency_table_size() const { return dependency_tables_.count(); }

inline const DependenyTableStore &get_dependency_table() const { return dependency_tables_; }

inline void set_sys_schema_version(int64_t schema_version) { sys_schema_version_ = schema_version; }

inline void set_tenant_schema_version(int64_t schema_version) { tenant_schema_version_ = schema_version; }

inline int64_t get_tenant_schema_version() const { return tenant_schema_version_; }

inline int64_t get_sys_schema_version() const { return sys_schema_version_; }

int init_dependency_table_store(int64_t dependency_table_cnt) { return dependency_tables_.init(dependency_table_cnt); }

inline DependenyTableStore &get_dependency_table() { return dependency_tables_; }

int get_base_table_version(const uint64_t table_id, int64_t &table_version) const;

inline ObOutlineState &get_outline_state() { return outline_state_; }

inline const ObOutlineState &get_outline_state() const { return outline_state_; }

inline void set_outline_state(const ObOutlineState &state) { outline_state_ = state; }

int set_params_info(const ParamStore &params);

const common::Ob2DArray<ObParamInfo,

common::OB_MALLOC_BIG_BLOCK_SIZE,

common::ObWrapperAllocator, false> &get_params_info() const { return params_info_; }

inline void set_is_contain_virtual_table(bool is_contain_virtual_table) { is_contain_virtual_table_ = is_contain_virtual_table; }

inline void set_is_contain_inner_table(bool is_contain_inner_table) { is_contain_inner_table_ = is_contain_inner_table; }

inline bool is_contain_virtual_table() const { return is_contain_virtual_table_; }

inline bool is_contain_inner_table() const { return is_contain_inner_table_; }

virtual void inc_pre_expr_ref_count() {}

virtual void dec_pre_expr_ref_count() {}

virtual int64_t get_pre_expr_ref_count() const {return -1;}

virtual void set_pre_calc_expr_handler(PreCalcExprHandler* handler) {UNUSED(handler);}

virtual PreCalcExprHandler* get_pre_calc_expr_handler(){return NULL;}

inline const common::ObDList<ObPreCalcExprFrameInfo> &get_pre_calc_frames() const

{

return pre_calc_frames_;

}

inline common::ObDList<ObPreCalcExprFrameInfo> &get_pre_calc_frames()

{

return pre_calc_frames_;

}

inline void set_fetch_cur_time(bool fetch_cur_time) { fetch_cur_time_ = fetch_cur_time; }

inline bool get_fetch_cur_time() const { return fetch_cur_time_; }

inline void set_ignore(bool ignore) { is_ignore_stmt_ = ignore; }

inline bool is_ignore() const { return is_ignore_stmt_; }

inline void set_stmt_type(stmt::StmtType stmt_type) { stmt_type_ = stmt_type; }

inline stmt::StmtType get_stmt_type() const { return stmt_type_; }

inline void set_need_param(bool need_param) { need_param_ = need_param; }

inline bool need_param() const { return need_param_; }

static int match_pre_calc_cons(common::ObDList<ObPreCalcExprConstraint> &cached_cons,

const ObPlanCacheCtx &pc_ctx,

const bool is_ignore_stmt,

bool &is_matched);

static int is_same_pre_calc_cons(const ObPreCalcExprConstraint &cons1,

const ObPreCalcExprConstraint &cons2,

bool &is_same);

static int is_same_expr(const ObExpr *expr1,

const ObExpr *expr2,

bool &is_same);

static int check_pre_calc_cons(const bool is_ignore_stmt,

bool &is_match,

ObPreCalcExprConstraint &pre_calc_con,

ObExecContext &exec_ctx);

static int pre_calculation(const bool is_ignore_stmt,

ObPreCalcExprFrameInfo &pre_calc_frame,

ObExecContext &exec_ctx,

const uint64_t calc_types = PRE_CALC_DEFAULT);

virtual void reset();

virtual void dump_deleted_log_info(const bool is_debug_log = true) const;

virtual int check_need_add_cache_obj_stat(ObILibCacheCtx &ctx, bool &need_real_add);

static int type_to_name(const ObLibCacheNameSpace ns,

common::ObIAllocator &allocator,

common::ObString &type_name);

VIRTUAL_TO_STRING_KV(K_(tenant_schema_version),

K_(sys_schema_version),

K_(dependency_tables),

K_(outline_state),

K_(params_info),

K_(is_contain_virtual_table),

K_(is_contain_inner_table),

K_(fetch_cur_time));

int64_t tenant_schema_version_;

int64_t sys_schema_version_;

DependenyTableStore dependency_tables_;

//for outline use

ObOutlineState outline_state_;//TODO:check this need to be

// store the expressions need to be calculated when plan beginning

common::ObDList<ObPreCalcExprFrameInfo> pre_calc_frames_;

// Store the information of parameterized parameters and the result values of calculable expressions

common::Ob2DArray<ObParamInfo,

common::OB_MALLOC_BIG_BLOCK_SIZE,

common::ObWrapperAllocator, false> params_info_;

bool is_contain_virtual_table_;//for virtual table service, if it is determined that the statement involves a virtual table

bool is_contain_inner_table_;//for internal table service, if it is determined that the statement involves an internal table

bool fetch_cur_time_;

bool is_ignore_stmt_;

stmt::StmtType stmt_type_;

bool need_param_;