/**
 * 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_cache_object.h"
#include "sql/plan_cache/ob_cache_object_factory.h"
#include "sql/plan_cache/ob_plan_cache.h"
#include "share/schema/ob_schema_getter_guard.h"
#include "share/ob_truncated_string.h"
#include "sql/engine/expr/ob_sql_expression.h"
#include "sql/engine/ob_exec_context.h"
#include "sql/engine/ob_physical_plan_ctx.h"
#include "pl/ob_pl.h"

#include <cstring>

namespace oceanbase
{
using namespace common;
using namespace share::schema;
namespace sql
{

void ObParamInfo::reset()
{
  flag_.reset();
  scale_ = 0;
  type_ = common::ObNullType;
  ext_real_type_ = common::ObNullType;
  is_oracle_empty_string_ = false;
  col_type_ = common::CS_TYPE_INVALID;
  precision_ = PRECISION_UNKNOWN_YET;
}

OB_SERIALIZE_MEMBER(ObParamInfo,
                    flag_,
                    scale_,
                    type_,
                    ext_real_type_,
                    is_oracle_empty_string_,
                    col_type_,
                    precision_);

ObPlanCacheObject::ObPlanCacheObject(ObLibCacheNameSpace ns, lib::MemoryContext &mem_context)
  : ObILibCacheObject(ns, mem_context),
    tenant_schema_version_(OB_INVALID_VERSION),
    sys_schema_version_(OB_INVALID_VERSION),
    dependency_tables_(allocator_),
    outline_state_(),
    pre_calc_frames_(),
    params_info_( (ObWrapperAllocator(allocator_)) ),
    is_contain_virtual_table_(false),
    is_contain_inner_table_(false),
    fetch_cur_time_(false),
    is_ignore_stmt_(false),
    stmt_type_(stmt::T_NONE),
    need_param_(true)
{
}

int ObPlanCacheObject::set_params_info(const ParamStore &params)
{
  int ret = OB_SUCCESS;
  int64_t N = params.count();
  ObParamInfo param_info;
  if (N > 0 && OB_FAIL(params_info_.reserve(N))) {
    OB_LOG(WARN, "fail to reserve params info", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
    param_info.flag_ = params.at(i).get_param_flag();
    param_info.type_ = params.at(i).get_param_meta().get_type();
    param_info.col_type_ = params.at(i).get_collation_type();
    if (ObSQLUtils::is_oracle_empty_string(params.at(i))) {
      param_info.is_oracle_empty_string_ = true;
    }
    if (params.at(i).get_param_meta().get_type() != params.at(i).get_type()) {
      LOG_TRACE("differ in set_params_info",
                K(params.at(i).get_param_meta().get_type()),
                K(params.at(i).get_type()),
                K(common::lbt()));
    }
    if (params.at(i).is_ext()) {
      ObDataType data_type;
      if (OB_FAIL(ObSQLUtils::get_ext_obj_data_type(params.at(i), data_type))) {
        LOG_WARN("fail to get ext obj data type", K(ret));
      } else {
        param_info.ext_real_type_ = data_type.get_obj_type();
        param_info.scale_ = data_type.get_scale();
      }
      LOG_DEBUG("ext params info", K(data_type), K(param_info), K(params.at(i)));
    } else {
      param_info.scale_ = params.at(i).get_scale();
      param_info.precision_ = params.at(i).get_precision();
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(params_info_.push_back(param_info))) {
        LOG_WARN("failed to push back param info", K(ret));
      }
    }
    param_info.reset();
  }
  return ret;
}

int ObPlanCacheObject::get_base_table_version(const uint64_t table_id, int64_t &table_version) const
{
  int ret = OB_SUCCESS;
  ARRAY_FOREACH(dependency_tables_, i) {
    const ObSchemaObjVersion &obj_version = dependency_tables_.at(i);
    if (obj_version.object_id_ == table_id) {
      //所有的dependency table的table_id应该是唯一的，其实判断table id就够了，这里再判断下table type，冗余性的检查下
      if (obj_version.is_base_table() || ObDependencyTableType::DEPENDENCY_VIEW == obj_version.get_type()) {
        table_version = obj_version.version_;
      } else {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("invalid dependency table type", K(obj_version));
      }
      break;
    }
  }
  return ret;
}

void ObPlanCacheObject::reset()
{
  ObILibCacheObject::reset();
  tenant_schema_version_ = OB_INVALID_VERSION;
  sys_schema_version_ = OB_INVALID_VERSION;
  dependency_tables_.reset();
  outline_state_.reset();
  pre_calc_frames_.reset();
  params_info_.reset();
  is_contain_virtual_table_ = false;
  is_contain_inner_table_ = false;
  fetch_cur_time_ = false;
  is_ignore_stmt_ = false;
  stmt_type_ = stmt::T_NONE;
  need_param_ = true;
}

int ObPlanCacheObject::check_pre_calc_cons(const bool is_ignore_stmt,
                                        bool &is_match,
                                        ObPreCalcExprConstraint &pre_calc_con,
                                        ObExecContext &exec_ctx)
{
  int ret = OB_SUCCESS;
  is_match = true;
  ObPhysicalPlanCtx *phy_plan_ctx = exec_ctx.get_physical_plan_ctx();
  ObPreCalcExprFrameInfo &pre_calc_frame = pre_calc_con.pre_calc_expr_info_;
  const PreCalcExprExpectResult expect_res = pre_calc_con.expect_result_;
  ObSEArray<ObDatumObjParam, 4> datum_params;
  if (OB_ISNULL(phy_plan_ctx)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("invalid physical plan ctx", K(ret), K(phy_plan_ctx));
  } else if (OB_FALSE_IT(phy_plan_ctx->set_ignore_stmt(is_ignore_stmt))) {
  } else if (PRE_CALC_ERROR == expect_res) {
    if (OB_FAIL(pre_calc_frame.eval_expect_err(exec_ctx, is_match))) {
      LOG_WARN("failed to eval pre calc expr frame info expect error", K(ret));
    }
  } else if (OB_FAIL(pre_calc_frame.eval(exec_ctx, datum_params))) {
    LOG_TRACE("failed to eval pre calc expr frame info", K(ret));
    is_match = false;
    ret = OB_SUCCESS;
  } else {
    ObObjParam obj_param;
    for (int64_t i = 0; OB_SUCC(ret) && is_match && i < datum_params.count(); ++i) {
      if (OB_FAIL(datum_params.at(i).to_objparam(obj_param, &exec_ctx.get_allocator()))) {
        LOG_WARN("failed to obj param", K(ret));
      } else if (OB_FAIL(pre_calc_con.check_is_match(obj_param, is_match))) {
        LOG_WARN("failed to check is match", K(ret));
      } // else end
    } // for end
  }
  return ret;
}

// used for add plan
int ObPlanCacheObject::match_pre_calc_cons(common::ObDList<ObPreCalcExprConstraint> &cached_cons,
                                           const ObPlanCacheCtx &pc_ctx,
                                           const bool is_ignore_stmt,
                                           bool &is_matched)
{
  int ret = OB_SUCCESS;
  is_matched = false;
  const ObDList<ObPreCalcExprConstraint> *cur_cons = pc_ctx.sql_ctx_.all_pre_calc_constraints_;
  if (OB_ISNULL(cur_cons)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(pc_ctx.sql_ctx_.all_pre_calc_constraints_));
  } else if (cached_cons.get_size() != cur_cons->get_size()) {
    is_matched = false;
  } else {
    is_matched = true;
    bool finish = false;
    ObPreCalcExprConstraint *cached_con = cached_cons.get_first();
    const ObPreCalcExprConstraint *cur_con = cur_cons->get_first();
    while (!finish && is_matched && OB_SUCC(ret)) {
      if (cached_cons.get_header() == cached_con || cur_cons->get_header() == cur_con) {
        finish = true;
        is_matched = (cached_cons.get_header() == cached_con) && (cur_cons->get_header() == cur_con);
      } else if (OB_ISNULL(cached_con) || OB_ISNULL(cur_con)) {
        is_matched = false;
      } else if (OB_FAIL(check_pre_calc_cons(is_ignore_stmt, is_matched, *cached_con, pc_ctx.exec_ctx_))) {
        LOG_WARN("failed to pre calculate expression and match constraint", K(ret));
      } else if (!is_matched) {
      } else if (OB_FAIL(is_same_pre_calc_cons(*cached_con, *cur_con, is_matched))) {
        LOG_WARN("failed to check is same pre calc cons", K(ret));
      } else if (!is_matched) {
      } else {
        cached_con = cached_con->get_next();
        cur_con = cur_con->get_next();
      }
    }
  }
  return ret;
}

// check two pre calc expr constraint is same
int ObPlanCacheObject::is_same_pre_calc_cons(const ObPreCalcExprConstraint &cons1,
                                             const ObPreCalcExprConstraint &cons2,
                                             bool &is_same)
{
  int ret = OB_SUCCESS;
  is_same = false;
  const ObIArray<ObExpr*> &rt_exprs1 = cons1.pre_calc_expr_info_.pre_calc_rt_exprs_;
  const ObIArray<ObExpr*> &rt_exprs2 = cons2.pre_calc_expr_info_.pre_calc_rt_exprs_;
  if (cons1.expect_result_ != cons2.expect_result_
      || rt_exprs1.count() != rt_exprs2.count()) {
    is_same = false;
  } else {
    is_same = true;
    for (int64_t i = 0; is_same && OB_SUCC(ret) && i < rt_exprs1.count(); ++i) {
      if (OB_FAIL(is_same_expr(rt_exprs1.at(i), rt_exprs2.at(i), is_same))) {
        LOG_WARN("failed to check is is_same_expr", K(ret));
      }
    }
  }
  return ret;
}

// just recursively check ObExpr count and type now
// todo: compare more informations for ObExpr tree
int ObPlanCacheObject::is_same_expr(const ObExpr *expr1,
                                    const ObExpr *expr2,
                                    bool &is_same)
{
  int ret = OB_SUCCESS;
  is_same = false;
  if (NULL == expr1 || NULL == expr2) {
    is_same = (expr1 == expr2);
  } else if (expr1->type_ != expr2->type_ || expr1->arg_cnt_ != expr2->arg_cnt_) {
    is_same = false;
  } else if (T_QUESTIONMARK == expr1->type_) {
    // check param_idx is same
    is_same = expr1->extra_ == expr2->extra_;
  } else {
    is_same = true;
    for (int64_t i = 0; is_same && OB_SUCC(ret) && i < expr1->arg_cnt_; ++i) {
      if (OB_FAIL(SMART_CALL(is_same_expr(expr1->args_[i], expr2->args_[i], is_same)))) {
        LOG_WARN("failed to smart call check is is_same_expr", K(ret));
      }
    }
  }
  return ret;
}

int ObPlanCacheObject::pre_calculation(const bool is_ignore_stmt,
                                   ObPreCalcExprFrameInfo &pre_calc_frame,
                                   ObExecContext &exec_ctx,
                                   const uint64_t calc_types) /* default PRE_CALC_DEFAULT */
{
  int ret = OB_SUCCESS;
  ObPhysicalPlanCtx *phy_plan_ctx = exec_ctx.get_physical_plan_ctx();
  ObSQLSessionInfo *session = exec_ctx.get_my_session();
  ObSEArray<ObDatumObjParam, 4> datum_params;
  // datum_store will be used out of the block, use exec_ctx's allocator
  DatumParamStore datum_store(ObWrapperAllocator(exec_ctx.get_allocator()));
  // TODO [zongmei.zzm]
  // create table t (a int primary key) partition by hash(a) partitions 2;
  // select * from t where a = '1' + 1
  // 新引擎类型推导会在a上加隐式cast: select * from t where cast (a as double) = ?
  // 结果就该sql的query range在新引擎下无法抽取，而老引擎是可以抽取query range的
  if (OB_ISNULL(phy_plan_ctx) || OB_ISNULL(session)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("invalid session or phy plan ctx", K(ret), K(phy_plan_ctx), K(session));
  } else if (OB_FALSE_IT(phy_plan_ctx->set_ignore_stmt(is_ignore_stmt))) {
  } else if (pre_calc_frame.pre_calc_rt_exprs_.count() <= 0) {
    /* do nothing */
  } else if (OB_FAIL(pre_calc_frame.eval(exec_ctx, datum_params))) {
    LOG_WARN("failed to eval pre calc expr frame info", K(ret),
             K(calc_types));
  } else if (OB_FAIL(datum_store.assign(datum_params))) {
    LOG_WARN("failed to push back datum param", K(ret), K(calc_types));
  } else if (PRE_CALC_DEFAULT == calc_types &&
             OB_FAIL(phy_plan_ctx->extend_datum_param_store(datum_store))) {
    LOG_WARN("failed to extend param frame", K(ret), K(calc_types));
  } else { /* do nothing */
  }

  return ret;
}

int ObPlanCacheObject::construct_array_params(const ObSqlExpression &expr,
                                          ObIAllocator &allocator,
                                          ObExprCtx &expr_ctx,
                                          ObNewRow &row,
                                          ObObjParam &result)
{
  int ret = OB_SUCCESS;
  int64_t bind_array_count = 0;
  void *ba_buf = NULL;
  void *data_buf = NULL;
  int64_t ba_buf_size = static_cast<int64_t>(sizeof(ObSqlArrayObj));
  int64_t data_buf_size = 0;
  ObSqlArrayObj *binding_array = NULL;
  ObObj tmp_obj;
  if (OB_ISNULL(expr_ctx.phy_plan_ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("physical plan ctx is null", K(ret));
  } else {
    const ParamStore &param_store = expr_ctx.phy_plan_ctx_->get_param_store();
    int64_t param_addr = 0;
    if (OB_UNLIKELY(expr.get_array_param_index() < 0
                    || expr.get_array_param_index() >= param_store.count())) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("array param index is invalid", K(expr.get_array_param_index()), K(param_store.count()));
    } else if (OB_UNLIKELY(!param_store.at(expr.get_array_param_index()).is_ext_sql_array())) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("param store obj is invalid", K(ret), K(param_store.at(expr.get_array_param_index())));
    } else if (OB_FAIL(param_store.at(expr.get_array_param_index()).get_ext(param_addr))) {
      LOG_WARN("get param addr failed", K(ret), K(param_store.at(expr.get_array_param_index())));
    } else {
      const ObSqlArrayObj *array_param = reinterpret_cast<const ObSqlArrayObj*>(param_addr);
      bind_array_count = array_param->count_;
      data_buf_size = static_cast<int64_t>(sizeof(ObObj) * bind_array_count);
    }
  }
  if (OB_FAIL(ret)) {
    //do thing
  } else if (OB_ISNULL(ba_buf = allocator.alloc(ba_buf_size))) {
    ret = OB_ALLOCATE_MEMORY_FAILED;
    LOG_WARN("allocate nested table failed", K(ret), K(ba_buf_size));
  } else if (OB_ISNULL(data_buf = allocator.alloc(data_buf_size))) {
    ret = OB_ALLOCATE_MEMORY_FAILED;
    LOG_WARN("allocate data buffer failed", K(ret), K(data_buf_size));
  } else {
    binding_array = new(ba_buf) ObSqlArrayObj();
    binding_array->data_ = new(data_buf) ObObjParam[bind_array_count];
    binding_array->count_ = bind_array_count;
  }
  expr_ctx.cur_array_index_ = 0;
  for (int64_t i = 0; OB_SUCC(ret) && i < bind_array_count; ++i) {
    tmp_obj.reset();
    if (OB_FAIL(expr.calc(expr_ctx, row, tmp_obj))) {
      LOG_WARN("calc array expr failed", K(ret), K(expr), K(row));
    } else if (OB_FAIL(ob_write_obj(allocator, tmp_obj, binding_array->data_[expr_ctx.cur_array_index_]))) {
      LOG_WARN("write obj failed", K(ret), K(tmp_obj));
    }
    ++expr_ctx.cur_array_index_;
  }
  if (OB_SUCC(ret)) {
    result.set_extend(reinterpret_cast<int64_t>(binding_array), T_EXT_SQL_ARRAY);
    result.set_param_meta();
  }
  return ret;
}

bool ObPlanCacheObject::has_sequence() const
{
  int ret = OB_SUCCESS;
  bool has_sequence = false;
  ARRAY_FOREACH(dependency_tables_, i) {
    const ObSchemaObjVersion &obj_version = dependency_tables_.at(i);
    if (DEPENDENCY_SEQUENCE == obj_version.object_type_) {
      has_sequence = true;
      break;
    }
  }
  return has_sequence;
}
int ObPlanCacheObject::get_audit_objects(
    common::ObIArray<share::schema::ObObjectStruct> &object_ids) const
{
  int ret = OB_SUCCESS;
  ObObjectStruct tmp_object_struct;
  ARRAY_FOREACH(dependency_tables_, i) {
    const ObSchemaObjVersion &obj_version = dependency_tables_.at(i);
    switch (obj_version.object_type_) {
      case DEPENDENCY_VIEW:
      case DEPENDENCY_TABLE: {
        tmp_object_struct.type_ = ObObjectType::TABLE;
        break;
      }
      case DEPENDENCY_PACKAGE:
      case DEPENDENCY_PACKAGE_BODY: {
        tmp_object_struct.type_ = ObObjectType::PACKAGE;
        break;
      }
      case DEPENDENCY_SEQUENCE: {
        tmp_object_struct.type_ = ObObjectType::SEQUENCE;
        break;
      }
      default: {
        //do nothing
      }
    }
    tmp_object_struct.id_ = static_cast<uint64_t>(obj_version.object_id_);
    if (OB_FAIL(object_ids.push_back(tmp_object_struct))) {
      LOG_WARN("failed to push_back table_id", K(ret));
      break;
    }
  }
  return ret;
}

int ObPlanCacheObject::check_need_add_cache_obj_stat(ObILibCacheCtx &ctx, bool &need_real_add)
{
  int ret = OB_SUCCESS;
  ObPlanCacheCtx &pc_ctx = static_cast<ObPlanCacheCtx&>(ctx);
  need_real_add = pc_ctx.need_add_obj_stat_;
  return ret;
}

int ObPlanCacheObject::type_to_name(const ObLibCacheNameSpace ns,
                                    common::ObIAllocator &allocator,
                                    common::ObString &type_name)
{
  int ret = OB_SUCCESS;
  const char* type_strs[] = {"NS_INVALID", "SQL_PLAN", "PROCEDURE", "FUNCTION", "ANONYMOUS", "TRIGGER", "PACKAGE", "NS_MAX"};
  char *buf = NULL;
  if (ns <= NS_INVALID || ns >= NS_MAX) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid cache obj type", K(ret), K(ns));
  } else {
    int32_t str_len = (int32_t)std::strlen(type_strs[static_cast<int64_t>(ns)]);
    if (OB_ISNULL(buf = static_cast<char *>(allocator.alloc(str_len)))) {
      ret = OB_ALLOCATE_MEMORY_FAILED;
      LOG_WARN("failed to allocate memory", K(ret), K(str_len));
    } else {
      MEMCPY(buf, type_strs[static_cast<int64_t>(ns)], str_len);
      type_name.assign(buf, str_len);
    }
  }
  return ret;
}

void ObPlanCacheObject::dump_deleted_log_info(const bool is_debug_log /* = true */) const
{
  ObString raw_sql;
  if (is_sql_crsr()) {
    const ObPhysicalPlan *plan = dynamic_cast<const ObPhysicalPlan *>(this);
    if (OB_ISNULL(plan)) {
      LOG_ERROR_RET(OB_ERR_UNEXPECTED, "the plan is null", K(plan), K(this));
    } else {
      raw_sql = ObTruncatedString(plan->stat_.raw_sql_, OB_MAX_SQL_LENGTH).string();
    }
  } else if (is_anon()) {
    const pl::ObPLFunction *pl_func = dynamic_cast<const pl::ObPLFunction *>(this);
    if (OB_ISNULL(pl_func)) {
      LOG_ERROR_RET(OB_ERR_UNEXPECTED, "the pl_func is null", K(this));
    } else {
      raw_sql = ObTruncatedString(pl_func->get_stat().raw_sql_, OB_MAX_SQL_LENGTH).string();
    }
  } else {
    // do nothing
  }
  if (is_debug_log) {
    SQL_PC_LOG(DEBUG, "Dumping Cache Deleted Info",
               K(object_id_),
               K(tenant_id_),
               K(added_to_lc_),
               K(ns_),
               K(get_ref_count()),
               K(log_del_time_),
               K(raw_sql),
               K(this));
  } else {
    SQL_PC_LOG(INFO, "Dumping Cache Deleted Info",
               K(object_id_),
               K(tenant_id_),
               K(added_to_lc_),
               K(ns_),
               K(get_ref_count()),
               K(log_del_time_),
               K(raw_sql),
               K(this));
  }
}

}  // namespace sql
}  // namespace oceanbase