/**

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

#define OCEANBASE_SQL_PLAN_CACHE_OB_I_LIB_CACHE_NODE_

#include "lib/list/ob_dlist.h"

#include "lib/lock/ob_spin_rwlock.h"

#include "lib/lock/ob_tc_rwlock.h"

#include "lib/stat/ob_latch_define.h"

#include "sql/plan_cache/ob_lib_cache_register.h"

#include "sql/plan_cache/ob_plan_cache_util.h"

namespace oceanbase

{

namespace common

{

class ObIAllocator;

}

namespace sql

{

class ObPlanCache;

class ObILibCacheKey;

class ObILibCacheCtx;

class ObILibCacheObject;

struct StmtStat

{

int64_t memory_used_;

int64_t last_active_timestamp_; // used now

int64_t execute_average_time_;

int64_t execute_slowest_time_;

int64_t execute_slowest_timestamp_;

int64_t execute_count_; // used now

int64_t execute_slow_count_;

int64_t ps_count_;

bool to_delete_;

StmtStat()

: memory_used_(0),

last_active_timestamp_(0),

execute_average_time_(0),

execute_slowest_time_(0),

execute_slowest_timestamp_(0),

execute_count_(0),

execute_slow_count_(0),

ps_count_(0),

to_delete_(false)

{

}

void reset()

{

memory_used_ = 0;

last_active_timestamp_ = 0;

execute_average_time_ = 0;

execute_slowest_time_ = 0;

execute_slowest_timestamp_ = 0;

execute_count_ = 0;

execute_slow_count_ = 0;

ps_count_ = 0;

to_delete_ = false;

}

double weight()

{

int64_t time_interval = common::ObTimeUtility::current_time() - last_active_timestamp_;

double weight = common::OB_PC_WEIGHT_NUMERATOR / static_cast<double>(time_interval);

return weight;

}

TO_STRING_KV(K_(memory_used),

K_(last_active_timestamp),

K_(execute_average_time),

K_(execute_slowest_time),

K_(execute_slowest_timestamp),

K_(execute_count),

K_(execute_slow_count),

K_(ps_count),

K_(to_delete));

};

typedef ObList<ObILibCacheObject*, ObIAllocator> CacheObjList;

// The abstract interface class of library cache node, each object in the ObLibCacheNameSpace

// enum structure needs to inherit from this interface and implement its own implementation class

class ObILibCacheNode

{

friend class ObLCNodeFactory;

public:

ObILibCacheNode(ObPlanCache *lib_cache, lib::MemoryContext &mem_context)

: mem_context_(mem_context),

allocator_(mem_context->get_safe_arena_allocator()),

rwlock_(),

ref_count_(0),

lib_cache_(lib_cache),

co_list_lock_(common::ObLatchIds::PLAN_SET_LOCK),

co_list_(allocator_)

{

lock_timeout_ts_ = GCONF.large_query_threshold;

}

virtual ~ObILibCacheNode();

/**

* @brief initialize library cache node

* @param cache_obj[in], object that need to be cached

* @return if success, return OB_SUCCESS, otherwise, return errno

*/

virtual int init(ObILibCacheCtx &ctx, const ObILibCacheObject *cache_obj);

/**

* @brief decrease the reference count of all cache objects in the library cache value by one

*/

void free_cache_obj_array();

/**

* @brief remove all plan stat from all cache objects in the library cache node

*/

int remove_all_plan_stat();

/**

* @brief remove cache obj from cache_obj_list_

* @param obj_id[in], obj id to remove

* @return if success, return OB_SUCCESS, otherwise, return errno

*/

int remove_cache_obj_entry(const ObCacheObjID obj_id);

/**

* @brief get cache object from library cache

* @param ctx[in], library cache context

* @return if success, return OB_SUCCESS, otherwise, return errno

*/

int get_cache_obj(ObILibCacheCtx &ctx, ObILibCacheKey *key, ObILibCacheObject *&cache_obj);

/**

* @brief add cache object to library cache

* @param ctx[in], library cache context

* @return if success, return OB_SUCCESS, otherwise, return errno

*/

int add_cache_obj(ObILibCacheCtx &ctx, ObILibCacheKey *key, ObILibCacheObject *cache_obj);

/**

* @brief erase cache object from library cache

* @param ctx[in], library cache context

* @return if success, return OB_SUCCESS, otherwise, return errno

*/

//int erase_cache_obj(ObILibCacheCtx &context, ObILibCacheObject *cache_obj);

virtual int lock(bool is_rdlock);

virtual int update_node_stat(ObILibCacheCtx &ctx);

StmtStat *get_node_stat() { return &node_stat_; }

int unlock() { return rwlock_.unlock(); }

int64_t inc_ref_count(const CacheRefHandleID ref_handle);

int64_t dec_ref_count(const CacheRefHandleID ref_handle);

int64_t get_ref_count() const { return ATOMIC_LOAD(&ref_count_); }

common::ObIAllocator *get_allocator() { return &allocator_; }

common::ObIAllocator &get_allocator_ref() { return allocator_; }

lib::MemoryContext &get_mem_context() { return mem_context_; }

int64_t get_mem_size();

ObPlanCache *get_lib_cache() const { return lib_cache_; }

VIRTUAL_TO_STRING_KV(K_(ref_count), K_(lock_timeout_ts));

protected:

void set_lock_timeout_threshold(int64_t threshold)

{

lock_timeout_ts_ = threshold;

}

/**

* @brief called by get_cache_obj(), each object in the ObLibCacheNameSpace enumeration structure

* needs to inherit this interface and implement its own inner get implementation

* @param ctx[in], library cache context

* @return if success, return OB_SUCCESS, otherwise, return errno

*/

virtual int inner_get_cache_obj(ObILibCacheCtx &ctx,

ObILibCacheKey *key,

ObILibCacheObject *&cache_obj) = 0;

/**

* @brief called by add_cache_obj(), each object in the ObLibCacheNameSpace enumeration structure

* needs to inherit this interface and implement its own inner add implementation

* @param ctx[in], library cache context

* @return if success, return OB_SUCCESS, otherwise, return errno

*/

virtual int inner_add_cache_obj(ObILibCacheCtx &ctx,

ObILibCacheKey *key,

ObILibCacheObject *cache_obj) = 0;

/**

* @brief called by erase_cache_obj(), each object in the ObLibCacheNameSpace enumeration structure

* needs to inherit this interface and implement its own inner erase implementation

* @param ctx[in], library cache context

* @return if success, return OB_SUCCESS, otherwise, return errno

*/

//int inner_erase_cache_obj(ObILibCacheCtx &ctx, ObILibCacheObject *cache_obj) = 0;

/**

* @brief called to do something before cache evicted

* @return if success, return OB_SUCCESS, otherwise, return errno

*/

virtual int before_cache_evicted();

protected:

lib::MemoryContext mem_context_;

// Note: all memory allocations in ObILibCacheNode can only use allocator_, when the ObILibCacheNode

// node is destructed, all memory allocated by allocator_ will be released

common::ObIAllocator &allocator_;

common::TCRWLock rwlock_;

int64_t ref_count_;

int64_t lock_timeout_ts_;

StmtStat node_stat_;

ObPlanCache *lib_cache_;

common::SpinRWLock co_list_lock_;

CacheObjList co_list_;

};

} // namespace common

} // namespace oceanbase

#endif // OCEANBASE_SQL_PLAN_CACHE_OB_I_LIB_CACHE_NODE_