/**
 * 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_OB_SQL_
#define OCEANBASE_SQL_OB_SQL_

#include "lib/string/ob_string.h"
#include "lib/net/ob_addr.h"
#include "share/schema/ob_schema_struct.h"
#include "sql/ob_sql_context.h"
#include "sql/resolver/prepare/ob_execute_stmt.h"
#include "sql/resolver/prepare/ob_deallocate_stmt.h"
#include "sql/plan_cache/ob_plan_cache.h"
#include "sql/monitor/ob_monitor_info_manager.h"
#include "sql/monitor/ob_security_audit_utils.h"
#include "sql/optimizer/ob_optimizer.h"
#include "sql/rewrite/ob_transform_rule.h"
#include "sql/executor/ob_maintain_dependency_info_task.h"
#include "sql/ob_spi.h"
#include "sql/udr/ob_udr_item_mgr.h"

namespace test
{
class TestOptimizerUtils;
}

namespace oceanbase
{

namespace share
{
class ObRsMgr;
} // end of namespace share
namespace share
{
namespace schema
{
class ObMaxConcurrentParam;
class ObOutlineInfo;
}
}
namespace common
{
class ObOptStatManager;
}
namespace sql
{
struct ObStmtPrepareResult;
class ObSPIService;
class ObIVirtualTableIteratorFactory;
struct ObSqlCtx;
class ObResultSet;
class ObLogPlan;

// this class is the main interface for sql module
class ObSql
{

  static const int64_t max_error_length;
  static const int64_t SQL_MEM_SIZE_LIMIT;
public:
  /// init SQL module
  int init(common::ObOptStatManager *opt_stat_mgr,
           rpc::frame::ObReqTransport *transport,
           common::ObITabletScan *vt_partition_service,
           common::ObAddr &addr,
           share::ObRsMgr &rs_mgr);
  void destroy();
public:
  /// print statatistics of SQL module
  void stat();

public:
  //These interface are one one mapping whit MySQL request type currently

  // Interface of SQL Engine for COM_QUERY request
  //
  // Handle all COM_QUERY request from mysqlclient
  // There are two kinds of COM_QUERY request
  // 1. general query such as "select * from table_test"
  // 2. text prepare such as "prepare stmt from select * from table_test"
  //
  // @param stmt[in]       input sql string
  // @param context[in]    sql context
  // @param result[out]
  //
  // @return oceanbase error code defined in lib/ob_errno.def
  virtual int stmt_query(const common::ObString &stmt,
                         ObSqlCtx &context,
                         ObResultSet &result);
  int handle_remote_query(const ObRemoteSqlInfo &remote_sql_info,
                          ObSqlCtx &context,
                          ObExecContext &exec_ctx,
                          ObCacheObjGuard& guard);
  virtual int stmt_prepare(const common::ObString &stmt,
                           ObSqlCtx &context,
                           ObResultSet &result,
                           bool is_inner_sql = true); //判断该次调用是外部请求prepare, 还是内部sql或者pl内sql

  /** Interface of SQL Engine for COM_
   * @param stmt_id [in]
   * @param params  [in]
   * @param context [in]
   * @param result [out]
   */
  virtual int stmt_execute(const ObPsStmtId stmt_id,
                           const stmt::StmtType stmt_type,
                           const ParamStore &params,
                           ObSqlCtx &context,
                           ObResultSet &result,
                           bool is_inner_sql);

  // Interface of SQL Engine for COM_FIELD_LIST request
  //
  // @brief: list fields of the specific table with some condition
  //
  // @param table_name [in]
  // @param wild_str[in]
  // @param context [in]
  // @param result [out]
  //
  // @return oceanbase error code defined in share/ob_errno.h
  int stmt_list_field(const common::ObString &table_name,
                      const common::ObString &wild_str,
                      ObSqlCtx &context,
                      ObResultSet &result);
  // Get plan cache by tenant id
  // if not exist, create a new plan cacha object
  //
  // @param tenant_id [in]
  //
  ObPsCache* get_ps_cache(const uint64_t tenant_id, const ObPCMemPctConf &pc_mem_conf);
  int get_plan_retry(ObPlanCache &plan_cache, ObPlanCacheCtx &pc_ctx, ObCacheObjGuard &guard);

  int revert_plan_cache(uint64_t tenant_id);

  int64_t get_execution_id() { return ATOMIC_AAF(&execution_id_, 1); }
  int64_t get_px_sequence_id() { return ATOMIC_AAF(&px_sequence_id_, 1); }
  //calculate calculable expr
  // stmt 全量 const folding.
  static int calc_pre_calculable_exprs(ObExecContext &exec_ctx,
                                       ObDMLStmt &stmt,
                                       ObPhysicalPlan &phy_plan);

  // 为了改写层 const folding 抽出来的函数
  static int calc_pre_calculable_exprs(common::ObIArray<ObHiddenColumnItem> &calculable_exprs,
                                       ObExecContext &exec_ctx,
                                       ObDMLStmt &stmt,
                                       ObPhysicalPlan &phy_plan);

  static int calc_pre_calculable_exprs(const ObDMLStmt &stmt,
                            const common::ObIArray<ObHiddenColumnItem> &calculable_exprs,
                            const bool is_ignore_stmt,
                            ObExecContext &exec_ctx,
                            ObPhysicalPlan &phy_plan,
                            const uint64_t calc_types = PRE_CALC_DEFAULT);

  // create calculable expr constraints
  static int create_expr_constraints(ObQueryCtx &query_ctx, ObExecContext &exec_ctx);
  static int create_expr_constraint(ObQueryCtx &query_ctx,
                                    ObExecContext &exec_ctx,
                                    const ObIArray<ObHiddenColumnItem> &pre_calc_exprs,
                                    const PreCalcExprExpectResult expect_result);
  //simplyfy and rewrite stmt
  static int transform_stmt(ObSqlSchemaGuard *sql_schema_guard,
                            common::ObOptStatManager *opt_stat_mgr,
                            common::ObAddr *self_addr,
                            ObPhysicalPlan *phy_plan,
                            ObExecContext &exec_ctx,
                            ObDMLStmt *&stmt,
                            bool ignore_trace_event=false);

  //optimize stmt, generate logical_plan
  static int optimize_stmt(ObOptimizer &optimizer,
                           const ObSQLSessionInfo &session_info,
                           ObDMLStmt &stmt,
                           ObLogPlan *&logical_plan);

  const common::ObAddr &get_addr() const  {return self_addr_; }

  int init_result_set(ObSqlCtx &context, ObResultSet &result_set);

  int handle_sql_execute(const ObString &sql,
                         ObSqlCtx &context,
                         ObResultSet &result,
                         ParamStore &params,
                         PlanCacheMode mode);

  int handle_pl_prepare(const ObString &sql,
                        ObSPIService::PLPrepareCtx &pl_prepare_ctx,
                        ObSPIService::PLPrepareResult &pl_prepare_result);

  int handle_pl_execute(const ObString &sql,
                        ObSQLSessionInfo &session_info,
                        ParamStore &params,
                        ObResultSet &result,
                        ObSqlCtx &context,
                        bool is_prepare_protocol,
                        bool is_dynamic_sql);
  static int construct_parameterized_params(const ParamStore &params,
                                            ObPlanCacheCtx &phy_ctx);

public:
  //for sql test only
  friend bool compare_stmt(const char *schema_file,  const char *str1, const char *str2);
  int fill_result_set(const ObPsStmtId stmt_id,
                      const ObPsStmtInfo &stmt_info,
                      ObResultSet &result);

public:
  ObSql()
  : inited_(false),
    opt_stat_mgr_(NULL),
    transport_(NULL),
    vt_partition_service_(NULL),
    rs_mgr_(NULL),
    execution_id_(0),
    px_sequence_id_(0)
  {
    px_sequence_id_ = ObTimeUtility::current_time();
  }

  virtual ~ObSql() { destroy(); }
  ObMaintainDepInfoTaskQueue &get_dep_info_queue() { return queue_; }

private:
  // disallow copy
  ObSql(const ObSql &other);
  ObSql &operator=(const ObSql &other);

  class TimeoutGuard
  {
  public:
    TimeoutGuard(ObSQLSessionInfo &session);
    ~TimeoutGuard();
  private:
    ObSQLSessionInfo &session_;
    int64_t worker_timeout_;
  };

private:
  int set_timeout_for_pl(ObSQLSessionInfo &session_info, int64_t &abs_timeout_us);

  int construct_param_store(const ParamStore &params,
                            ParamStore &param_store);
  int construct_ps_param_store(const ParamStore &params,
                               const ParamStore &fixed_params,
                               const ObIArray<int64_t> &fixed_param_idx,
                               ParamStore &param_store);
  int construct_param_store_from_parameterized_params(const ObPlanCacheCtx &phy_ctx,
                                                      ParamStore &param_store);
  bool is_exist_in_fixed_param_idx(const int64_t idx,
                                   const ObIArray<int64_t> &fixed_param_idx);
  int do_real_prepare(const ObString &stmt,
                      ObSqlCtx &context,
                      ObResultSet &result,
                      bool is_inner_sql);
  int do_add_ps_cache(const PsCacheInfoCtx &info_ctx,
                      share::schema::ObSchemaGetterGuard &schema_guard,
                      ObResultSet &result);
  int check_contain_temporary_table(share::schema::ObSchemaGetterGuard &schema_guard,
                                    ObResultSet &result,
                                    bool &is_contain_tmp_tbl);
  int fill_result_set(ObResultSet &result, ObSqlCtx *context, const PlanCacheMode mode, ObStmt &stmt);
  int fill_select_result_set(ObResultSet &result_set, ObSqlCtx *context, const PlanCacheMode mode,
                             ObCollationType collation_type, const ObString &type_name,
                             ObStmt &basic_stmt, ObField &field);
  int pc_add_udr_plan(const ObUDRItemMgr::UDRItemRefGuard &item_guard,
                      ObPlanCacheCtx &pc_ctx,
                      ObResultSet &result,
                      ObOutlineState &outline_state,
                      bool& plan_added);
  int handle_ps_prepare(const common::ObString &stmt,
                        ObSqlCtx &context,
                        ObResultSet &result,
                        bool is_inner_sql);

  int handle_ps_execute(const ObPsStmtId stmt_id,
                        const stmt::StmtType stmt_type,
                        const ParamStore &params,
                        ObSqlCtx &context,
                        ObResultSet &result,
                        bool is_inner_sql);

  int init_execute_params_for_ab(ObIAllocator &allocator,
                                 const ParamStore &params_store,
                                 ParamStore *&params);

  int reconstruct_pl_params_store(ObIAllocator &allocator,
                                  ObSqlCtx &context,
                                  const ParamStore &origin_params,
                                  ParamStore &pl_params,
                                  ParamStore *&pl_ab_params);

  int reconstruct_ps_params_store(ObIAllocator &allocator,
                                  ObSqlCtx &context,
                                  const ParamStore &params,
                                  const ParamStore &fixed_params,
                                  ObPsStmtInfo *ps_info,
                                  ParamStore &ps_param_store,
                                  ParamStore *&ps_ab_params);

  int handle_text_query(const common::ObString &stmt,
                        ObSqlCtx &context,
                        ObResultSet &result);
  int handle_physical_plan(const common::ObString &trimed_stmt,
                           ObSqlCtx &context,
                           ObResultSet &result,
                           ObPlanCacheCtx &pc_ctx,
                           const int get_plan_err);
  // @brief  Generate 'stmt' from syntax tree
  // @param parse_result[in]     syntax tree
  // @param select_item_param_infos           select_item_param_infos from fast parser
  // @param context[in]          sql context
  // @param allocator[in]        memory allocator
  // @param result_plan[out]
  // @param result[out]        - the id of the explain plan text column
  // @retval OB_SUCCESS execute success
  // @retval OB_SOME_ERROR special errno need to handle
  int generate_stmt(ParseResult &parse_result,
                    ObPlanCacheCtx *pc_ctx,
                    ObSqlCtx &context,
                    ObIAllocator &allocator,
                    ObResultSet &result,
                    ObStmt *&basic_stmt,
                    ParseResult *outline_parse_result = NULL);

  // Generate Physical Plan for given syntax tree
  // called by handle_text_query
  // && stmt_prepare && stmt_execute when necessary
  //
  // @param parse_result[in]   syntax tree
  // @param select_item_param_infos[in]      select_item_param_infos from fast parser
  // @param context[in]        sql context
  // @param allocator[in]      memory allocator
  // @param result[out]        result set include physical plan generated
  int generate_physical_plan(ParseResult &parse_result,
                             ObPlanCacheCtx *pc_ctx,
                             ObSqlCtx &context,
                             ObResultSet &result,
                             const bool is_begin_commit_stmt,
                             const PlanCacheMode mode,
                             ParseResult *outline_parse_result = NULL);

  int generate_plan(ParseResult &parse_result,
                    ObPlanCacheCtx *pc_ctx,
                    ObSqlCtx &sql_ctx,
                    ObResultSet &result,
                    const PlanCacheMode mode,
                    ObStmt *basic_stmt,
                    ObStmtNeedPrivs &stmt_need_privs,
                    ObStmtOraNeedPrivs &stmt_ora_need_privs);

  int generate_stmt_with_reconstruct_sql(ObDMLStmt* &stmt,
                                        ObPlanCacheCtx *pc_ctx,
                                        ObSqlCtx &context,
                                        ObResultSet &result,
                                        ObPhysicalPlan *phy_plan);

  //generate physical_plan
  static int code_generate(ObSqlCtx &sql_ctx,
                           ObResultSet &result,
                           ObDMLStmt *stmt,
                           share::schema::ObStmtNeedPrivs &stmt_need_privs,
                           share::schema::ObStmtOraNeedPrivs &stmt_ora_need_privs,
                           common::ObIArray<ObAuditUnit> &audit_units,
                           ObLogPlan *logical_plan,
                           ObPhysicalPlan *&phy_plan);

  int prepare_outline_for_phy_plan(ObLogPlan *logical_plan,
                                   ObPhysicalPlan *phy_plan);

  int sanity_check(ObSqlCtx &context);

  int init_exec_context(const ObSqlCtx &context, ObExecContext &exec_ctx);

  int get_outline_data(ObSqlCtx &context,
                       ObPlanCacheCtx &pc_ctx,
                       const ObString &signature_sql,
                       ObOutlineState &outline_state,
                       ParseResult &outline_parse_result);

  int get_outline_data(ObPlanCacheCtx &pc_ctx,
                       const ObString &signature_sql,
                       ObOutlineState &outline_state,
                       ObString &outline_content);

  int handle_large_query(int tmp_ret,
                         ObResultSet &result,
                         bool &need_disconnect,
                         ObExecContext &exec_ctx);
  int pc_get_plan_and_fill_result(ObPlanCacheCtx &pc_ctx,
                                  ObResultSet &result_set,
                                  int &get_plan_err,
                                  bool &need_disconnect);
  int pc_get_plan(ObPlanCacheCtx &pc_ctx,
                  ObCacheObjGuard& guard,
                  int &get_plan_err,
                  bool &need_disconnect);

  int parser_and_check(const ObString &outlined_stmt,
                       ObExecContext &exec_ctx,
                       ObPlanCacheCtx &pc_ctx,
                       ParseResult &parse_result,
                       int get_plan_err,
                       bool &add_plan_to_pc,
                       bool &is_enable_transform_tree);
  int handle_parser(const ObString &outlined_stmt,
                       ObExecContext &exec_ctx,
                       ObPlanCacheCtx &pc_ctx,
                       ParseResult &parse_result,
                       int get_plan_err,
                       bool &add_plan_to_pc,
                       bool &is_enable_transform_tree);

  int check_batched_multi_stmt_after_parser(ObPlanCacheCtx &pc_ctx,
                                            ParseResult &parse_result,
                                            bool add_plan_to_pc,
                                            bool &is_valid);
  int check_batched_multi_stmt_after_resolver(ObPlanCacheCtx &pc_ctx,
                                              const ObStmt &stmt,
                                              bool &is_valid);

  int before_resolve_array_params(ObPlanCacheCtx &pc_ctx,
                                  int64_t query_num,
                                  int64_t param_num,
                                  ParamStore *&ab_params,
                                  ObBitSet<> &neg_param_index,
                                  ObBitSet<> &not_param_index,
                                  ObBitSet<> &must_be_positive_index);

  int resolve_ins_multi_row_params(ObPlanCacheCtx &pc_ctx, const ObStmt &stmt, ParamStore *&ab_params);

  int resolve_multi_query_params(ObPlanCacheCtx &pc_ctx, const ObStmt &stmt, ParamStore *&ab_params);

  int replace_const_expr(common::ObIArray<ObRawExpr*> &raw_exprs,
                         ParamStore &param_store);
  int replace_const_expr(ObRawExpr *raw_expr,
                         ParamStore &param_store);
  void generate_ps_sql_id(const ObString &raw_sql,
                          ObSqlCtx &context);
  void generate_sql_id(ObPlanCacheCtx &pc_ctx,
                           bool add_plan_to_pc,
                           ParseResult &parse_result,
                           ObString &signature_sql,
                           int err_code);
  int pc_add_plan(ObPlanCacheCtx &pc_ctx,
                  ObResultSet &result,
                  ObOutlineState &outline_state,
                  ObPlanCache *plan_cache,
                  bool& plan_added);
  //检查经过参数化的模板SQL能否被prepare
  void check_template_sql_can_be_prepare(ObPlanCacheCtx &pc_ctx, ObPhysicalPlan &plan);
  int execute_get_plan(ObPlanCache &plan_cache,
                       ObPlanCacheCtx &pc_ctx,
                       ObCacheObjGuard& guard);
  int after_get_plan(ObPlanCacheCtx &pc_ctx,
                     ObSQLSessionInfo &session,
                     ObPhysicalPlan *plan,
                     bool from_plan_cache,
                     const ParamStore *ps_params,
                     uint64_t min_cluster_version);
  int need_add_plan(const ObPlanCacheCtx &ctx,
                    ObResultSet &result,
                    bool is_enable_pc,
                    bool &need_add_plan);

  template<typename ProcessorT>
  int handle_remote_batch_req(const ObReqTimestamp &req_ts, const char* buf, int32_t size);

  int clac_fixed_param_store(const stmt::StmtType stmt_type,
                             const common::ObIArray<int64_t> &raw_params_idx,
                             const common::ObIArray<ObPCParam *> &raw_params,
                             ObIAllocator &allocator,
                             ObSQLSessionInfo &session,
                             ParamStore &fixed_param_store);

  int handle_text_execute(const ObStmt *basic_stmt, ObSqlCtx &sql_ctx, ObResultSet &result);
  int check_need_reroute(ObPlanCacheCtx &pc_ctx, ObSQLSessionInfo &session, ObPhysicalPlan *plan, bool &need_reroute);
  int check_read_only_privilege(ParseResult &parse_result,
                                ObExecContext &exec_ctx,
                                ObSchemaGetterGuard &schema_guard,
                                ObSqlTraits &sql_traits);
  int get_reconstructed_batch_stmt(ObPlanCacheCtx &pc_ctx, ObString& stmt_sql);
  static int add_param_to_param_store(const ObObjParam &param,
                                      ParamStore &param_store);

  typedef hash::ObHashMap<uint64_t, ObPlanCache*> PlanCacheMap;
  friend class ::test::TestOptimizerUtils;
private:
  bool inited_;
  // BEGIN 全局单例依赖接口
  common::ObOptStatManager *opt_stat_mgr_;
  rpc::frame::ObReqTransport *transport_;
  common::ObITabletScan *vt_partition_service_;
  // END 全局单例依赖接口

  common::ObAddr self_addr_;
  share::ObRsMgr *rs_mgr_;
  volatile int64_t execution_id_ CACHE_ALIGNED;
  volatile uint64_t px_sequence_id_;
  ObMaintainDepInfoTaskQueue queue_;
};
} // end namespace sql
} // end namespace oceanbase

#endif //OCEANBASE_SQL_OB_SQL_