/**
 * 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 PL

#include "ob_pl_adt_service.h"
#include "common/ob_field.h"
#include "ob_pl_type.h"
#include "sql/resolver/expr/ob_raw_expr.h"
#include "lib/container/ob_2d_array.h"
#include "lib/utility/ob_template_utils.h"

namespace oceanbase
{
using namespace common;
using namespace jit;
namespace pl
{

int ObPLADTService::init(const int64_t arg_count, const int64_t param_count)
{
  int ret = OB_SUCCESS;
  arg_count_ = arg_count;
  param_count_ = param_count;
  return ret;
}

int ObPLADTService::get_objmeta(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == obj_meta_.get_v()) {
    ObLLVMType struct_type;
    ObSEArray<ObLLVMType, 4> obj_meta;
    ObLLVMType int8_type;
    if (OB_FAIL(helper_.get_llvm_type(ObTinyIntType, int8_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else {
      /*
        uint8_t type_;
        uint8_t cs_level_;    // collation level
        uint8_t cs_type_;     // collation type
        int8_t scale_;        // scale, 当type_ 为ObBitType时，该字段存储bit的length
       */
      if (OB_FAIL(obj_meta.push_back(int8_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(obj_meta.push_back(int8_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(obj_meta.push_back(int8_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(obj_meta.push_back(int8_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(helper_.create_struct_type(ObString("obj_meta"), obj_meta, struct_type))) {
        LOG_WARN("failed to create struct type", K(ret));
      } else {
        obj_meta_.set_v(struct_type.get_v());
      }
    }
  }
  if (OB_SUCC(ret)) {
    type = obj_meta_;
  }
  return ret;
}

int ObPLADTService::get_datum(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == datum_.get_v()) {
    ObLLVMType struct_type;
    ObSEArray<ObLLVMType, 2> datum;
    ObLLVMType int32_type;
    ObLLVMType int64_type;
    if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, int32_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else {
      /*
        union
        {
        int32_t val_len_;
        number::ObNumber::Desc nmb_desc_;
        };  // sizeof = 4
        ObObjValue v_;  // sizeof = 8
       */
      if (OB_FAIL(datum.push_back(int32_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(datum.push_back(int64_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(helper_.create_struct_type(ObString("datum"), datum, struct_type))) {
        LOG_WARN("failed to create struct type", K(ret));
      } else {
        datum_.set_v(struct_type.get_v());
      }
    }
  }
  if (OB_SUCC(ret)) {
    type = datum_;
  }
  return ret;
}

int ObPLADTService::get_obj(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == obj_.get_v()) {
    ObLLVMType struct_type;
    ObSEArray<ObLLVMType, 3> obj;
    ObLLVMType objmeta;
    ObLLVMType int32_type;
    ObLLVMType int64_type;
    if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, int32_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(get_objmeta(objmeta))) {
      LOG_WARN("push_back error", K(ret));
    } else {
      /*
        ObObjMeta meta_;  // sizeof = 4
        union
        {
        int32_t val_len_;
        number::ObNumber::Desc nmb_desc_;
        };  // sizeof = 4
        ObObjValue v_;  // sizeof = 8
      */
      if (OB_FAIL(obj.push_back(objmeta))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(obj.push_back(int32_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(obj.push_back(int64_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(helper_.create_struct_type(ObString("obj"), obj, struct_type))) {
        LOG_WARN("failed to create struct type", K(ret));
      } else {
        obj_.set_v(struct_type.get_v());
      }
    }
  }
  if (OB_SUCC(ret)) {
    type = obj_;
  }
  return ret;
}

int ObPLADTService::get_objparam(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == obj_param_.get_v()) {
    ObLLVMType struct_type;
    ObSEArray<ObLLVMType, 4> obj_param;
    ObLLVMType obj_type;
    ObLLVMType obj_meta_type;
    ObLLVMType int8_type;
    ObLLVMType int32_type;
    ObLLVMType int64_type;
    if (OB_FAIL(helper_.get_llvm_type(ObTinyIntType, int8_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, int32_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(get_obj(obj_type))) {
      LOG_WARN("push_back error", K(ret));
    } else if (OB_FAIL(get_objmeta(obj_meta_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else {
      ObLLVMType param_flag_type;
      ObSEArray<ObLLVMType, 2> param_flag;
      /*
        union
        {
          uint8_t flag_;
          struct {
            uint8_t need_to_check_type_: 1; //TRUE if the type need to be checked by plan cache, FALSE otherwise
            uint8_t need_to_check_bool_value_ : 1;//TRUE if the bool value need to be checked by plan cache, FALSE otherwise
            uint8_t expected_bool_value_ : 1;//bool value, effective only when need_to_check_bool_value_ is true
            uint8_t reserved_ : 5;
          };
        };
      */
      if (OB_FAIL(param_flag.push_back(int64_type))) { //VTable
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(param_flag.push_back(int8_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(helper_.create_struct_type(ObString("obj"), param_flag, param_flag_type))) {
        LOG_WARN("failed to create struct type", K(ret));
      } else { /*do nothing*/ }

      if (OB_SUCC(ret)) {
        /*
          ObAccuracy accuracy_;
          uint32_t res_flags_;  // BINARY, NUM, NOT_NULL, TIMESTAMP, etc
          // reference: src/lib/regex/include/mysql_com.h
          ParamFlag flag_;
         */
        if (OB_FAIL(obj_param.push_back(obj_type))) {
          LOG_WARN("push_back error", K(ret));
        } else if (OB_FAIL(obj_param.push_back(int64_type))) { //ObAccuracy
          LOG_WARN("push_back error", K(ret));
        } else if (OB_FAIL(obj_param.push_back(int32_type))) {
          LOG_WARN("push_back error", K(ret));
        } else if (OB_FAIL(obj_param.push_back(param_flag_type))) {
          LOG_WARN("push_back error", K(ret));
        } else if (OB_FAIL(obj_param.push_back(int32_type))) {  // raw_text_pos_
          LOG_WARN("push_back error", K(ret));
        } else if (OB_FAIL(obj_param.push_back(int32_type))) {  // raw_text_len_
          LOG_WARN("push_back error", K(ret));
        } else if (OB_FAIL(obj_param.push_back(obj_meta_type))) { //param_meta_
          LOG_WARN("push_back error", K(ret));
        } else if (OB_FAIL(helper_.create_struct_type(ObString("objparam"), obj_param, struct_type))) {
          LOG_WARN("failed to create struct type", K(ret));
        } else {
          obj_param_.set_v(struct_type.get_v());
        }
      }
    }
  }
  if (OB_SUCC(ret)) {
    type = obj_param_;
  }
  return ret;
}

int ObPLADTService::get_param_store(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == seg_param_store_.get_v()) {
    ObLLVMType struct_type;
    ObLLVMType block_alloc;
    ObLLVMType blocks;
    ObLLVMType int8_type;
    ObLLVMType int32_type;
    ObLLVMType int64_type;
    if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, int32_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObTinyIntType, int8_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(get_seg_pointer_array(blocks))) {
      LOG_WARN("failed to get_seg_pointer_array", K(ret));
    } else if (OB_FAIL(get_wrapper_allocator(block_alloc))) {
      LOG_WARN("failed to get_wrapper_allocator", K(ret));
    } else  {
      /*
        int32_t magic_;
        ObWrapperAllocator block_alloc_
        ObSEArray<char *, 64, ObWrapperAllocator, false> blocks_;
        int64_t count_;
        int64_t capacity_;
      */
      ObSEArray<ObLLVMType, 32> seg_param_store;
      if (OB_FAIL(seg_param_store.push_back(int64_type))) { // vtable
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_param_store.push_back(int32_type))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_param_store.push_back(block_alloc))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_param_store.push_back(blocks))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_param_store.push_back(int64_type))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_param_store.push_back(int64_type))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(helper_.create_struct_type(ObString("seg_param_store"),
                                                    seg_param_store, struct_type))) {
        LOG_WARN("failed to create struct type", K(ret));
      } else {
        seg_param_store_.set_v(struct_type.get_v());
      }
    }
  }
  if (OB_SUCC(ret)) {
    type = seg_param_store_;
  }
  return ret;
}

int ObPLADTService::get_data_type(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == data_type_.get_v()) {
    ObLLVMType struct_type;
    ObSEArray<ObLLVMType, 4> data_type;
    ObLLVMType obj_meta_type;
    ObLLVMType int8_type;
    ObLLVMType int32_type;
    ObLLVMType int64_type;
    if (OB_FAIL(helper_.get_llvm_type(ObTinyIntType, int8_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, int32_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(get_objmeta(obj_meta_type))) {
      LOG_WARN("push_back error", K(ret));
    } else {
      /*
        ObObjMeta meta_;
        ObAccuracy accuracy_;
        ObCharsetType charset_;
        bool is_binary_collation_
        bool is_zero_fill_;
       */
      if (OB_FAIL(data_type.push_back(obj_meta_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(data_type.push_back(int64_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(data_type.push_back(int32_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(data_type.push_back(int8_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(data_type.push_back(int8_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(helper_.create_struct_type(ObString("data_type"),
                                                    data_type,
                                                    struct_type))) {
        LOG_WARN("failed to create struct type", K(ret));
      } else {
        data_type_.set_v(struct_type.get_v());
      }
    }
  }
  if (OB_SUCC(ret)) {
    type = data_type_;
  }
  return ret;
}

int ObPLADTService::get_elem_desc(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == elem_desc_.get_v()) {
    ObLLVMType struct_type;
    ObSEArray<ObLLVMType, 4> elem_desc;
    ObLLVMType obj_meta_type;
    ObLLVMType int8_type;
    ObLLVMType int32_type;
    ObLLVMType int64_type;
    if (OB_FAIL(helper_.get_llvm_type(ObTinyIntType, int8_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, int32_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(get_objmeta(obj_meta_type))) {
      LOG_WARN("push_back error", K(ret));
    } else {
      /*
        ObObjMeta meta_;
        ObAccuracy accuracy_;
        ObCharsetType charset_;
        bool is_binary_collation_
        bool is_zero_fill_;
        ObPLType type_;
        bool not_null_;
        int32_t field_cnt_;
       */
      if (OB_FAIL(elem_desc.push_back(obj_meta_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(elem_desc.push_back(int64_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(elem_desc.push_back(int32_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(elem_desc.push_back(int8_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(elem_desc.push_back(int8_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(elem_desc.push_back(int32_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(elem_desc.push_back(int8_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(elem_desc.push_back(int32_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(helper_.create_struct_type(ObString("elem_desc"),
                                                    elem_desc,
                                                    struct_type))) {
        LOG_WARN("failed to create struct type", K(ret));
      } else {
        elem_desc_.set_v(struct_type.get_v());
      }
    }
  }
  if (OB_SUCC(ret)) {
    type = elem_desc_;
  }
  return ret;
}

int ObPLADTService::get_pl_exec_context(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == pl_exec_context_.get_v()) {
    ObLLVMType struct_type;
    ObSEArray<ObLLVMType, 5> pl_exec_context;
    ObLLVMType seg_param_store;
    ObLLVMType seg_param_store_pointer;
    ObLLVMType obj;
    ObLLVMType obj_pointer;
    ObLLVMType int8_type;
    ObLLVMType int32_type;
    ObLLVMType int32_pointer_type;
    ObLLVMType int64_type;
    if (OB_FAIL(helper_.get_llvm_type(ObTinyIntType, int8_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, int32_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(int32_type.get_pointer_to(int32_pointer_type))) {
      LOG_WARN("failed to get_pointer_to", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(get_param_store(seg_param_store))) {
      LOG_WARN("push_back error", K(ret));
    } else if (OB_FAIL(seg_param_store.get_pointer_to(seg_param_store_pointer))) {
      LOG_WARN("failed to get pointer to", K(ret));
    } else if (OB_FAIL(get_obj(obj))) {
      LOG_WARN("push_back error", K(ret));
    } else if (OB_FAIL(obj.get_pointer_to(obj_pointer))) {
      LOG_WARN("failed to get pointer to", K(ret));
    } else {
      /*
          common::ObIAllocator *allocator_;
          sql::ObExecContext *exec_ctx_;
          common::Ob2DArray<common::ObObjParam, ObWrapperAllocator, false> *params_;
          common::ObObj *result_;
          int *status_;
          ObPLException *pre_reserved_e_;
          ObPLFunction *func_;
          bool in_function_;
       */
      if (OB_FAIL(pl_exec_context.push_back(int64_type))) { //VTable
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(pl_exec_context.push_back(int64_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(pl_exec_context.push_back(int64_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(pl_exec_context.push_back(seg_param_store_pointer))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(pl_exec_context.push_back(obj_pointer))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(pl_exec_context.push_back(int32_pointer_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(pl_exec_context.push_back(int64_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(pl_exec_context.push_back(int8_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(pl_exec_context.push_back(int64_type))) { // plcontext
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(helper_.create_struct_type(ObString("pl_exec_context"), pl_exec_context, struct_type))) {
        LOG_WARN("failed to create struct type", K(ret));
      } else {
        pl_exec_context_.set_v(struct_type.get_v());
      }
    }
  }
  if (OB_SUCC(ret)) {
    type = pl_exec_context_;
  }
  return ret;
}


int ObPLADTService::get_argv(ObLLVMType &type)
{
  return get_argv(arg_count_, type);
}

int ObPLADTService::get_argv(int64_t argc, ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  ObLLVMType array_type;
  ObLLVMType int64_type;
  if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {
    LOG_WARN("failed to get_llvm_type", K(ret));
  } else if (OB_FAIL(ObLLVMArrayType::get(int64_type, argc, array_type))) {
    LOG_WARN("failed to get array type", K(ret));
  } else {
    type.set_v(array_type.get_v());
  }
  return ret;
}

int ObPLADTService::get_pl_condition_value(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == pl_condition_value_.get_v()) {
    ObLLVMType struct_type;
    ObSEArray<ObLLVMType, 6> pl_condition_value;
    ObLLVMType int8_type;
    ObLLVMType int64_type;
    ObLLVMType char_type;
    if (OB_FAIL(helper_.get_llvm_type(ObTinyIntType, int8_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObCharType, char_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else {
      /*
        ObPLConditionType type_;
        int64_t error_code_;
        const char *sql_state_;
        int64_t str_len_;
        int64_t stmt_id_;
        bool signal_;
       */
      if (OB_FAIL(pl_condition_value.push_back(int64_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(pl_condition_value.push_back(int64_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(pl_condition_value.push_back(char_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(pl_condition_value.push_back(int64_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(pl_condition_value.push_back(int64_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(pl_condition_value.push_back(int8_type))) {
        LOG_WARN("push_back error", K(ret));
      } else if (OB_FAIL(helper_.create_struct_type(ObString("pl_condition_value"), pl_condition_value, struct_type))) {
        LOG_WARN("failed to create struct type", K(ret));
      } else {
        pl_condition_value_.set_v(struct_type.get_v());
      }
    }
  }
  if (OB_SUCC(ret)) {
    type = pl_condition_value_;
  }
  return ret;
}

int ObPLADTService::get_unwind_exception(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == unwind_exception_.get_v()) {
    ObLLVMType struct_type;
    ObSEArray<ObLLVMType, 1> pl_unwind_exception;
    /*
      _Unwind_Exception_Class exception_class;
      _Unwind_Exception_Cleanup_Fn exception_cleanup;
      _Unwind_Word private_1;
      _Unwind_Word private_2;
     */
    //只映射第一项exception_class
    ObLLVMType int64_type;
    if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(pl_unwind_exception.push_back(int64_type))) {
      LOG_WARN("push_back error", K(ret));
    } else if (OB_FAIL(helper_.create_struct_type(ObString("unwind_exception"), pl_unwind_exception, struct_type))) {
      LOG_WARN("failed to create struct type", K(ret));
    } else {
      unwind_exception_.set_v(struct_type.get_v());
    }
  }
  if (OB_SUCC(ret)) {
    type = unwind_exception_;
  }
  return ret;
}

int ObPLADTService::get_pl_exception(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == pl_exception_.get_v()) {
    ObLLVMType struct_type;
    ObSEArray<ObLLVMType, 2> pl_exception;
    ObLLVMType condition_value;
    ObLLVMType unwind_exception;
    if (OB_FAIL(get_pl_condition_value(condition_value))) {
      LOG_WARN("push_back error", K(ret));
    } else if (OB_FAIL(get_unwind_exception(unwind_exception))) {
      LOG_WARN("push_back error", K(ret));
    } else if (OB_FAIL(pl_exception.push_back(condition_value))) {
      LOG_WARN("push_back error", K(ret));
    } else if (OB_FAIL(pl_exception.push_back(unwind_exception))) {
      LOG_WARN("push_back error", K(ret));
    } else if (OB_FAIL(helper_.create_struct_type(ObString("pl_exception"), pl_exception, struct_type))) {
      LOG_WARN("failed to create struct type", K(ret));
    } else {
      pl_exception_.set_v(struct_type.get_v());
    }
  }
  if (OB_SUCC(ret)) {
    type = pl_exception_;
  }
  return ret;
}

int ObPLADTService::get_landingpad_result(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == landingpad_result_.get_v()) {
    ObLLVMType struct_type;
    ObSEArray<ObLLVMType, 2> landingpad_result;
    ObLLVMType tinyint_pointer;
    ObLLVMType int8_type;
    ObLLVMType int32_type;
    if (OB_FAIL(helper_.get_llvm_type(ObTinyIntType, int8_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, int32_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(int8_type.get_pointer_to(tinyint_pointer))) {
      LOG_WARN("failed to get_pointer_to", K(ret));
    } else if (OB_FAIL(landingpad_result.push_back(tinyint_pointer))) {
      LOG_WARN("push_back error", K(ret));
    } else if (OB_FAIL(landingpad_result.push_back(int32_type))) {
      LOG_WARN("push_back error", K(ret));
    } else if (OB_FAIL(helper_.create_struct_type(ObString("landingpad_result"), landingpad_result, struct_type))) {
      LOG_WARN("failed to create struct type", K(ret));
    } else {
      landingpad_result_.set_v(struct_type.get_v());
    }
  }
  if (OB_SUCC(ret)) {
    type = landingpad_result_;
  }
  return ret;
}

int ObPLADTService::get_obstring(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == obstring_.get_v()) {
    /**
      obstr_size_t buffer_size_;
      obstr_size_t data_length_;
      char *ptr_;
    */
    ObLLVMType struct_type;
    ObSEArray<ObLLVMType, 3> obstring;
    ObLLVMType int32_type;
    ObLLVMType char_type;
    if (OB_FAIL(helper_.get_llvm_type(ObIntType, int32_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObCharType, char_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(obstring.push_back(int32_type))) {
      LOG_WARN("push_back error", K(ret));
    } else if (OB_FAIL(obstring.push_back(int32_type))) {
      LOG_WARN("push_back error", K(ret));
    } else if (OB_FAIL(obstring.push_back(char_type))) {
      LOG_WARN("push_back error", K(ret));
    } else if (OB_FAIL(helper_.create_struct_type(ObString("obstring"), obstring, struct_type))) {
      LOG_WARN("failed to create struct type", K(ret));
    } else {
      obstring_.set_v(struct_type.get_v());
    }
  }
  if (OB_SUCC(ret)) {
    type = obstring_;
  }
  return ret;
}

int ObPLADTService::get_seg_pointer_array(jit::ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == seg_pointer_array_.get_v()) {
    ObLLVMType struct_type;
    ObLLVMType int32_type;
    ObLLVMType int64_type;
    ObLLVMType local_data_buf;
    ObLLVMType pointer_carray_pointer;
    ObLLVMType wrapper_allocator;
    ObLLVMType memory_context;
    ObLLVMType int8_type;
    if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, int32_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObTinyIntType, int8_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(get_wrapper_allocator(wrapper_allocator))) {
      LOG_WARN("failed to get wrapper_allocator", K(ret));
    } else if (OB_FAIL(get_memory_context(memory_context))) {
      LOG_WARN("failed to get memory_context", K(ret));
    } else if (OB_FAIL(ObLLVMHelper::get_array_type(int64_type,
                                                    common::OB_BLOCK_POINTER_ARRAY_SIZE,
                                                    local_data_buf))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else if (OB_FAIL(local_data_buf.get_pointer_to(pointer_carray_pointer))) {
      LOG_WARN("failed to get_pointer_to", K(ret));
    } else {
      /*
        T *data_;
        int64_t count_;
        char local_data_buf_[LOCAL_ARRAY_SIZE * sizeof(T)];
        int64_t block_size_; // 申请内存的块单位
        int64_t capacity_; // 标记ObSEArray的内部可用空间
        int64_t max_print_count_; //表示最大需要打印的元素数量；
        int32_t error_;  //
        ObWrapperAllocator block_allocator_;
        bool has_alloc_;
        lib::MemoryContext mem_context_;
      */
      ObSEArray<ObLLVMType, 16> seg_pointer_array;
      if (OB_FAIL(seg_pointer_array.push_back(int64_type))) { // vtable
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_pointer_array.push_back(pointer_carray_pointer))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_pointer_array.push_back(int64_type))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_pointer_array.push_back(local_data_buf))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_pointer_array.push_back(int64_type))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_pointer_array.push_back(int64_type))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_pointer_array.push_back(int64_type))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_pointer_array.push_back(int32_type))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_pointer_array.push_back(wrapper_allocator))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_pointer_array.push_back(int8_type))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(seg_pointer_array.push_back(memory_context))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(helper_.create_struct_type(ObString("seg_pointer_array"),
                                                    seg_pointer_array, struct_type))) {
        LOG_WARN("failed to create struct type", K(ret));
      } else {
        seg_pointer_array_.set_v(struct_type.get_v());
      }
    }
  }
  if (OB_SUCC(ret)) {
    type = seg_pointer_array_;
  }
  return ret;
}

int ObPLADTService::get_wrapper_allocator(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == wrapper_allocator_.get_v()) {
    ObLLVMType struct_type;
    ObLLVMType int64_type;
    if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else {
      /*
        ObIAllocator *alloc_;
       */
      ObSEArray<ObLLVMType, 2> wrapper_allocator;
      if (OB_FAIL(wrapper_allocator.push_back(int64_type))) { // vtable
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(wrapper_allocator.push_back(int64_type))) {
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(helper_.create_struct_type(ObString("wrapper_allocator"),
                                                    wrapper_allocator, struct_type))) {
        LOG_WARN("failed to create struct type", K(ret));
      } else {
        wrapper_allocator_.set_v(struct_type.get_v());
      }
    }
  }
  if (OB_SUCC(ret)) {
    type = wrapper_allocator_;
  }
  return ret;
}

int ObPLADTService::get_memory_context(ObLLVMType &type)
{
  int ret = OB_SUCCESS;
  if (NULL == memory_context_.get_v()) {
    ObLLVMType struct_type;
    ObLLVMType int64_type;
    if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {
      LOG_WARN("failed to get_llvm_type", K(ret));
    } else {
      /*
        int64_t magic_code_;
        int64_t seq_id_;
        __MemoryContext__ *ref_context_;
      */
      STATIC_ASSERT(sizeof(lib::MemoryContext) == sizeof(int64_t) * 3, "check MemoryContext layout failed");
      ObSEArray<ObLLVMType, 3> memory_context;
      if (OB_FAIL(memory_context.push_back(int64_type))) { // magic_code_
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(memory_context.push_back(int64_type))) { // seq_id_
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(memory_context.push_back(int64_type))) { // ref_context_
        LOG_WARN("failed to push back element", K(ret));
      } else if (OB_FAIL(helper_.create_struct_type(ObString("memory_context"),
                                                    memory_context, struct_type))) {
        LOG_WARN("failed to create struct type", K(ret));
      } else {
        memory_context_.set_v(struct_type.get_v());
      }
    }
  }
  if (OB_SUCC(ret)) {
    type = memory_context_;
  }
  return ret;
}

}
}