/**
 * 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_REWRITE
#include "sql/rewrite/ob_transform_pre_process.h"
#include "sql/rewrite/ob_transformer_impl.h"
#include "lib/allocator/ob_allocator.h"
#include "lib/oblog/ob_log_module.h"
#include "common/ob_common_utility.h"
#include "common/ob_smart_call.h"
#include "share/ob_unit_getter.h"
#include "share/schema/ob_column_schema.h"
#include "sql/ob_sql_context.h"
#include "sql/resolver/expr/ob_raw_expr.h"
#include "sql/resolver/expr/ob_raw_expr_util.h"
#include "sql/optimizer/ob_optimizer_util.h"
#include "sql/code_generator/ob_expr_generator_impl.h"
#include "sql/engine/ob_physical_plan.h"
#include "sql/engine/ob_exec_context.h"
#include "sql/engine/ob_physical_plan.h"
#include "sql/engine/expr/ob_expr_arg_case.h"
#include "sql/engine/expr/ob_expr_xmlparse.h"
#include "sql/session/ob_sql_session_info.h"
#include "share/config/ob_server_config.h"
#include "sql/rewrite/ob_transform_utils.h"
#include "sql/resolver/dml/ob_insert_all_stmt.h"
#include "sql/resolver/dml/ob_select_stmt.h"
#include "sql/resolver/dml/ob_select_resolver.h"
#include "sql/resolver/dml/ob_merge_stmt.h"
#include "sql/resolver/dml/ob_merge_resolver.h"
#include "sql/resolver/dml/ob_update_stmt.h"
#include "sql/rewrite/ob_expand_aggregate_utils.h"
#include "pl/ob_pl_stmt.h"
#include "pl/ob_pl_resolver.h"
#include "sql/privilege_check/ob_ora_priv_check.h"
#include "sql/resolver/dml/ob_insert_all_stmt.h"
#include "sql/engine/expr/ob_expr_align_date4cmp.h"

using namespace oceanbase::common;
using namespace oceanbase::share;
using namespace oceanbase::share::schema;
namespace oceanbase
{
using namespace common;
namespace sql
{
int ObTransformPreProcess::transform_one_stmt(common::ObIArray<ObParentDMLStmt> &parent_stmts,
                                              ObDMLStmt *&stmt,
                                              bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  bool is_happened = false;
  if (OB_ISNULL(stmt)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("stmt is NULL", K(ret));
  } else if (OB_FAIL(ObTransformUtils::right_join_to_left(stmt))) {
    LOG_WARN("failed to transform right join as left", K(ret));
  } else if (parent_stmts.empty() && lib::is_oracle_mode() &&
              OB_FAIL(formalize_limit_expr(*stmt))) {
    LOG_WARN("formalize stmt fialed", K(ret));
  } else {
    if (OB_SUCC(ret) && parent_stmts.empty()) {
      if (OB_FAIL(expand_correlated_cte(stmt, is_happened))) {
        LOG_WARN("failed to expand correlated cte", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("expand correlated cte", is_happened);
        LOG_TRACE("succeed to expand correlated cte", K(is_happened), K(ret));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_json_object_expr_with_star(parent_stmts, stmt, is_happened))) {
        LOG_WARN("failed to transform for json object star", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform for udt columns", is_happened);
        LOG_TRACE("succeed to transform for udt columns", K(is_happened), K(ret));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_udt_columns(parent_stmts, stmt, is_happened))) {
        LOG_WARN("failed to transform for transform for cast multiset", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform for udt columns", is_happened);
        LOG_TRACE("succeed to transform for udt columns", K(is_happened), K(ret));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_cast_multiset_for_stmt(stmt, is_happened))) {
        LOG_WARN("failed to transform for transform for cast multiset", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform for cast multiset", is_happened);
        LOG_TRACE("succeed to transform for cast multiset", K(is_happened), K(ret));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(add_all_rowkey_columns_to_stmt(stmt, is_happened))) {
        LOG_WARN("faield to add all rowkey columns", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("add all rowkey columns:", is_happened);
        LOG_TRACE("succeed to add all rowkey columns", K(is_happened));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(eliminate_having(stmt, is_happened))) {
        LOG_WARN("failed to elinimate having", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("eliminating having statement:", is_happened);
        LOG_TRACE("succeed to eliminating having statement", K(is_happened));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transformer_rowid_expr(stmt, is_happened))) {
        LOG_WARN("failed to transform rowid expr", K(ret));
      } else if (OB_FAIL(add_rowid_constraint(*stmt))) {
        LOG_WARN("add rowid constraint failed", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform rowid expr:", is_happened);
        LOG_TRACE("succeed to transform rowid expr", K(is_happened), K(ret));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(replace_func_is_serving_tenant(stmt, is_happened))) {
        LOG_WARN("failed to replace function is_serving_tenant", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("replace is_serving_tenant function:", is_happened);
        LOG_TRACE("succeed to replace function", K(is_happened));
      }
    }
#ifdef OB_BUILD_LABEL_SECURITY
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_for_label_se_table(stmt, is_happened))) {
        LOG_WARN("failed to transform for label security table", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform for label security table:", is_happened);
        LOG_TRACE("succeed to transform for label security table", K(is_happened), K(ret));
      }
    }
#endif
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_for_rls_table(stmt, is_happened))) {
        LOG_WARN("failed to transform for rls table", K(ret));
      } else {
        trans_happened |= is_happened;
        LOG_TRACE("succeed to transform for rls table", K(is_happened), K(ret));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_for_merge_into(stmt, is_happened))) {
        LOG_WARN("failed to transform for merge into", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform for merge into:", is_happened);
        LOG_TRACE("succeed to transform for merge into", K(is_happened), K(ret));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_for_temporary_table(stmt, is_happened))) {
        LOG_WARN("failed to transform for temporary table", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform for temporary table:", is_happened);
        LOG_TRACE("succeed to transform for temporary table", K(is_happened), K(ret));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_outerjoin_exprs(stmt, is_happened))) {
        LOG_WARN("failed to transform outer join exprs", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform outer join exprs:", is_happened);
        LOG_TRACE("succeed to transform outer join exprs", K(is_happened), K(ret));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_for_batch_stmt(stmt, is_happened))) {
        LOG_WARN("failed to transform for batch update", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform for batch stmt:", is_happened);
        LOG_TRACE("succeed to transform for batch stmt", K(is_happened), K(ret));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_exprs(stmt, is_happened))) {
        LOG_WARN("transform exprs failed", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform exprs:", is_happened);
        LOG_TRACE("success to transform exprs", K(is_happened));
      }
    }
    /*transform_for_nested_aggregate、transformer_aggr_expr两个函数强依赖，必须保证两者改写顺序*/
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_for_nested_aggregate(stmt, is_happened))) {
        LOG_WARN("failed to transform for nested aggregate.", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform for nested aggregate:", is_happened);
        LOG_TRACE("succeed to transform for nested aggregate", K(is_happened), K(ret));
      }
      if (OB_SUCC(ret)) {
        if (OB_FAIL(transformer_aggr_expr(stmt, is_happened))) {
          LOG_WARN("failed to transform aggr expr", K(ret));
        } else {
          trans_happened |= is_happened;
          OPT_TRACE("transform aggr expr:", is_happened);
          LOG_TRACE("succeed to transform aggr expr", K(is_happened), K(ret));
        }
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_full_outer_join(stmt, is_happened))) {
        LOG_WARN("failed to transform full outer join", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform full outer join:", is_happened);
        LOG_TRACE("succeed to transform full outer join", K(is_happened));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_for_hierarchical_query(stmt, is_happened))) {
        LOG_WARN("failed to transform for hierarchical query", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform hierarchical query:", is_happened);
        LOG_TRACE("succeed to transform hierarchical query", K(is_happened));
      }
    }

    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_rownum_as_limit_offset(parent_stmts, stmt, is_happened))) {
        LOG_WARN("failed to transform rownum as limit", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform rownum as limit:", is_happened);
        LOG_TRACE("succeed to transform rownum as limit", K(is_happened));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_groupingsets_rollup_cube(stmt, is_happened))) {
        LOG_WARN("failed to transform for transform for grouping sets, rollup and cube.", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("transform for grouping sets and multi rollup:", is_happened);
        LOG_TRACE("succeed to transform for grouping sets and multi rollup",K(is_happened), K(ret));
      }
    }

    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_rollup_exprs(stmt, is_happened))) {
        LOG_WARN("failed to transform rollup exprs", K(ret));
      } else {
        trans_happened |= is_happened;
        LOG_TRACE("succeed to transform rollup exprs",  K(is_happened));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_for_last_insert_id(stmt, is_happened))) {
        LOG_WARN("failed to transform for last_insert_id.", K(ret));
      } else {
        trans_happened |= is_happened;
        LOG_TRACE("succeed to transform for last_insert_id.",K(is_happened), K(ret));
      }
    }
    if (OB_SUCC(ret)) {
      LOG_DEBUG("transform pre process succ", K(*stmt));
     if (OB_FAIL(stmt->formalize_stmt(ctx_->session_info_))) {
        LOG_WARN("failed to formalize stmt", K(ret));
      //} else if (OB_FAIL(stmt->formalize_stmt_expr_reference())) {
      //  LOG_WARN("failed to formalize stmt reference", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::need_transform(const common::ObIArray<ObParentDMLStmt> &parent_stmts,
                                          const int64_t current_level,
                                          const ObDMLStmt &stmt,
                                          bool &need_trans)
{
  UNUSED(parent_stmts);
  UNUSED(current_level);
  UNUSED(stmt);
  need_trans = true;
  return OB_SUCCESS;
}

int ObTransformPreProcess::add_all_rowkey_columns_to_stmt(ObDMLStmt *stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->schema_checker_)
      || OB_ISNULL(ctx_->expr_factory_) || OB_ISNULL(ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null", K(ret), K(stmt), K(ctx_));
  } else {
    ObIArray<TableItem*> &tables = stmt->get_table_items();
    TableItem *table_item = NULL;
    const ObTableSchema *table_schema = NULL;
    ObSEArray<ColumnItem, 16> column_items;
    for (int64_t i = 0; OB_SUCC(ret) && i < tables.count(); ++i) {
      if (OB_ISNULL(table_item = tables.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null", K(ret), K(table_item));
      } else if (!table_item->is_basic_table()) {
        /* do nothing */
      } else if (OB_FAIL(ctx_->schema_checker_->get_table_schema(ctx_->session_info_->get_effective_tenant_id(),
                                                                 table_item->ref_id_,
                                                                 table_schema,
                                                                 table_item->is_link_table()))) {
        LOG_WARN("table schema not found", K(table_schema));
      } else if (OB_ISNULL(table_schema)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get invalid table schema", K(table_schema));
      } else if (OB_FAIL(add_all_rowkey_columns_to_stmt(*table_schema, *table_item,
                                                        *ctx_->expr_factory_,
                                                        *stmt,
                                                        column_items))) {
        LOG_WARN("add all rowkey exprs failed", K(ret));
      }
    }

    if (OB_SUCC(ret) && !column_items.empty()) {
      ObIArray<ColumnItem> &orign_column_items = stmt->get_column_items();
      for (int i = 0; OB_SUCC(ret) && i < orign_column_items.count(); ++i) {
        if (OB_ISNULL(orign_column_items.at(i).expr_)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret), K(orign_column_items.at(i).expr_));
        } else if (!orign_column_items.at(i).expr_->is_rowkey_column() &&
                   OB_FAIL(column_items.push_back(orign_column_items.at(i)))) {
          LOG_WARN("failed to push back column item", K(ret));
        }
      }
      if (OB_SUCC(ret)) {
        if (OB_FAIL(stmt->get_column_items().assign(column_items))) {
          LOG_WARN("failed to assign column items", K(ret));
        } else {
          trans_happened = true;
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::add_all_rowkey_columns_to_stmt(const ObTableSchema &table_schema,
                                                          const TableItem &table_item,
                                                          ObRawExprFactory &expr_factory,
                                                          ObDMLStmt &stmt,
                                                          ObIArray<ColumnItem> &column_items)
{
  int ret = OB_SUCCESS;
  const ObRowkeyInfo &rowkey_info = table_schema.get_rowkey_info();
  const ObColumnSchemaV2 *column_schema = NULL;
  uint64_t column_id = OB_INVALID_ID;
  ColumnItem *exists_col_item = NULL;
  ObColumnRefRawExpr *rowkey = NULL;
  for (int col_idx = 0; OB_SUCC(ret) && col_idx < rowkey_info.get_size(); ++col_idx) {
    if (OB_FAIL(rowkey_info.get_column_id(col_idx, column_id))) {
      LOG_WARN("Failed to get column id", K(ret));
    } else if (NULL != (exists_col_item = stmt.get_column_item_by_id(table_item.table_id_,
                                                                     column_id))) {
      if (OB_FAIL(column_items.push_back(*exists_col_item))) {
        LOG_WARN("failed to push back column item", K(ret));
      }
    } else if (OB_MOCK_LINK_TABLE_PK_COLUMN_ID == column_id && table_item.is_link_table()) {
      continue;
    } else if (OB_ISNULL(column_schema = (table_schema.get_column_schema(column_id)))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("failed to get column schema", K(column_id), K(ret));
    } else if (OB_FAIL(ObRawExprUtils::build_column_expr(expr_factory, *column_schema, rowkey))) {
      LOG_WARN("build column expr failed", K(ret));
    } else if (OB_ISNULL(rowkey)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("failed to create raw expr for dummy output", K(ret));
    } else {
      ColumnItem column_item;
      rowkey->set_ref_id(table_item.table_id_, column_schema->get_column_id());
      rowkey->set_column_attr(table_item.get_table_name(), column_schema->get_column_name_str());
      rowkey->set_database_name(table_item.database_name_);
      if (!table_item.alias_name_.empty()) {
        rowkey->set_table_alias_name();
      }
      column_item.table_id_ = rowkey->get_table_id();
      column_item.column_id_ = rowkey->get_column_id();
      column_item.base_tid_ = table_item.ref_id_;
      column_item.base_cid_ = rowkey->get_column_id();
      column_item.column_name_ = rowkey->get_column_name();
      column_item.set_default_value(column_schema->get_cur_default_value());
      column_item.expr_ = rowkey;
      if (OB_FAIL(stmt.add_column_item(column_item))) {
        LOG_WARN("add column item to stmt failed", K(ret));
      } else if (OB_FAIL(column_items.push_back(column_item))) {
        LOG_WARN("failed to push back column item", K(ret));
      } else if (FALSE_IT(rowkey->clear_explicited_referece())) {
      } else if (OB_FAIL(rowkey->formalize(NULL))) {
        LOG_WARN("formalize rowkey failed", K(ret));
      } else if (OB_FAIL(rowkey->pull_relation_id())) {
        LOG_WARN("failed to pullup relation ids", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::formalize_limit_expr(ObDMLStmt &stmt)
{
  int ret = OB_SUCCESS;

  ObRawExpr *limit_expr = stmt.get_limit_expr();
  ObRawExpr *offset_expr = stmt.get_offset_expr();
  ObRawExpr *percent_expr = stmt.get_limit_percent_expr();
  ObSEArray<ObRawExpr *, 4> params;
  bool transed_zero = false;
  ObConstRawExpr *one_expr = NULL;
  ObConstRawExpr *zero_expr = NULL;
  if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->exec_ctx_) || OB_ISNULL(ctx_->exec_ctx_->get_physical_plan_ctx())
      || OB_ISNULL(ctx_->allocator_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("ctx is null", K(ret));
  } else if (limit_expr != NULL) {
    bool is_null_value = false;
    int64_t limit_value = 0;
    ObRawExpr *cmp_expr = NULL;
    if (OB_FAIL(ObTransformUtils::get_expr_int_value(limit_expr,
                                                  &ctx_->exec_ctx_->get_physical_plan_ctx()->get_param_store(),
                                                  ctx_->exec_ctx_,
                                                  ctx_->allocator_,
                                                  limit_value,
                                                  is_null_value))) {
      LOG_WARN("failed to get_expr_int_value", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                                            ObIntType,
                                                            1,
                                                            one_expr))) {
      LOG_WARN("build expr failed", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                                            ObIntType,
                                                            0,
                                                            zero_expr))) {
      LOG_WARN("build expr failed", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::create_double_op_expr(*ctx_->expr_factory_, ctx_->session_info_, T_OP_GE,
                                                            cmp_expr, limit_expr, one_expr))) {
      LOG_WARN("create_double_op_expr_failed", K(ret));

    } else if (!is_null_value && limit_value >= 1) {
      if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, cmp_expr, true))) {
        LOG_WARN("add param failed", K(ret));
      }
    } else {
      stmt.set_limit_offset(zero_expr, NULL);
      transed_zero = true;
      if (OB_FAIL(params.push_back(cmp_expr))) {
        LOG_WARN("push back failed", K(ret));
      }
    }
  } else if (percent_expr != NULL) {
    bool is_null_value = false;
    double limit_value = 0;
    ObRawExpr *cmp_expr = NULL;
    ObConstRawExpr *double_zero_expr = NULL;
    if (OB_FAIL(ObTransformUtils::get_percentage_value(percent_expr,
                                                       &stmt,
                                                       &ctx_->exec_ctx_->get_physical_plan_ctx()->get_param_store(),
                                                       ctx_->exec_ctx_,
                                                       ctx_->allocator_,
                                                       limit_value,
                                                       is_null_value))) {
      LOG_WARN("failed to get_percentage_value", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::build_const_double_expr(*ctx_->expr_factory_,
                                                               ObDoubleType,
                                                               0,
                                                               double_zero_expr))) {
      LOG_WARN("build expr failed", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                                            ObIntType,
                                                            0,
                                                            zero_expr))) {
      LOG_WARN("build expr failed", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::create_double_op_expr(*ctx_->expr_factory_, ctx_->session_info_, T_OP_GT,
                                                             cmp_expr, percent_expr, double_zero_expr))) {
      LOG_WARN("create_double_op_expr_failed", K(ret));
    } else if (!is_null_value && limit_value > 0) {
      if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, cmp_expr, true))) {
        LOG_WARN("add param failed", K(ret));
      }
    } else {
      stmt.set_limit_percent_expr(NULL);
      stmt.set_limit_offset(zero_expr, NULL);
      transed_zero = true;
      if (OB_FAIL(params.push_back(cmp_expr))) {
        LOG_WARN("push back failed", K(ret));
      }
    }
  }

  if (OB_FAIL(ret)) {
  } else if (offset_expr != NULL) {
    bool is_null_value = false;
    int64_t offset_value = 0;
    ObRawExpr *cmp_expr = NULL;
    if (OB_FAIL(ObTransformUtils::get_expr_int_value(offset_expr,
                                                  &ctx_->exec_ctx_->get_physical_plan_ctx()->get_param_store(),
                                                  ctx_->exec_ctx_,
                                                  ctx_->allocator_,
                                                  offset_value,
                                                  is_null_value))) {
      LOG_WARN("failed to get_expr_int_value", K(ret));
    } else if (zero_expr == NULL && OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                                            ObIntType,
                                                            0,
                                                            zero_expr))) {
      LOG_WARN("build expr failed", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::create_double_op_expr(*ctx_->expr_factory_, ctx_->session_info_, T_OP_GE,
                                                              cmp_expr, offset_expr, zero_expr))) {
      LOG_WARN("create_double_op_expr_failed", K(ret));
    } else if (offset_value >= 0) {
      if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, cmp_expr, true))) {
        LOG_WARN("add param failed", K(ret));
      }
    } else if (is_null_value) {
      stmt.set_limit_offset(zero_expr, NULL);
      transed_zero = true;
      ObRawExpr *new_cond = NULL;
      if (OB_FAIL(ObRawExprUtils::build_is_not_null_expr(*ctx_->expr_factory_, offset_expr,
                                                     true, new_cond))) {
        LOG_WARN("build expr failed", K(ret));
      } else if (OB_FAIL(params.push_back(new_cond))) {
        LOG_WARN("push back failed", K(ret));
      }
    } else {
      stmt.set_limit_offset(stmt.get_limit_expr(), zero_expr);
      transed_zero = true;
      if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, cmp_expr, false))) {
        LOG_WARN("add param failed", K(ret));
      }
    }
  }


  if (OB_SUCC(ret) && params.count() > 0 && transed_zero) {
    ObRawExpr* and_expr = NULL;
    if (OB_FAIL(ObRawExprUtils::build_and_expr(*ctx_->expr_factory_, params, and_expr))) {
      LOG_WARN("build and expr failed", K(ret));
    } else  if (OB_FAIL(and_expr->formalize(ctx_->session_info_))) {
      LOG_WARN("formalize failed", K(ret));
    } else if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, and_expr, false))) {
      LOG_WARN("add param failed", K(ret));
    }
  }

  if (OB_SUCC(ret)) {
    ObSEArray<ObSelectStmt *, 2> child_stmts;
    if (OB_FAIL(stmt.get_child_stmts(child_stmts))) {
      LOG_WARN("get child_stmts failed", K(ret));
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < child_stmts.count(); i++) {
      if (OB_ISNULL(child_stmts.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("stmt is null", K(ret));
      } else if (OB_FAIL(SMART_CALL(formalize_limit_expr(*child_stmts.at(i))))) {
        LOG_WARN("formalize limit expr failed", K(ret));
      }
    }
  }
  return ret;
}

/* @brief,ObTransformPreProcess::release_single_item_groupingsets
 * if grouping sets has one item only, then release grouping sets.
 * eg:
 * group by grouping sets(c1) ---> group by c1
 * group by grouping sets(rollup(c1, c2)) ---> group by rollup(c1, c2)
 * group by grouping sets(cube(c1, c2)) ---> group by cube(c1, c2)
 */
int ObTransformPreProcess::remove_single_item_groupingsets(ObSelectStmt &stmt,
                                                           bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  ObIArray<ObGroupingSetsItem> &grouping_sets_items = stmt.get_grouping_sets_items();
  typedef ObSEArray<ObGroupingSetsItem, 4> GroupingSetsArray;
  SMART_VAR(GroupingSetsArray, tmp_grouping_sets_items) {
    for (int64_t i = 0; OB_SUCC(ret) && i < grouping_sets_items.count(); ++i) {
      bool is_released = true;
      int64_t grouping_sets_expr_cnt = grouping_sets_items.at(i).grouping_sets_exprs_.count();
      int64_t rollup_cnt = grouping_sets_items.at(i).rollup_items_.count();
      int64_t cube_cnt = grouping_sets_items.at(i).cube_items_.count();
      if (grouping_sets_expr_cnt == 1 && rollup_cnt == 0 && cube_cnt == 0) {
        if (OB_FAIL(append(stmt.get_group_exprs(),
                           grouping_sets_items.at(i).grouping_sets_exprs_.at(0).groupby_exprs_))) {
          LOG_WARN("failed to append group exprs", K(ret));
        }
      } else if (grouping_sets_expr_cnt == 0 && rollup_cnt == 1 && cube_cnt == 0) {
        if (OB_FAIL(stmt.add_rollup_item(grouping_sets_items.at(i).rollup_items_.at(0)))) {
          LOG_WARN("failed to add multi rollup item", K(ret));
        }
      } else if (grouping_sets_expr_cnt == 0 && rollup_cnt == 0 && cube_cnt == 1) {
        if (OB_FAIL(stmt.add_cube_item(grouping_sets_items.at(i).cube_items_.at(0)))) {
          LOG_WARN("failed to add multi cube item", K(ret));
        }
      } else {
        is_released = false;
      }
      if (OB_SUCC(ret) && !is_released &&
          OB_FAIL(tmp_grouping_sets_items.push_back(grouping_sets_items.at(i)))) {
        LOG_WARN("failed to push back item", K(ret));
      }
    }
    if (OB_SUCC(ret) && grouping_sets_items.count() != tmp_grouping_sets_items.count()) {
      grouping_sets_items.reset();
      bool is_happened = false;
      if (OB_ISNULL(ctx_)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpected NULL", K(ret), KP(ctx_));
      } else if (!stmt.has_group_by() && OB_FAIL(ObTransformUtils::set_limit_expr(&stmt, ctx_))) {
        LOG_WARN("add limit expr failed", K(ret));
      } else if (!stmt.has_group_by() && OB_FAIL(eliminate_having(&stmt, is_happened))) {
        LOG_WARN("failed to eliminate having", K(ret));
      } else if (OB_FAIL(grouping_sets_items.assign(tmp_grouping_sets_items))) {
        LOG_WARN("failed to assign stmt's grouping sets items", K(ret));
      } else {
        trans_happened = true;
        LOG_TRACE("eliminate having", K(is_happened));
      }
    }
  }
  return ret;
}

/* @brief,ObTransformPreProcess::try_convert_rollup
 * if stmt doesn't have rollup_exprs, then convert rollup_item which has the most count of exprs to
 * rollup_exprs
 * eg:
 * rollup_exprs = [], rollup_items = [[c1, c2], [(c1, c2), c1, c3, c4], [c1, c2, c3]]
 * --->
 * rollup_exprs = [c1, c2, c3], rollup_items = [[c1, c2], [(c1, c2), c1, c3, c4]]
 */
/*
 * group_id:
 *   (1). all deal in pre_process
 * grouping/grouping_id:
 *   (2). if single rollup and rollup_exprs are one item like 'group by rollup(c1, c2)', deal functions in engine.
 *   (3). else deal functions in pre_process.
 */
int ObTransformPreProcess::try_convert_rollup(ObDMLStmt *&stmt, ObSelectStmt *select_stmt)
{
  int ret = OB_SUCCESS;
  bool can_conv_rollup = false;
  bool has_group_id_func = false;
  bool has_grouping_func = false;
  if (OB_ISNULL(stmt) || OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected NULL", K(ret), KP(stmt), KP(select_stmt));
  } else if (select_stmt->get_rollup_exprs().empty() && !select_stmt->get_rollup_items().empty()) {
    for (int64_t i = 0; OB_SUCC(ret) && !has_group_id_func && i < select_stmt->get_aggr_item_size(); ++i) {
      ObRawExpr *expr = select_stmt->get_aggr_items().at(i);
      if (OB_ISNULL(expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected NULL ptr", K(ret));
      } else if (T_FUN_GROUP_ID == expr->get_expr_type()) {
        has_group_id_func = true;
      } else if (T_FUN_GROUPING_ID == expr->get_expr_type() ||
                 T_FUN_GROUPING == expr->get_expr_type()) {
        has_grouping_func = true;
      }
    }
    if (OB_SUCC(ret) && !has_group_id_func) {
      if (!has_grouping_func) {
        can_conv_rollup = true;
      } else if (select_stmt->get_rollup_items_size() == 1 &&
                 select_stmt->get_grouping_sets_items_size() == 0 &&
                 select_stmt->get_cube_items_size() == 0) {
        can_conv_rollup = true;
      }
    }
    if (OB_SUCC(ret) && can_conv_rollup) {
      int64_t idx = -1;
      int64_t cnt = 0;
      for (int64_t i = 0; i < select_stmt->get_rollup_items_size(); ++i) {
        bool can_conv_this_rollup = true;
        const ObIArray<ObGroupbyExpr> &rollup_list_exprs =
                                          select_stmt->get_rollup_items().at(i).rollup_list_exprs_;
        for (int64_t j = 0; can_conv_this_rollup && j < rollup_list_exprs.count(); ++j) {
          if (rollup_list_exprs.at(j).groupby_exprs_.count() != 1) {
            can_conv_this_rollup = false;
          }
        }
        if (can_conv_this_rollup && rollup_list_exprs.count() > cnt) {
          cnt = rollup_list_exprs.count();
          idx = i;
        }
      }
      if (idx >= 0) {
        const ObIArray<ObGroupbyExpr> &rollup_list_exprs =
                                        select_stmt->get_rollup_items().at(idx).rollup_list_exprs_;
        for (int64_t i = 0; OB_SUCC(ret) && i < rollup_list_exprs.count(); ++i) {
          if (OB_FAIL(select_stmt->get_rollup_exprs().push_back(
                                                  rollup_list_exprs.at(i).groupby_exprs_.at(0)))) {
            LOG_WARN("failed to push back exprs", K(ret));
          }
        }
        if (OB_SUCC(ret)) {
          select_stmt->get_rollup_items().remove(idx);
          stmt = select_stmt;
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::create_cte_for_groupby_items(ObSelectStmt &stmt)
{
  int ret = OB_SUCCESS;
  bool can_pre_aggregate = false;
  bool is_correlated = false;
  ObSelectStmt *view_stmt = NULL;
  if (OB_FAIL(check_pre_aggregate(stmt, can_pre_aggregate))) {
    LOG_WARN("fialed to check pre aggregate", K(ret));
  } else if (!can_pre_aggregate) {
    if (OB_FAIL(ObTransformUtils::create_simple_view(ctx_, &stmt, view_stmt))) {
      LOG_WARN("failed to create simple view", K(ret), K(stmt));
    }
  } else if (OB_FAIL(ObTransformUtils::create_view_with_pre_aggregate(&stmt, view_stmt, ctx_))) {
    LOG_WARN("failed to create view with pushdown groupby", K(ret), K(stmt));
  } else { /* do nothing */ }

  if (OB_FAIL(ret)) {
  } else if (OB_ISNULL(view_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("view stmt is null", K(ret), K(view_stmt));
  } else if (OB_FAIL(is_subquery_correlated(view_stmt, is_correlated))) {
    LOG_WARN("failed to check subquery correlated", K(ret));
  } else if (is_correlated) {
    ret = OB_NOT_SUPPORTED; // TODO GROUPING_SETS
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "correlated temp table now");
    LOG_WARN("correlated temp table is not support now!", K(ret));
  } else if (OB_FAIL(add_generated_table_as_temp_table(ctx_, &stmt))) {
    LOG_WARN("failed to add generated table as temp table", K(ret));
  } else { /* do nothing */ }
  return ret;
}

/*
 * select c1, sum(c2) from t1 group by grouping sets(c1, c2) having sum(c2) > 2 order by c1;
 * --->(pull cte)
 * with cte as : select c1, c2, sum(c2) from t1 group by c1, c2
 * select cte.c1, cte.c3 from cte group by grouping sets(cte.c1, cte.c2)
 *   having cte.c3 > 2 order by cte.c1;
 * --->(create_view_with_groupby_items)
 * 1.
 * with view as : select cte.c1, cte.c3 from cte group by grouping sets(cte.c1, cte.c2)
 *                  having cte.c3 > 2;
 * select v.c1, v.c2 from v order by v.c1;
 * 2.
 * view select cte.c1, cte.c3 from cte group by grouping sets(cte.c1, cte.c2)
 *                  having cte.c3 > 2
 */
int ObTransformPreProcess::expand_stmt_groupby_items(ObSelectStmt &stmt)
{
  int ret = OB_SUCCESS;
  TableItem *view_table_item = NULL;
  if (OB_FAIL(ObTransformUtils::create_view_with_groupby_items(&stmt, view_table_item, ctx_))) {
    LOG_WARN("failed to create simple view", K(ret));
  } else if (OB_ISNULL(view_table_item)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("failed to create view with groupby", K(ret), K(view_table_item));
  } else if (OB_FAIL(create_set_view_stmt(&stmt, view_table_item))) {
    LOG_WARN("failed to create grouping sets view.", K(ret));
  } else { /* do nothing */ }
  return ret;
}

/*@brief,ObTransformPreProcess::transform_groupingsets_rollup_cube
 *
 * as following steps to transform grouping sets stmt to set stmt:
 * 1. create cte for "grouping sets/rollup/cube"
 *    (1). Creating spj stmt from origin stmt with considering whether do pre_aggregation;
 *    (2). According to the spj stmt separated in the previous step, creating temp table and add
 *         it to origin stmt
 * 2. According to "grouping sets/rollup/cube" and stmt created in the previous
 *    step,creating set stmt
 * 3. Merging set stmt created in the previous step and origin stmt into transform stmt
 *
 * tranform stmt with
 * grouping sets or multi rollup to equal set stmt.
 * for grouping sets stmt:
 *  1.select c1,c2 from t1 group by grouping sets(c1,c2);
 * <==>
 *  select c1, NULL from t1 group by c1
 *union all
 *  select NULL, c2 from t1 group by c1;
 *
 *  2.select c1,c2,c3,c4 from t1 group by grouping sets(c1,c2), grouping sets(c3,c4);
 *<==>
 *  select c1,NULL,c3,NULL from t1 group by c1,c3
 * union all
 *  select c1,NULL,NULL,c4 from t1 group by c1,c4
 * union all
 *  select NULL,c2,c3,NULL from t1 group by c2,c3
 * union all
 *  select NULL,c2,NULL,c4 from t1 group by c2,c4;
 *
 *  as above, {c1,c2} * {c3,c4}  ==> Cartesian product
 *
 * for multi rollup stmt:
 * 1.select c1,c2,c3,sum(c3) from t1 group by rollup((c1,c2),c3);
 * <==>
 *  select c1,c2,c3,sum(c3) from t1 group by c1,c2,c3
 * union all
 *  select c1,c2,NULL,sum(c3) from t1 group by c1,c2
 * union all
 *  select NULL,NULL,NULL,sum(c3) from t1;
 *
 * 2.select c1,c2,c3,sum(c3) from t1 group by rollup (c1,c2),rollup(c3);
 * <==>
 *  select c1,c2,c3,sum(c3) from t1 group by c1,c2,c3
 * union all
 *  select c1,c2,NULL,sum(c3) from t1 group by c1,c2
 * union all
 *  select c1,NULL,c3,sum(c3) from t1 group by c1,c3
 * union all
 *  select c1,NULL,NULL,sum(c3) from t1 group by c1
 * union all
 *  select NULL,NULL,c3,sum(c3) from t1 group by c3
 * union all
 *  select NULL,NULL,NULL,sum(c3) from t1;
 *
 *  as above, {(c1,c2),(c1),(NULL)} * {(c3),(NULL)}  ==> Cartesian product
 */
int ObTransformPreProcess::transform_groupingsets_rollup_cube(ObDMLStmt *&stmt,
                                                              bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  ObSelectStmt *select_stmt = NULL;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null.", K(ret));
  } else if (!stmt->is_select_stmt()) {
    /* do nothing.*/
  } else if (FALSE_IT(select_stmt = static_cast<ObSelectStmt *>(stmt))) {
  } else if (OB_FAIL(remove_single_item_groupingsets(*select_stmt, trans_happened))) {
    LOG_WARN("failed to transform single item grouping sets", K(ret));
  } else if (OB_FAIL(try_convert_rollup(stmt, select_stmt))) {
    LOG_WARN("failed to convert multi rollup", K(ret));
  } else if (select_stmt->get_grouping_sets_items().count() == 0 &&
             select_stmt->get_rollup_items().count() == 0 &&
             select_stmt->get_cube_items().count() == 0) {
    // deal select item like 'c1 - 1'
  } else if (OB_FAIL(ObTransformUtils::replace_stmt_expr_with_groupby_exprs(select_stmt, ctx_))) {
    LOG_WARN("replace stmt expr with groupby exprs failed", K(ret));
  } else if (OB_FAIL(create_cte_for_groupby_items(*select_stmt))) {
    LOG_WARN("failed to create spj view.", K(ret));
  } else if (OB_FAIL(expand_stmt_groupby_items(*select_stmt))) {
    LOG_WARN("failed to expand grouping_sets_items/rollup_items/cube_items", K(ret));
  } else {
    trans_happened = true;
  }
  if (OB_SUCC(ret) && trans_happened) {
    stmt = select_stmt;
    LOG_TRACE("succeed to transform transform for grouping sets, rollup or cube", K(*stmt));
  }
  return ret;
}

int ObTransformPreProcess::is_subquery_correlated(const ObSelectStmt *stmt,
                                                  bool &is_correlated)
{
  int ret = OB_SUCCESS;
  hash::ObHashSet<uint64_t> param_set;
  if (OB_FAIL(param_set.create(128, "PreProcess", "HashNode"))) {
    LOG_WARN("failed to create param set", K(ret));
  } else if (OB_FAIL(is_subquery_correlated(stmt, param_set, is_correlated))) {
    LOG_WARN("failed to check is subquery correlated", K(ret));
  }

  if (param_set.created()) {
    int tmp_ret = param_set.destroy();
    if (OB_SUCC(ret) && OB_FAIL(tmp_ret)) {
      LOG_WARN("failed to destory param set", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::is_subquery_correlated(const ObSelectStmt *stmt,
                                                  hash::ObHashSet<uint64_t> &param_set,
                                                  bool &is_correlated)
{
  int ret = OB_SUCCESS;
  ObArray<ObRawExpr *> relation_exprs;
  ObArray<ObSelectStmt *> child_stmts;
  if (OB_FAIL(stmt->get_relation_exprs(relation_exprs))) {
    LOG_WARN("failed to get relation exprs", K(ret));
  } else if (OB_FAIL(stmt->get_child_stmts(child_stmts))) {
    LOG_WARN("failed to get child stmts", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && !is_correlated && i < relation_exprs.count(); ++i) {
    if (OB_FAIL(has_new_exec_param(relation_exprs.at(i), param_set, is_correlated))) {
      LOG_WARN("failed to check has new exec param", K(ret));
    }
  }
  if (OB_SUCC(ret) && !is_correlated && OB_FAIL(add_exec_params(*stmt, param_set))) {
    LOG_WARN("failed to add exec params", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && !is_correlated && i < child_stmts.count(); ++i) {
    if (OB_FAIL(SMART_CALL(is_subquery_correlated(child_stmts.at(i),
                                                  param_set,
                                                  is_correlated)))) {
      LOG_WARN("failed to check is subquery correlated", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::add_exec_params(const ObSelectStmt &stmt,
                                           hash::ObHashSet<uint64_t> &param_set)
{
  int ret = OB_SUCCESS;
  for (int64_t i = 0; OB_SUCC(ret) && i < stmt.get_subquery_expr_size(); ++i) {
    ObQueryRefRawExpr *query_ref = stmt.get_subquery_exprs().at(i);
    if (OB_ISNULL(query_ref)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("query_ref is null", K(ret));
    }
    for (int64_t j = 0; OB_SUCC(ret) && j < query_ref->get_exec_params().count(); ++j) {
      ObExecParamRawExpr *exec_param = query_ref->get_exec_param(j);
      uint64_t key = reinterpret_cast<uint64_t>(exec_param);
      if (OB_FAIL(param_set.set_refactored(key))) {
        if (OB_HASH_EXIST == ret) {
          ret = OB_SUCCESS;
        } else {
          LOG_WARN("failed to add expr into set", K(ret));
        }
      }
    }
  }

  return ret;
}

int ObTransformPreProcess::has_new_exec_param(const ObRawExpr *expr,
                                              const hash::ObHashSet<uint64_t> &param_set,
                                              bool &has_new)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr is null", K(ret), K(expr));
  } else if (expr->is_exec_param_expr()) {
    uint64_t key = reinterpret_cast<uint64_t>(expr);
    int tmp_ret = param_set.exist_refactored(key);
    if (OB_HASH_NOT_EXIST == tmp_ret) {
      has_new = true;
    } else if (OB_UNLIKELY(OB_HASH_EXIST != tmp_ret)) {
      ret = tmp_ret;
      LOG_WARN("failed to check hash set", K(ret), K(ret));
    }
  } else if (expr->has_flag(CNT_DYNAMIC_PARAM)) {
    for (int64_t i = 0; OB_SUCC(ret) && !has_new && i < expr->get_param_count(); ++i) {
      if (OB_FAIL(SMART_CALL(has_new_exec_param(expr->get_param_expr(i),
                                                param_set,
                                                has_new)))) {
        LOG_WARN("failed to check has new exec param", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::add_generated_table_as_temp_table(ObTransformerCtx *ctx,
                                                             ObDMLStmt *stmt)
{
  int ret = OB_SUCCESS;
  TableItem *table_item = NULL;
  if (OB_ISNULL(ctx) || OB_ISNULL(ctx->allocator_) || OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ctx), K(stmt), K(ret));
  } else if (OB_UNLIKELY(1 != stmt->get_table_items().count()) ||
             OB_ISNULL(table_item = stmt->get_table_item(0)) ||
             OB_UNLIKELY(!table_item->is_generated_table()) ||
             OB_ISNULL(table_item->ref_query_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected error", K(stmt->get_table_items().count()), K(table_item), K(ret));
  } else if (OB_FALSE_IT(table_item->alias_name_ = table_item->table_name_)) {
  } else if (OB_FAIL(stmt->generate_view_name(*ctx->allocator_, table_item->table_name_, true))) {
    LOG_WARN("failed to generate view name", K(ret));
  } else {
    table_item->type_ = TableItem::TEMP_TABLE;
    for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_column_items().count(); i++) {
      if (OB_ISNULL(stmt->get_column_item(i)) || OB_ISNULL(stmt->get_column_item(i)->expr_)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret));
      } else {
        stmt->get_column_item(i)->expr_->set_table_name(table_item->alias_name_);
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::calc_grouping_in_grouping_sets(const ObIArray<ObRawExpr*> &groupby_exprs,
                                                          const ObIArray<ObRawExpr*> &rollup_exprs,
                                                          ObAggFunRawExpr *expr,
                                                          ObRawExpr *&new_expr)
{
  int ret = OB_SUCCESS;
  new_expr = NULL;
  ObConstRawExpr *one_expr = NULL;
  ObSysFunRawExpr *cast_expr = NULL;
  if (OB_ISNULL(expr) ||
      OB_ISNULL(ctx_) ||
      OB_ISNULL(ctx_->expr_factory_) ||
      OB_ISNULL(ctx_->session_info_) ||
      expr->get_expr_type() != T_FUN_GROUPING) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null expr or wrong type", K(ret), K(expr), K(ctx_));
  } else if (OB_UNLIKELY(expr->get_param_count() != 1)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected error", K(ret), K(*expr));
  } else if (ObOptimizerUtil::find_item(groupby_exprs, expr->get_param_expr(0)) ||
             ObOptimizerUtil::find_item(rollup_exprs, expr->get_param_expr(0))) {
    /*do nothing*/
  } else if (OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                                          ObIntType,
                                                          1,
                                                          one_expr))) {
    LOG_WARN("failed to build const int expr", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::create_cast_expr(*ctx_->expr_factory_,
                                                      one_expr,
                                                      expr->get_result_type(),
                                                      cast_expr,
                                                      ctx_->session_info_))) {
    LOG_WARN("create cast expr failed", K(ret));
  } else if (OB_FAIL(cast_expr->add_flag(IS_INNER_ADDED_EXPR))) {
    LOG_WARN("failed to add flag", K(ret));
  } else {
    new_expr = cast_expr;
  }
  return ret;
}

/*grouping sets is tranformed into union all, so  the grouping_id function must finish in transformer. 
 *grouping_id function in stmt without rollup is done here. 
 *select grouping_id(c1) from t1 group by grouping sets(c1,c2) will be transformed to 
 *select {new_value1} from t1 group by c1 UNION ALL select {new_value2} from t1 group by c2.
 * new value is a const value we have calculated in the following function.
 * here new_value1 is 0, and new_value2 is 1. So the stmt is:
 * select 0 from t1 group by c1 UNION ALL select 1 from t1 group by c2;
 */
int ObTransformPreProcess::calc_grouping_id_in_grouping_sets(
                                                          const ObIArray<ObRawExpr*> &groupby_exprs,
                                                          const ObIArray<ObRawExpr*> &rollup_exprs,
                                                          ObAggFunRawExpr *expr,
                                                          ObRawExpr *&new_expr)
{
  int ret = OB_SUCCESS;
  new_expr = NULL;
  uint64_t new_value = 0;
  ObConstRawExpr *int_expr = NULL;
  ObSysFunRawExpr *cast_expr = NULL;
  if (OB_ISNULL(expr) ||
      OB_ISNULL(ctx_) ||
      OB_ISNULL(ctx_->expr_factory_) ||
      OB_ISNULL(ctx_->session_info_) ||
      expr->get_expr_type() != T_FUN_GROUPING_ID) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null expr", K(ret), K(expr), K(ctx_));
  } else if (OB_UNLIKELY(expr->get_param_count() == 0)) {
    ret = OB_INVALID_ARGUMENT_NUM;
    LOG_WARN("invalid number of argument", K(ret));
  } else if (rollup_exprs.count() != 0) {
    // do nothing. for stmt that has rollup, the grouping_id is done in executor.
  } else {
    for (int64_t expr_idx = 0; expr_idx < expr->get_param_count(); expr_idx++) {
      if (ObOptimizerUtil::find_item(groupby_exprs, expr->get_param_expr(expr_idx))) {
        new_value = new_value << 1;
      } else {
        new_value = new_value << 1;
        new_value++;
      }
    }
    if (OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                                     ObIntType,
                                                     new_value,
                                                     int_expr))) {
      LOG_WARN("failed to build const int expr", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::create_cast_expr(*ctx_->expr_factory_,
                                                        int_expr,
                                                        expr->get_result_type(),
                                                        cast_expr,
                                                        ctx_->session_info_))) {
      LOG_WARN("create cast expr failed", K(ret));
    } else if (OB_FAIL(cast_expr->add_flag(IS_INNER_ADDED_EXPR))) {
      LOG_WARN("failed to add flag", K(ret));
    } else {
      new_expr = cast_expr;
    }
  }
  return ret;
}

/* since OB's grouping sets will be expanded to UNION ALL. We have to calculate the group_id() here
 * rather than the executor.
 * select group_id() from t1 group by grouping sets (c1,c2); will first be transformed to 
 * select group_id() from t1 group by c1 UNION ALL select group_id() from t1 group by c2;
 * and than be transformed to 
 * select {duplicated_groupby_num1} from t1 group by c1 UNION ALL select {duplicated_groupby_num2} from t1 group by c2;
 * duplicated_groupby_num is a const value that we have calculated in the following function
 * 
 * @brief
 *  @param groupby_exprs_list: store all previous sub stmt's groupby exprs.
 *  @param origin_groupby_num: groupby_exprs'number in origin stmt.
 * 
 * we traversal the groupby_exprs_list from 0 to cur_index to find out how many sub stmts have same groupby_exprs will
 * current sub stmt. 
 */
int ObTransformPreProcess::calc_group_id_in_grouping_sets(
                                                  const ObIArray<ObRawExpr*> &groupby_exprs,
                                                  const ObIArray<ObRawExpr*> &rollup_exprs,
                                                  const ObIArray<ObGroupbyExpr> &groupby_exprs_list,
                                                  const int64_t cur_index,
                                                  const int64_t origin_groupby_num,
                                                  ObAggFunRawExpr *expr,
                                                  ObRawExpr *&new_expr)
{
  int ret = OB_SUCCESS;
  int64_t duplicated_groupby_num = 0;
  ObConstRawExpr *int_expr = NULL;
  ObSysFunRawExpr *cast_expr = NULL;
  const ObIArray<ObRawExpr*> &now_groupby_exprs = groupby_exprs_list.at(cur_index).groupby_exprs_;
  if (OB_ISNULL(expr) ||
      OB_ISNULL(ctx_) ||
      OB_ISNULL(ctx_->expr_factory_) ||
      OB_ISNULL(ctx_->session_info_) ||
      expr->get_expr_type() != T_FUN_GROUP_ID) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null expr", K(ret), K(expr), K(ctx_));
  } else if (OB_UNLIKELY(expr->get_param_count() != 0)) {
    ret = OB_INVALID_ARGUMENT_NUM;
    LOG_WARN("invalid number of argument", K(ret));
  } else if (rollup_exprs.count() != 0) {
    ret = OB_NOT_SUPPORTED;
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "use group_id coexisting grouping sets, rollup or cube");
    LOG_WARN("group_id doesn't support coexisting grouping sets and rollup", K(ret));
  } else {
    for (int64_t i = 0; i < cur_index; ++i) {
      bool match = true;
      const ObIArray<ObRawExpr*> &origin_groupby_exprs = groupby_exprs_list.at(i).groupby_exprs_;
      for(int64_t j = origin_groupby_num; match && j < now_groupby_exprs.count(); ++j) {
        if (!ObOptimizerUtil::find_item(origin_groupby_exprs, now_groupby_exprs.at(j))) {
          match = false;
        }
      }
      for (int64_t j = 0; match && j< origin_groupby_exprs.count(); ++j) {
        if (!ObOptimizerUtil::find_item(now_groupby_exprs, origin_groupby_exprs.at(j))) {
          match = false;
        }
      }
      if (match) {
        //if match inc the duplciated count.
        duplicated_groupby_num++;
      }
    }
    // the group id is duplicated_groupby_num;
    if (OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                                     ObIntType,
                                                     duplicated_groupby_num,
                                                     int_expr))) {
      LOG_WARN("failed to build const int expr", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::create_cast_expr(*ctx_->expr_factory_,
                                                        int_expr,
                                                        expr->get_result_type(),
                                                        cast_expr,
                                                        ctx_->session_info_))) {
      LOG_WARN("create cast expr failed", K(ret));
    } else if (OB_FAIL(cast_expr->add_flag(IS_INNER_ADDED_EXPR))) {
      LOG_WARN("failed to add flag", K(ret));
    } else {
      new_expr = cast_expr;
    }
  }
  return ret;
}

int ObTransformPreProcess::calc_group_type_aggr_func(const ObIArray<ObRawExpr*> &groupby_exprs,
                                                     const ObIArray<ObRawExpr*> &rollup_exprs,
                                                     const ObIArray<ObGroupbyExpr> &groupby_exprs_list,
                                                     const int64_t cur_index,
                                                     const int64_t origin_groupby_num,
                                                     ObAggFunRawExpr *expr,
                                                     ObRawExpr *&new_expr)
{
  int ret = OB_SUCCESS;
  new_expr = NULL;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("failed. unexpected NULL", K(ret));
  } else if (T_FUN_GROUPING == expr->get_expr_type() &&
             OB_FAIL(calc_grouping_in_grouping_sets(groupby_exprs, rollup_exprs, expr, new_expr))) {
    LOG_WARN("failed to calculate grouping in grouping sets", K(ret), K(*expr));
  } else if (T_FUN_GROUPING_ID == expr->get_expr_type() &&
             OB_FAIL(calc_grouping_id_in_grouping_sets(groupby_exprs, rollup_exprs, expr,
                                                       new_expr))) {
    LOG_WARN("failed to calculate grouping_id in grouping sets", K(ret), K(*expr));
  } else if (T_FUN_GROUP_ID == expr->get_expr_type() &&
             OB_FAIL(calc_group_id_in_grouping_sets(groupby_exprs, rollup_exprs, groupby_exprs_list,
                                                    cur_index, origin_groupby_num, expr,
                                                    new_expr))) {
    LOG_WARN("failed to calculate grouping in grouping sets", K(ret), K(*expr));
  }
  return ret;
}

/*@brief, ObTransformPreProcess::convert_select_having_in_groupby_stmt, according to oracle action:
 * if the expr not in group by expr except in aggr, the expr will replaced with NULL; eg:
 *  select c1, c2, max(c1), max(c2) from t1 group by grouping sets(c1,c2) having c1 > 1 or c2 > 1 or sum(c1) > 2 or sum(c2) > 2;
 * <==>
 *  select c1, NULL, max(c1), max(c1) from t1 group by c1 having c1 > 1 or NULL > 1 or sum(c1) > 2 or sum(c2) > 2
 * union all
 *  select NULL, c2, max(c1), max(c1) from t1 group by c2 having NULL > 1 or c2 > 1 or sum(c1) > 2 or sum(c2) > 2;
 *
 *  select nvl(c1,1),c3 from t1 group by grouping sets(nvl(c1,1),c3);
 * <==>
 *  select nvl(c1,1), NULL from t1 group by nvl(c1,1)
 * union all
 *  select NULL, c3 from t1 group by c3;
 *
 * select nvl(c1,1) + c3 from t1 group by grouping sets(nvl(c1,1),c3);
 *
 */
int ObTransformPreProcess::convert_select_having_in_groupby_stmt(
                                                  const ObIArray<ObGroupbyExpr> &groupby_exprs_list,
                                                  const ObIArray<ObGroupbyExpr> &rollup_exprs_list,
                                                  const ObIArray<ObRawExpr*> &groupby_exprs,
                                                  const int64_t cur_index,
                                                  const ObSelectStmt &origin_stmt,
                                                  ObSelectStmt &substmt)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObRawExpr*, 4> old_exprs;
  ObSEArray<ObRawExpr*, 4> new_exprs;
  ObSEArray<ObAggFunRawExpr*, 4> tmp_agg_exprs;
  ObSEArray<ObRawExpr*, 4> cur_groupby_exprs;
  ObSEArray<ObRawExpr*, 4> other_groupby_exprs;
  // 1. build cur_groupby_exprs and other_groupby_exprs
  if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("failed. get unexpected null", K(ret), K(ctx_));
  } else if (OB_FAIL(append_array_no_dup(cur_groupby_exprs, substmt.get_group_exprs()))) {
    LOG_WARN("failed to append groupby exprs", K(ret));
  } else if (OB_FAIL(append_array_no_dup(cur_groupby_exprs, substmt.get_rollup_exprs()))) {
    LOG_WARN("failed to append groupby exprs", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < groupby_exprs.count(); ++i) {
    ObRawExpr *expr = NULL;
    if (OB_ISNULL(expr = groupby_exprs.at(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("failed. get unexpected NULL", K(ret));
    } else if (ObOptimizerUtil::find_item(cur_groupby_exprs, expr)) {
      /* do nothing */
    } else if (OB_FAIL(add_var_to_array_no_dup(other_groupby_exprs, expr))) {
      LOG_WARN("failed to add var into other groupby exprs", K(ret));
    }
  }
  // 2. try convert other_groupby_exprs to null and convert group_type _aggr
  if (OB_SUCC(ret)) {
    ObRawExpr *null_expr = NULL;
    ObSysFunRawExpr *cast_expr = NULL;
    ObRawExpr *new_expr = NULL;
    for (int64_t i = 0; OB_SUCC(ret) && i < other_groupby_exprs.count(); ++i) {
      ObRawExpr *expr = other_groupby_exprs.at(i);
      if (OB_ISNULL(expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("failed. get unexpected null", K(ret), K(expr));
      } else if (OB_FAIL(ObRawExprUtils::build_null_expr(*ctx_->expr_factory_, null_expr))) {
        LOG_WARN("failed build null exprs.", K(ret));
      } else if (OB_FAIL(ObRawExprUtils::create_cast_expr(*ctx_->expr_factory_,
                                                          null_expr,
                                                          expr->get_result_type(),
                                                          cast_expr,
                                                          ctx_->session_info_))) {
        LOG_WARN("create cast expr failed", K(ret));
      } else if (OB_FAIL(cast_expr->add_flag(IS_INNER_ADDED_EXPR))) {
        LOG_WARN("failed to add flag", K(ret));
      } else if (OB_FAIL(old_exprs.push_back(expr))) {
        LOG_WARN("failed to push back into old_exprs", K(ret));
      } else if (OB_FAIL(new_exprs.push_back(cast_expr))) {
        LOG_WARN("failed to push back into new_exprs", K(ret));
      }
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < substmt.get_aggr_item_size(); ++i) {
      ObAggFunRawExpr *agg_expr = substmt.get_aggr_item(i);
      if (OB_ISNULL(agg_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("failed. get unexpected null", K(ret), K(agg_expr));
      } else if (OB_FAIL(calc_group_type_aggr_func(substmt.get_group_exprs(),
                                                  substmt.get_rollup_exprs(),
                                                  groupby_exprs_list,
                                                  cur_index,
                                                  origin_stmt.get_group_expr_size(),
                                                  agg_expr,
                                                  new_expr))) {
        LOG_WARN("failed to replace group type aggr func", K(ret), K(*agg_expr));
      } else if (OB_ISNULL(new_expr)) {
        if (OB_FAIL(tmp_agg_exprs.push_back(agg_expr))) {
          LOG_WARN("failed to remove item", K(ret), K(*agg_expr));
        }
      } else if (OB_FAIL(old_exprs.push_back(agg_expr))) {
        LOG_WARN("failed to push back into old_exprs", K(ret));
      } else if (OB_FAIL(new_exprs.push_back(new_expr))) {
        LOG_WARN("failed to push back into new_exprs", K(ret));
      }
    }
  }
  // 3. do the replacement
  if (OB_SUCC(ret)) {
    ObStmtExprReplacer replacer;
    replacer.remove_all();
    replacer.set_recursive(false);
    replacer.add_scope(SCOPE_SELECT);
    replacer.add_scope(SCOPE_HAVING);
    ObSEArray<ObRawExpr*, 4> skip_exprs;
    if (OB_FAIL(substmt.get_aggr_items().assign(tmp_agg_exprs))) {
      LOG_WARN("failed to assign array", K(ret));
    } else if (OB_FAIL(append(skip_exprs, cur_groupby_exprs))) {
      LOG_WARN("failed to append into skip_exprs", K(ret));
    } else if (OB_FAIL(append(skip_exprs, substmt.get_aggr_items()))) {
      LOG_WARN("failed to append into skip_exprs", K(ret));
    } else if (OB_FAIL(replacer.add_replace_exprs(old_exprs, new_exprs, &skip_exprs))) {
      LOG_WARN("failed to add replace exprs", K(ret));
    } else if (OB_FAIL(substmt.iterate_stmt_expr(replacer))) {
      LOG_WARN("failed to iterate stmt expr", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::create_groupby_substmt(const ObIArray<ObRawExpr*> &origin_groupby_exprs,
                                                  const ObIArray<ObRawExpr*> &origin_rollup_exprs,
                                                  ObSelectStmt &origin_stmt,
                                                  ObSelectStmt *&sub_stmt,
                                                  ObIArray<ObRawExpr*> &substmt_exprs)
{
  int ret = OB_SUCCESS;
  ObDMLStmt *stmt_copy = NULL;
  ObSEArray<ObRawExpr*, 4> origin_exprs;
  ObStmtExprGetter origin_visitor;
  origin_visitor.remove_all();
  origin_visitor.add_scope(SCOPE_GROUPBY);
  origin_visitor.set_recursive(false);
  ObStmtExprGetter substmt_visitor;
  substmt_visitor.remove_all();
  substmt_visitor.add_scope(SCOPE_GROUPBY);
  substmt_visitor.set_recursive(false);
  int64_t idx = -1;
  if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->stmt_factory_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected NULL", K(ret), KP(ctx_));
  } else if (OB_FAIL(ObTransformUtils::deep_copy_stmt(*ctx_->stmt_factory_,
                                                      *ctx_->expr_factory_,
                                                      &origin_stmt,
                                                      stmt_copy))) {
    LOG_WARN("failed to deep copy from stmt.", K(ret));
  } else if (OB_ISNULL(sub_stmt = static_cast<ObSelectStmt*>(stmt_copy))) {
    LOG_WARN("failed. get unexpected NULL", K(ret));
  } else if (OB_FAIL(origin_stmt.get_relation_exprs(origin_exprs, origin_visitor))) {
    LOG_WARN("failed to get relation exprs on origin stmt", K(ret));
  } else if (OB_FAIL(sub_stmt->get_relation_exprs(substmt_exprs, substmt_visitor))) {
    LOG_WARN("failed to get relation exprs on substmt", K(ret));
  } else {
    sub_stmt->get_grouping_sets_items().reset();
    sub_stmt->get_rollup_items().reset();
    sub_stmt->get_cube_items().reset();
    sub_stmt->get_rollup_exprs().reset();
    sub_stmt->get_group_exprs().reset();
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < origin_groupby_exprs.count(); ++i) {
    ObRawExpr *expr = NULL;
    if (!ObOptimizerUtil::find_item(origin_exprs, origin_groupby_exprs.at(i), &idx)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("failed. origin exprs should have origin_groupby_exprs.at(i)", K(ret));
    } else if (OB_ISNULL(expr = substmt_exprs.at(idx))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("failed. get unexpected NULL", K(ret));
    } else if (OB_FAIL(sub_stmt->get_group_exprs().push_back(expr))) {
      LOG_WARN("failed to push back to groupby_exprs", K(ret));
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < origin_rollup_exprs.count(); ++i) {
    ObRawExpr *expr = NULL;
    if (!ObOptimizerUtil::find_item(origin_exprs, origin_rollup_exprs.at(i), &idx)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("failed. origin exprs should have origin_rollup_exprs.at(i)", K(ret));
    } else if (OB_ISNULL(expr = substmt_exprs.at(idx))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("failed. get unexpected NULL", K(ret));
    } else if (OB_FAIL(sub_stmt->get_rollup_exprs().push_back(expr))) {
      LOG_WARN("failed to push back to rollup_exprs", K(ret));
    }
  }
  /* case
   * select c1, 1 from t1 group by grouping sets(c1, ()) having sum(c1) > 0
   * --->
   * select c1, 1 from t1 group by c1 having sum(c1) > 0
   * union all
   * select NULL, 1 from t1 group by 1 having sum(c1) > 0;
   */
  if (OB_SUCC(ret) && sub_stmt->get_group_exprs().empty() && sub_stmt->get_rollup_exprs().empty()) {
    ObConstRawExpr *one_expr = NULL;
    if (OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                                     ObNumberType,
                                                     1,
                                                     one_expr))) {
      LOG_WARN("build expr failed", K(ret));
    } else if (OB_FAIL(sub_stmt->get_group_exprs().push_back(one_expr))) {
      LOG_WARN("failed to push back into groupby exprs", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::create_child_stmts_for_groupby_sets(ObSelectStmt *origin_stmt,
                                                               ObIArray<ObSelectStmt*> &child_stmts)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObGroupbyExpr, 4> groupby_exprs_list;
  ObSEArray<ObGroupbyExpr, 4> rollup_exprs_list;
  if (OB_ISNULL(origin_stmt) || OB_ISNULL(ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected NULL", K(ret), KP(origin_stmt), KP(ctx_));
  } else if (OB_FAIL(get_groupby_and_rollup_exprs_list(origin_stmt, groupby_exprs_list, rollup_exprs_list))) {
    LOG_WARN("failed to get groupby and rollup exprs list", K(ret));
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < groupby_exprs_list.count(); ++i) {
      ObSelectStmt *groupby_stmt = NULL;
      ObSEArray<ObRawExpr*, 4> groupby_exprs;
      if (OB_FAIL(create_groupby_substmt(groupby_exprs_list.at(i).groupby_exprs_,
                                         rollup_exprs_list.at(i).groupby_exprs_,
                                         *origin_stmt,
                                         groupby_stmt,
                                         groupby_exprs))) {
        LOG_WARN("failed to init groupby stmt", K(ret));
      } else if (OB_FAIL(convert_select_having_in_groupby_stmt(groupby_exprs_list,
                                                               rollup_exprs_list,
                                                               groupby_exprs,
                                                               i,
                                                               *origin_stmt,
                                                               *groupby_stmt))) {
        LOG_WARN("failed to convert select list and having from grouping sets.", K(ret));
      } else if (OB_FAIL(groupby_stmt->recursive_adjust_statement_id(ctx_->allocator_,
                                                                     ctx_->src_hash_val_,
                                                                     i + 1))) {
        LOG_WARN("failed to recursive adjust statement id", K(ret));
      } else if (OB_FAIL(groupby_stmt->update_stmt_table_id(*origin_stmt))) {
        LOG_WARN("failed to update stmt table id.", K(ret));
      } else if (OB_FAIL(groupby_stmt->formalize_stmt(ctx_->session_info_))) {
        LOG_WARN("failed to formalized stmt.", K(ret));
      } else if (OB_FAIL(child_stmts.push_back(groupby_stmt))) {
        LOG_WARN("failed to push back child stmt");
      }
    }
  }
  return ret;
}

/* as following to create set stmt:
* 1. get total group by stmt count(grouping sets + multi rollup + multi cube)
* 2. deep copy origin stmt;
* 3. generate group by exprs and add stmt;
* 4. deal with stmt other attribute: select list、aggr、column and so on;
* 5. create set stmt.
*/
int ObTransformPreProcess::create_set_view_stmt(ObSelectStmt *stmt, TableItem *view_table_item)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObSelectStmt*, 4> child_stmts;
  ObSelectStmt *parent_stmt = NULL;
  ObSelectStmt *set_view_stmt = NULL;
  if (OB_ISNULL(stmt)||
      OB_ISNULL(view_table_item) ||
      OB_ISNULL(parent_stmt = view_table_item->ref_query_) ||
      OB_ISNULL(ctx_) ||
      OB_ISNULL(ctx_->allocator_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("origin stmt is null", K(ret));
  } else if (OB_FAIL(create_child_stmts_for_groupby_sets(parent_stmt, child_stmts))) {
    LOG_WARN("failed to create child stmts for groupby set stmt", K(ret), K(*parent_stmt));
  } else if (OB_FAIL(ObTransformUtils::create_set_stmt(ctx_, ObSelectStmt::UNION, false,
                                                       child_stmts, set_view_stmt))) {
    LOG_WARN("failed to create set stmt", K(ret));
  } else if (OB_ISNULL(set_view_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (OB_FAIL(set_view_stmt->formalize_stmt(ctx_->session_info_))) {
    LOG_WARN("failed to formalize stmt", K(ret));
  // it is to rename the select items by recreating the select items with same select exprs
  } else if (FALSE_IT(view_table_item->ref_query_ = set_view_stmt)) {
  } else if (OB_FAIL(ObTransformUtils::refresh_select_items_name(*ctx_->allocator_,
                                                                 set_view_stmt))) {
    LOG_WARN("failed to refresh select items name", K(ret));
  } else if (OB_FAIL(ObTransformUtils::refresh_column_items_name(stmt,
                                                                 view_table_item->table_id_))) {
    LOG_WARN("failed to refresh column items name", K(ret));
  }
  return ret;
}

/*
 *  just do combination bewteen grouping sets
 *  group by grouping sets(c1, c2), grouping sets(rollup(c3), cube(c4)) --->
 *  group by c1, rollup(c3) union all
 *  group by c2, rollup(c3) union all
 *  group by c1, cube(c4) union all
 *  group by c2, cube(c4)
*/
int ObTransformPreProcess::simple_expand_grouping_sets_items(
                                           ObIArray<ObGroupingSetsItem> &grouping_sets_items,
                                           ObIArray<ObGroupingSetsItem> &simple_grouping_sets_items)
{
  int ret = OB_SUCCESS;
  if (grouping_sets_items.empty()) {
    /* do nothing */
  } else {
    int total_cnt = 1;
    for (int64_t i = 0; i < grouping_sets_items.count(); ++i) {
      total_cnt = total_cnt * (grouping_sets_items.at(i).grouping_sets_exprs_.count() +
                               grouping_sets_items.at(i).rollup_items_.count() +
                               grouping_sets_items.at(i).cube_items_.count());
    }
    if (OB_FAIL(simple_grouping_sets_items.prepare_allocate(total_cnt))) {
      LOG_WARN("failed to prepare allocate", K(ret));
    } else {
      for (int64_t i = 0; OB_SUCC(ret) && i < total_cnt; ++i) {
        int64_t bit_count = i;
        int64_t index = 0;
        for (int64_t j = 0; OB_SUCC(ret) && j < grouping_sets_items.count(); ++j) {
          ObGroupingSetsItem &item = grouping_sets_items.at(j);
          int64_t item_count = item.grouping_sets_exprs_.count() + item.rollup_items_.count() +
                               item.cube_items_.count();
          index = bit_count % (item_count);
          bit_count = bit_count / (item_count);
          if (index < item.grouping_sets_exprs_.count()) {
            if (OB_FAIL(simple_grouping_sets_items.at(i).grouping_sets_exprs_.push_back(
                        item.grouping_sets_exprs_.at(index)))) {
              LOG_WARN("failed to push back item", K(ret));
            }
          } else if (index >= item.grouping_sets_exprs_.count() &&
                     index < item.grouping_sets_exprs_.count() + item.rollup_items_.count()) {
            if (OB_FAIL(simple_grouping_sets_items.at(i).rollup_items_.push_back(
                        item.rollup_items_.at(index - item.grouping_sets_exprs_.count())))) {
              LOG_WARN("failed to push back item", K(ret));
            }
          } else if (index >= item.grouping_sets_exprs_.count() + item.rollup_items_.count() &&
                     index < item.grouping_sets_exprs_.count() + item.rollup_items_.count() +
                             item.cube_items_.count()) {
            if (OB_FAIL(simple_grouping_sets_items.at(i).cube_items_.push_back(
                        item.cube_items_.at(index - item.grouping_sets_exprs_.count() -
                                            item.rollup_items_.count())))) {
              LOG_WARN("failed to push back item", K(ret));
            }
          } else {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get unexpected error", K(ret), K(index), K(item.grouping_sets_exprs_.count()),
                     K(item.rollup_items_.count()), K(item.cube_items_.count()));
          }
        }
      }
    }
  }
  return ret;
}

/*
 * 1. cube(c1, c2, c3) ---> rollup(c1) X rollup(c2) X rollup(c3)
*/
int ObTransformPreProcess::expand_cube_item(ObCubeItem &cube_item,
                                            common::ObIArray<ObRollupItem> &rollup_items) {
  int ret = OB_SUCCESS;
  for (int64_t i = 0; OB_SUCC(ret) && i < cube_item.cube_list_exprs_.count(); ++i) {
    ObRollupItem rollup_item;
    if (OB_FAIL(rollup_item.rollup_list_exprs_.push_back(cube_item.cube_list_exprs_.at(i)))) {
      LOG_WARN("failed to append item", K(ret));
    } else if (OB_FAIL(rollup_items.push_back(rollup_item))) {
      LOG_WARN("failed to push back item", K(ret));
    }
  }
  return ret;
}

/*
 * 1. cube(c1, c2, c3), cube(c1, c2) ---> rollup(c1), rollup(c2), rollup(c3), rollup(c1), rollup(c2)
*/
int ObTransformPreProcess::expand_cube_items(common::ObIArray<ObCubeItem> &cube_items,
                                             common::ObIArray<ObRollupItem> &rollup_items)
{
  int ret = OB_SUCCESS;
  for (int64_t i = 0; OB_SUCC(ret) && i < cube_items.count(); ++i) {
    ObCubeItem &cube_item = cube_items.at(i);
    if (OB_FAIL(expand_cube_item(cube_item, rollup_items))) {
      LOG_WARN("failed expand multi cube item", K(ret), K(cube_items), K(i));
    }
  }
  return ret;
}

int ObTransformPreProcess::get_groupby_exprs_list(ObIArray<ObGroupingSetsItem> &grouping_sets_items,
                                                  ObIArray<ObRollupItem> &rollup_items,
                                                  ObIArray<ObCubeItem> &cube_items,
                                                  ObIArray<ObGroupbyExpr> &groupby_exprs_list)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObGroupbyExpr, 4> grouping_sets_exprs_list;
  ObSEArray<ObGroupbyExpr, 4> rollup_exprs_list;
  ObSEArray<ObGroupbyExpr, 4> tmp_groupby_exprs_list;
  ObSEArray<ObRollupItem, 4> tmp_rollup_items;
  ObSEArray<ObGroupbyExpr, 4> tmp_rollup_exprs_list;
  if (OB_FAIL(expand_grouping_sets_items(grouping_sets_items, grouping_sets_exprs_list))) {
    LOG_WARN("failed to expand grouping sets items", K(ret));
  } else if (OB_FAIL(expand_rollup_items(rollup_items, rollup_exprs_list))) {
    LOG_WARN("failed to expand grouping sets items", K(ret));
  } else if (OB_FAIL(combination_two_rollup_list(grouping_sets_exprs_list,
                                                 rollup_exprs_list,
                                                 tmp_groupby_exprs_list))) {
    LOG_WARN("failed to expand grouping sets items", K(ret));
  } else if (OB_FAIL(expand_cube_items(cube_items, tmp_rollup_items))){
    LOG_WARN("failed to expand multi cube items", K(ret));
  } else if (OB_FAIL(expand_rollup_items(tmp_rollup_items, tmp_rollup_exprs_list))) {
    LOG_WARN("failed to expand grouping sets items", K(ret));
  } else if (OB_FAIL(combination_two_rollup_list(tmp_groupby_exprs_list,
                                                 tmp_rollup_exprs_list,
                                                 groupby_exprs_list))) {
    LOG_WARN("failed to expand grouping sets items", K(ret));
  } else {
    LOG_TRACE("succeed to get groupby exprs list", K(grouping_sets_exprs_list),
                                                   K(rollup_exprs_list),
                                                   K(cube_items),
                                                   K(groupby_exprs_list));
  }
  return ret;
}

/*
 * transform_grouping_sets_to_rollup_exprs should do things like
 * origin_groupby_exprs_list = [(c1, c2, c3), (c1, c2), c1]
 * --->
 * rollup(c2, c3), c1
 * but not support now
 */
int ObTransformPreProcess::transform_grouping_sets_to_rollup_exprs(ObSelectStmt &origin_stmt,
                                                ObIArray<ObGroupbyExpr> &origin_groupby_exprs_list,
                                                ObIArray<ObGroupbyExpr> &groupby_exprs_list,
                                                ObIArray<ObGroupbyExpr> &rollup_exprs_list)
{
  int ret = OB_SUCCESS;
  ObIArray<ObRawExpr*> &groupby_exprs = origin_stmt.get_group_exprs();
  ObIArray<ObRawExpr*> &rollup_exprs = origin_stmt.get_rollup_exprs();
  /* TODO GROUPING_SETS:
   * 1. Do transform grouping sets to rollup in the future.
   * 2. And what is more, if has_group_id = true, remember to handle it.
   */
  for (int64_t i = 0; OB_SUCC(ret) && i < origin_groupby_exprs_list.count(); ++i) {
    ObGroupbyExpr groupby_expr;
    ObGroupbyExpr rollup_expr;
    if (OB_FAIL(groupby_exprs_list.push_back(groupby_expr))) {
      LOG_WARN("failed to push_back groupby_exprs_list", K(ret));
    } else if (OB_FAIL(rollup_exprs_list.push_back(rollup_expr))) {
      LOG_WARN("failed to push_back rollup_exprs_list", K(ret));
    } else if (OB_FAIL(append_array_no_dup(groupby_exprs_list.at(i).groupby_exprs_, groupby_exprs))) {
      LOG_WARN("failed to append array no dup", K(ret));
    } else if (OB_FAIL(append_array_no_dup(groupby_exprs_list.at(i).groupby_exprs_,
                                            origin_groupby_exprs_list.at(i).groupby_exprs_))) {
      LOG_WARN("failed to push back", K(ret));
    } else if (OB_FAIL(append(rollup_exprs_list.at(i).groupby_exprs_, rollup_exprs))) {
      LOG_WARN("failed to append", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::get_groupby_and_rollup_exprs_list(ObSelectStmt *origin_stmt,
                                                        ObIArray<ObGroupbyExpr> &groupby_exprs_list,
                                                        ObIArray<ObGroupbyExpr> &rollup_exprs_list)
{
  int ret = OB_SUCCESS;
  ObIArray<ObGroupingSetsItem> &grouping_sets_items = origin_stmt->get_grouping_sets_items();
  ObIArray<ObRollupItem> &rollup_items = origin_stmt->get_rollup_items();
  ObIArray<ObCubeItem> &cube_items = origin_stmt->get_cube_items();
  ObSEArray<ObGroupbyExpr, 4> temp_groupby_exprs_list;
  if (OB_ISNULL(origin_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("origin stmt is NULL", K(ret), K(origin_stmt));
  } else if (OB_FAIL(get_groupby_exprs_list(grouping_sets_items,
                                            rollup_items,
                                            cube_items,
                                            temp_groupby_exprs_list))) {
    LOG_WARN("failed to get group by exprs list", K(ret));
  } else if (temp_groupby_exprs_list.empty()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("temp_groupby_exprs_list is empty", K(ret));
  } else if (OB_FAIL(transform_grouping_sets_to_rollup_exprs(*origin_stmt,
                                                             temp_groupby_exprs_list,
                                                             groupby_exprs_list,
                                                             rollup_exprs_list))) {
    LOG_WARN("failed to transform_grouping_sets_to_rollup_exprs", K(ret));
  } else if (groupby_exprs_list.count() != rollup_exprs_list.count() ||
             groupby_exprs_list.count() != temp_groupby_exprs_list.count()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("groupby_exprs_list is not same size to rollup_exprs_list or temp_groupby_exprs_list",
             K(ret), K(temp_groupby_exprs_list), K(groupby_exprs_list), K(rollup_exprs_list));
  } else { /* do nothing */ }
  return ret;
}
/*@brief,ObTransformPreProcess::expand_grouping_sets_items,Creating a complete group exprs. such as:
 * select c1,c2,c3,c4 from t1 group by grouping sets(c1,c2), grouping sets(c3,c4);
 * <==>
 * select c1,NULL,c3,NULL from t1 group by c1,c3
 * union all
 * select c1,NULL,NULL,c4 from t1 group by c1,c4
 * union all
 * select NULL,c2,c3,NULL from t1 group by c2,c3
 * union all
 * select NULL,c2,NULL,c4 from t1 group by c2,c4;
 * as above example, multi grouping sets is actually grouping sets cartesian product.
 */
int ObTransformPreProcess::expand_grouping_sets_items(
                                                  ObIArray<ObGroupingSetsItem> &grouping_sets_items,
                                                  ObIArray<ObGroupbyExpr> &grouping_sets_exprs)
{
  int ret = OB_SUCCESS;
  typedef ObSEArray<ObGroupingSetsItem, 4> GroupingSetsArray;
  SMART_VAR(GroupingSetsArray, tmp_grouping_sets_items) {
    if (OB_FAIL(simple_expand_grouping_sets_items(grouping_sets_items, tmp_grouping_sets_items))) {
      LOG_WARN("failed to simple expand grouping_sets_items", K(ret));
    } else {
      for (int64_t i = 0; OB_SUCC(ret) && i < tmp_grouping_sets_items.count(); ++i) {
        ObGroupbyExpr groupby_item;
        for (int64_t j = 0; OB_SUCC(ret) && j < tmp_grouping_sets_items.at(i).grouping_sets_exprs_.count(); ++j) {
          if (OB_FAIL(append(groupby_item.groupby_exprs_,
                        tmp_grouping_sets_items.at(i).grouping_sets_exprs_.at(j).groupby_exprs_))) {
            LOG_WARN("failed to append exprs", K(ret));
          } else {/*do nothing*/}
        }
        // multi cube -> multi rollup
        if (OB_SUCC(ret) && tmp_grouping_sets_items.at(i).cube_items_.count() > 0) {
          ObSEArray<ObRollupItem, 4> tmp_rollup_items;
          if (OB_FAIL(expand_cube_items(tmp_grouping_sets_items.at(i).cube_items_,
                                        tmp_rollup_items))) {
            LOG_WARN("failed to expand multi rollup items", K(ret));
          } else if (OB_FAIL(append(tmp_grouping_sets_items.at(i).rollup_items_,
                                    tmp_rollup_items))) {
            LOG_WARN("failed to append tmp multi rollup items", K(ret));
          } else {/* do nothing */}
        }
        if (OB_SUCC(ret)) {
          if (tmp_grouping_sets_items.at(i).rollup_items_.count() > 0) {
            ObSEArray<ObGroupbyExpr, 4> groupby_exprs_list;
            if (OB_FAIL(expand_rollup_items(tmp_grouping_sets_items.at(i).rollup_items_,
                                            groupby_exprs_list))) {
              LOG_WARN("failed to expand multi rollup items", K(ret));
            } else {
              for (int64_t k = 0; OB_SUCC(ret) && k < groupby_exprs_list.count(); ++k) {
                if (OB_FAIL(append(groupby_exprs_list.at(k).groupby_exprs_,
                                   groupby_item.groupby_exprs_))) {
                  LOG_WARN("failed to append exprs", K(ret));
                } else if (OB_FAIL(grouping_sets_exprs.push_back(groupby_exprs_list.at(k)))) {
                  LOG_WARN("failed to push back groupby exprs", K(ret));
                } else {/*do nothing*/}
              }
            }
          } else if (OB_FAIL(grouping_sets_exprs.push_back(groupby_item))) {
            LOG_WARN("failed to push back item", K(ret));
          } else {/*do nothing*/}
        }
      }
    }
  }
  return ret;
}

/*
rollup(c1), rollup(c2) --->
[(), c1, c2, (c1, c2)]
*/
int ObTransformPreProcess::expand_rollup_items(ObIArray<ObRollupItem> &rollup_items,
                                               ObIArray<ObGroupbyExpr> &rollup_list_exprs)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObGroupbyExpr, 4> result_rollup_list_exprs;
  for (int64_t i = 0; OB_SUCC(ret) && i < rollup_items.count(); ++i) {
    ObRollupItem &rollup_item = rollup_items.at(i);
    ObSEArray<ObGroupbyExpr, 4> tmp_rollup_list_exprs;
    ObGroupbyExpr empty_item;
    if (OB_FAIL(tmp_rollup_list_exprs.push_back(empty_item))) {
      LOG_WARN("failed to push back item", K(ret));
    } else {
      for (int64_t j = 0; OB_SUCC(ret) && j < rollup_item.rollup_list_exprs_.count(); ++j) {
        ObGroupbyExpr item;
        if (OB_FAIL(append(item.groupby_exprs_, tmp_rollup_list_exprs.at(j).groupby_exprs_))) {
          LOG_WARN("failed to append exprs", K(ret));
        } else if (OB_FAIL(append(item.groupby_exprs_,
                                  rollup_item.rollup_list_exprs_.at(j).groupby_exprs_))) {
          LOG_WARN("failed to append exprs", K(ret));
        } else if (OB_FAIL(tmp_rollup_list_exprs.push_back(item))) {
          LOG_WARN("failed to push back item", K(ret));
        } else {/*do nothing*/}
      }
      if (OB_SUCC(ret)) {
        if (OB_FAIL(combination_two_rollup_list(result_rollup_list_exprs,
                                                tmp_rollup_list_exprs,
                                                rollup_list_exprs))) {
          LOG_WARN("failed to combination two rollup list", K(ret));
        } else if (OB_FAIL(result_rollup_list_exprs.assign(rollup_list_exprs))) {
          LOG_WARN("failed to assign exprs", K(ret));
        } else {/*do nothing*/}
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::combination_two_rollup_list(ObIArray<ObGroupbyExpr> &rollup_list_exprs1,
                                                       ObIArray<ObGroupbyExpr> &rollup_list_exprs2,
                                                       ObIArray<ObGroupbyExpr> &rollup_list_exprs)
{
  int ret = OB_SUCCESS;
  rollup_list_exprs.reset();
  if (rollup_list_exprs1.count() == 0 && rollup_list_exprs2.count() > 0) {
    if (OB_FAIL(append(rollup_list_exprs, rollup_list_exprs2))) {
      LOG_WARN("failed to append exprs", K(ret));
    } else {/*do nothing*/}
  } else if (rollup_list_exprs1.count() > 0 && rollup_list_exprs2.count() == 0) {
    if (OB_FAIL(append(rollup_list_exprs, rollup_list_exprs1))) {
      LOG_WARN("failed to append exprs", K(ret));
    } else {/*do nothing*/}
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < rollup_list_exprs1.count(); ++i) {
      for (int64_t j = 0; OB_SUCC(ret) && j < rollup_list_exprs2.count(); ++j) {
        ObGroupbyExpr item;
        if (OB_FAIL(append(item.groupby_exprs_,
                          rollup_list_exprs1.at(i).groupby_exprs_))) {
          LOG_WARN("failed to append exprs", K(ret));
        } else if (OB_FAIL(append(item.groupby_exprs_,
                                  rollup_list_exprs2.at(j).groupby_exprs_))) {
          LOG_WARN("failed to append exprs", K(ret));
        } else if (OB_FAIL(rollup_list_exprs.push_back(item))) {
          LOG_WARN("failed to push back item", K(ret));
        } else {/*do nothing*/}
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_for_hierarchical_query(ObDMLStmt *stmt,
                                                            bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("param is null", K(ret));
  } else if (stmt->is_hierarchical_query()) {
    ObSelectStmt *select_stmt = static_cast<ObSelectStmt *>(stmt);
    ObSelectStmt *hierarchical_stmt = NULL;
    TableItem *table = NULL;
    //connect by视图分离
    if (OB_FAIL(stmt->formalize_stmt(ctx_->session_info_))) {
        LOG_WARN("failed to formalize stmt", K(ret));
    } else if (OB_FAIL(try_split_hierarchical_query(*select_stmt, hierarchical_stmt))) {
      LOG_WARN("failed to try split hierarchical query", K(ret));
    } else if (OB_ISNULL(hierarchical_stmt)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null stmt", K(ret));
    } else if (OB_FAIL(create_and_mock_join_view(*hierarchical_stmt))) {
      LOG_WARN("failed to transform from item", K(ret));
    } else {
      trans_happened = true;
    }
  }
  return ret;
}

int ObTransformPreProcess::try_split_hierarchical_query(ObSelectStmt &stmt,
                                                        ObSelectStmt *&hierarchical_stmt)
{
  int ret = OB_SUCCESS;
  bool need_split = false;
  TableItem *table = NULL;
  if (OB_FAIL(check_need_split_hierarchical_query(stmt, need_split))) {
    LOG_WARN("failed to check need split hierarchical query", K(ret));
  } else if (!need_split) {
    hierarchical_stmt = &stmt;
  } else if (OB_FAIL(create_connect_by_view(stmt))) {
    LOG_WARN("failed to create connect by view", K(ret));
  } else if (OB_UNLIKELY(stmt.get_table_size() != 1)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect table size after create connect by view", K(stmt.get_table_size()), K(ret));
  } else if (OB_ISNULL(table = stmt.get_table_item(0))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item is null", K(ret));
  } else if (OB_UNLIKELY(!table->is_generated_table())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expect generated table after create connect by view", K(ret));
  } else if (OB_ISNULL(table->ref_query_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null ref query", K(ret));
  } else {
    hierarchical_stmt = table->ref_query_;
  }
  return ret;
}

int ObTransformPreProcess::check_need_split_hierarchical_query(ObSelectStmt &stmt, bool &need_split)
{
  int ret = OB_SUCCESS;
  need_split = false;
  if (stmt.has_subquery()
      || (stmt.has_order_by() && !stmt.is_order_siblings())
      || stmt.has_distinct()
      || stmt.has_group_by()
      || stmt.has_rollup()
      || stmt.has_window_function()
      || stmt.has_limit()
      || stmt.is_contains_assignment()
      || stmt.has_sequence()
      || stmt.has_ora_rowscn()) {
    need_split = true;
  } else {
    ObSEArray<ObRawExpr *, 8> join_conds;
    ObSEArray<ObRawExpr *, 8> other_conds;
    if (OB_FAIL(classify_join_conds(stmt, join_conds, other_conds))) {
      LOG_WARN("failed to classify join conditions", K(ret));
    } else if (!other_conds.empty()) {
      need_split = true;
    }
  }
  return ret;
}

class ReplaceRownumRowidExpr : public ObIRawExprReplacer
{
public:
  ReplaceRownumRowidExpr(ObSelectStmt *stmt) : view_stmt_(stmt) {}
  virtual int generate_new_expr(ObRawExprFactory &expr_factory,
                                ObRawExpr *old_expr,
                                ObRawExpr *&new_expr)
  {
    int ret = OB_SUCCESS;
    if (OB_ISNULL(old_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("old expr is null", K(ret));
    } else if (old_expr->has_flag(IS_ROWNUM)) {
      if (OB_FAIL(ObRawExprUtils::build_rownum_expr(expr_factory, new_expr))) {
        LOG_WARN("failed to build rownum expr", K(ret));
      } else if (OB_ISNULL(new_expr) || OB_ISNULL(view_stmt_)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("failed to build new expr", K(ret), K(new_expr), K(view_stmt_));
      } else if (OB_FAIL(view_stmt_->get_pseudo_column_like_exprs().push_back(new_expr))) {
        LOG_WARN("failed to add rownum expr into view stmt", K(ret));
      }
    } else if (old_expr->get_expr_type() == T_FUN_SYS_CALC_UROWID) {
      if (OB_FAIL(ObRawExprCopier::copy_expr_node(expr_factory,
                                                  old_expr,
                                                  new_expr))) {
        LOG_WARN("failed to copy calc urowid expr", K(ret));
      } else if (OB_ISNULL(new_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("failed to build new calc rowid expr", K(ret));
      }
    }
    return ret;
  }
  ObSelectStmt *view_stmt_;
};

int ObTransformPreProcess::create_connect_by_view(ObSelectStmt &stmt)
{
  int ret = OB_SUCCESS;
  //把层次查询相关的运算全都封装在view内部
  ObSelectStmt* view_stmt = NULL;
  ObStmtFactory *stmt_factory = NULL;
  ObRawExprFactory *expr_factory = NULL;
  ObSQLSessionInfo *session_info = NULL;
  //connect by view需要投影出来的表达式
  ObSEArray<ObRawExpr *, 4> select_list;
  //LEVEL、CONNECT_BY_ISLEAF、CONNECT_BY_ISCYCLE
  //CONNECT_BY_ROOT、PRIOR、CONNECT_BY_PATH表达式
  ObSEArray<ObRawExpr *, 4> connect_by_related_exprs;
  if (OB_ISNULL(ctx_) ||
      OB_ISNULL(session_info = ctx_->session_info_) ||
      OB_ISNULL(stmt_factory = ctx_->stmt_factory_) ||
      OB_ISNULL(expr_factory = ctx_->expr_factory_) ||
      OB_ISNULL(ctx_->allocator_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(stmt_factory), K(expr_factory),
                                    K(stmt), K(ret));
  } else if (OB_FAIL(stmt_factory->create_stmt<ObSelectStmt>(view_stmt))) {
    LOG_WARN("failed to create stmt", K(ret));
  } else if (OB_FAIL(view_stmt->ObDMLStmt::assign(stmt))) {
    LOG_WARN("failed to assign stmt", K(ret));
  } else if (OB_FAIL(view_stmt->adjust_statement_id(ctx_->allocator_,
                                                    ctx_->src_qb_name_,
                                                    ctx_->src_hash_val_))) {
    LOG_WARN("failed to adjust statement id", K(ret));
  } else {
    view_stmt->set_stmt_type(stmt::T_SELECT);
    /*in:
    ObDMLStmt::assign won't assign has_prior/order_siblings/is_hierarchical_query. 
    So we need to set it manually.
    */
   view_stmt->set_has_prior(stmt.has_prior());
   view_stmt->set_order_siblings(stmt.is_order_siblings());
   view_stmt->set_hierarchical_query(stmt.is_hierarchical_query());
  // 1. handle table, columns, from
  // dml_stmt: from table, semi table, joined table
    stmt.get_semi_infos().reuse();
    stmt.get_column_items().reuse();
    stmt.get_part_exprs().reset();
    stmt.get_check_constraint_items().reset();
    stmt.set_hierarchical_query(false);
    //prior相关表达式放在视图内计算
    stmt.set_has_prior(false);
    if (stmt.is_order_siblings()) {
      //order by siblings需要放到视图内计算
      stmt.get_order_items().reset();
      stmt.set_order_siblings(false);
    } else {
      //普通order by需要在层次查询完再计算
    }
  }
  // 2. handle where conditions
  if (OB_SUCC(ret)) {
    ObSEArray<ObRawExpr *, 8> join_conds;
    ObSEArray<ObRawExpr *, 8> other_conds;
    if (OB_FAIL(classify_join_conds(stmt, join_conds, other_conds))) {
      LOG_WARN("failed to classify join conditions", K(ret));
    } else if (OB_FAIL(stmt.get_condition_exprs().assign(other_conds))) {
      LOG_WARN("failed to assign rownum conditions", K(ret));
    } else if (OB_FAIL(view_stmt->get_condition_exprs().assign(join_conds))) {
      LOG_WARN("failed to assign normal conditions", K(ret));
    } else {
      stmt.reset_table_items();
      stmt.get_joined_tables().reuse();
      stmt.clear_from_items();
      if (OB_FAIL(stmt.rebuild_tables_hash())) {
        LOG_WARN("failed to rebuild tables hash", K(ret));
      }
    }
  }
  // 3. handle clauses processed by the upper_stmt
  if (OB_SUCC(ret)) {
    // consider following parts:
    // select: group-by, rollup, select subquery, window function, distinct, sequence,
    //         order by, limit, select into, connect by
    if (!view_stmt->is_order_siblings()) {
      //普通的order by需要在上层stmt计算
      view_stmt->get_order_items().reset();
    } else {
      //sibling order在层次查询内部计算
    }
    view_stmt->set_limit_offset(NULL, NULL);
    view_stmt->set_limit_percent_expr(NULL);
    view_stmt->set_fetch_with_ties(false);
    view_stmt->set_has_fetch(false);
    view_stmt->clear_sequence();
    view_stmt->set_select_into(NULL);
    view_stmt->get_pseudo_column_like_exprs().reset();
    //填充层次查询信息
    view_stmt->set_hierarchical_query(true);
    view_stmt->set_nocycle(stmt.is_nocycle());
    ObRawExprCopier copier(*expr_factory);
    ReplaceRownumRowidExpr replacer(view_stmt);
    if (OB_FAIL(copier.copy_on_replace(stmt.get_start_with_exprs(),
                                       view_stmt->get_start_with_exprs(),
                                       &replacer))) {
      LOG_WARN("failed to generate start with expr", K(ret));
    } else if (OB_FAIL(copier.copy_on_replace(stmt.get_connect_by_exprs(),
                                              view_stmt->get_connect_by_exprs(),
                                              &replacer))) {
      LOG_WARN("failed to copy and replace connect by expr", K(ret));
    } else {
      stmt.get_start_with_exprs().reset();
      stmt.get_connect_by_exprs().reset();
    }
  }
  // 4. 处理 connect by related expr
  if (OB_SUCC(ret)) {
    //提取所有层次查询相关表达式，在层次查询内计算，然后投影出来
    if (OB_FAIL(extract_connect_by_related_exprs(stmt, connect_by_related_exprs))) {
      LOG_WARN("failed to extract connect by related exprs", K(ret));
    }
  }
  // 5. finish creating the child stmts
  if (OB_SUCC(ret)) {
    // create select list
    ObSEArray<ObRawExpr *, 4> columns;
    ObSqlBitSet<> from_tables;
    ObSEArray<ObRawExpr*, 16> shared_exprs;
    if (OB_FAIL(view_stmt->get_from_tables(from_tables))) {
      LOG_WARN("failed to get from tables", K(ret));
    } else if (OB_FAIL(view_stmt->get_column_exprs(columns))) {
      LOG_WARN("failed to get column exprs", K(ret));
    } else if (OB_FAIL(ObTransformUtils::extract_table_exprs(*view_stmt,
                                                             columns,
                                                             from_tables,
                                                             select_list))) {
      LOG_WARN("failed to extract table exprs", K(ret));
    } else if (OB_FAIL(append(select_list, connect_by_related_exprs))) {
      LOG_WARN("failed to append connect by related exprs", K(ret));
    } else if (OB_FAIL(ObTransformUtils::create_select_item(*ctx_->allocator_,
                                                            select_list,
                                                            view_stmt))) {
      LOG_WARN("failed to create select items", K(ret));
    } else if (OB_FAIL(ObTransformUtils::extract_shared_expr(&stmt,
                                                             view_stmt,
                                                             shared_exprs))) {
      LOG_WARN("failed to extract shared expr", K(ret));
    } else if (OB_FAIL(ObOptimizerUtil::remove_item(shared_exprs, select_list))) {
      LOG_WARN("failed to remove duplicate exprs", K(ret));
    } else if (OB_FAIL(ObTransformUtils::create_select_item(*ctx_->allocator_,
                                                            shared_exprs,
                                                            view_stmt))) {
      LOG_WARN("failed to create select items", K(ret));
    } else if (view_stmt->get_select_item_size() == 0 &&
                OB_FAIL(ObTransformUtils::create_dummy_select_item(*view_stmt, ctx_))) {
      LOG_WARN("failed to create dummy select item", K(ret));
    } else if (OB_FAIL(view_stmt->adjust_subquery_list())) {
      LOG_WARN("failed to adjust subquery list", K(ret));
    } else if (OB_FAIL(ObTransformUtils::adjust_pseudo_column_like_exprs(*view_stmt))) {
      LOG_WARN("failed to adjust pseudo column like exprs", K(ret));
    }
  }
  // 6. link upper stmt and view stmt
  TableItem *table_item = NULL;
  ObSEArray<ObRawExpr *, 4> columns;
  if (OB_SUCC(ret)) {
    if (OB_FAIL(ObOptimizerUtil::remove_item(stmt.get_subquery_exprs(),
                                             view_stmt->get_subquery_exprs()))) {
      LOG_WARN("failed to remove subqueries", K(ret));
    } else if (OB_FAIL(ObTransformUtils::add_new_table_item(ctx_,
                                                            &stmt,
                                                            view_stmt,
                                                            table_item))) {
      LOG_WARN("failed to add new table item", K(ret));
    } else if (OB_ISNULL(table_item)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("table item is null", K(ret));
    } else if (OB_FAIL(stmt.add_from_item(table_item->table_id_))) {
      LOG_WARN("failed to add from item", K(ret));
    } else if (OB_FAIL(ObTransformUtils::create_columns_for_view(ctx_,
                                                                 *table_item,
                                                                 &stmt,
                                                                 columns))) {
      LOG_WARN("failed to create columns for view", K(ret));
    }
  }
  // 7. formalize
  if (OB_SUCC(ret)) {
    ObSEArray<ObRawExpr *, 4> view_output;
    ObSEArray<ObRawExpr *, 4> view_columns;
    if (OB_FAIL(stmt.get_view_output(*table_item, view_output, view_columns))) {
      LOG_WARN("failed to get view output", K(ret));
    } else if (OB_FAIL(stmt.replace_relation_exprs(view_output, view_columns))) {
      LOG_WARN("failed to replace inner stmt expr", K(ret));
    } else if (OB_FAIL(ObTransformUtils::adjust_pseudo_column_like_exprs(stmt))) {
      LOG_WARN("failed to adjust pseudo column like exprs", K(ret));
    } else if (OB_FAIL(stmt.formalize_stmt(session_info))) {
      LOG_WARN("failed to formalize stmt", K(ret));
    }
  }
  return ret;
}

/**
 * @brief create_and_mock_join_view
 * 层次查询会把所有的连接运算封装到视图内部计算，
 * 处理时会生成两个相同的视图，第一个做个root节点
 * 生成子计划，第二个作为子节点的生成子计划，在这里
 * start with会预处理放入第一个视图内，其他表达式
 * 引用第二个视图
 */
int ObTransformPreProcess::create_and_mock_join_view(ObSelectStmt &stmt)
{
  int ret = OB_SUCCESS;
  bool has_for_update = false;
  ObSelectStmt* left_view_stmt = NULL;
  ObSelectStmt* right_view_stmt = NULL;
  ObStmtFactory *stmt_factory = NULL;
  ObRawExprFactory *expr_factory = NULL;
  ObSQLSessionInfo *session_info = NULL;
  ObSEArray<ObRawExpr *, 4> select_list;
  if (OB_ISNULL(ctx_) ||
      OB_ISNULL(session_info = ctx_->session_info_) ||
      OB_ISNULL(stmt_factory = ctx_->stmt_factory_) ||
      OB_ISNULL(expr_factory = ctx_->expr_factory_) ||
      OB_ISNULL(ctx_->allocator_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(stmt_factory), K(expr_factory),
                                    K(stmt), K(ret));
  } else if (OB_FAIL(stmt_factory->create_stmt<ObSelectStmt>(left_view_stmt))) {
    LOG_WARN("failed to create stmt", K(ret));
  } else if (OB_FAIL(stmt_factory->create_stmt<ObSelectStmt>(right_view_stmt))) {
    LOG_WARN("failed to create stmt", K(ret));
  } else if (OB_FAIL(left_view_stmt->ObDMLStmt::assign(stmt))) {
    LOG_WARN("failed to assign stmt", K(ret));
  } else if (OB_FAIL(left_view_stmt->adjust_statement_id(ctx_->allocator_,
                                                         ctx_->src_qb_name_,
                                                         ctx_->src_hash_val_))) {
    LOG_WARN("failed to adjust statement id", K(ret));
  } else {
    has_for_update = stmt.has_for_update();
    left_view_stmt->set_stmt_type(stmt::T_SELECT);
    left_view_stmt->set_has_prior(stmt.has_prior());
    left_view_stmt->set_order_siblings(stmt.is_order_siblings());
    left_view_stmt->set_hierarchical_query(stmt.is_hierarchical_query());
  // 1. handle table, columns, from
  // dml_stmt: from table, semi table, joined table
    stmt.reset_table_items();
    stmt.get_joined_tables().reuse();
    stmt.get_semi_infos().reuse();
    stmt.get_column_items().reuse();
    stmt.clear_from_items();
    stmt.get_part_exprs().reset();
    stmt.get_check_constraint_items().reset();
    if (OB_FAIL(stmt.rebuild_tables_hash())) {
      LOG_WARN("failed to rebuild tables hash", K(ret));
    }
  }
  // 2. handle where conditions
  if (OB_SUCC(ret)) {
    ObRawExprCopier copier(*expr_factory);
    ReplaceRownumRowidExpr replacer(left_view_stmt);
    if (OB_FAIL(left_view_stmt->get_condition_exprs().assign(stmt.get_condition_exprs()))) {
      LOG_WARN("failed to assign conditions", K(ret));
    } else if (OB_FAIL(copier.copy_on_replace(stmt.get_start_with_exprs(),
                                              left_view_stmt->get_start_with_exprs(),
                                              &replacer))) {
      LOG_WARN("failed to copy on replace start with exprs", K(ret));
    } else {
      stmt.get_condition_exprs().reset();
      stmt.get_start_with_exprs().reset();
    }
  }
  // 3. handle clauses processed by the upper_stmt
  if (OB_SUCC(ret)) {
    // consider following parts:
    // select: group-by, rollup, select subquery, window function, distinct, sequence,
    //         order by, limit, select into, start with, connect by
    left_view_stmt->get_order_items().reset();
    left_view_stmt->set_limit_offset(NULL, NULL);
    left_view_stmt->set_limit_percent_expr(NULL);
    left_view_stmt->set_fetch_with_ties(false);
    left_view_stmt->set_has_fetch(false);
    left_view_stmt->clear_sequence();
    left_view_stmt->set_select_into(NULL);
    left_view_stmt->get_pseudo_column_like_exprs().reset();
    left_view_stmt->get_connect_by_exprs().reset();
    left_view_stmt->set_hierarchical_query(false);
    left_view_stmt->set_has_prior(false);
    left_view_stmt->set_order_siblings(false);
  }
  // 4. finish creating the left child stmts
  if (OB_SUCC(ret)) {
    // create select list
    ObSEArray<ObRawExpr *, 4> columns;
    ObSEArray<ObQueryRefRawExpr *, 4> query_refs;
    ObSqlBitSet<> from_tables;
    ObSEArray<ObRawExpr*, 16> shared_exprs;
    if (OB_FAIL(left_view_stmt->get_from_tables(from_tables))) {
      LOG_WARN("failed to get from tables", K(ret));
    } else if (OB_FAIL(left_view_stmt->get_column_exprs(columns))) {
      LOG_WARN("failed to get column exprs", K(ret));
    } else if (OB_FAIL(ObTransformUtils::extract_table_exprs(*left_view_stmt,
                                                             columns,
                                                             from_tables,
                                                             select_list))) {
      LOG_WARN("failed to extract table exprs", K(ret));
    } else if (OB_FAIL(ObTransformUtils::extract_shared_expr(&stmt,
                                                             left_view_stmt,
                                                             shared_exprs))) {
      LOG_WARN("failed to extract shared expr", K(ret));
    } else if (OB_FAIL(append_array_no_dup(select_list, shared_exprs))) {
      LOG_WARN("failed to append shared exprs", K(ret));
    } else if (OB_FAIL(ObTransformUtils::create_select_item(*ctx_->allocator_,
                                                            select_list,
                                                            left_view_stmt))) {
      LOG_WARN("failed to create select items", K(ret));
    } else if (left_view_stmt->get_select_item_size() == 0 &&
              OB_FAIL(ObTransformUtils::create_dummy_select_item(*left_view_stmt, ctx_))) {
      LOG_WARN("failed to create dummy select item", K(ret));
    } else if (OB_FAIL(left_view_stmt->adjust_subquery_list())) {
      LOG_WARN("failed to adjust subquery list", K(ret));
    }
  }
  // 5. copy left stmt to right stmt
  if (OB_SUCC(ret)) {
    int64_t sub_num = 1;
    if (OB_FAIL(right_view_stmt->deep_copy(*stmt_factory,
                                            *expr_factory,
                                            *left_view_stmt))) {
      LOG_WARN("failed to copy stmt", K(ret));
    } else if (OB_FAIL(right_view_stmt->recursive_adjust_statement_id(ctx_->allocator_,
                                                                      ctx_->src_hash_val_,
                                                                      sub_num))) {
      LOG_WARN("failed to adjust statement id", K(ret));
    } else if (OB_FAIL(right_view_stmt->update_stmt_table_id(*left_view_stmt))) {
      LOG_WARN("failed to update stmt table id", K(ret));
    } else {
      right_view_stmt->get_start_with_exprs().reset();
    }
  }
  // 6. link upper stmt and view stmt
  TableItem *left_table_item = NULL;
  ObSEArray<ObRawExpr *, 4> left_columns;
  TableItem *right_table_item = NULL;
  ObSEArray<ObRawExpr *, 4> right_columns;
  if (OB_SUCC(ret)) {
    //为左右视图创建table item
    if (OB_FAIL(ObTransformUtils::add_new_table_item(ctx_,
                                                     &stmt,
                                                     left_view_stmt,
                                                     left_table_item))) {
      LOG_WARN("failed to add new table item", K(ret));
    } else if (OB_ISNULL(left_table_item)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("table item is null", K(ret));
    } else if (OB_FAIL(ObTransformUtils::create_columns_for_view(ctx_,
                                                                 *left_table_item,
                                                                 &stmt,
                                                                 left_columns))) {
      LOG_WARN("failed to create columns for view", K(ret));
    } else if (OB_FAIL(ObTransformUtils::add_new_table_item(ctx_,
                                                            &stmt,
                                                            right_view_stmt,
                                                            right_table_item))) {
      LOG_WARN("failed to add new table item", K(ret));
    } else if (OB_ISNULL(right_table_item)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("table item is null", K(ret));
    } else if (OB_FAIL(ObTransformUtils::create_columns_for_view(ctx_,
                                                                 *right_table_item,
                                                                 &stmt,
                                                                 right_columns))) {
      LOG_WARN("failed to create columns for copy stmt", K(ret));
    }
  }
  // 7. 预处理start with exprs，放置到第一个视图的where condition
  //调整subquery exprs
  if (OB_SUCC(ret)) {
    if (OB_FAIL(left_view_stmt->add_condition_exprs(left_view_stmt->get_start_with_exprs()))) {
      LOG_WARN("failed to push start with exprs to view", K(ret));
    } else if (OB_FAIL(left_view_stmt->adjust_subquery_list())) {
      LOG_WARN("failed to adjust subquery list", K(ret));
    } else if (OB_FAIL(right_view_stmt->adjust_subquery_list())) {
      LOG_WARN("failed to adjust subquery list", K(ret));
    } else if (OB_FAIL(ObTransformUtils::adjust_pseudo_column_like_exprs(*left_view_stmt))) {
      LOG_WARN("failed to adjust pseudo column like exprs", K(ret));
    } else if (OB_FAIL(ObTransformUtils::adjust_pseudo_column_like_exprs(*right_view_stmt))) {
      LOG_WARN("failed to adjust pseudo column like exprs", K(ret));
    } else {
      left_view_stmt->get_start_with_exprs().reset();
    }
  }
  // 8. 如果stmt有for update标记，需要把标记打在connect by的右侧表上，
  // 同时清除左侧表上的for update标记
  if (OB_SUCC(ret) && has_for_update) {
    for (int64_t i = 0; OB_SUCC(ret) && i < left_view_stmt->get_table_size(); ++i) {
      TableItem *table = left_view_stmt->get_table_item(i);
      if (OB_ISNULL(table)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null table item", K(ret));
      } else {
        table->for_update_ = false;
      }
    }
  }

  // 9. replace prior exprs to left table column
  if (OB_SUCC(ret)) {
    ObSEArray<ObRawExpr *, 4> connect_by_prior_exprs;
    ObSEArray<ObRawExpr *, 4> prior_exprs;
    ObSEArray<ObRawExpr *, 4> converted_exprs;
    ObSEArray<ObRawExpr *, 16> relation_exprs;
    if (OB_FAIL(get_prior_exprs(stmt.get_connect_by_exprs(), connect_by_prior_exprs))) {
      LOG_WARN("failed to get prior exprs", K(ret));
    } else if (OB_FAIL(modify_prior_exprs(*ctx_->expr_factory_,
                                          stmt,
                                          select_list,
                                          right_columns,
                                          connect_by_prior_exprs,
                                          converted_exprs,
                                          false))) {
      LOG_WARN("failed to modify prior exprs", K(ret));
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < converted_exprs.count(); ++i) {
      ObRawExpr *expr = converted_exprs.at(i);
      if (OB_ISNULL(expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("expr is null", K(ret));
      } else if (OB_FAIL(stmt.add_connect_by_prior_expr(expr))) {
        LOG_WARN("failed to add connect by prior expr", K(ret));
      }
    }
    converted_exprs.reuse();
    if (OB_FAIL(ret)) {
    } else if (OB_FAIL(stmt.get_relation_exprs(relation_exprs))) {
      LOG_WARN("get stmt relation exprs fail", K(ret));
    } else if (OB_FAIL(get_prior_exprs(relation_exprs, prior_exprs))) {
      LOG_WARN("failed to get prior exprs", K(ret));
    } else if (OB_FAIL(modify_prior_exprs(*ctx_->expr_factory_,
                                          stmt,
                                          select_list,
                                          left_columns,
                                          prior_exprs,
                                          converted_exprs,
                                          true))) {
      LOG_WARN("failed to modify prior exprs", K(ret));
    } else if (OB_FAIL(stmt.replace_relation_exprs(prior_exprs, converted_exprs))) {
      LOG_WARN("failed to replace stmt expr", K(ret));
    }
  }

  // 10. create connect by joined table
  if (OB_SUCC(ret)) {
    TableItem *joined_table = NULL;
    stmt.get_joined_tables().reset();
    if (OB_FAIL(ObTransformUtils::add_new_joined_table(ctx_, stmt, CONNECT_BY_JOIN,
                                                       left_table_item, right_table_item,
                                                       stmt.get_connect_by_exprs(),
                                                       joined_table,
                                                       true))) {
      LOG_WARN("failed to add new joined table", K(ret));
    } else if (OB_FAIL(stmt.add_from_item(joined_table->table_id_, true))) {
      LOG_WARN("failed to add from item", K(ret));
    } else {
      stmt.clear_connect_by_exprs();
    }
  }

  // 11. replace expr in parent stmt and formalize
  if (OB_SUCC(ret)) {
    if (OB_FAIL(ObOptimizerUtil::remove_item(stmt.get_subquery_exprs(),
                                             left_view_stmt->get_subquery_exprs()))) {
      LOG_WARN("failed to remove subqueries", K(ret));
    } else if (!select_list.empty()
               && OB_FAIL(stmt.replace_relation_exprs(select_list, right_columns))) {
      LOG_WARN("failed to replace inner stmt expr", K(ret));
    } else if (OB_FAIL(ObTransformUtils::adjust_pseudo_column_like_exprs(stmt))) {
      LOG_WARN("failed to adjust pseudo column like exprs", K(ret));
    } else if (OB_FAIL(stmt.formalize_stmt(session_info))) {
      LOG_WARN("failed to formalize stmt", K(ret));
    } else if (OB_FAIL(stmt.formalize_stmt_expr_reference(expr_factory, session_info))) {
      LOG_WARN("failed to formalize stmt expr reference", K(ret));
    }
  }
  // 12. ignore for temp table optimization
  if (OB_SUCC(ret)) {
    if (OB_FAIL(ctx_->temp_table_ignore_stmts_.push_back(left_view_stmt))) {
      LOG_WARN("failed to push back stmt", K(ret));
    } else if (OB_FAIL(ctx_->temp_table_ignore_stmts_.push_back(right_view_stmt))) {
      LOG_WARN("failed to push back stmt", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::classify_join_conds(ObSelectStmt &stmt,
                                              ObIArray<ObRawExpr *> &normal_join_conds,
                                              ObIArray<ObRawExpr *> &other_conds)
{
  int ret = OB_SUCCESS;
  //将where condition分成普通连接条件和其他条件
  //CONNECT_BY_PATH不会出现在where condition中
  for (int64_t i = 0; OB_SUCC(ret) && i < stmt.get_condition_size(); ++i) {
    ObRawExpr *cond_expr = NULL;
    bool in_from_item = false;
    if (OB_ISNULL(cond_expr = stmt.get_condition_expr(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("condition expr is null", K(ret));
    } else if (cond_expr->has_flag(CNT_LEVEL) ||
              cond_expr->has_flag(CNT_CONNECT_BY_ISLEAF) ||
              cond_expr->has_flag(CNT_CONNECT_BY_ISCYCLE) ||
              cond_expr->has_flag(CNT_CONNECT_BY_ROOT) ||
              cond_expr->has_flag(CNT_PRIOR) ||
              cond_expr->has_flag(CNT_SUB_QUERY)) {
      if (OB_FAIL(other_conds.push_back(cond_expr))) {
        LOG_WARN("failed to add condition expr into upper stmt", K(ret));
      }
    } else if (OB_FAIL(is_cond_in_one_from_item(stmt, cond_expr, in_from_item))) {
      LOG_WARN("failed to check cond is in from item", K(ret));
    } else if (!in_from_item) {
      //如果下推的join condition与select expr共享了sub_query expr
      //需要将subquery下推到view，然后构造select expr吐出
      if (OB_FAIL(normal_join_conds.push_back(cond_expr))) {
        LOG_WARN("failed to add condition expr into join view stmt", K(ret));
      }
    } else {
      //from item filter
      if (OB_FAIL(other_conds.push_back(cond_expr))) {
        LOG_WARN("failed to add condition expr into upper stmt", K(ret));
      }
    }
  }
  return ret;
}

/**
 * 例如select * from t1 lef join t2 on xxx , t3
 *        where t1.c1 = t2.c1 and t2.c2 = t3.c2
 * t1.c1 = t2.c1来自一个from item，t2.c2 = t3.c2来自两个from item
 * 所以t1.c1 = t2.c1应该在层次查询之后做，t2.c2 = t3.c2在层次查询之前做。
 */
int ObTransformPreProcess::is_cond_in_one_from_item(ObSelectStmt &stmt,
                                                    ObRawExpr *expr,
                                                    bool &in_from_item)
{
  int ret = OB_SUCCESS;
  TableItem *table = NULL;
  ObSqlBitSet<> table_ids;
  in_from_item = false;
  if (OB_ISNULL(expr)) {
    ret =  OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null expr", K(ret));
  } else if (expr->get_relation_ids().is_empty()) {
    in_from_item = true;
  }
  int64_t N = stmt.get_from_item_size();
  for (int64_t i = 0; OB_SUCC(ret) && !in_from_item && i < N; ++i) {
    table_ids.reuse();
    FromItem &item = stmt.get_from_items().at(i);
    if (item.is_joined_) {
      table = stmt.get_joined_table(item.table_id_);
    } else {
      table = stmt.get_table_item_by_id(item.table_id_);
    }
    if (OB_ISNULL(table)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null table item", K(ret));
    } else if (OB_FAIL(stmt.get_table_rel_ids(table->is_joined_table() ?
                                              *(static_cast<JoinedTable*>(table)) :
                                              *table,
                                              table_ids))) {
      LOG_WARN("failed to get table rel ids", K(ret));
    } else if (expr->get_relation_ids().is_subset(table_ids)) {
      in_from_item = true;
    }
  }
  return ret;
}

int ObTransformPreProcess::extract_connect_by_related_exprs(ObSelectStmt &stmt,
                                                            ObIArray<ObRawExpr*> &special_exprs)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObRawExpr*, 16> relation_exprs;
  if (OB_FAIL(stmt.get_relation_exprs(relation_exprs))) {
    LOG_WARN("failed to relation exprs", K(ret));
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < relation_exprs.count(); i++) {
      ObRawExpr *expr = relation_exprs.at(i);
      if (OB_FAIL(extract_connect_by_related_exprs(expr, special_exprs))) {
        LOG_WARN("failed to extract connect by related exprs", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::extract_connect_by_related_exprs(ObRawExpr *expr,
                                                            ObIArray<ObRawExpr*> &special_exprs)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null expr", K(ret));
  } else if (T_LEVEL == expr->get_expr_type() ||
             T_CONNECT_BY_ISLEAF == expr->get_expr_type() ||
             T_CONNECT_BY_ISCYCLE == expr->get_expr_type() ||
             T_OP_CONNECT_BY_ROOT == expr->get_expr_type() ||
             T_OP_PRIOR == expr->get_expr_type() ||
             T_FUN_SYS_CONNECT_BY_PATH == expr->get_expr_type()) {
    if (ObOptimizerUtil::find_item(special_exprs, expr)) {
      //do nothing
    } else if (OB_FAIL(special_exprs.push_back(expr))) {
      LOG_WARN("failed to push back connect by expr", K(ret));
    }
  } else if (expr->has_flag(CNT_LEVEL) ||
             expr->has_flag(CNT_CONNECT_BY_ISLEAF) ||
             expr->has_flag(CNT_CONNECT_BY_ISCYCLE) ||
             expr->has_flag(CNT_CONNECT_BY_ROOT) ||
             expr->has_flag(CNT_PRIOR) ||
             expr->has_flag(CNT_SYS_CONNECT_BY_PATH)) {
    int64_t N = expr->get_param_count();
    for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
      if (OB_FAIL(extract_connect_by_related_exprs(expr->get_param_expr(i), special_exprs))) {
        LOG_WARN("failed to extract connect by eprs", K(ret));
      }
    }
  } else {
    //do nothing
  }
  return ret;
}

int ObTransformPreProcess::get_prior_exprs(ObIArray<ObRawExpr *> &exprs,
                                           ObIArray<ObRawExpr *> &prior_exprs)
{
  int ret = OB_SUCCESS;
  for (int64_t i = 0; OB_SUCC(ret) && i < exprs.count(); ++i) {
    if (OB_FAIL(get_prior_exprs(exprs.at(i), prior_exprs))) {
      LOG_WARN("failed to get prior exprs", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::get_prior_exprs(ObRawExpr *expr,
                                           ObIArray<ObRawExpr *> &prior_exprs)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr is null", K(ret));
  } else if (T_OP_PRIOR == expr->get_expr_type()) {
    if (OB_FAIL(add_var_to_array_no_dup(prior_exprs, expr))) {
      LOG_WARN("failed to add prior exprs", K(ret));
    }
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
      if (OB_FAIL(SMART_CALL(get_prior_exprs(expr->get_param_expr(i), prior_exprs)))) {
        LOG_WARN("failed to get prior exprs", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::modify_prior_exprs(ObRawExprFactory &expr_factory,
                                              ObSelectStmt &stmt,
                                              const ObIArray<ObRawExpr *> &parent_columns,
                                              const ObIArray<ObRawExpr *> &left_columns,
                                              const ObIArray<ObRawExpr *> &prior_exprs,
                                              ObIArray<ObRawExpr *> &convert_exprs,
                                              const bool only_columns)
{
  int ret = OB_SUCCESS;
  ObRawExprCopier copier(expr_factory);
  if (!parent_columns.empty()
      && OB_FAIL(copier.add_replaced_expr(parent_columns, left_columns))) {
    LOG_WARN("failed to add replaced expr", K(ret));
  }
  for (int64_t i = 0; i < prior_exprs.count() && OB_SUCC(ret); i++) {
    ObRawExpr *raw_expr = prior_exprs.at(i);
    ObRawExpr *new_expr = NULL;
    if (OB_ISNULL(raw_expr) || OB_UNLIKELY(T_OP_PRIOR != raw_expr->get_expr_type())
        || OB_UNLIKELY(1 != raw_expr->get_param_count())
        || OB_ISNULL(raw_expr->get_param_expr(0))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("invalid expr", KPC(raw_expr), K(ret));
    } else if (only_columns && !raw_expr->has_flag(CNT_COLUMN)) {
      // do nothing
    } else if (OB_FAIL(copier.copy_on_replace(raw_expr->get_param_expr(0), new_expr))) {
      LOG_WARN("failed to copy on replace expr", K(ret));
    } else {
      raw_expr = new_expr;
    }
    if (OB_FAIL(ret)) {
    } else if (OB_FAIL(convert_exprs.push_back(raw_expr))) {
      LOG_WARN("failed to push back new prior param expr", K(ret));
    }
  }
  return ret;
}

uint64_t ObTransformPreProcess::get_real_tid(uint64_t tid, ObSelectStmt &stmt)
{
  uint64_t real_tid = OB_INVALID_ID;
  for (int64_t i = 0; i < stmt.get_table_size(); i ++) {
    TableItem *table_item = stmt.get_table_item(i);
    if (tid == table_item->table_id_) {
      real_tid = table_item->ref_id_;
      break;
    }
  }
  return real_tid;
}

int ObTransformPreProcess::eliminate_having(ObDMLStmt *stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected NULL pointer", K(stmt), K(ret));
  } else if (!stmt->is_select_stmt()) {
    // do nothing
  } else {
    ObSelectStmt *select_stmt = static_cast<ObSelectStmt *>(stmt);
    if (!select_stmt->has_group_by() && !select_stmt->get_having_exprs().empty()) {
      if (OB_FAIL(append(select_stmt->get_condition_exprs(), select_stmt->get_having_exprs()))) {
        LOG_WARN("failed to append condition exprs", K(ret));
      } else {
        select_stmt->get_having_exprs().reset();
        trans_happened = true;
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::replace_func_is_serving_tenant(ObDMLStmt *&stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("invalid parameter or data member", K(ret), K(stmt), K(ctx_));
  } else if (OB_ISNULL(ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("session info is NULL", K(ret));
  } else {
    common::ObIArray<ObRawExpr*> &cond_exprs = stmt->get_condition_exprs();
    for (int64_t i = 0; OB_SUCC(ret) && i < cond_exprs.count(); ++i) {
      if (OB_ISNULL(cond_exprs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("cond expr is NULL", K(ret), K(i), K(cond_exprs));
      } else if (OB_FAIL(recursive_replace_func_is_serving_tenant(*stmt, cond_exprs.at(i), trans_happened))) { // 此处必须直接传cond_exprs.at(i)，因为可能需要修改它的值
        LOG_WARN("fail to recursive replace functino is_serving_tenant",
                        K(ret), K(i), K(*cond_exprs.at(i)));
      } else if (OB_ISNULL(cond_exprs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("null pointer", K(ret));
      } else if (OB_FAIL(cond_exprs.at(i)->formalize(ctx_->session_info_))) {
        LOG_WARN("failed to formalize expr", K(ret), K(i), K(*cond_exprs.at(i)));
      } else {/*do nothing*/}
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(stmt->pull_all_expr_relation_id())) {
        LOG_WARN("pull stmt all expr relation ids failed", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::recursive_replace_func_is_serving_tenant(ObDMLStmt &stmt,
                                                                    ObRawExpr *&cond_expr,
                                                                    bool &trans_happened)
{
  int ret = OB_SUCCESS;
  bool is_stack_overflow = false;
  if (OB_ISNULL(cond_expr) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("cond_expr is NULL", K(cond_expr), K_(ctx));
  } else if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
    LOG_WARN("failed to check stack overflow", K(ret));
  } else if (is_stack_overflow) {
    ret = OB_SIZE_OVERFLOW;
    LOG_WARN("too deep recursive", K(ret), K(is_stack_overflow));
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < cond_expr->get_param_count(); ++i) {
      // 此处必须直接传cond_expr->get_param_expr(i)，因为可能需要修改它的值
      if (OB_FAIL(SMART_CALL(recursive_replace_func_is_serving_tenant(stmt,
                                                                      cond_expr->get_param_expr(i),
                                                                      trans_happened)))) {
        LOG_WARN("fail to recursive replace_func_is_serving_tenant", K(ret));
      }
    }
    // 如果是函数is_serving_tenant并且tenant_id为常量表达式，则改写为(svr_ip, svr_port) in ((ip1,
    // port1), (ip2, port2), ...)的形式
    // 如果当前租户是系统租户，直接返回true
    if (OB_SUCC(ret) && T_FUN_IS_SERVING_TENANT == cond_expr->get_expr_type()) {
      int64_t tenant_id_int64 = -1;
      if (OB_UNLIKELY(3 != cond_expr->get_param_count())) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("T_FUN_IS_SERVING_TENANT must has 3 params",
                        K(ret), K(cond_expr->get_param_count()), K(*cond_expr));
      } else if (OB_ISNULL(cond_expr->get_param_expr(0))
                 || OB_ISNULL(cond_expr->get_param_expr(1))
                 || OB_ISNULL(cond_expr->get_param_expr(2))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("T_FUN_IS_SERVING_TENANT has a null param",
                        K(ret), K(cond_expr->get_param_expr(0)),
                        K(cond_expr->get_param_expr(1)),
                        K(cond_expr->get_param_expr(2)), K(*cond_expr));
      } else if (!cond_expr->get_param_expr(2)->is_static_scalar_const_expr()) {
      } else if (OB_ISNULL(ctx_)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("ctx_ is NULL", K(ret));
      } else if (OB_ISNULL(ctx_->exec_ctx_) || OB_ISNULL(ctx_->session_info_) || OB_ISNULL(ctx_->allocator_)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("invalid argument",
                        K(ret), K(ctx_->exec_ctx_), K(ctx_->session_info_), K(ctx_->allocator_));
      } else if (OB_FAIL(calc_const_raw_expr_and_get_int(stmt,
                                                         cond_expr->get_param_expr(2),
                                                         *ctx_->exec_ctx_,
                                                         ctx_->session_info_,
                                                         *ctx_->allocator_,
                                                         tenant_id_int64))) {
        LOG_WARN("fail to calc tenant id", K(ret), K(*cond_expr->get_param_expr(2)));
      } else if (OB_UNLIKELY(tenant_id_int64 <= 0)) {
        ret = OB_INVALID_ARGUMENT;
        LOG_WARN("tenant id is <= 0", K(ret), K(tenant_id_int64));
      } else {
        uint64_t tenant_id = static_cast<uint64_t>(tenant_id_int64);
        // if current tenant is sys, return true directly
        if (OB_SYS_TENANT_ID == tenant_id) {
          ObConstRawExpr *true_expr = NULL;
          if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_VARCHAR, true_expr))) {
            LOG_WARN("create const expr failed", K(ret));
          } else if (OB_ISNULL(true_expr)) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("true expr is NULL", K(ret));
          } else {
            ObObj true_obj;
            true_obj.set_bool(true);
            true_expr->set_value(true_obj);
            cond_expr = true_expr;
            trans_happened = true;
          }
        } else {
          ObUnitInfoGetter ui_getter;
          ObArray<ObAddr> servers;
          if (OB_ISNULL(ctx_->exec_ctx_->get_sql_proxy())) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("sql proxy from exec_ctx_ is NULL", K(ret));
          } else if (OB_FAIL(ui_getter.init(*ctx_->exec_ctx_->get_sql_proxy(), &GCONF))) {
            LOG_WARN("fail to init ObUnitInfoGetter", K(ret));
          } else if (OB_FAIL(ui_getter.get_tenant_servers(tenant_id, servers))) {
            LOG_WARN("fail to get servers of a tenant", K(ret));
          } else if (0 == servers.count()) {
            // 没找到该tenant_id对应的observer，可能该tenant_id是非法的，为了能通过query
            // range，将这里改成where false的形式，这样虽然优化器会返回所有partition，但是
            // ObPhyOperator中会处理好false的条件，不会进行多余的查询
            ObConstRawExpr *false_expr = NULL;
            if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_VARCHAR, false_expr))) {
              LOG_WARN("create varchar expr failed", K(ret));
            } else if (OB_ISNULL(false_expr)){
              ret = OB_ERR_UNEXPECTED;
              LOG_WARN("false expr is NULL", K(ret));
            } else {
              ObObj false_obj;
              false_obj.set_bool(false);
              false_expr->set_value(false_obj);
              cond_expr = false_expr;
              trans_happened = true;
            }
          } else {
            ObOpRawExpr *in_op = NULL;
            ObOpRawExpr *left_row_op = NULL;
            ObOpRawExpr *right_row_op = NULL;
            if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_OP_IN, in_op))) {
              LOG_WARN("create in operator expr", K(ret));
            } else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_OP_ROW, left_row_op))) {
              LOG_WARN("create left row operator failed", K(ret));
            } else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_OP_ROW, right_row_op))) {
              LOG_WARN("create right row op failed", K(ret));
            } else if (OB_ISNULL(in_op) || OB_ISNULL(left_row_op) || OB_ISNULL(right_row_op)) {
              ret = OB_ERR_UNEXPECTED;
              LOG_WARN("operator is null", K(in_op), K(left_row_op), K(right_row_op));
            } else {/*do nothing*/}

            for (int64_t i = 0; OB_SUCC(ret) && i < servers.count(); ++i) {
              ObAddr server = servers.at(i);
              ObOpRawExpr *row_op = NULL;
              ObConstRawExpr *ip_expr = NULL;
              ObConstRawExpr *port_expr = NULL;
              char *ip_buf = NULL;
              ObObj ip_obj;
              ObObj port_obj;
              if (OB_UNLIKELY(NULL == (ip_buf = static_cast<char*>(ctx_->allocator_->alloc(OB_MAX_SERVER_ADDR_SIZE))))) {
                ret = OB_ALLOCATE_MEMORY_FAILED;
                LOG_ERROR("fail to alloc ip str buffer", K(ret), LITERAL_K(OB_MAX_SERVER_ADDR_SIZE));
              } else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_OP_ROW, row_op))) {
                LOG_WARN("create row operator expr failed", K(ret));
              } else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_VARCHAR, ip_expr))) {
                LOG_WARN("create ip operator expr failed", K(ret));
              } else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_INT, port_expr))) {
                LOG_WARN("create port expr failed", K(ret));
              } else if (OB_UNLIKELY(!server.ip_to_string(ip_buf, OB_MAX_SERVER_ADDR_SIZE))) {
                ret = OB_INVALID_ARGUMENT;
                LOG_WARN("convert server addr to ip failed", K(ret), K(i), K(server));
              } else if (OB_ISNULL(row_op) || OB_ISNULL(ip_expr) || OB_ISNULL(port_expr)) {
                ret = OB_ERR_UNEXPECTED;
                LOG_WARN("expr is null", K(row_op), K(ip_expr), K(port_expr));
              } else {
                ip_obj.set_varchar(ObString(ip_buf));
                ip_obj.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
                ip_obj.set_collation_level(CS_LEVEL_SYSCONST);
                port_obj.set_int(server.get_port());
                ip_expr->set_value(ip_obj);
                port_expr->set_value(port_obj);
                if (OB_FAIL(row_op->set_param_exprs(ip_expr, port_expr))) {
                  LOG_WARN("fail to set param expr", K(ret));
                } else if (OB_FAIL(right_row_op->add_param_expr(row_op))) {
                  LOG_WARN("fail to add param expr", K(ret));
                } else {/*do nothing*/}
              }
            }
            if (OB_SUCC(ret)) {
              if (OB_FAIL(left_row_op->set_param_exprs(cond_expr->get_param_expr(0), cond_expr->get_param_expr(1)))) {
                LOG_WARN("fail to set param expr", K(ret));
              } else if (OB_FAIL(in_op->set_param_exprs(left_row_op, right_row_op))) {
                LOG_WARN("fail to set param expr", K(ret));
              } else {
                cond_expr = in_op;
                trans_happened = true;
              }
            }
          }
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::calc_const_raw_expr_and_get_int(const ObStmt &stmt,
                                                           ObRawExpr *const_expr,
                                                           ObExecContext &exec_ctx,
                                                           ObSQLSessionInfo *session,
                                                           ObIAllocator &allocator,
                                                           int64_t &result)
{
  int ret = OB_SUCCESS;
  ObMySQLProxy *sql_proxy = NULL;
  ObPhysicalPlanCtx *plan_ctx = NULL;
  ObObj result_int_obj;
  bool got_result = false;
  if (OB_ISNULL(const_expr) || OB_ISNULL(session)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("expr or session is NULL", KP(session), KP(const_expr), K(ret));
  } else if (OB_UNLIKELY(!const_expr->is_static_scalar_const_expr())) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("expr is not const expr", K(ret), K(*const_expr));
  } else if (OB_ISNULL(sql_proxy = exec_ctx.get_sql_proxy())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("sql proxy is NULL", K(ret));
  } else if (OB_ISNULL(plan_ctx = exec_ctx.get_physical_plan_ctx())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("physical plan ctx is NULL", K(ret));
  } else if (OB_FAIL(ObSQLUtils::calc_const_or_calculable_expr(ctx_->exec_ctx_,
                                                               const_expr,
                                                               result_int_obj,
                                                               got_result,
                                                               exec_ctx.get_allocator(),
                                                               false))) {
    LOG_WARN("failed to calc const or calculable expr", K(ret));
  } else if (OB_UNLIKELY(false == ob_is_integer_type(result_int_obj.get_type()))) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("tenant id result must integer", K(ret), K(result_int_obj));
  } else {
    result = result_int_obj.get_int();
  }
  return ret;
}

/**
 * 1) select * from temp_t1 x, t2 y, temp_t3 z where ... ==>
 *    select * from temp_t1 x, t2 y, temp_t3 z where ... AND x.__session_id = xxx and z.__session_id = xxx;
 * 2) update temp_t set c1 = 1 where ... ==>
 *    update temp_t set c1 = 1 where ... AND __session_id = xxx;
 * 3) delete from temp_t where ... ==>
 *    delete from temp_t where ... AND __session_id = xxx;
 */
int ObTransformPreProcess::transform_for_temporary_table(ObDMLStmt *&stmt,
                                                         bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("null stmt or ctx", K(ret), K(stmt), K(ctx_));
  } else if (OB_ISNULL(ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("session info is NULL", K(ret));
  } else if (/*false == ctx_->session_info_->is_inner() //内部session不附加条件, 给定的sql已经考虑过了*/
             ObSQLSessionInfo::USER_SESSION == ctx_->session_info_->get_session_type()) {
    common::ObArray<TableItem*> table_item_list;
    int64_t num_from_items = stmt->get_from_item_size();
    //1, collect all table item
    for(int64_t i = 0; OB_SUCC(ret) && i < num_from_items; ++i) {
      const FromItem &from_item = stmt->get_from_item(i);
      if (from_item.is_joined_) {
        JoinedTable *joined_table_item = stmt->get_joined_table(from_item.table_id_);
        if (OB_FAIL(collect_all_tableitem(stmt, joined_table_item, table_item_list))) {
          LOG_WARN("failed to collect table item", K(ret));
        }
      } else {
        TableItem *table_item = NULL;
        table_item = stmt->get_table_item_by_id(from_item.table_id_);
        if (OB_FAIL(collect_all_tableitem(stmt, table_item, table_item_list))) {
          LOG_WARN("failed to collect table item", K(ret));
        }
      }
    }
    //2, for each temporary table item, add session_id = xxx filter
    for (int64 i = 0; OB_SUCC(ret) && i < table_item_list.count(); ++i) {
      TableItem *table_item = table_item_list.at(i);
      if (OB_ISNULL(table_item)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("table item is null", K(ret));
      } else if (table_item->is_basic_table()) {
        uint64_t table_ref_id = table_item->ref_id_;
        const ObTableSchema *table_schema = NULL;
        if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->schema_checker_)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("ctx_ or schema_cheker_ is NULL", K(ret), K(ctx_), K(ctx_->schema_checker_));
        } else if (OB_FAIL(ctx_->schema_checker_->get_table_schema(ctx_->session_info_->get_effective_tenant_id(), table_ref_id, table_schema, table_item->is_link_table()))) {
          LOG_WARN("failed to get table schema", K(table_ref_id), K(ret));
        } else if (OB_ISNULL(table_schema)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("table should not be null", K(table_ref_id));
        } else if (table_schema->is_oracle_tmp_table()) {
          // 单表查询时直接添加 filter; 多表时创建 view 并在内部添加 filter
          TableItem *view_table = NULL;
          ObSelectStmt *ref_query = NULL;
          TableItem *child_table = NULL;
          if (stmt->is_single_table_stmt()) {
            if (OB_FAIL(add_filter_for_temporary_table(*stmt, *table_item, table_schema->is_oracle_trx_tmp_table()))) {
              LOG_WARN("add filter for temporary table failed", K(ret));
            } else {
              trans_happened = true;
            }
          } else if (OB_FAIL(ObTransformUtils::replace_with_empty_view(ctx_,
                                                                       stmt,
                                                                       view_table,
                                                                       table_item))) {
            LOG_WARN("failed to create empty view table", K(ret));
          } else if (OB_FAIL(ObTransformUtils::create_inline_view(ctx_,
                                                                  stmt,
                                                                  view_table,
                                                                  table_item))) {
            LOG_WARN("failed to create inline view", K(ret));
          } else if (!view_table->is_generated_table()
                     || OB_ISNULL(ref_query = view_table->ref_query_)
                     || !ref_query->is_single_table_stmt()
                     || OB_ISNULL(child_table = ref_query->get_table_item(0))) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get unexpected view table", K(ret), K(*view_table));
          } else if (OB_FAIL(add_filter_for_temporary_table(*ref_query, *child_table, table_schema->is_oracle_trx_tmp_table()))) {
            LOG_WARN("add filter for temporary table failed", K(ret));
          } else {
            trans_happened = true;
          }
        }
      }
    }
    ObInsertStmt *ins_stmt = dynamic_cast<ObInsertStmt*>(stmt);
    if (OB_SUCC(ret) && NULL != ins_stmt) {
      // value exprs for insert stmt is not included in relation expr array.
      ObIArray<ObRawExpr*> &value_vectors = ins_stmt->get_values_vector();
      for (int64_t i = 0; OB_SUCC(ret) && i < value_vectors.count(); ++i) {
        ObRawExpr *expr = value_vectors.at(i);
        bool is_happened = false;
        if (OB_FAIL(transform_expr(*ctx_->expr_factory_,
                                   *ctx_->session_info_,
                                   expr,
                                   is_happened))) {
          LOG_WARN("transform expr failed", K(ret));
        } else if(OB_ISNULL(expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("expr is NULL", K(ret));
        } else {
          value_vectors.at(i) = expr;
          trans_happened |= is_happened;
        }
      }
    }
  }
  return ret;
}

//为stmt->where添加session_id = xxx
int ObTransformPreProcess::add_filter_for_temporary_table(ObDMLStmt &stmt,
                                                          const TableItem &table_item,
                                                          bool is_trans_scope_temp_table)
{
  int ret = OB_SUCCESS;
  ObRawExpr *equal_expr = NULL;
  ObConstRawExpr *temp_table_type = NULL;
  ObColumnRefRawExpr *expr_col = NULL;
  ObSysFunRawExpr *expr_temp_table_ssid = NULL;
  if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->session_info_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("some parameter is NULL", K(ret), K(ctx_));
  }

  //build column expr
  if (OB_SUCC(ret)) {
    ColumnItem *exist_col_item = NULL;
    if (NULL != (exist_col_item = stmt.get_column_item(table_item.table_id_, OB_HIDDEN_SESSION_ID_COLUMN_NAME))) {
      expr_col = exist_col_item->expr_;
    } else {
      ColumnItem column_item;
      ObExprResType result_type;
      result_type.set_int();
      if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_REF_COLUMN, expr_col))) {
        LOG_WARN("fail to create raw expr", K(ret));
      } else if (OB_ISNULL(expr_col)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("expr_col is null", K(expr_col), K(ret));
      } else {
        expr_col->set_table_name(table_item.get_table_name());
        expr_col->set_column_name(OB_HIDDEN_SESSION_ID_COLUMN_NAME);
        expr_col->set_ref_id(table_item.table_id_, OB_HIDDEN_SESSION_ID_COLUMN_ID);
        expr_col->set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
        expr_col->set_collation_level(CS_LEVEL_IMPLICIT);
        expr_col->set_result_type(result_type);
        column_item.expr_ = expr_col;
        column_item.table_id_ = expr_col->get_table_id();
        column_item.column_id_ = expr_col->get_column_id();
        column_item.column_name_ = expr_col->get_column_name();
        if (OB_FAIL(expr_col->add_relation_id(stmt.get_table_bit_index(table_item.table_id_)))) {
          LOG_WARN("failed to add relation id", K(ret));
        } else if (OB_FAIL(stmt.add_column_item(column_item))) {
          LOG_WARN("add column item to stmt failed", K(ret));
        }
      }
    }
  }

  if (OB_SUCC(ret)) {
    if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_INT, temp_table_type))) {
      LOG_WARN("create const raw expr failed", K(ret));
    } else if (OB_ISNULL(temp_table_type)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("expr temp table ssid", K(ret));
    } else {
      ObObj val;
      val.set_int(is_trans_scope_temp_table ? 1 : 0);
      temp_table_type->set_value(val);
    }
  }

  //build session id expr
  if (OB_SUCC(ret)) {
    if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_FUN_GET_TEMP_TABLE_SESSID, expr_temp_table_ssid))) {
      LOG_WARN("create const raw expr failed", K(ret));
    } else if (OB_ISNULL(expr_temp_table_ssid)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("expr temp table ssid", K(ret));
    } else {
      expr_temp_table_ssid->set_func_name(N_TEMP_TABLE_SSID);
      if (OB_FAIL(expr_temp_table_ssid->add_param_expr(temp_table_type))) {
        LOG_WARN("fail to add param expr", K(ret));
      }
    }
  }

  //build equal expr
  if (OB_SUCC(ret)) {
    if (OB_FAIL(ObRawExprUtils::create_equal_expr(*(ctx_->expr_factory_),
                                                  ctx_->session_info_,
                                                  expr_temp_table_ssid,
                                                  expr_col,
                                                  equal_expr))) {
      LOG_WARN("Creation of equal expr for outer stmt fails", K(ret));
    }
  }

  if (OB_SUCC(ret)) {
    if (OB_FAIL(equal_expr->formalize(ctx_->session_info_))) {
      LOG_WARN("fail to formalize expr", K(ret));
    } else if (OB_FAIL(stmt.get_condition_exprs().push_back(equal_expr))) {
      LOG_WARN("failed to push back new filter", K(ret));
    } else {
      LOG_TRACE("add new filter succeed", K(stmt.get_condition_exprs()), K(*equal_expr));
    }
  }
  return ret;
}

//递归收集from_item中所有TableItem, 用于后续的查询改写
int ObTransformPreProcess::collect_all_tableitem(ObDMLStmt *stmt,
                                                 TableItem *table_item,
                                                 common::ObArray<TableItem*> &table_item_list)
{
  int ret = OB_SUCCESS;
  bool is_stack_overflow = false;
  if (OB_ISNULL(table_item)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item is null", K(ret));
  } else if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
    LOG_WARN("failed to check stack overflow", K(ret));
  } else if (is_stack_overflow) {
    ret = OB_SIZE_OVERFLOW;
    LOG_WARN("too deep recursive", K(ret), K(is_stack_overflow));
  } else {
    if (table_item->is_joined_table()) {
      JoinedTable *joined_table_item = static_cast<JoinedTable *>(table_item);
      if (OB_FAIL(SMART_CALL(collect_all_tableitem(stmt, joined_table_item->left_table_,
                                                   table_item_list)))) {
        LOG_WARN("failed to collect temp table item", K(ret));
      } else if (OB_FAIL(SMART_CALL(collect_all_tableitem(stmt, joined_table_item->right_table_,
                                                          table_item_list)))) {
        LOG_WARN("failed to collect temp table item", K(ret));
      }
    } else if (table_item->is_basic_table() &&
               OB_FAIL(add_var_to_array_no_dup(table_item_list, table_item))) {
      LOG_WARN("failed to push table item", K(ret));
    }
  }
  return ret;
}

#ifdef OB_BUILD_LABEL_SECURITY
/**
 * 假如t1的安全列是 c_label，对应的安全策略是 policy_name, 会在下面三种语句添加filter
 * 1) select * from t1 where  ..
 * 2) update t1 set c1 = 1 where ..
 * 3) delete from t1 where ..
 *
 * filter: 0 == ols_label_value_cmp_le(ols_session_label(policy_name), c_label)
 *
 */
int ObTransformPreProcess::transform_for_label_se_table(ObDMLStmt *stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->schema_checker_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("null unexpected", K(ret), K(stmt), K(ctx_), K(ctx_->schema_checker_));
  } else if (OB_ISNULL(ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("session info is NULL", K(ret));
  } else if (!ctx_->session_info_->is_inner()) { //内部session不用条件进行过滤
    common::ObArray<TableItem*> table_item_list;
    int64_t num_from_items = stmt->get_from_item_size();
    //1, collect all table item
    for(int64_t i = 0; OB_SUCC(ret) && i < num_from_items; ++i) {
      const FromItem &from_item = stmt->get_from_item(i);
      if (from_item.is_joined_) {
        JoinedTable *joined_table_item = stmt->get_joined_table(from_item.table_id_);
        if (OB_FAIL(collect_all_tableitem(stmt, joined_table_item, table_item_list))) {
          LOG_WARN("failed to collect table item", K(ret));
        }
      } else {
        TableItem *table_item = NULL;
        table_item = stmt->get_table_item_by_id(from_item.table_id_);
        if (OB_FAIL(collect_all_tableitem(stmt, table_item, table_item_list))) {
          LOG_WARN("failed to collect table item", K(ret));
          LOG_WARN("failed to collect table item", K(ret), K(*stmt));
        }
      }
    }

    //2, for each label security table item, add label column filter
    for (int64_t i = 0; OB_SUCC(ret) && i < table_item_list.count(); ++i) {
      TableItem *table_item = table_item_list.at(i);
      if (OB_ISNULL(table_item)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("table item is null", K(ret));
      } else if (table_item->is_basic_table() || table_item->is_link_table()) {
        uint64_t table_ref_id = table_item->ref_id_;
        const ObTableSchema *table_schema = NULL;
        if (OB_FAIL(ctx_->schema_checker_->get_table_schema(ctx_->session_info_->get_effective_tenant_id(), table_ref_id, table_schema, table_item->is_link_table()))) {
          LOG_WARN("failed to get table schema", K(table_ref_id), K(ret));
        } else if (OB_ISNULL(table_schema)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("table should not be null", K(table_ref_id));
        } else if (table_schema->has_label_se_column()) {
          const ObIArray<uint64_t> &label_se_column_ids = table_schema->get_label_se_column_ids();
          for (int64_t j = 0; OB_SUCC(ret) && j < label_se_column_ids.count(); ++j) {
            const ObColumnSchemaV2 *column_schema = NULL;
            ObString policy_name;
            if (OB_ISNULL(column_schema = table_schema->get_column_schema(label_se_column_ids.at(j)))) {
              ret = OB_ERR_UNEXPECTED;
              LOG_WARN("column schema not exist", K(ret), K(label_se_column_ids.at(j)));
            } else if (OB_FAIL(ctx_->schema_checker_->get_label_se_policy_name_by_column_name(
                                 ctx_->session_info_->get_effective_tenant_id(),
                                 column_schema->get_column_name_str(),
                                 policy_name))) {
              LOG_WARN("fail to get policy name", K(ret));
            } else if (OB_FAIL(add_filter_for_label_se_table(*stmt, *table_item, policy_name, *column_schema))) {
              LOG_WARN("add filter for temporary table failed", K(ret));
            }
          }
          if (OB_SUCC(ret)) {
            trans_happened = true;
          }
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::add_filter_for_label_se_table(ObDMLStmt &stmt,
                                                         const TableItem &table_item,
                                                         const ObString &policy_name,
                                                         const ObColumnSchemaV2 &column_schema)
{
  int ret = OB_SUCCESS;
  ObRawExprFactory *expr_factory = NULL;
  ObSQLSessionInfo *session_info = NULL;

  if (OB_ISNULL(ctx_)
      || OB_ISNULL(session_info = ctx_->session_info_)
      || OB_ISNULL(expr_factory = ctx_->expr_factory_)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("some parameter is NULL", K(ret), K(ctx_), K(expr_factory), K(session_info));
  }

  ObConstRawExpr *policy_name_expr = NULL;
  if (OB_SUCC(ret)) {
    if (OB_FAIL(ObRawExprUtils::build_const_string_expr(*expr_factory,
                                                        ObVarcharType,
                                                        policy_name,
                                                        ObCharset::get_default_collation(ObCharset::get_default_charset()),
                                                        policy_name_expr))) {
      LOG_WARN("fail to build expr", K(ret));
    }
  }

  ObSysFunRawExpr *session_label_expr = NULL;
  if (OB_SUCC(ret)) {
    if (OB_FAIL(expr_factory->create_raw_expr(T_FUN_LABEL_SE_SESSION_LABEL, session_label_expr))) {
      LOG_WARN("create expr failed", K(ret));
    } else {
      ObString func_name = ObString::make_string(N_OLS_SESSION_LABEL);
      session_label_expr->set_func_name(func_name);
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(session_label_expr->add_param_expr(policy_name_expr))) {
        LOG_WARN("fail to add param expr", K(ret));
      }
    }
  }

  ObColumnRefRawExpr *col_expr = NULL;
  if (OB_SUCC(ret)) {
    ColumnItem *col_item = NULL;
    if (NULL != (col_item = stmt.get_column_item_by_id(table_item.table_id_, column_schema.get_column_id()))) {
      col_expr = col_item->expr_;
      col_expr->set_explicited_reference();
    } else {
      if (OB_FAIL(ObRawExprUtils::build_column_expr(*expr_factory, column_schema, col_expr))) {
        LOG_WARN("fail to build column expr", K(ret));
      } else {
        col_expr->set_table_id(table_item.table_id_);
        col_expr->set_table_name(table_item.table_name_);
        col_expr->set_explicited_reference();
        ColumnItem column_item;
        column_item.expr_ = col_expr;
        column_item.table_id_ = col_expr->get_table_id();
        column_item.column_id_ = col_expr->get_column_id();
        column_item.column_name_ = col_expr->get_column_name();
        if (OB_FAIL(stmt.add_column_item(column_item))) {
          LOG_WARN("add column item to stmt failed", K(ret));
        }
      }
    }
  }
  ObSysFunRawExpr *label_cmp_expr = NULL;
  if (OB_SUCC(ret)) {
    ObString func_name = ObString::make_string(N_OLS_LABEL_VALUE_CMP_LE);

    if (OB_FAIL(expr_factory->create_raw_expr(T_FUN_LABEL_SE_LABEL_VALUE_CMP_LE, label_cmp_expr))) {
      LOG_WARN("create expr failed", K(ret));
    } else {
      label_cmp_expr->set_func_name(func_name);
    }

    if (OB_SUCC(ret)) {
      if (OB_FAIL(label_cmp_expr->add_param_expr(col_expr))) {
        LOG_WARN("fail to add param expr", K(ret));
      } else if (OB_FAIL(label_cmp_expr->add_param_expr(session_label_expr))) {
        LOG_WARN("fail to add parm expr", K(ret));
      }
    }
  }
  ObConstRawExpr *zero_int_expr = NULL;
  if (OB_SUCC(ret)) {
    if (OB_FAIL(ObRawExprUtils::build_const_int_expr(*expr_factory, ObIntType, 0, zero_int_expr))) {
      LOG_WARN("fail to build expr", K(ret));
    }
  }
  ObRawExpr *equal_expr = NULL;
  if (OB_SUCC(ret)) {
    if (OB_FAIL(ObRawExprUtils::create_equal_expr(*expr_factory,
                                                  session_info,
                                                  label_cmp_expr,
                                                  zero_int_expr,
                                                  equal_expr))) {
      LOG_WARN("fail to create equal expr", K(ret));
    }
  }

  if (OB_SUCC(ret)) {
    if (OB_FAIL(stmt.get_condition_exprs().push_back(equal_expr))) {
      LOG_WARN("failed to push back new filter", K(ret));
    } else {
      LOG_TRACE("add new filter succeed", K(stmt.get_condition_exprs()), K(*equal_expr));
    }
  }
  return ret;
}
#endif

/**
 * ObTransformPreProcess::transform_for_rls_table
 * generate predicate from rls policy on table and add them to the stmt
 * 1) add filter for select/update/delete
 *    select * from t1
 * => select * from t1 where ...
 *    update t1 set c1 = 1
 * => update t1 set c1 = 1 where ...
 *    delete from t1
 * => delete from t1 where ...
 * 2) if column-masking is enable, transform select item instead of add filter for select
 *    select c1 from t1
 * => select (case when ... then c1 else null end) c1 from t1
 * 3) if update_check is set, then add check constraint instead of adding filter for insert/update
 *    insert into t1 values(...)
 *    update t1 set c1 = 1
 */
int ObTransformPreProcess::transform_for_rls_table(ObDMLStmt *stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  bool exempt_rls_policy = false;
  bool contain_rls_table = false;
  ObSQLSessionInfo *session_info = NULL;
  ObSchemaChecker *schema_checker = NULL;
  trans_happened = false;
  if (OB_ISNULL(stmt)
      || OB_ISNULL(ctx_)
      || OB_ISNULL(schema_checker = ctx_->schema_checker_)
      || OB_ISNULL(session_info = ctx_->session_info_)
      || OB_ISNULL(stmt->get_query_ctx())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("null unexpected", K(ret), K(stmt), K(ctx_), K(ret));
  } else if (OB_FAIL(check_exempt_rls_policy(exempt_rls_policy))) {
    LOG_WARN("failed to check exempt_rls_policy for rls", K(ret));
  } else {
    ObSEArray<TableItem*, 4> table_item_list;
    if (OB_FAIL(table_item_list.assign(stmt->get_table_items()))) {
      LOG_WARN("failed to assign table item list");
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < table_item_list.count(); ++i) {
      TableItem *table_item = table_item_list.at(i);
      if (OB_ISNULL(table_item)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("table item is null", K(ret));
      } else if ((table_item->is_basic_table() &&
                  !table_item->is_system_table_ &&
                  !table_item->is_link_table()) ||
                 table_item->is_view_table_) {
        uint64_t table_ref_id = table_item->ref_id_;
        const ObTableSchema *table_schema = NULL;
        if (OB_FAIL(schema_checker->get_table_schema(session_info->get_effective_tenant_id(),
                                                     table_ref_id, table_schema))) {
          LOG_WARN("failed to get table schema", K(ret));
        } else if (OB_ISNULL(table_schema)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("table schema is null", K(table_ref_id), K(ret));
        }
        for (int64_t j = 0; OB_SUCC(ret) && j < table_schema->get_rls_policy_ids().count(); ++j) {
          const ObRlsPolicySchema *policy_schema = NULL;
          if (OB_FAIL(schema_checker->get_schema_guard()->get_rls_policy_schema_by_id(
                session_info->get_effective_tenant_id(),
                table_schema->get_rls_policy_ids().at(j),
                policy_schema))) {
            LOG_WARN("failed to get rls policy schema", K(ret));
          } else if (OB_ISNULL(policy_schema)) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("policy schema is null");
          } else if (!policy_schema->get_enable_flag()) {
            // do nothing
          } else if (FALSE_IT(contain_rls_table = true)) {
          } else if (exempt_rls_policy) {
            // do nothing
          } else if (OB_FAIL(transform_for_single_rls_policy(*stmt, *table_item, *policy_schema, trans_happened))) {
            LOG_WARN("failed to transform for single rls policy");
          }
        }
      }
    }
    if (OB_SUCC(ret) && contain_rls_table) {
      ObPCPrivInfo priv_info;
      priv_info.sys_priv_ = PRIV_ID_EXEMPT_ACCESS_POLICY;
      priv_info.has_privilege_ = exempt_rls_policy;
      if (OB_FAIL(stmt->get_query_ctx()->all_priv_constraints_.push_back(priv_info))) {
        LOG_WARN("failed to add rls policy constraint", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::check_exempt_rls_policy(bool &exempt_rls_policy)
{
  int ret = OB_SUCCESS;
  exempt_rls_policy = false;
  ObSQLSessionInfo *session_info = NULL;
  ObSchemaChecker *schema_checker = NULL;
  if (OB_ISNULL(ctx_)
      || OB_ISNULL(session_info = ctx_->session_info_)
      || OB_ISNULL(schema_checker = ctx_->schema_checker_)
      || OB_ISNULL(schema_checker->get_schema_guard())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("null unexpected", K(ctx_), K(ret));
  } else if (!session_info->is_user_session() || session_info->is_tenant_changed()) {
    exempt_rls_policy = true;
  } else if (OB_FAIL(ObOraSysChecker::check_ora_user_sys_priv(*schema_checker->get_schema_guard(),
                                                        session_info->get_effective_tenant_id(),
                                                        session_info->get_priv_user_id(),
                                                        session_info->get_database_name(),
                                                        PRIV_ID_EXEMPT_ACCESS_POLICY,
                                                        session_info->get_enable_role_array()))) {
    if (OB_ERR_NO_PRIVILEGE == ret) {
      ret = OB_SUCCESS;
      LOG_TRACE("lack EXEMPT ACCESS POLICY priv, need trans");
    } else {
      LOG_WARN("failed to check ora user sys priv", K(ret));
    }
  } else {
    exempt_rls_policy = true;
  }
  return ret;
}

int ObTransformPreProcess::check_need_transform_column_level(ObDMLStmt &stmt,
                                                             const TableItem &table_item,
                                                             const ObRlsPolicySchema &policy_schema,
                                                             bool &need_trans)
{
  int ret = OB_SUCCESS;
  need_trans = false;
  if (!stmt.is_select_stmt() || !policy_schema.is_column_level_policy()) {
    // do nothing
  } else {
    const int64_t sec_column_count = policy_schema.get_sec_column_count();
    for (int64_t i = 0; OB_SUCC(ret) && !need_trans && i < sec_column_count; ++i) {
      const ObRlsSecColumnSchema* rls_column = policy_schema.get_sec_column_by_idx(i);
      if (OB_ISNULL(rls_column)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get null rls column", K(ret));
      } else if (NULL != stmt.get_column_item_by_id(table_item.table_id_,
                                                    rls_column->get_column_id())) {
        need_trans = true;
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_for_single_rls_policy(ObDMLStmt &stmt,
                                                           TableItem &table_item,
                                                           const ObRlsPolicySchema &policy_schema,
                                                           bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObString predicate_str;
  ObRawExpr *expr = NULL;
  ObRawExpr *policy_expr = NULL;
  ObSEArray<ObQualifiedName, 1> columns;
  bool need_trans = true;
  if (OB_FAIL(calc_policy_function(stmt, table_item, policy_schema, policy_expr, predicate_str))) {
    LOG_WARN("failed to calc policy function", K(table_item), K(policy_schema), K(ret));
  } else if (OB_FAIL(build_policy_predicate_expr(predicate_str, table_item, columns, expr))) {
    LOG_WARN("failed to build predicate expr", K(predicate_str), K(ret));
  } else {
    switch (stmt.get_stmt_type()) {
    case stmt::T_SELECT: {
      bool need_filter = false;
      bool need_replace = false;
      if (!policy_schema.has_stmt_type_flag(RLS_POLICY_SELECT_FLAG)) {
        // do nothing
      } else if (!policy_schema.is_column_level_policy()) {
        need_filter = true;
      } else {
        if (check_need_transform_column_level(stmt, table_item, policy_schema, need_trans)) {
          LOG_WARN("failed to check need trans for column level policy", K(ret));
        } else if (!need_trans) {
          // do nothing
        } else if (policy_schema.has_stmt_type_flag(RLS_POLICY_SEC_ALL_ROWS_FLAG)) {
          need_replace = true;
        } else {
          need_filter = true;
        }
      }
      if (OB_SUCC(ret)) {
        if (need_filter) {
          if (OB_FAIL(add_filter_for_rls_select(stmt, table_item, columns, expr))) {
            LOG_WARN("failed to add filter for rls table", K(ret));
          } else {
            trans_happened = true;
          }
        } else if (need_replace) {
          if (OB_FAIL(replace_expr_for_rls(stmt, table_item, policy_schema, columns, expr))) {
            LOG_WARN("failed to add modify expr for rls table", K(ret));
          } else {
            trans_happened = true;
          }
        }
      }
      break;
    }
    case stmt::T_DELETE: {
      if (!policy_schema.has_stmt_type_flag(RLS_POLICY_DELETE_FLAG)) {
        // do nothing
      } else if (OB_FAIL(add_filter_for_rls(stmt, table_item, columns, expr))) {
        LOG_WARN("failed to add filter for rls table", K(ret));
      } else {
        trans_happened = true;
      }
      break;
    }
    case stmt::T_UPDATE: {
      if (!policy_schema.has_stmt_type_flag(RLS_POLICY_UPDATE_FLAG)) {
        // do nothing
      } else if (OB_FAIL(add_filter_for_rls(stmt, table_item, columns, expr))) {
        LOG_WARN("failed to add filter for rls table", K(ret));
      } else if (policy_schema.get_check_opt()) {
        if (OB_FAIL(add_constraint_for_rls(stmt, table_item, columns, expr))) {
          LOG_WARN("failed to add filter for rls table", K(ret));
        } else {
          trans_happened = true;
        }
      } else {
        trans_happened = true;
      }
      break;
    }
    case stmt::T_INSERT:
    case stmt::T_INSERT_ALL: {
      if (!policy_schema.has_stmt_type_flag(RLS_POLICY_INSERT_FLAG)) {
        // do nothing
      } else if (OB_FAIL(add_constraint_for_rls(stmt, table_item, columns, expr))) {
        LOG_WARN("failed to add filter for rls table", K(ret));
      } else {
        trans_happened = true;
      }
      break;
    }
    case stmt::T_MERGE: {
      int64_t merge_flag = RLS_POLICY_INSERT_FLAG | RLS_POLICY_UPDATE_FLAG | RLS_POLICY_DELETE_FLAG;
      if (!policy_schema.has_partial_stmt_type_flag(merge_flag)) {
        // do nothing
      } else if (!policy_schema.has_stmt_type_flag(merge_flag)) {
        ret = OB_ERR_MERGE_INTO_WITH_POLICY;
        LOG_WARN("rls policy does not contain all flag of insert, update and delete", K(ret));
      } else if (OB_FAIL(add_filter_for_rls_merge(stmt, table_item, columns, expr))) {
        LOG_WARN("failed to add filter for rls table", K(ret));
      } else if (OB_FAIL(add_constraint_for_rls(stmt, table_item, columns, expr))) {
        LOG_WARN("failed to add filter for rls table", K(ret));
      } else {
        trans_happened = true;
      }
      break;
    }
    default:
      ret = OB_NOT_SUPPORTED;
      LOG_WARN("not supported stmt type", K(stmt.get_stmt_type()), K(ret));
      break;
    }
  }
  if (OB_SUCC(ret)) {
    if (!(policy_schema.has_stmt_type_flag(RLS_POLICY_STATIC_FLAG)
        || policy_schema.has_stmt_type_flag(RLS_POLICY_SHARE_STATIC_FLAG))
        && need_trans) {
      if (OB_FAIL(add_rls_policy_constraint(policy_expr, predicate_str))) {
        LOG_WARN("failed to add rls policy constraint", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::calc_policy_function(ObDMLStmt &stmt,
                                                const TableItem &table_item,
                                                const ObRlsPolicySchema &policy_schema,
                                                ObRawExpr *&policy_expr,
                                                ObString &predicate_str)
{
  int ret = OB_SUCCESS;
  ObSQLSessionInfo *session_info = NULL;
  ObSchemaChecker *schema_checker = NULL;
  ObRawExprFactory *expr_factory = NULL;
  if (OB_ISNULL(ctx_)
      || OB_ISNULL(session_info = ctx_->session_info_)
      || OB_ISNULL(schema_checker = ctx_->schema_checker_)
      || OB_ISNULL(schema_checker->get_schema_guard())
      || OB_ISNULL(expr_factory = ctx_->expr_factory_)
      || OB_ISNULL(ctx_->exec_ctx_)
      || OB_ISNULL(ctx_->allocator_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("null unexpected", K(ctx_), K(ret));
  } else if (OB_ISNULL(ctx_->exec_ctx_->get_sql_proxy())
             || OB_ISNULL(ctx_->exec_ctx_->get_physical_plan_ctx())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("null unexpected", K(ret));
  } else {
    ObConstRawExpr *object_schema_expr = NULL;
    ObConstRawExpr *object_name_expr = NULL;
    ObUDFRawExpr *udf_expr = NULL;
    ObUDFInfo udf_info;
    ObResolverParams params;
    ObObj result_obj;
    udf_info.udf_database_ = policy_schema.get_policy_function_schema();
    udf_info.udf_package_ = policy_schema.get_policy_package_name();
    udf_info.udf_name_ = policy_schema.get_policy_function_name();
    udf_info.udf_param_num_ = 2; // database_name and table_name
    params.schema_checker_ = schema_checker;
    params.session_info_ = session_info;
    params.allocator_ = ctx_->allocator_;
    params.expr_factory_ = expr_factory;
    params.sql_proxy_ = ctx_->exec_ctx_->get_sql_proxy();
    if (OB_FAIL(ObRawExprUtils::build_const_string_expr(*expr_factory,
        ObVarcharType,
        table_item.database_name_,
        ObCharset::get_default_collation(ObCharset::get_default_charset()),
        object_schema_expr))) {
      LOG_WARN("failed to create object schema expr", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::build_const_string_expr(*expr_factory,
        ObVarcharType,
        table_item.get_table_name(),
        ObCharset::get_default_collation(ObCharset::get_default_charset()),
        object_name_expr))) {
      LOG_WARN("failed to create object name expr", K(ret));
    } else if (OB_FAIL(expr_factory->create_raw_expr(T_FUN_UDF, udf_expr))) {
      LOG_WARN("failed to create raw expr", K(ret));
    } else if (OB_FAIL(udf_expr->add_param_expr(object_schema_expr))) {
      LOG_WARN("failed to add param expr", K(object_schema_expr), K(ret));
    } else if (OB_FAIL(udf_expr->add_param_expr(object_name_expr))) {
      LOG_WARN("failed to add param expr", K(object_name_expr), K(ret));
    } else if (FALSE_IT(udf_info.ref_expr_ = udf_expr)) {
    } else if (OB_FAIL(ObRawExprUtils::resolve_udf_info(
        *params.allocator_, *params.expr_factory_, *params.session_info_, *params.schema_checker_->get_schema_guard(), udf_info))) {
      LOG_WARN("failed to init udf_info", K(udf_info), K(ret));
    } else if (OB_FAIL(udf_expr->formalize(session_info))) {
      LOG_WARN("failed to formalize", K(ret));
    } else if (OB_FAIL(ObSQLUtils::calc_const_expr(*ctx_->exec_ctx_, udf_expr, result_obj,
                *ctx_->allocator_, ctx_->exec_ctx_->get_physical_plan_ctx()->get_param_store()))){
      LOG_WARN("faild to calc const epxr", K(ret));
    } else if (OB_UNLIKELY(!result_obj.is_varchar())) {
      ret = OB_ERR_POLICY_PREDICATE;
      LOG_WARN("invalid policy function result", K(result_obj), K(ret));
    } else if (OB_FAIL(result_obj.get_string(predicate_str))) {
      LOG_WARN("failed to get string", K(ret));
    } else {
      policy_expr = udf_expr;
    }
    if (OB_SUCC(ret) && udf_expr->need_add_dependency()) {
      ObSchemaObjVersion udf_version;
      OZ (udf_expr->get_schema_object_version(udf_version));
      OZ (stmt.add_global_dependency_table(udf_version));
    }
  }
  return ret;
}

int ObTransformPreProcess::build_policy_predicate_expr(const common::ObString &predicate_str,
                                                       const TableItem &table_item,
                                                       ObIArray<ObQualifiedName> &columns,
                                                       ObRawExpr *&expr)
{
  int ret = OB_SUCCESS;
  ObSQLSessionInfo *session_info = NULL;
  ObRawExprFactory *expr_factory = NULL;
  const ParseNode *node = NULL;
  const ObColumnSchemaV2 *col_schema = NULL;
  if (OB_ISNULL(ctx_)
      || OB_ISNULL(session_info = ctx_->session_info_)
      || OB_ISNULL(expr_factory = ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("null unexpected", K(ctx_), K(ret));
  } else if (OB_FAIL(ObRawExprUtils::build_rls_predicate_expr(predicate_str, *expr_factory,
      *session_info, columns, expr))) {
    LOG_WARN("failed to build rls predicate exr", K(predicate_str));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < columns.count(); ++i) {
    const ObQualifiedName &q_name = columns.at(i);
    if (q_name.is_sys_func()) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("invalid column expr", K(q_name), K(ret));
    } else if (OB_UNLIKELY(!q_name.database_name_.empty()
                           && 0 != q_name.database_name_.compare(table_item.database_name_))) {
      ret = OB_ERR_POLICY_FUNCTION;
      LOG_WARN("database name not match", K(q_name), K(table_item.database_name_), K(ret));
    } else if (OB_UNLIKELY(!q_name.tbl_name_.empty()
                           && 0 != q_name.tbl_name_.compare(table_item.table_name_))) {
      ret = OB_ERR_POLICY_FUNCTION;
      LOG_WARN("table name not match", K(q_name), K(table_item.table_name_), K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::add_rls_policy_constraint(const ObRawExpr *expr,
                                                     const common::ObString &predicate_str)
{
  int ret = OB_SUCCESS;
  ObConstRawExpr *str_expr = NULL;
  ObRawExpr *eq_expr = NULL;
  if (OB_ISNULL(expr) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)
      || OB_ISNULL(ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::build_const_string_expr(*ctx_->expr_factory_,
                                ObVarcharType,
                                predicate_str,
                                ObCharset::get_default_collation(ObCharset::get_default_charset()),
                                str_expr))) {
    LOG_WARN("failed to build const string expr", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::create_equal_expr(*ctx_->expr_factory_,
                                                       ctx_->session_info_,
                                                       expr,
                                                       str_expr,
                                                       eq_expr))) {
    LOG_WARN("failed to create equal expr", K(ret));
  } else if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, eq_expr, true, true))) {
    LOG_WARN("failed to add bool constraint", K(ret));
  }
  return ret;
}

int ObTransformPreProcess::build_rls_filter_expr(ObDMLStmt &stmt,
                                                 const TableItem &table_item,
                                                 const ObIArray<ObQualifiedName> &columns,
                                                 ObRawExpr *predicate_expr,
                                                 ObRawExpr *&expr)
{
  int ret = OB_SUCCESS;
  const ObTableSchema *table_schema = NULL;
  if (OB_ISNULL(predicate_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr is null", K(ret));
  } else if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (OB_FAIL(ctx_->schema_checker_->get_table_schema(
      ctx_->session_info_->get_effective_tenant_id(), table_item.ref_id_, table_schema))) {
    LOG_WARN("failed to get table schema", K(table_item.ref_id_), K(ret));
  } else if (OB_ISNULL(table_schema)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table should not be null", K(table_item.ref_id_));
  } else {
    ObRawExprCopier copier(*ctx_->expr_factory_);
    for (int64_t i = 0; OB_SUCC(ret) && i < columns.count(); ++i) {
      const ObQualifiedName &q_name = columns.at(i);
      ColumnItem *col_item = NULL;
      ObColumnRefRawExpr *col_expr = NULL;
      const ObColumnSchemaV2 *column_schema = NULL;
      if (NULL != (col_item = stmt.get_column_item(table_item.table_id_, q_name.col_name_))) {
        col_expr = col_item->expr_;
      } else if (OB_ISNULL(column_schema = table_schema->get_column_schema(q_name.col_name_))) {
        ret = OB_ERR_POLICY_PREDICATE;
        LOG_WARN("not found column in table", K(q_name), K(ret));
      } else if (OB_FAIL(ObRawExprUtils::build_column_expr(*ctx_->expr_factory_, *column_schema,
                                                          col_expr))) {
        LOG_WARN("failed to build column expr", K(ret));
      } else {
        col_expr->set_table_name(table_item.table_name_);
        col_expr->set_table_id(table_item.table_id_);
        ColumnItem column_item;
        column_item.expr_ = col_expr;
        column_item.table_id_ = col_expr->get_table_id();
        column_item.column_id_ = col_expr->get_column_id();
        column_item.column_name_ = col_expr->get_column_name();
        if (OB_FAIL(stmt.add_column_item(column_item))) {
          LOG_WARN("add column item to stmt failed", K(ret), K(column_item));
        }
      }
      if (OB_FAIL(ret)) {
      } else if (OB_FAIL(copier.add_replaced_expr(q_name.ref_expr_, col_expr))) {
        LOG_WARN("failed to add expr", K(ret));
      }
    }
    if (OB_FAIL(ret)) {
    } else if (OB_FAIL(copier.copy_on_replace(predicate_expr, expr))) {
      LOG_WARN("failed to copy on replace expr", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::build_rls_constraint_expr(const ObDmlTableInfo &table_info,
                                                     const ObIArray<ObQualifiedName> &columns,
                                                     ObRawExpr *predicate_expr,
                                                     ObRawExpr *&expr)
{
  int ret = OB_SUCCESS;
  ObRawExprCopier copier(*ctx_->expr_factory_);
  for (int64_t i = 0; OB_SUCC(ret) && i < columns.count(); ++i) {
    const ObQualifiedName &q_name = columns.at(i);
    bool found = false;
    for (int64_t j = 0; OB_SUCC(ret) && !found && j < table_info.column_exprs_.count(); ++j) {
      ObColumnRefRawExpr *col = table_info.column_exprs_.at(j);
      if (OB_ISNULL(col)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("column expr is null", K(j), K(ret));
      } else if (0 != q_name.col_name_.compare(col->get_column_name())) {
        // do nothing
      } else if (OB_FAIL(copier.add_replaced_expr(q_name.ref_expr_, col))) {
        LOG_WARN("failed to add replaced expr", K(ret));
      } else {
        found = true;
      }
    }
    if (OB_FAIL(ret)) {
    } else if (OB_UNLIKELY(!found)) {
      ret = OB_INVALID_ARGUMENT;
      LOG_WARN("column not found in column_conv exprs", K(q_name), K(ret));
    }
  }
  if (OB_FAIL(ret)) {
  } else if (OB_FAIL(copier.copy_on_replace(predicate_expr, expr))) {
    LOG_WARN("failed to copy on replace expr", K(ret));
  }
  return ret;
}

int ObTransformPreProcess::add_filter_for_rls_select(ObDMLStmt &stmt,
                                                     TableItem &table_item,
                                                     const ObIArray<ObQualifiedName> &columns,
                                                     ObRawExpr *expr)
{
  int ret = OB_SUCCESS;
  TableItem *view_table = NULL;
  ObSelectStmt *ref_query = NULL;
  TableItem *child_table = NULL;
  if (stmt.is_single_table_stmt()) {
    if (OB_FAIL(add_filter_for_rls(stmt, table_item, columns, expr))) {
      LOG_WARN("failed to add filter for rls table", K(ret));
    }
  } else if (OB_FAIL(ObTransformUtils::replace_with_empty_view(ctx_,
                                                               &stmt,
                                                               view_table,
                                                               &table_item))) {
    LOG_WARN("failed to create empty view table", K(ret));
  } else if (OB_FAIL(ObTransformUtils::create_inline_view(ctx_,
                                                          &stmt,
                                                          view_table,
                                                          &table_item))) {
    LOG_WARN("failed to create inline view", K(ret));
  } else if (!view_table->is_generated_table()
              || OB_ISNULL(ref_query = view_table->ref_query_)
              || !ref_query->is_single_table_stmt()
              || OB_ISNULL(child_table = ref_query->get_table_item(0))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected view table", K(ret), K(*view_table));
  } else if (OB_FAIL(add_filter_for_rls(*ref_query, *child_table, columns, expr))) {
    LOG_WARN("failed to add filter for rls table", K(ret));
  }
  return ret;
}

int ObTransformPreProcess::add_filter_for_rls_merge(ObDMLStmt &stmt,
                                                    const TableItem &table_item,
                                                    const ObIArray<ObQualifiedName> &columns,
                                                    ObRawExpr *predicate_expr)
{
  int ret = OB_SUCCESS;
  ObRawExpr *expr = NULL;
  if (OB_UNLIKELY(!stmt.is_merge_stmt())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("add rls constraint for invalid stmt type", K(stmt.get_stmt_type()), K(ret));
  } else {
    ObMergeStmt *merge_stmt = static_cast<ObMergeStmt *>(&stmt);
    if (OB_FAIL(build_rls_filter_expr(stmt, table_item, columns, predicate_expr, expr))) {
      LOG_WARN("failed to build filter expr", K(ret));
    } else if (OB_FAIL(merge_stmt->get_match_condition_exprs().push_back(expr))) {
      LOG_WARN("failed to add new condition", K(ret));
    } else {
      LOG_TRACE("add new filter succeed", K(merge_stmt->get_match_condition_exprs()), K(*expr));
    }
  }
  return ret;
}

int ObTransformPreProcess::add_filter_for_rls(ObDMLStmt &stmt,
                                              const TableItem &table_item,
                                              const ObIArray<ObQualifiedName> &columns,
                                              ObRawExpr *predicate_expr)
{
  int ret = OB_SUCCESS;
  ObRawExpr *expr = NULL;
  if (OB_FAIL(build_rls_filter_expr(stmt, table_item, columns, predicate_expr, expr))) {
    LOG_WARN("failed to build filter expr", K(ret));
  } else if (OB_FAIL(stmt.add_condition_expr(expr))) {
    LOG_WARN("failed to add new condition", K(ret));
  } else {
    LOG_TRACE("add new filter succeed", K(stmt.get_condition_exprs()), K(*expr));
  }
  return ret;
}

int ObTransformPreProcess::add_constraint_for_rls(ObDMLStmt &stmt,
                                                  const TableItem &table_item,
                                                  const ObIArray<ObQualifiedName> &columns,
                                                  ObRawExpr *predicate_expr)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObDmlTableInfo*, 2> table_infos;
  bool found = false;
  if (OB_ISNULL(predicate_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr is null", K(ret));
  } else if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (OB_UNLIKELY(!stmt.is_dml_write_stmt())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("add rls constraint for invalid stmt type", K(stmt.get_stmt_type()), K(ret));
  } else if (OB_FAIL(static_cast<ObDelUpdStmt &>(stmt).get_dml_table_infos(table_infos))) {
    LOG_WARN("failed to get dml table info", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < table_infos.count(); ++i) {
    ObDmlTableInfo* table_info = table_infos.at(i);
    ObRawExpr *expr = NULL;
    if (OB_ISNULL(table_info)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null table_info", K(ret));
    } else if (table_info->loc_table_id_ != table_item.table_id_) {
      // do nothing
    } else if (OB_FAIL(build_rls_constraint_expr(*table_info, columns, predicate_expr, expr))) {
      LOG_WARN("failed to build rls constraint expr", K(ret));
    } else if (OB_FAIL(table_info->check_constraint_exprs_.push_back(expr))) {
      LOG_WARN("failed to add check constrinat", K(ret));
    } else {
      found = true;
    }
  }
  if (OB_FAIL(ret)) {
  } else if (OB_UNLIKELY(!found)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item not found", K(table_item), K(ret));
  }

  return ret;
}

int ObTransformPreProcess::replace_expr_for_rls(ObDMLStmt &stmt,
                                                const TableItem &table_item,
                                                const ObRlsPolicySchema &policy_schema,
                                                const ObIArray<ObQualifiedName> &columns,
                                                ObRawExpr *predicate_expr)
{
  int ret = OB_SUCCESS;
  ObRawExpr *expr = NULL;
  ObSEArray<ObRawExprPointer, 16> relation_expr_pointers;
  ObSEArray<ObRawExpr *, 1> old_exprs;
  ObSEArray<ObRawExpr *, 1> new_exprs;
  const int64_t sec_column_count = policy_schema.get_sec_column_count();
  if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (OB_FAIL(build_rls_filter_expr(stmt, table_item, columns, predicate_expr, expr))) {
    LOG_WARN("failed to build filter expr", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < sec_column_count; ++i) {
    const ObRlsSecColumnSchema* rls_column = policy_schema.get_sec_column_by_idx(i);
    ColumnItem *column_item = NULL;
    if (OB_ISNULL(rls_column)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get null rls column", K(ret));
    } else if (NULL != (column_item = stmt.get_column_item_by_id(table_item.table_id_,
                                                                 rls_column->get_column_id()))) {
      ObRawExpr *old_expr = column_item->expr_;
      ObRawExpr *new_expr = NULL;
      ObRawExpr *when_expr = NULL;
      ObRawExpr *null_expr = NULL;
      if (OB_FAIL(ObRawExprUtils::build_null_expr(*ctx_->expr_factory_, null_expr))) {
        LOG_WARN("failed to build null expr", K(ret));
      } else if (FALSE_IT(when_expr = expr)) {
      } else if (OB_FAIL(ObRawExprUtils::build_case_when_expr(*ctx_->expr_factory_,
                                                              when_expr,
                                                              old_expr,
                                                              null_expr,
                                                              new_expr))) {
        LOG_WARN("failed to build case when expr", K(ret));
      } else if (OB_FAIL(old_exprs.push_back(old_expr)) || OB_FAIL(new_exprs.push_back(new_expr))) {
        LOG_WARN("failed to push expr", K(ret));
      }
    }
  }
  if (OB_FAIL(ret)) {
  } else if (OB_FAIL(stmt.replace_relation_exprs(old_exprs, new_exprs))) {
    LOG_WARN("stmt replace inner expr failed", K(ret));
  }
  return ret;
}

int ObTransformPreProcess::get_first_level_output_exprs(
    ObSelectStmt *sub_stmt,
    common::ObIArray<ObRawExpr*>& inner_aggr_exprs)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(sub_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select stmt is null", K(ret));
  } else {
    common::ObIArray<ObAggFunRawExpr*> &aggr_exprs = sub_stmt->get_aggr_items();
    for (int64_t i = 0; OB_SUCC(ret) && i < aggr_exprs.count(); i++) {
      if (OB_ISNULL(aggr_exprs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("expr of aggr expr is null", K(ret));
      } else if (aggr_exprs.at(i)->is_nested_aggr()) {
        /*do nothing.*/
      } else {
        int64_t N = aggr_exprs.at(i)->get_param_count();
        for (int64_t j = 0; OB_SUCC(ret) && j < N; ++j) {
          if (OB_ISNULL(aggr_exprs.at(i)->get_param_expr(j))) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get unexpected null", K(ret));
          } else if (aggr_exprs.at(i)->get_param_expr(j)->is_const_expr()) {
            //do nothing
          } else if (OB_FAIL(add_var_to_array_no_dup(inner_aggr_exprs,
                                                     aggr_exprs.at(i)->get_param_expr(j)))) {
            LOG_WARN("failed to to add var to array no dup.", K(ret));
          } else { /*do nothing.*/ }
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::generate_child_level_aggr_stmt(ObSelectStmt *select_stmt,
                                                          ObSelectStmt *&sub_stmt)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObRawExpr*, 4> complex_aggr_exprs;
  if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->stmt_factory_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select stmt is null", K(ret));
  } else if (OB_FAIL(ctx_->stmt_factory_->create_stmt<ObSelectStmt>(sub_stmt))) {
    LOG_WARN("failed to create stmt.", K(ret));
  } else if (FALSE_IT(sub_stmt->set_query_ctx(select_stmt->get_query_ctx()))) {
  } else if (OB_FAIL(sub_stmt->deep_copy(*ctx_->stmt_factory_,
                                         *ctx_->expr_factory_,
                                         *select_stmt))) {
    LOG_WARN("failed to deep copy from nested stmt.", K(ret));
  } else if (OB_FAIL(sub_stmt->adjust_statement_id(ctx_->allocator_,
                                                   ctx_->src_qb_name_,
                                                   ctx_->src_hash_val_))) {
    LOG_WARN("failed to recursive adjust statement id", K(ret));
  } else if (OB_FAIL(get_first_level_output_exprs(sub_stmt,
                                                  complex_aggr_exprs))) {
    LOG_WARN("failed to extract levels aggr.", K(ret));
  } else {
    sub_stmt->get_aggr_items().reset();
    sub_stmt->get_select_items().reset();
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < sub_stmt->get_having_exprs().count(); ++i) {
    if (OB_FAIL(ObTransformUtils::extract_aggr_expr(sub_stmt->get_having_exprs().at(i),
                                                    sub_stmt->get_aggr_items()))) {
      LOG_WARN("failed to extract aggr exprs.", K(ret));
    } else { /*do nothing.*/ }
  }
  for (int64_t j = 0; OB_SUCC(ret) && j < complex_aggr_exprs.count(); ++j) {
    if (OB_FAIL(ObTransformUtils::extract_aggr_expr(complex_aggr_exprs.at(j),
                                                    sub_stmt->get_aggr_items()))) {
      LOG_WARN("failed to extract aggr exprs.", K(ret));
    } else if (OB_FAIL(ObTransformUtils::create_select_item(*ctx_->allocator_,
                                                            complex_aggr_exprs.at(j),
                                                            sub_stmt))) {
      LOG_WARN("failed to push back into select item array.", K(ret));
    } else { /*do nothing.*/ }
  }

  if (OB_SUCC(ret)) {
    //try transform_groupingsets_rollup_cube:
    //  SELECT count(sum(c1)) FROM t1 GROUP BY GROUPING sets(c1, c2);
    bool is_happened = false;
    ObDMLStmt *dml_stmt = static_cast<ObDMLStmt *>(sub_stmt);
    if (OB_FAIL(transform_groupingsets_rollup_cube(dml_stmt, is_happened))) {
      LOG_WARN("failed to transform for transform for grouping sets, rollup and cube.", K(ret));
    } else if (is_happened) {
      sub_stmt = static_cast<ObSelectStmt *>(dml_stmt);
      LOG_TRACE("succeed to transform for grouping sets and rollup",K(is_happened), K(ret));
    } else {/*do nothing*/}
  }
  return ret;
}

int ObTransformPreProcess::remove_nested_aggr_exprs(ObSelectStmt *stmt)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else {
    ObSEArray<ObAggFunRawExpr *, 4> aggr_exprs;
    for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_aggr_items().count(); i++) {
      if (OB_ISNULL(stmt->get_aggr_items().at(i))) {
       ret = OB_ERR_UNEXPECTED;
       LOG_WARN("expr of aggr expr is null", K(ret));
      } else if (stmt->get_aggr_items().at(i)->is_nested_aggr()) {
       /*do nothing.*/
      } else if (OB_FAIL(aggr_exprs.push_back(stmt->get_aggr_items().at(i)))) {
       LOG_WARN("failed to assign to inner aggr exprs.", K(ret));
      } else { /*do nothing.*/ }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(stmt->get_aggr_items().assign(aggr_exprs))) {
        LOG_WARN("failed to extract second aggr items.", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::construct_column_items_from_exprs(
    const ObIArray<ObRawExpr*> &column_exprs,
    ObIArray<ColumnItem> &column_items)
{
  int ret = OB_SUCCESS;
  for (int64_t i = 0; OB_SUCC(ret) && i < column_exprs.count(); ++i) {
    ColumnItem column_item;
    ObColumnRefRawExpr* expr = static_cast<ObColumnRefRawExpr*>(column_exprs.at(i));
    column_item.expr_ = expr;
    column_item.table_id_ = expr->get_table_id();
    column_item.column_id_ = expr->get_column_id();
    column_item.column_name_ = expr->get_expr_name();
    if (OB_FAIL(column_items.push_back(column_item))) {
      LOG_WARN("failed to push back into temp column items.", K(ret));
    } else { /*do nothing.*/ }
  }
  return ret;
}

int ObTransformPreProcess::generate_parent_level_aggr_stmt(ObSelectStmt *&select_stmt,
                                                           ObSelectStmt *sub_stmt)
{
  int ret = OB_SUCCESS;
  TableItem *view_table_item = NULL;
  ObSEArray<ObRawExpr *, 4> old_exprs;
  ObSEArray<ObRawExpr *, 4> new_exprs;
  ObSEArray<ColumnItem, 4> column_items;
  if (OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select stmt is null", K(ret));
  } else {
    select_stmt->get_table_items().reset();
    select_stmt->get_joined_tables().reset();
    select_stmt->get_from_items().reset();
    select_stmt->get_order_items().reset();
    select_stmt->get_column_items().reset();
    select_stmt->get_condition_exprs().reset();
    select_stmt->get_part_exprs().reset();
    select_stmt->get_check_constraint_items().reset();
    select_stmt->get_group_exprs().reset();
    select_stmt->get_rollup_exprs().reset();
    select_stmt->get_grouping_sets_items().reset();
    select_stmt->get_rollup_items().reset();
    select_stmt->get_cube_items().reset();
    select_stmt->get_having_exprs().reset();
    if (OB_FAIL(get_first_level_output_exprs(select_stmt,
                                             old_exprs))) {
      LOG_WARN("failed to get column exprs from stmt from.", K(ret));
    } else if (OB_FAIL(remove_nested_aggr_exprs(select_stmt))) {
      LOG_WARN("failed to extract second aggr items.", K(ret));
    } else if (OB_FAIL(ObTransformUtils::add_new_table_item(ctx_,
                                                            select_stmt,
                                                            sub_stmt,
                                                            view_table_item))) {
      LOG_WARN("failed to add new table item.", K(ret));
    } else if (OB_FAIL(select_stmt->add_from_item(view_table_item->table_id_))) {
      LOG_WARN("failed to add from item", K(ret));
    } else if (OB_FAIL(ObTransformUtils::create_columns_for_view(ctx_,
                                                                 *view_table_item,
                                                                 select_stmt,
                                                                 new_exprs))) {
      LOG_WARN("failed to get select exprs from grouping sets view.", K(ret));
    } else if (OB_FAIL(construct_column_items_from_exprs(new_exprs, column_items))) {
      LOG_WARN("failed to construct column items from exprs.", K(ret));
    } else if (OB_FAIL(replace_group_id_in_stmt(select_stmt))) {
      LOG_WARN("fail to replace group_id in nested aggr");
    } else if (OB_FAIL(select_stmt->replace_relation_exprs(old_exprs, new_exprs))) {
      LOG_WARN("failed to replace inner stmt exprs.", K(ret));
    } else if (OB_FAIL(select_stmt->get_column_items().assign(column_items))) {
      LOG_WARN("failed to assign column items.", K(ret));
    } else if (OB_FAIL(select_stmt->rebuild_tables_hash())) {
      LOG_WARN("failed to rebuild tables hash.", K(ret));
    } else if (OB_FAIL(select_stmt->update_column_item_rel_id())) {
      LOG_WARN("failed to update column items rel id.", K(ret));
    } else if (OB_FAIL(select_stmt->formalize_stmt(ctx_->session_info_))) {
      LOG_WARN("failed to formalized stmt.", K(ret));
    } else { /*do nothing.*/ }
  }
  return ret;
}

int ObTransformPreProcess::transform_for_nested_aggregate(ObDMLStmt *&stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret), K(stmt), K(ctx_));
  } else if (!stmt->is_select_stmt()) {
    /*do nothing.*/
  } else {
    ObSelectStmt *sub_stmt = NULL;
    ObSelectStmt *select_stmt = static_cast<ObSelectStmt *>(stmt);
    /**
     * 本函数将含有嵌套聚合的stmt改写成两层stmt
     * select sum(b), max(sum(b)) from t1 group by b;
     * 以上sql可以改写成
     * select sum(v.b), max(v.sum_b)
     * from (
     *      select b, sum(b) as sum_b
     *      from t1
     *      group by b
     *      ) v
     * 其中generate_child_level_aggr_stmt函数生成视图v
     * generate_parent_level_aggr_stmt生成外部stmt
     */
    if (!select_stmt->contain_nested_aggr()) {
      /*do nothing.*/
    } else if (OB_FAIL(generate_child_level_aggr_stmt(select_stmt,
                                                      sub_stmt))) {
      LOG_WARN("failed to generate first level aggr stmt.", K(ret));
    } else if (OB_FAIL(generate_parent_level_aggr_stmt(select_stmt,
                                                       sub_stmt))) {
      LOG_WARN("failed to generate nested aggr stmt.", K(ret));
    } else if (OB_FAIL(select_stmt->formalize_stmt(ctx_->session_info_))) {
      LOG_WARN("failed to formalize stmt.", K(ret));
    } else {
      trans_happened = true;
      stmt = select_stmt;
    }
  }
  return ret;
}

int ObTransformPreProcess::replace_group_id_in_stmt(ObSelectStmt *stmt)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else {
    // replace group_id in select list;
    ObIArray<SelectItem> &sel_items = stmt->get_select_items();
    for (int64_t i = 0; OB_SUCC(ret) && i < sel_items.count(); i++) {
      if (OB_ISNULL(sel_items.at(i).expr_)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("expr of select item shouldn't be null", K(ret));
      } else if (OB_FAIL(replace_group_id_in_expr_recursive(sel_items.at(i).expr_))) {
        LOG_WARN("fail to replace expr in selet items", K(ret));
      }
    }
    // replace group_id in having exprs;
    for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_having_expr_size(); i++) {
      if (OB_ISNULL(stmt->get_having_exprs().at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("having expr shouldn't be null", K(ret));
      } else if (OB_FAIL(replace_group_id_in_expr_recursive(stmt->get_having_exprs().at(i)))) {
        LOG_WARN("fail to replace expr in having exprs", K(ret));
      }
    }
    // replace group_id in order by exprs;
    for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_order_item_size(); i++) {
      if (OB_ISNULL(stmt->get_order_item(i).expr_)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("having expr shouldn't be null", K(ret));
      } else if (OB_FAIL(replace_group_id_in_expr_recursive(stmt->get_order_item(i).expr_))) {
        LOG_WARN("fail to replace expr in having exprs", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::replace_group_id_in_expr_recursive(ObRawExpr *&expr)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null pointer", K(ret));
  } else {
    if (expr->is_aggr_expr()) {
      if (expr->get_expr_type() == T_FUN_GROUP_ID) {
        // replace group id with 0;
        ObConstRawExpr *c_expr = NULL;
        if (OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                                         ObIntType,
                                                         0,
                                                         c_expr))) {
          LOG_WARN("fail to build const expr", K(ret));
        } else if (OB_ISNULL(c_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("c_expr is null", K(ret));
        } else {
          expr = c_expr;
        }
      }
    } else {
      // recursive check hierarchical expr(exclude aggr_expr);
      ObRawExpr *tmp_expr = NULL;
      for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); i++) {
        if (OB_ISNULL(tmp_expr = expr->get_param_expr(i))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get param expr is null", K(ret));
        } else if (OB_FAIL(replace_group_id_in_expr_recursive(tmp_expr))) {
          LOG_WARN("fail to replace group id in expr", K(ret));
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_for_merge_into(ObDMLStmt *&stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item is null", K(ret), K(stmt), K(ctx_));
  } else if (stmt->get_stmt_type() != stmt::T_MERGE) {
    /*do nothing*/
  } else if (OB_ISNULL(stmt->get_query_ctx()) ||
             OB_UNLIKELY(stmt->get_table_size() != 2)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("invalid stmt", K(stmt), K(ret));
  } else {
    const int64_t TARGET_TABLE_IDX = 0;
    const int64_t SOURCE_TABLE_IDX = 1;
    TableItem *new_table = NULL;
    ObMergeStmt *merge_stmt = static_cast<ObMergeStmt*>(stmt);
    TableItem *target_table = stmt->get_table_item(TARGET_TABLE_IDX);
    TableItem *source_table = stmt->get_table_item(SOURCE_TABLE_IDX);
    bool is_valid = false;
    if (OB_ISNULL(target_table) || OB_ISNULL(source_table)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("invalid table item", K(target_table), K(source_table), K(ret));
    } else if (OB_FAIL(check_can_transform_insert_only_merge_into(merge_stmt,
                                                                  is_valid))) {
      LOG_WARN("failed to check can transform insert only merge into", K(ret));
    } else if (is_valid) {
      ObDMLStmt* insert_stmt = NULL;
      if (OB_FAIL(transform_insert_only_merge_into(stmt, insert_stmt))) {
        LOG_WARN("failed to transform for insert only merge into", K(ret));
      } else {
        stmt = insert_stmt;
        trans_happened = true;
      }
    } else if (merge_stmt->has_update_clause() && !merge_stmt->has_insert_clause()) {
      if (OB_FAIL(transform_update_only_merge_into(stmt))) {
        LOG_WARN("failed to transform for update only merge into", K(ret));
      } else {
        trans_happened = true;
      }
    } else if (ObTransformUtils::add_new_joined_table(ctx_,
                                                      *merge_stmt,
                                                      LEFT_OUTER_JOIN,
                                                      source_table,
                                                      target_table,
                                                      merge_stmt->get_match_condition_exprs(),
                                                      new_table,
                                                      true)) {
      LOG_WARN("failed to add new joined table", K(ret));
    } else if (OB_ISNULL(new_table)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("new join table is NULL", K(ret));
    } else if (OB_FAIL(merge_stmt->add_from_item(new_table->table_id_,
                                                 new_table->is_joined_table()))) {
      LOG_WARN("fail to add from item", K(new_table), K(ret));
    } else if (OB_FAIL(transform_merge_into_subquery(merge_stmt))) {
      LOG_WARN("failed to transform merge into subquery", K(ret));
    } else {
      merge_stmt->get_match_condition_exprs().reset();
      trans_happened = true;
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_merge_into_subquery(ObMergeStmt *merge_stmt)
{
  int ret = OB_SUCCESS;
  ObRawExprFactory *expr_factory = NULL;
  ObRawExpr *matched_expr = NULL;
  ObRawExpr *not_matched_expr = NULL;
  bool update_has_subquery = false;
  bool insert_has_subquery = false;
  ObSEArray<ObRawExpr*, 8> condition_subquery_exprs;
  ObSEArray<ObRawExpr*, 8> target_subquery_exprs;
  ObSEArray<ObRawExpr*, 8> delete_subquery_exprs;
  if (OB_ISNULL(merge_stmt) || OB_ISNULL(expr_factory = ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret), K(merge_stmt));
  } else if (!merge_stmt->has_subquery()) {
    // do nothing
  } else if (OB_FAIL(create_matched_expr(*merge_stmt, matched_expr, not_matched_expr))) {
    LOG_WARN("failed to build matched expr", K(ret));
  } else if (OB_FAIL(get_update_insert_condition_subquery(merge_stmt,
                                                          matched_expr,
                                                          not_matched_expr,
                                                          update_has_subquery,
                                                          insert_has_subquery,
                                                          condition_subquery_exprs))) {
    LOG_WARN("failed to allocate update insert condition subquery", K(ret));
  } else if (OB_FAIL(get_update_insert_target_subquery(merge_stmt,
                                                       matched_expr,
                                                       not_matched_expr,
                                                       update_has_subquery,
                                                       insert_has_subquery,
                                                       target_subquery_exprs))) {
    LOG_WARN("failed to allocate update insert target subquery", K(ret));
  } else if (OB_FAIL(get_delete_condition_subquery(merge_stmt,
                                                   matched_expr,
                                                   update_has_subquery,
                                                   delete_subquery_exprs))) {
    LOG_WARN("failed to allocate delete condition subquery", K(ret));
  } else if (OB_FAIL(merge_stmt->formalize_stmt_expr_reference(expr_factory, ctx_->session_info_))) {
    LOG_WARN("failed to formalize stmt expr reference", K(ret));
  }
  return ret;
}

int ObTransformPreProcess::create_matched_expr(ObMergeStmt &stmt,
                                                ObRawExpr *&matched_flag,
                                                ObRawExpr *&not_matched_flag)
{
  int ret = OB_SUCCESS;
  ObMergeTableInfo& table_info = stmt.get_merge_table_info();
  ObRawExpr *not_null_expr = NULL;
  for (int64_t i = 0; OB_SUCC(ret) && i < table_info.column_exprs_.count(); ++i) {
    ObColumnRefRawExpr *column = NULL;
    if (OB_ISNULL(column = table_info.column_exprs_.at(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("column expr is null", K(ret));
    } else if (column->is_not_null_for_read()) {
      not_null_expr = column;
      break;
    }
  }
  if (OB_SUCC(ret)) {
    if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_) || OB_ISNULL(ctx_->session_info_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("context is invalid", K(ret), K(ctx_));
    } else if (OB_ISNULL(not_null_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("failed to find not null expr from merge into target table", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::build_is_not_null_expr(
                         *ctx_->expr_factory_,
                         not_null_expr,
                         true,
                         matched_flag))) {
      LOG_WARN("failed to build is not null expr", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::build_is_not_null_expr(
                         *ctx_->expr_factory_,
                         not_null_expr,
                         false,
                         not_matched_flag))) {
      LOG_WARN("failed to build is null expr", K(ret));
    } else if (OB_FAIL(matched_flag->formalize(ctx_->session_info_))) {
      LOG_WARN("failed to formalize matched expr", K(ret));
    } else if (OB_FAIL(not_matched_flag->formalize(ctx_->session_info_))) {
      LOG_WARN("failed to formalize not matched flag", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::get_update_insert_condition_subquery(ObMergeStmt *merge_stmt,
                                                                ObRawExpr *matched_expr,
                                                                ObRawExpr *not_matched_expr,
                                                                bool &update_has_subquery,
                                                                bool &insert_has_subquery,
                                                                ObIArray<ObRawExpr*> &new_subquery_exprs)
{
  int ret = OB_SUCCESS;
  bool where_has_subquery = false;
  update_has_subquery = false;
  insert_has_subquery = false;
  if (OB_ISNULL(merge_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(merge_stmt), K(ctx_));
  } else if (OB_FAIL(ObOptimizerUtil::check_expr_contain_subquery(merge_stmt->get_update_condition_exprs(),
                                                                  update_has_subquery))) {
    LOG_WARN("failed to check whether expr contain subquery", K(ret));
  } else if (OB_FAIL(ObOptimizerUtil::check_expr_contain_subquery(merge_stmt->get_insert_condition_exprs(),
                                                                  insert_has_subquery))) {
    LOG_WARN("failed to check whether expr contain subquery", K(ret));
  } else if (OB_FAIL(ObOptimizerUtil::check_expr_contain_subquery(merge_stmt->get_condition_exprs(),
                                                                  where_has_subquery))) {
    LOG_WARN("failed to check whether expr contain subquery", K(ret));
  } else if (update_has_subquery &&
             OB_FAIL(generate_merge_conditions_subquery(matched_expr,
                                                        merge_stmt->get_update_condition_exprs()))) {
    LOG_WARN("failed to generate condition subquery", K(ret));
  } else if (insert_has_subquery &&
             OB_FAIL(generate_merge_conditions_subquery(not_matched_expr,
                                                        merge_stmt->get_insert_condition_exprs()))) {
    LOG_WARN("failed to generate condition subquery", K(ret));
  } else if (where_has_subquery &&
             OB_FAIL(generate_merge_conditions_subquery(matched_expr,
                                                        merge_stmt->get_condition_exprs()))) {
    LOG_WARN("failed to generate condition subquery", K(ret));
  } else if (update_has_subquery &&
             OB_FAIL(append(new_subquery_exprs, merge_stmt->get_update_condition_exprs()))) {
    LOG_WARN("failed to append subquery exprs", K(ret));
  } else if (insert_has_subquery &&
             OB_FAIL(append(new_subquery_exprs, merge_stmt->get_insert_condition_exprs()))) {
    LOG_WARN("failed to append subquery exprs", K(ret));
  } else if (where_has_subquery &&
             OB_FAIL(append(new_subquery_exprs, merge_stmt->get_condition_exprs()))) {
    LOG_WARN("failed to append subquery exprs", K(ret));
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < new_subquery_exprs.count(); i++) {
      ObRawExpr *raw_expr = NULL;
      if (OB_ISNULL(raw_expr = new_subquery_exprs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret));
      } else if (OB_FAIL(raw_expr->formalize(ctx_->session_info_))) {
        LOG_WARN("failed to formalize case expr", K(ret));
      } else if (OB_FAIL(raw_expr->pull_relation_id())) {
        LOG_WARN("failed to pull relation id and levels", K(ret));
      } else { /*do nothing*/ }
    }
  }
  return ret;
}

int ObTransformPreProcess::generate_merge_conditions_subquery(ObRawExpr *matched_expr,
                                                              ObIArray<ObRawExpr*> &condition_exprs)
{
  int ret = OB_SUCCESS;
  ObRawExpr *and_expr = NULL;
  ObSEArray<ObRawExpr *, 4> param_conditions;
  ObSEArray<ObRawExpr*, 8> subquery_exprs;
  ObRawExprFactory *expr_factory = NULL;
  if (OB_ISNULL(matched_expr) || OB_ISNULL(expr_factory = ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret));
  } else if (OB_FAIL(ObOptimizerUtil::get_subquery_exprs(condition_exprs, subquery_exprs))) {
    LOG_WARN("failed to classify subquery exprs", K(ret));
  } else if (subquery_exprs.empty()) {
    /*do nothing*/
  } else if (OB_FAIL(param_conditions.push_back(matched_expr)) ||
             OB_FAIL(append(param_conditions, condition_exprs))) {
    LOG_WARN("failed to push back expr", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::build_and_expr(*expr_factory, param_conditions, and_expr))) {
    LOG_WARN("failed to build matched expr", K(ret));
  } else if (OB_ISNULL(and_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret));
  } else {
    condition_exprs.reuse();
    if (OB_FAIL(condition_exprs.push_back(and_expr))) {
      LOG_WARN("failed to push back expr", K(ret));
    } else { /*do nothing*/ }
  }
  return ret;
}

int ObTransformPreProcess::get_update_insert_target_subquery(ObMergeStmt *merge_stmt,
                                                             ObRawExpr *matched_expr,
                                                             ObRawExpr *not_matched_expr,
                                                             bool update_has_subquery,
                                                             bool insert_has_subquery,
                                                             ObIArray<ObRawExpr*> &new_subquery_exprs)
{
  int ret = OB_SUCCESS;
  ObRawExpr *null_expr = NULL;
  ObSEArray<ObRawExpr*, 8> temp_exprs;
  ObSEArray<ObRawExpr*, 8> assign_exprs;
  ObSEArray<ObRawExpr*, 8> update_subquery_exprs;
  ObSEArray<ObRawExpr*, 8> insert_values_subquery_exprs;
  ObRawExprFactory *expr_factory = NULL;
  if (OB_ISNULL(merge_stmt) || OB_ISNULL(ctx_) ||
      OB_ISNULL(expr_factory = ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret));
  } else if (OB_FAIL(merge_stmt->get_assignments_exprs(assign_exprs))) {
    LOG_WARN("failed to get table assignment exprs", K(ret));
  } else if (OB_FAIL(ObOptimizerUtil::get_subquery_exprs(assign_exprs,
                                                         update_subquery_exprs))) {
    LOG_WARN("failed to get subquery exprs", K(ret));
  } else if (OB_FAIL(ObOptimizerUtil::get_subquery_exprs(merge_stmt->get_values_vector(),
                                                         insert_values_subquery_exprs))) {
    LOG_WARN("failed to get subquery exprs", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::build_null_expr(*expr_factory, null_expr))) {
    LOG_WARN("failed to build null expr", K(ret));
  } else if (OB_ISNULL(null_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null expr", K(null_expr), K(ret));
  } else {
    if (!update_subquery_exprs.empty()) {
      ObRawExpr *update_matched_expr = NULL;
      if (merge_stmt->get_update_condition_exprs().empty()) {
        update_matched_expr = matched_expr;
      } else if (update_has_subquery) {
        if (OB_UNLIKELY(1 != merge_stmt->get_update_condition_exprs().count()) ||
            OB_ISNULL(merge_stmt->get_update_condition_exprs().at(0))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected error", K(ret));
        } else {
          update_matched_expr = merge_stmt->get_update_condition_exprs().at(0);
        }
      } else if (OB_FAIL(temp_exprs.push_back(matched_expr)) ||
                 OB_FAIL(append(temp_exprs, merge_stmt->get_update_condition_exprs()))) {
        LOG_WARN("failed to append exprs", K(ret));
      } else if (OB_FAIL(ObRawExprUtils::build_and_expr(*expr_factory,
                                                        temp_exprs,
                                                        update_matched_expr))) {
        LOG_WARN("failed to build and expr", K(ret));
      } else if (OB_ISNULL(update_matched_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret));
      } else { /*do nothing*/ }

      for (int64_t i = 0; OB_SUCC(ret) && i < update_subquery_exprs.count(); i++) {
        ObRawExpr *raw_expr = NULL;
        ObRawExpr *cast_expr = NULL;
        ObRawExpr *case_when_expr = NULL;
        if (OB_ISNULL(raw_expr = update_subquery_exprs.at(i))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret));
        } else if (OB_FAIL(ObRawExprUtils::try_add_cast_expr_above(
                              ctx_->expr_factory_,
                              ctx_->session_info_,
                              *null_expr,
                              raw_expr->get_result_type(),
                              cast_expr))) {
          LOG_WARN("try add cast expr above failed", K(ret));
        } else if (OB_FAIL(ObRawExprUtils::build_case_when_expr(*expr_factory,
                                                                update_matched_expr,
                                                                raw_expr,
                                                                cast_expr,
                                                                case_when_expr))) {
          LOG_WARN("failed to build case when expr", K(ret));
        } else if (OB_ISNULL(case_when_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret));
        } else if (OB_FAIL(new_subquery_exprs.push_back(case_when_expr))) {
          LOG_WARN("failed to push back case when expr", K(ret));
        } else { /*do nothing*/ }
      }
    }
    if (OB_SUCC(ret) && !insert_values_subquery_exprs.empty()) {
      ObRawExpr *insert_matched_expr = NULL;
      if (merge_stmt->get_insert_condition_exprs().empty()) {
        insert_matched_expr = not_matched_expr;
      } else if (insert_has_subquery) {
        if (OB_UNLIKELY(1 != merge_stmt->get_insert_condition_exprs().count()) ||
            OB_ISNULL(merge_stmt->get_insert_condition_exprs().at(0))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret));
        } else {
          insert_matched_expr = merge_stmt->get_insert_condition_exprs().at(0);
        }
      } else if (OB_FAIL(temp_exprs.push_back(not_matched_expr)) ||
                 OB_FAIL(temp_exprs.assign(merge_stmt->get_insert_condition_exprs()))) {
        LOG_WARN("failed to fill and child exprs", K(ret));
      } else if (OB_FAIL(ObRawExprUtils::build_and_expr(*expr_factory, temp_exprs,
                                                        insert_matched_expr))) {
        LOG_WARN("failed to build and expr", K(ret));
      } else if (OB_ISNULL(insert_matched_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret));
      } else { /*do nothing*/ }

      for (int64_t i = 0; OB_SUCC(ret) && i < insert_values_subquery_exprs.count(); i++) {
        ObRawExpr *raw_expr = NULL;
        ObRawExpr *case_when_expr = NULL;
        if (OB_ISNULL(raw_expr = insert_values_subquery_exprs.at(i))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret));
        } else if (OB_FAIL(ObRawExprUtils::build_case_when_expr(*expr_factory,
                                                                insert_matched_expr,
                                                                raw_expr,
                                                                null_expr,
                                                                case_when_expr))) {
          LOG_WARN("failed to build case when expr", K(ret));
        } else if (OB_ISNULL(case_when_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret));
        } else if (OB_FAIL(new_subquery_exprs.push_back(case_when_expr))) {
          LOG_WARN("failed to push back subquery exprs", K(ret));
        } else { /*do nothing*/ }
      }
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < new_subquery_exprs.count(); i++) {
      ObRawExpr *raw_expr = NULL;
      if (OB_ISNULL(raw_expr = new_subquery_exprs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret));
      } else if (OB_FAIL(raw_expr->formalize(ctx_->session_info_))) {
        LOG_WARN("failed to formalize case expr", K(ret));
      } else if (OB_FAIL(raw_expr->pull_relation_id())) {
        LOG_WARN("failed to pull relation id and levels", K(ret));
      } else { /*do nothing*/ }
    }
    if (OB_SUCC(ret) && !new_subquery_exprs.empty()) {
      ObSEArray<ObRawExpr*, 8> old_subquery_exprs;
      if (OB_FAIL(append(old_subquery_exprs, update_subquery_exprs)) ||
          OB_FAIL(append(old_subquery_exprs, insert_values_subquery_exprs))) {
        LOG_WARN("failed to append exprs", K(ret));
      } else if (OB_UNLIKELY(old_subquery_exprs.count() != new_subquery_exprs.count())) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected array count", K(old_subquery_exprs.count()),
            K(new_subquery_exprs.count()), K(ret));
      } else if (OB_FAIL(merge_stmt->replace_relation_exprs(old_subquery_exprs, new_subquery_exprs))) {
        LOG_WARN("failed to replace merge stmt", K(ret));
      } else { /*do nothing*/ }
    }
  }
  return ret;
}

int ObTransformPreProcess::get_delete_condition_subquery(ObMergeStmt *merge_stmt,
                                                         ObRawExpr *matched_expr,
                                                         bool update_has_subquery,
                                                         ObIArray<ObRawExpr*> &new_subquery_exprs)
{
  int ret = OB_SUCCESS;
  ObRawExprFactory *expr_factory = NULL;
  bool delete_has_subquery = false;
  if (OB_ISNULL(merge_stmt) || OB_ISNULL(ctx_) ||
      OB_ISNULL(expr_factory = ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret));
  } else if (OB_FAIL(ObOptimizerUtil::check_expr_contain_subquery(merge_stmt->get_delete_condition_exprs(),
                                                                  delete_has_subquery))) {
    LOG_WARN("failed to check whether expr contain subquery", K(ret));
  } else if (!delete_has_subquery) {
    /*do nothing*/
  } else {
    ObSqlBitSet<> check_table_set;
    ObSEArray<ObRawExpr*, 8> temp_exprs;
    ObRawExpr *delete_matched_expr = NULL;
    ObSEArray<ObRawExpr*, 8> all_column_exprs;
    ObSEArray<ObRawExpr*, 8> delete_column_exprs;
    if (OB_FAIL(check_table_set.add_member(merge_stmt->get_table_bit_index(
                                           merge_stmt->get_target_table_id())))) {
      LOG_WARN("failed to add table set", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::extract_column_exprs(merge_stmt->get_delete_condition_exprs(),
                                                            all_column_exprs))) {
      LOG_WARN("failed to extract column exprs", K(ret));
    } else if (OB_FAIL(ObTransformUtils::extract_table_exprs(*merge_stmt,
                                                             all_column_exprs,
                                                             check_table_set,
                                                             delete_column_exprs))) {
      LOG_WARN("failed to extract table exprs", K(ret));
    } else if (delete_column_exprs.empty()) {
      /*do nothing*/
    } else {
      ObSEArray<ObRawExpr*, 8> old_exprs;
      ObSEArray<ObRawExpr*, 8> new_exprs;
      ObAssignments &table_assigns  = merge_stmt->get_merge_table_info().assignments_;
      for (int64_t j = 0; OB_SUCC(ret) && j < table_assigns.count(); j++) {
        if (OB_ISNULL(table_assigns.at(j).column_expr_) ||
            OB_ISNULL(table_assigns.at(j).expr_)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret));
        } else if (!ObOptimizerUtil::find_item(delete_column_exprs,
                                               table_assigns.at(j).column_expr_)) {
          /*do nothing*/
        } else if (table_assigns.at(j).expr_->has_flag(CNT_SUB_QUERY) ||
                   table_assigns.at(j).expr_->has_flag(CNT_ONETIME)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("not support replace column expr with subquery expr", K(ret));
        } else if (OB_FAIL(old_exprs.push_back(table_assigns.at(j).column_expr_)) ||
                   OB_FAIL(new_exprs.push_back(table_assigns.at(j).expr_))) {
          LOG_WARN("failed to push back exprs", K(ret));
        }  else { /*do nothing*/ }
      }
      if (OB_SUCC(ret)) {
        if (OB_FAIL(ObTransformUtils::replace_exprs(old_exprs,
                                                    new_exprs,
                                                    merge_stmt->get_delete_condition_exprs()))) {
          LOG_WARN("failed to replace exprs", K(ret));
        }
      }
    }
    if (OB_FAIL(ret)) {
      /*do nothing*/
    } else if (merge_stmt->get_update_condition_exprs().empty()) {
      delete_matched_expr = matched_expr;
    } else if (update_has_subquery) {
      if (OB_UNLIKELY(1 != merge_stmt->get_update_condition_exprs().count()) ||
          OB_ISNULL(merge_stmt->get_update_condition_exprs().at(0))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected error", K(ret));
      } else {
        delete_matched_expr = merge_stmt->get_update_condition_exprs().at(0);
      }
    } else if (OB_FAIL(temp_exprs.push_back(matched_expr)) ||
               OB_FAIL(append(temp_exprs, merge_stmt->get_update_condition_exprs()))) {
      LOG_WARN("failed to push back exprs", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::build_and_expr(*expr_factory,
                                                      temp_exprs,
                                                      delete_matched_expr))) {
      LOG_WARN("failed to build matched expr", K(ret));
    } else if (OB_ISNULL(delete_matched_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get unexpected null", K(ret));
    } else { /*do nothing*/}

    if (OB_FAIL(ret)) {
      /*do nothing*/
    } else if (OB_FAIL(generate_merge_conditions_subquery(delete_matched_expr,
                                                          merge_stmt->get_delete_condition_exprs()))) {
      LOG_WARN("failed to generate merge conditions", K(ret));
    } else if (OB_FAIL(append(new_subquery_exprs, merge_stmt->get_delete_condition_exprs()))) {
      LOG_WARN("failed to append new exprs", K(ret));
    } else {
      for (int64_t i = 0; OB_SUCC(ret) && i < new_subquery_exprs.count(); i++) {
        ObRawExpr *raw_expr = NULL;
        if (OB_ISNULL(raw_expr = new_subquery_exprs.at(i))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret));
        } else if (OB_FAIL(raw_expr->formalize(ctx_->session_info_))) {
          LOG_WARN("failed to formalize case expr", K(ret));
        } else if (OB_FAIL(raw_expr->pull_relation_id())) {
          LOG_WARN("failed to pull relation id and levels", K(ret));
        } else { /*do nothing*/ }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_update_only_merge_into(ObDMLStmt* stmt)
{
  int ret = OB_SUCCESS;
  ObMergeStmt *merge_stmt = NULL;
  const int64_t TARGET_TABLE_IDX = 0;
  const int64_t SOURCE_TABLE_IDX = 1;
  TableItem *target_table = NULL;
  TableItem *source_table = NULL;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret), K(stmt));
  } else if (stmt->get_stmt_type() != stmt::T_MERGE) {
    /*do nothing*/
  } else if (OB_FALSE_IT(merge_stmt = static_cast<ObMergeStmt*>(stmt))) {
  } else if (OB_ISNULL(source_table = merge_stmt->get_table_item(SOURCE_TABLE_IDX)) ||
             OB_ISNULL(target_table = merge_stmt->get_table_item(TARGET_TABLE_IDX))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item is null", K(ret), K(stmt));
  } else if (OB_FAIL(merge_stmt->add_from_item(source_table->table_id_, source_table->is_joined_table()))) {
    LOG_WARN("failed to add from item", K(ret));
  } else if (OB_FAIL(merge_stmt->add_from_item(target_table->table_id_, target_table->is_joined_table()))) {
    LOG_WARN("failed to add from item", K(ret));
  } else if (OB_FAIL(merge_stmt->get_condition_exprs().assign(merge_stmt->get_match_condition_exprs()))) {
    LOG_WARN("failed to assign match condition exprs", K(ret));
  } else if (OB_FAIL(append(merge_stmt->get_condition_exprs(), merge_stmt->get_update_condition_exprs()))) {
    LOG_WARN("failed to append condition exprs", K(ret));
  } else if (OB_FALSE_IT(merge_stmt->get_match_condition_exprs().reset())) {
  } else if (OB_FALSE_IT(merge_stmt->get_update_condition_exprs().reset())) {
  } else if (OB_FAIL(transform_merge_into_subquery(merge_stmt))) {
    LOG_WARN("failed to transform merge into subquery", K(ret));
  }
  return ret;
}

int ObTransformPreProcess::create_source_view_for_merge_into(ObMergeStmt *merge_stmt, TableItem *&view_table)
{
  int ret = OB_SUCCESS;
  const int64_t SOURCE_TABLE_IDX = 1;
  TableItem *source_table = NULL;
  ObSEArray<ObRawExpr*, 8> insert_values_subquery_exprs;
  if (OB_ISNULL(merge_stmt) || OB_ISNULL(ctx_) ||
      OB_ISNULL(ctx_->allocator_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item is null", K(ret), K(merge_stmt), K(ctx_));
  } else if (OB_ISNULL(source_table = merge_stmt->get_table_item(SOURCE_TABLE_IDX))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item is null", K(ret), K(merge_stmt), K(ctx_));
  } else if (OB_FAIL(ObTransformUtils::replace_with_empty_view(ctx_,
                                                               merge_stmt,
                                                               view_table,
                                                               source_table))) {
    LOG_WARN("failed to create empty view table", K(ret));
  } else if (OB_FAIL(ObTransformUtils::create_inline_view(ctx_,
                                                          merge_stmt,
                                                          view_table,
                                                          source_table))) {
    LOG_WARN("failed to create view with table", K(ret));
  } else if (OB_FAIL(ObOptimizerUtil::get_subquery_exprs(merge_stmt->get_values_vector(),
                                                         insert_values_subquery_exprs))) {
    LOG_WARN("failed to get subquery exprs", K(ret));
  } else if (!insert_values_subquery_exprs.empty()) {
    ObSelectStmt* view_stmt = view_table->ref_query_;
    ObSEArray<ObRawExpr *, 8> tmp_column_exprs;
    ObSEArray<ObRawExpr *, 8> tmp_select_exprs;
    if (OB_ISNULL(view_stmt)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("select stmt is null", K(ret));
    } else if (OB_FAIL(ObTransformUtils::create_select_item(*ctx_->allocator_,
                                                            insert_values_subquery_exprs,
                                                            view_stmt))) {
      LOG_WARN("failed to create select item", K(ret));
    } else if (OB_FAIL(ObTransformUtils::create_columns_for_view(ctx_, *view_table, merge_stmt, tmp_column_exprs))) {
      LOG_WARN("failed to create column items", K(ret));
    } else if (OB_FAIL(ObTransformUtils::convert_column_expr_to_select_expr(tmp_column_exprs, *view_stmt,
                                                                            tmp_select_exprs))) {
      LOG_WARN("failed to convert column expr to select expr", K(ret));
    } else {
      ObSEArray<ObRawExpr *, 8> old_column_exprs;
      ObSEArray<ObRawExpr *, 8> view_column_exprs;
      ObSEArray<ObRawExpr *, 8> old_subquery_exprs;
      ObSEArray<ObRawExpr *, 8> new_subquery_column_exprs;
      for (int64_t i = 0; OB_SUCC(ret) && i < insert_values_subquery_exprs.count(); ++i) {
        ObRawExpr* expr = NULL;
        int64_t idx = -1;
        if (OB_ISNULL(expr = insert_values_subquery_exprs.at(i))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret));
        } else if (!ObOptimizerUtil::find_item(tmp_select_exprs, expr, &idx)) {
        } else if (OB_FAIL(old_subquery_exprs.push_back(expr))) {
          LOG_WARN("failed to push back", K(ret));
        } else if (OB_FAIL(new_subquery_column_exprs.push_back(tmp_column_exprs.at(idx)))) {
          LOG_WARN("failed to push back", K(ret));
        }
      }
      for (int64_t i = 0; OB_SUCC(ret) && i < tmp_select_exprs.count(); ++i) {
        ObRawExpr *expr = tmp_select_exprs.at(i);
        if (OB_ISNULL(expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret));
        } else if (!expr->is_column_ref_expr()) {
          // do nothing
        } else if (OB_FAIL(old_column_exprs.push_back(expr))) {
          LOG_WARN("failed to push back", K(ret));
        } else if (OB_FAIL(view_column_exprs.push_back(tmp_column_exprs.at(i)))) {
          LOG_WARN("failed to push back", K(ret));
        }
      }
      if (OB_FAIL(ret)) {
      } else if (OB_FAIL(merge_stmt->replace_relation_exprs(old_subquery_exprs,
                                                            new_subquery_column_exprs))) {
        LOG_WARN("failed to replace relation exprs", K(ret));
      } else if (OB_FAIL(view_stmt->replace_relation_exprs(view_column_exprs, old_column_exprs))) {
        LOG_WARN("failed tp replace relation exprs", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_insert_only_merge_into(ObDMLStmt* stmt, ObDMLStmt*& out)
{
  int ret = OB_SUCCESS;
  ObStmtFactory *stmt_factory = NULL;
  ObMergeStmt *merge_stmt = NULL;
  ObInsertStmt *insert_stmt = NULL;
  ObSelectStmt *select_stmt = NULL;
  TableItem *target_table = NULL;
  TableItem *inner_source_table = NULL;
  SemiInfo  *semi_info = NULL;
  TableItem *view_table = NULL;
  TableItem *inner_target_table = NULL;
  ObSEArray<ObDMLStmt::PartExprItem, 8> part_items;
  ObSEArray<ObDMLStmt::PartExprItem, 8> inner_part_items;
  ObSEArray<ColumnItem, 8> column_items;
  ObSEArray<ColumnItem, 8> inner_column_items;
  ObSEArray<ObRawExpr*, 8> old_column_exprs;
  ObSEArray<ObRawExpr*, 8> new_column_exprs;
  int32_t old_bit_id = OB_INVALID_INDEX;
  int32_t new_bit_id = OB_INVALID_INDEX;
  const int64_t TARGET_TABLE_IDX = 0;
  bool dummy = false;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_) ||
      OB_ISNULL(stmt_factory = ctx_->stmt_factory_) ||
      OB_ISNULL(ctx_->allocator_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item is null", K(ret), K(stmt), K(ctx_));
  } else if (stmt->get_stmt_type() != stmt::T_MERGE) {
    /*do nothing*/
  } else if (OB_FALSE_IT(merge_stmt = static_cast<ObMergeStmt*>(stmt))) {
  } else if (OB_ISNULL(target_table = merge_stmt->get_table_item(TARGET_TABLE_IDX))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item is null", K(ret), K(stmt), K(ctx_));
  } else if (OB_FAIL(create_source_view_for_merge_into(merge_stmt,
                                                       view_table))) {
    LOG_WARN("failed to create source view for merge into", K(ret));
  } else if (OB_FAIL(stmt_factory->create_stmt<ObInsertStmt>(insert_stmt))) {
    LOG_WARN("failed to create insert stmt", K(ret));
  } else if (OB_FAIL(insert_stmt->ObDelUpdStmt::assign(*merge_stmt))) {
    LOG_WARN("failed to assign stmt", K(ret));
  } else if (OB_FAIL(insert_stmt->get_insert_table_info().assign(merge_stmt->get_merge_table_info()))) {
    LOG_WARN("failed to assign table info", K(ret));
  } else if (OB_FALSE_IT(insert_stmt->set_stmt_type(stmt::T_INSERT))) {
  } else if (OB_FAIL(insert_stmt->add_from_item(view_table->table_id_, view_table->is_joined_table()))) {
    LOG_WARN("failed to add from item to insert stmt", K(ret));
  } else if (OB_ISNULL(select_stmt = view_table->ref_query_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select stmt is null", K(ret), K(select_stmt));
  } else if (OB_ISNULL(inner_source_table = select_stmt->get_table_item(0))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item is null", K(ret));
  } else if (OB_ISNULL(inner_target_table = select_stmt->create_table_item(*ctx_->allocator_))) {
    ret = OB_ALLOCATE_MEMORY_FAILED;
    LOG_ERROR("create table item failed");
  } else {
    ObRawExprCopier expr_copier(*ctx_->expr_factory_);
    if (OB_FAIL(inner_target_table->deep_copy(expr_copier, *target_table))) {
      LOG_WARN("failed to copy table item", K(ret));
    } else if (OB_FALSE_IT(inner_target_table->table_id_ = select_stmt->get_query_ctx()->available_tb_id_--)) {
    } else if (OB_FAIL(ObTransformUtils::add_table_item(select_stmt, inner_target_table))) {
      LOG_WARN("failed to add table item", K(ret));
    } else if (target_table->is_generated_table()) {
      ObSelectStmt *ref_stmt = NULL;
      if (OB_FAIL(stmt_factory->create_stmt<ObSelectStmt>(ref_stmt))) {
        LOG_WARN("failed to create insert stmt", K(ret));
      } else if (OB_FAIL(ref_stmt->deep_copy(*stmt_factory, expr_copier, *target_table->ref_query_))) {
        LOG_WARN("failed to copy ref query", K(ret));
      } else if (OB_FAIL(ref_stmt->recursive_adjust_statement_id(ctx_->allocator_,
                                                                 ctx_->src_hash_val_,
                                                                 1))) {
        LOG_WARN("failed to recursive adjust statement id", K(ret));
      } else if (OB_FAIL(ref_stmt->update_stmt_table_id(*target_table->ref_query_))) {
        LOG_WARN("failed to update table id", K(ret));
      } else if (OB_FALSE_IT(inner_target_table->ref_query_ = ref_stmt)) {
      } else if (OB_FAIL(ref_stmt->adjust_subquery_list())) {
        LOG_WARN("failed to adjust subquery list", K(ret));
      }
    }
    if (OB_FAIL(ret)) {
    } else if (OB_UNLIKELY(OB_INVALID_INDEX ==
                           (new_bit_id = select_stmt->get_table_bit_index(inner_target_table->table_id_)))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("failed to get table index id", K(ret));
    } else if (OB_UNLIKELY(OB_INVALID_INDEX ==
                           (old_bit_id = insert_stmt->get_table_bit_index(target_table->table_id_)))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("failed to get table index id", K(ret));
    } else if (OB_FAIL(insert_stmt->get_column_items(target_table->table_id_, column_items))) {
      LOG_WARN("failed to get column items", K(ret));
    } else if (OB_FAIL(deep_copy_stmt_objects<ColumnItem>(expr_copier,
                                                          column_items,
                                                          inner_column_items))) {
      LOG_WARN("failed to deep copy column items", K(ret));
    } else if (OB_FAIL(ObTransformUtils::update_table_id_for_column_item(column_items,
                                                                         target_table->table_id_,
                                                                         inner_target_table->table_id_,
                                                                         old_bit_id,
                                                                         new_bit_id,
                                                                         inner_column_items))) {
      LOG_WARN("failed to update table id for column item", K(ret));
    } else if (OB_FAIL(select_stmt->add_column_item(inner_column_items))) {
      LOG_WARN("failed to add column itemes", K(ret));
    } else if (OB_FAIL(insert_stmt->get_part_expr_items(target_table->table_id_, part_items))) {
      LOG_WARN("failed to get part expr items", K(ret));
    } else if (OB_FAIL(deep_copy_stmt_objects<ObDMLStmt::PartExprItem>(expr_copier,
                                                                       part_items,
                                                                       inner_part_items))) {
      LOG_WARN("failed to deep copy part expr items", K(ret));
    } else if (OB_FAIL(ObTransformUtils::update_table_id_for_part_item(part_items,
                                                                       target_table->table_id_,
                                                                       inner_target_table->table_id_,
                                                                       inner_part_items))) {
      LOG_WARN("failed to update table id for part item", K(ret));
    } else if (OB_FAIL(select_stmt->set_part_expr_items(inner_part_items))) {
      LOG_WARN("failed to set part expr items", K(ret));
    } else if (OB_FAIL(insert_stmt->get_column_exprs(view_table->table_id_, old_column_exprs))) {
      LOG_WARN("failed to get column exprs", K(ret));
    } else if (OB_FAIL(ObTransformUtils::convert_column_expr_to_select_expr(
                                         old_column_exprs,
                                         *select_stmt,
                                         new_column_exprs))) {
      LOG_WARN("failed to convert column expr to select expr", K(ret));
    } else if (OB_FAIL(ObTransformUtils::extract_copier_exprs(expr_copier,
                                                              old_column_exprs,
                                                              new_column_exprs))) {
      LOG_WARN("failed to extract copier exprs", K(ret));
    } else if (OB_FAIL(select_stmt->add_condition_exprs(merge_stmt->get_insert_condition_exprs()))) {
      LOG_WARN("failed to add condition exprs", K(ret));
    } else if (OB_ISNULL(semi_info = static_cast<SemiInfo *>(ctx_->allocator_->alloc(sizeof(SemiInfo))))) {
      ret = OB_ALLOCATE_MEMORY_FAILED;
      LOG_WARN("failed to allocate semi info", K(ret));
    } else if (OB_FALSE_IT(semi_info = new(semi_info)SemiInfo())) {
    } else if (OB_FAIL(semi_info->semi_conditions_.assign(merge_stmt->get_match_condition_exprs()))) {
      LOG_WARN("failed to assign join conditions", K(ret));
    } else if (OB_FALSE_IT(semi_info->join_type_ = LEFT_ANTI_JOIN)) {
    } else if (OB_FALSE_IT(semi_info->right_table_id_ = inner_target_table->table_id_)) {
    } else if (OB_FALSE_IT(semi_info->semi_id_ = select_stmt->get_query_ctx()->available_tb_id_--)) {
    } else if (OB_FAIL(semi_info->left_table_ids_.push_back(inner_source_table->table_id_))) {
      LOG_WARN("failed to assign semi info left table ids", K(ret));
    } else if (OB_FAIL(select_stmt->get_semi_infos().push_back(semi_info))) {
      LOG_WARN("failed to assign semi infos", K(ret));
    } else if (OB_FAIL(select_stmt->replace_relation_exprs(old_column_exprs, new_column_exprs))) {
      LOG_WARN("failed to replace relation exprs", K(ret));
    } else if (OB_FAIL(select_stmt->adjust_subquery_list())) {
      LOG_WARN("failed to adjust subquery list", K(ret));
    } else if (OB_FAIL(transform_exprs(select_stmt, dummy))) {
      LOG_WARN("failed to transform exprs", K(ret));
    } else if (OB_FAIL(insert_stmt->adjust_subquery_list())) {
      LOG_WARN("failed to adjust subquery list", K(ret));
    } else {
      out = insert_stmt;
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_exprs(ObDMLStmt *stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_)
      || OB_ISNULL(ctx_->expr_factory_) || OB_ISNULL(ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt or context is null", K(ret));
  } else {
    ObArray<ObRawExprPointer> relation_exprs;
    ObStmtExprGetter getter;
    getter.set_relation_scope();
    getter.add_scope(SCOPE_BASIC_TABLE);
    if (OB_FAIL(stmt->get_relation_exprs(relation_exprs, getter))) {
      LOG_WARN("failed to get all relation exprs", K(ret));
    } else {
      for (int i = 0; OB_SUCC(ret) && i < relation_exprs.count(); i++) {
        bool is_happened = false;
        ObRawExpr *expr = NULL;
        if (OB_FAIL(relation_exprs.at(i).get(expr))) {
          LOG_WARN("failed to get expr", K(ret));
        } else if (OB_ISNULL(expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("expr is NULL", K(ret));
        } else if (OB_FAIL(transform_expr(*ctx_->expr_factory_,
                                          *ctx_->session_info_,
                                          expr,
                                          is_happened))) {
          LOG_WARN("transform expr failed", K(ret));
        } else if (OB_FAIL(relation_exprs.at(i).set(expr))) {
          LOG_WARN("failed to set expr", K(ret));
        } else {
          trans_happened |= is_happened;
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_expr(ObRawExprFactory &expr_factory,
                                          const ObSQLSessionInfo &session,
                                          ObRawExpr *&expr,
                                          bool &trans_happened)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("expr is NULL", K(ret));
  }
  if (OB_SUCC(ret)) {
    // rewrite `c1 in (c2, c3)` to `c1 = c2 or c1 = c3`
    if (OB_FAIL(replace_in_or_notin_recursively(
                expr_factory, session, expr, trans_happened))) {
      LOG_WARN("replace in or not in failed", K(ret), K(expr));
    }
  }
  if (OB_SUCC(ret)) {
    // rewrite
    //   `cast c1 when c2 then xxx when c3 then xxx else xxx end`
    // to:
    //   `cast when c1 = c2 then xxx when c1 = c3 then xxx else xxx end`
    if (OB_FAIL(transform_arg_case_recursively(
                expr_factory, session, expr, trans_happened))) {
      LOG_WARN("transform arg case failed", K(ret));
    }
  }
  if (OB_SUCC(ret)) {
    const uint64_t ob_version = GET_MIN_CLUSTER_VERSION();
    // The rewriting is done for the purpose of MySQL compatibility.
    if ((ob_version >= CLUSTER_VERSION_4_2_1_0) && lib::is_mysql_mode()) {
      if (OB_FAIL(replace_align_date4cmp_recursively(
                      expr_factory, expr))) {
            LOG_WARN("replace align_date4cmp failed", K(ret), K(expr));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_in_or_notin_expr_without_row(ObRawExprFactory &expr_factory,
                                                                  const ObSQLSessionInfo &session,
                                                                  const bool is_in_expr,
                                                                  ObRawExpr *&in_expr,
                                                                  bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObRawExpr *left_expr = in_expr->get_param_expr(0);
  ObRawExpr *right_expr = in_expr->get_param_expr(1);
  ObSEArray<DistinctObjMeta, 4> distinct_types;
  for (int i = 0; OB_SUCC(ret) && i < right_expr->get_param_count(); i++) {
    if (OB_ISNULL(right_expr->get_param_expr(i))) {
      ret = OB_INVALID_ARGUMENT;
      LOG_WARN("invalid null param expr", K(ret), K(right_expr->get_param_expr(i)));
    } else {
      ObObjType obj_type = right_expr->get_param_expr(i)->get_result_type().get_type();
      ObCollationType coll_type = right_expr->get_param_expr(i)
                                              ->get_result_type().get_collation_type();
      ObCollationLevel coll_level = right_expr->get_param_expr(i)
                                              ->get_result_type().get_collation_level();
      if (OB_UNLIKELY(obj_type == ObMaxType)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected obj type", K(ret), K(obj_type), K(*in_expr));
      } else if (OB_FAIL(add_var_to_array_no_dup(distinct_types,
                                               DistinctObjMeta(obj_type, coll_type, coll_level)))) {
        LOG_WARN("failed to push back", K(ret));
      } else {
        LOG_DEBUG("add param expr type", K(i), K(obj_type));
      }
    }
  } // for end

  if (OB_FAIL(ret)) {
    // do nothing
  } else if (1 == distinct_types.count()) {
    // only one type contained in right row expr, do not need rewrite
    // set should_deduce_type = true
    ObOpRawExpr *op_raw_expr = dynamic_cast<ObOpRawExpr *>(in_expr);
    if (OB_ISNULL(op_raw_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("invalid null op_raw_expr", K(ret));
    } else {
      op_raw_expr->set_deduce_type_adding_implicit_cast(true);
    }
  } else {
    LOG_DEBUG("distinct types", K(distinct_types));
    ObSEArray<ObRawExpr *, 4> transed_in_exprs;
    ObSEArray<ObRawExpr *, 4> same_type_exprs;
    for (int i = 0; OB_SUCC(ret) && i < distinct_types.count(); i++) {
      same_type_exprs.reuse();
      DistinctObjMeta obj_meta = distinct_types.at(i);
      for (int j = 0; OB_SUCC(ret) && j < right_expr->get_param_count(); j++) {
        ObObjType obj_type = right_expr->get_param_expr(j)->get_result_type().get_type();
        ObCollationType coll_type = right_expr->get_param_expr(j)
                                                ->get_result_type().get_collation_type();
        ObCollationLevel coll_level = right_expr->get_param_expr(j)
                                                ->get_result_type().get_collation_level();
        DistinctObjMeta tmp_meta(obj_type, coll_type, coll_level);
        if (obj_meta == tmp_meta
            && OB_FAIL(same_type_exprs.push_back(right_expr->get_param_expr(j)))) {
          LOG_WARN("failed to add param expr", K(ret));
        } else { /* do nothing */ }
      }  // for end
      if (OB_SUCC(ret) && OB_FAIL(create_partial_expr(expr_factory, left_expr, same_type_exprs,
                                                      is_in_expr, transed_in_exprs))) {
        LOG_WARN("failed to create partial expr", K(ret));
      }
    } // for end
    if (OB_FAIL(ret)) {
    } else if (OB_FAIL(get_final_transed_or_and_expr(expr_factory,
                                                     session,
                                                     is_in_expr,
                                                     transed_in_exprs,
                                                     in_expr))) {
      LOG_WARN("failed to get final transed or expr", K(ret));
    } else {
      trans_happened = true;
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_in_or_notin_expr_with_row(ObRawExprFactory &expr_factory,
                                                               const ObSQLSessionInfo &session,
                                                               const bool is_in_expr,
                                                               ObRawExpr *&in_expr,
                                                               bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObRawExpr *left_expr = in_expr->get_param_expr(0);
  ObRawExpr *right_expr = in_expr->get_param_expr(1);
  int row_dim = T_REF_QUERY != left_expr->get_expr_type() ? left_expr->get_param_count() :
                                    static_cast<ObQueryRefRawExpr*>(left_expr)->get_output_column();
  ObSEArray<ObSEArray<DistinctObjMeta, 4>, 4> distinct_row_types;
  ObSEArray<ObSEArray<DistinctObjMeta, 4>, 4> all_row_types;

  for (int i = 0; OB_SUCC(ret) && i < right_expr->get_param_count(); i++) {
    if (OB_ISNULL(right_expr->get_param_expr(i))) {
      ret = OB_INVALID_ARGUMENT;
      LOG_WARN("invalid null param expr", K(ret));
    } else if (OB_UNLIKELY(right_expr->get_param_expr(i)->get_param_count() != row_dim)) {
      ret = OB_INVALID_ARGUMENT;
      LOG_WARN("invalid param cnt", K(row_dim),
               K(right_expr->get_param_expr(i)->get_param_count()));
    } else {
      ObSEArray<DistinctObjMeta, 4> tmp_row_type;
      for (int j = 0; OB_SUCC(ret) && j < right_expr->get_param_expr(i)->get_param_count();
           j++) {
        if (OB_ISNULL(right_expr->get_param_expr(i)->get_param_expr(j))) {
          ret = OB_INVALID_ARGUMENT;
          LOG_WARN("invalid null param expr", K(ret));
        } else {
          const ObRawExpr *param_expr = right_expr->get_param_expr(i)->get_param_expr(j);
          const ObObjType obj_type = param_expr->get_result_type().get_type();
          const ObCollationType coll_type = param_expr->get_result_type().get_collation_type();
          const ObCollationLevel coll_level = param_expr->get_result_type().get_collation_level();
          if (OB_UNLIKELY(obj_type == ObMaxType)) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get unexpected obj type", K(ret), K(obj_type), K(*in_expr));
          } else if (OB_FAIL(tmp_row_type.push_back(
                                               DistinctObjMeta(obj_type, coll_type, coll_level)))) {
            LOG_WARN("failed to push back element", K(ret));
          } else { /* do nothing */ }
        }
      } // for end
      if (OB_FAIL(ret)) {
        // do nothing
      } else if (OB_FAIL(add_row_type_to_array_no_dup(distinct_row_types, tmp_row_type))) {
        LOG_WARN("failed to add_row_type_to_array_no_dup", K(ret));
      } else if (OB_FAIL(all_row_types.push_back(tmp_row_type))) {
        LOG_WARN("failed to push back element", K(ret));
      } else { /* do nothing */ }
    }
  } // for end
  if (OB_FAIL(ret)) {
    // do nothing
  } else if (1 == distinct_row_types.count()) {
    // all rows are same, do nothing
    ObOpRawExpr *op_raw_expr = dynamic_cast<ObOpRawExpr *>(in_expr);
    if (OB_ISNULL(op_raw_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("invalid null op_raw_expr", K(ret));
    } else {
      op_raw_expr->set_deduce_type_adding_implicit_cast(true);
    }
  } else {
    ObSEArray<ObRawExpr *, 4> transed_in_exprs;
    ObSEArray<ObRawExpr *, 4> same_type_exprs;
    for (int i = 0; OB_SUCC(ret) && i < distinct_row_types.count(); i++) {
      same_type_exprs.reuse();
      for (int j = 0; OB_SUCC(ret) && j < all_row_types.count(); j++) {
        if (is_same_row_type(distinct_row_types.at(i), all_row_types.at(j)) &&
            OB_FAIL(same_type_exprs.push_back(right_expr->get_param_expr(j)))) {
          LOG_WARN("failed to add param expr", K(ret));
        }
      } // for end
      if (OB_SUCC(ret) && OB_FAIL(create_partial_expr(expr_factory, left_expr, same_type_exprs,
                                                      is_in_expr, transed_in_exprs))) {
        LOG_WARN("failed to create partial expr", K(ret));
      }
    } // for end
    if (OB_FAIL(ret)) {
    } else if (OB_FAIL(get_final_transed_or_and_expr(
                expr_factory, session, is_in_expr, transed_in_exprs, in_expr))) {
      LOG_WARN("failed to get final transed in expr", K(ret));
    } else {
      trans_happened = true;
    }
  }
  return ret;
}

int ObTransformPreProcess::create_partial_expr(ObRawExprFactory &expr_factory,
                                               ObRawExpr *left_expr,
                                               ObIArray<ObRawExpr*> &same_type_exprs,
                                               const bool is_in_expr,
                                               ObIArray<ObRawExpr*> &transed_in_exprs)
{
  int ret = OB_SUCCESS;
  ObOpRawExpr *tmp_expr = NULL;
  ObOpRawExpr *tmp_row_expr = NULL;
  ObRawExpr *tmp_left_expr = left_expr;
  ObRawExpr *tmp_right_expr = NULL;
  if (OB_UNLIKELY(same_type_exprs.empty()) || OB_ISNULL(left_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected empty same_type_exprs", K(ret), K(same_type_exprs), K(left_expr));
  } else if (left_expr->get_expr_type() == T_OP_ROW &&
             OB_FAIL(ObRawExprCopier::copy_expr_node(expr_factory,
                                                     left_expr,
                                                     tmp_left_expr))) {
    // Comment for T_OP_ROW
    // for T_OP_ROW expr, the cast is not added above the expr
    // it is added on the expr's param.
    // when the expr is used by different predicates
    // we may need add different cast for its param
    // hence, we need to copy the expr node.
    // we do not need to copy its param, the param can be shared used.
    LOG_WARN("failed to copy expr node", K(ret));
  } else if (1 == same_type_exprs.count()) { // = / <>
    if (OB_FAIL(expr_factory.create_raw_expr(is_in_expr ? T_OP_EQ : T_OP_NE, tmp_expr))) {
      LOG_WARN("failed to create or create raw expr", K(ret));
    } else {
      tmp_right_expr = same_type_exprs.at(0);
    }
  } else if (OB_FAIL(expr_factory.create_raw_expr(is_in_expr ? T_OP_IN : T_OP_NOT_IN, tmp_expr)) // in / not in
             || OB_FAIL(expr_factory.create_raw_expr(T_OP_ROW, tmp_row_expr))) {
    LOG_WARN("failed to create or create raw expr", K(ret));
  } else if (OB_ISNULL(tmp_row_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null expr", K(ret), K(tmp_row_expr));
  } else if (OB_FAIL(append(tmp_row_expr->get_param_exprs(), same_type_exprs))) {
    LOG_WARN("failed to append exprs", K(ret));
  } else {
    tmp_right_expr = tmp_row_expr;
  }

  if (OB_FAIL(ret)) {
  } else if (OB_ISNULL(tmp_expr) || OB_ISNULL(tmp_left_expr) || OB_ISNULL(tmp_right_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null expr", K(ret), K(tmp_expr),
                                    K(tmp_left_expr), K(tmp_right_expr));
  } else if (OB_FAIL(tmp_expr->add_param_expr(tmp_left_expr))
            || OB_FAIL(tmp_expr->add_param_expr(tmp_right_expr))) {
    LOG_WARN("failed to add param exprs", K(ret));
  } else if (OB_FAIL(transed_in_exprs.push_back(tmp_expr))) {
    LOG_WARN("failed to push back element", K(ret));
  } else {
    tmp_expr->set_deduce_type_adding_implicit_cast(true);
    LOG_DEBUG("partial in expr", K(*tmp_expr), K(*tmp_right_expr), K(*left_expr));
  }
  return ret;
}

int ObTransformPreProcess::transform_arg_case_recursively(
    ObRawExprFactory &expr_factory,
    const ObSQLSessionInfo &session,
    ObRawExpr *&expr,
    bool &trans_happened)
{
  int ret = OB_SUCCESS;
  if (T_OP_ARG_CASE == expr->get_expr_type()) {
    if (OB_FAIL(transform_arg_case_expr(expr_factory, session, expr, trans_happened))) {
      LOG_WARN("failed to transform_arg_case_expr", K(ret));
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
    if (OB_FAIL(SMART_CALL(transform_arg_case_recursively(expr_factory,
                           session,
                           expr->get_param_expr(i),
                           trans_happened)))) {
      LOG_WARN("failed to transform arg case expr", K(ret), K(i));
    }
  }
  return ret;
}

// in engine 3.0 transform arg_case_when_expr to simple_case_when_expr
// eg:
// case arg when when1 then then1       case when arg = when1 then then1
//          when when1 then then2  ->        when arg = when2 then then2
//          else else1                       else else1
int ObTransformPreProcess::transform_arg_case_expr(ObRawExprFactory &expr_factory,
                                                   const ObSQLSessionInfo &session,
                                                   ObRawExpr *&expr,
                                                   bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObCaseOpRawExpr *case_expr = static_cast<ObCaseOpRawExpr*>(expr);
  ObRawExpr *arg_expr = case_expr->get_arg_param_expr();
  ObCaseOpRawExpr *new_case_expr = NULL;
  if (OB_FAIL(expr_factory.create_raw_expr(T_OP_CASE, new_case_expr))) {
    LOG_WARN("failed to create case expr", K(ret));
  } else if (OB_ISNULL(new_case_expr) || OB_ISNULL(arg_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr is NULL", K(ret), KP(new_case_expr), KP(arg_expr));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < case_expr->get_when_expr_size(); ++i) {
    ObRawExpr *when_expr = case_expr->get_when_param_expr(i);
    ObRawExpr *then_expr = case_expr->get_then_param_expr(i);
    ObRawExpr *tmp_arg_expr = arg_expr;
    ObOpRawExpr *equal_expr = NULL;
    if (OB_ISNULL(when_expr) || OB_ISNULL(then_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("when_expr is NULL", K(ret), KP(when_expr), KP(then_expr));
    } else if (T_OP_ROW == arg_expr->get_expr_type() &&
               OB_FAIL(ObRawExprCopier::copy_expr_node(expr_factory,
                                                       arg_expr,
                                                       tmp_arg_expr))) {
      // See the Comment for T_OP_ROW above
      LOG_WARN("failed to copy expr", K(ret));
    } else if (OB_FAIL(create_equal_expr_for_case_expr(expr_factory,
                                                       session,
                                                       tmp_arg_expr,
                                                       when_expr,
                                                       case_expr->get_result_type(),
                                                       equal_expr))) {
      LOG_WARN("failed to create equal expr", K(ret));
    } else if (OB_FAIL(new_case_expr->add_when_param_expr(equal_expr)) ||
              OB_FAIL(new_case_expr->add_then_param_expr(then_expr))) {
      LOG_WARN("failed to add param expr", K(ret));
    }
  } // for end
  ObRawExpr* tmp_case_expr = static_cast<ObRawExpr*>(new_case_expr);
  if (OB_SUCC(ret) &&
      !case_expr->is_called_in_sql() &&
      OB_FAIL(ObRawExprUtils::set_call_in_pl(tmp_case_expr))) {
    LOG_WARN("failed to set call_in_pl flag", K(ret));
  }
  if (OB_SUCC(ret)) {
    new_case_expr->set_default_param_expr(case_expr->get_default_param_expr());
    if (OB_FAIL(new_case_expr->formalize(&session))) {
      LOG_WARN("failed to formalize", K(ret));
    } else {
      expr = static_cast<ObRawExpr*>(new_case_expr);
      trans_happened = true;
    }
  }
  return ret;
}

int ObTransformPreProcess::create_equal_expr_for_case_expr(ObRawExprFactory &expr_factory,
                                                           const ObSQLSessionInfo &session,
                                                           ObRawExpr *arg_expr,
                                                           ObRawExpr *when_expr,
                                                           const ObExprResType &case_res_type,
                                                           ObOpRawExpr *&equal_expr)
{
  int ret = OB_SUCCESS;
  ObObjType obj_type = ObMaxType;
  const ObExprResType &arg_type = arg_expr->get_result_type();
  const ObExprResType &when_type = when_expr->get_result_type();
  ObRawExpr *new_when_expr = NULL; // cast expr may added
  ObRawExpr *new_arg_expr = NULL;
  if (OB_ISNULL(arg_expr) || OB_ISNULL(when_expr)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid argument", K(ret), KP(arg_expr), KP(when_expr));
  } else if (OB_FAIL(expr_factory.create_raw_expr(T_OP_EQ, equal_expr))) {
    LOG_WARN("failed to create equal expr", K(ret));
  } else {
    if (OB_FAIL(ObExprArgCase::get_cmp_type(obj_type, arg_type.get_type(),
                                            when_type.get_type(),
                                            ObMaxType))) { // last argument is unused
      LOG_WARN("failed to get_cmp_type", K(ret));
    } else if (lib::is_mysql_mode() && ob_is_string_type(obj_type)) {
      // when cmp_type is string, need to use case_res_type.calc_type_.cs_type_ as
      // collation type. it is aggregated by all when_exprs.
      // eg: select case col_utf8_general_ci when col_utf8_general_ci then 'a'
      //                                     when col_utf8_bin then 'b' end from tbl;
      //     use col_utf8_bin to compare(see in ObExprArgCase::calc_result_typeN())
      ObExprResType cmp_type;
      cmp_type.set_type(obj_type);
      cmp_type.set_collation_type(case_res_type.get_calc_collation_type());
      cmp_type.set_collation_level(case_res_type.get_calc_collation_level());
      if (ObRawExprUtils::try_add_cast_expr_above(&expr_factory, &session,
                                                  *arg_expr, cmp_type, new_arg_expr) ||
          ObRawExprUtils::try_add_cast_expr_above(&expr_factory, &session,
                                                  *when_expr, cmp_type, new_when_expr)) {
        LOG_WARN("failed to add_cast", K(ret), KP(new_arg_expr), KP(new_when_expr));
      }
    } else {
      new_arg_expr = arg_expr;
      new_when_expr = when_expr;
    }
  }
  if (OB_SUCC(ret)) {
    if (OB_ISNULL(new_when_expr) || OB_ISNULL(new_arg_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("expr is NULL", K(ret), KP(new_when_expr), KP(new_arg_expr));
    } else if (OB_FAIL(equal_expr->add_param_expr(new_arg_expr)) ||
               OB_FAIL(equal_expr->add_param_expr(new_when_expr))) {
      LOG_WARN("failed to add_param_expr", K(ret));
    }
  }
  return ret;
}

bool ObTransformPreProcess::is_same_row_type(const ObIArray<DistinctObjMeta> &left,
                                             const ObIArray<DistinctObjMeta> &right)
{
  bool ret_bool = true;
  if (left.count() != right.count()) {
    ret_bool = false;
  }
  for (int i = 0; ret_bool && i < left.count(); i++) {
    ret_bool = (left.at(i) == right.at(i));
  } // for end
  return ret_bool;
}

int ObTransformPreProcess::get_final_transed_or_and_expr(
    ObRawExprFactory &expr_factory,
    const ObSQLSessionInfo &session,
    const bool is_in_expr,
    ObIArray<ObRawExpr *> &transed_in_exprs,
    ObRawExpr *&final_or_expr)
{
  int ret = OB_SUCCESS;
  ObOpRawExpr *transed_or_expr = NULL;
  ObOpRawExpr *tmp_or_expr = NULL;
  ObOpRawExpr *last_or_expr = NULL;
  ObItemType op_type = is_in_expr ? T_OP_OR : T_OP_AND;
  if (OB_FAIL(expr_factory.create_raw_expr(op_type, transed_or_expr))) {
    LOG_WARN("failed to create or expr", K(ret));
  } else if (OB_ISNULL(transed_or_expr)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid null expr", K(ret), K(transed_or_expr));
  } else if (OB_FAIL(transed_or_expr->add_param_expr(transed_in_exprs.at(0)))) {
    LOG_WARN("failed to add param expr", K(ret));
  } else {
    last_or_expr = transed_or_expr;
    int cur_idx = 1;
    for (; OB_SUCC(ret) && cur_idx < transed_in_exprs.count() - 1; cur_idx++) {
      if (OB_FAIL(expr_factory.create_raw_expr(op_type, tmp_or_expr))) {
        LOG_WARN("failed to create raw expr", K(ret));
      } else if (OB_ISNULL(tmp_or_expr)) {
        ret = OB_INVALID_ARGUMENT;
        LOG_WARN("invalid null expr", K(ret));
      } else if (OB_FAIL(last_or_expr->add_param_expr(tmp_or_expr))) {
        LOG_WARN("failed to add param expr", K(ret));
      } else if (OB_FAIL(tmp_or_expr->add_param_expr(transed_in_exprs.at(cur_idx)))) {
        LOG_WARN("failed to add param expr", K(ret));
      } else {
        last_or_expr = tmp_or_expr;
      }
    }  // for end
    if (OB_FAIL(ret)) {
      // do nothing
    } else if (OB_FAIL(last_or_expr->add_param_expr(transed_in_exprs.at(cur_idx)))) {
      LOG_WARN("failed to add param expr", K(ret));
    } else if (OB_FAIL(transed_or_expr->formalize(&session))) {
      LOG_WARN("expr formalize failed", K(ret));
    } else {
      final_or_expr = transed_or_expr;
    }
  }
  return ret;
}

int ObTransformPreProcess::add_row_type_to_array_no_dup(
                             ObIArray<ObSEArray<DistinctObjMeta, 4>> &row_type_array,
                             const ObSEArray<DistinctObjMeta, 4> &row_type)
{
  int ret = OB_SUCCESS;
  bool founded = false;
  for (int i = 0; OB_SUCC(ret) && !founded && i < row_type_array.count(); i++) {
    if (is_same_row_type(row_type_array.at(i), row_type)) {
      founded = true;
    }
  }
  if (!founded && OB_FAIL(row_type_array.push_back(row_type))) {
    LOG_WARN("failed to push back element", K(ret));
  }
  return ret;
}

int ObTransformPreProcess::check_and_transform_in_or_notin(ObRawExprFactory &expr_factory,
                                                           const ObSQLSessionInfo &session,
                                                           ObRawExpr *&in_expr,
                                                           bool &trans_happened)
{
  int ret = OB_SUCCESS;
  if (OB_UNLIKELY(2 != in_expr->get_param_count())) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid param cnt", K(ret), K(in_expr->get_param_count()));
  } else if (OB_ISNULL(in_expr->get_param_expr(0)) ||
             OB_ISNULL(in_expr->get_param_expr(1))) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid null params", K(ret), K(in_expr->get_param_expr(0)),
             K(in_expr->get_param_expr(1)));
  } else if (T_OP_ROW == in_expr->get_param_expr(0)->get_expr_type() ||
             (T_REF_QUERY == in_expr->get_param_expr(0)->get_expr_type() &&
              static_cast<ObQueryRefRawExpr*>(in_expr->get_param_expr(0))->get_output_column() > 1)) {
    // (x, y) in ((x0, y0), (x1, y1), ...)
    // (select x, y from ...) in ((x0, y0), (x1, y1), ...))
    LOG_DEBUG("Before Transform", K(*in_expr));
    ret = transform_in_or_notin_expr_with_row(
        expr_factory, session, T_OP_IN == in_expr->get_expr_type(), in_expr, trans_happened);
  } else {
    // x in (x0, x1, ...)
    LOG_DEBUG("Before Transform", K(*in_expr));
    ret = transform_in_or_notin_expr_without_row(
        expr_factory, session, T_OP_IN == in_expr->get_expr_type(), in_expr, trans_happened);
  }
  if (OB_SUCC(ret)) {
    ObOpRawExpr *op_raw_expr = dynamic_cast<ObOpRawExpr *>(in_expr);
    if (OB_ISNULL(op_raw_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("invalid null op_raw_expr", K(ret));
    } else if (OB_FAIL(op_raw_expr->formalize(&session))) {
      LOG_WARN("formalize expr failed", K(ret));
    } else {
      LOG_DEBUG("After Transform", K(*op_raw_expr));
    }
  }
  return ret;
}

int ObTransformPreProcess::replace_in_or_notin_recursively(ObRawExprFactory &expr_factory,
                                                           const ObSQLSessionInfo &session,
                                                           ObRawExpr *&root_expr,
                                                           bool &trans_happened)
{
  int ret = OB_SUCCESS;
  for (int i = 0; OB_SUCC(ret) && i < root_expr->get_param_count(); i++) {
    if (OB_ISNULL(root_expr->get_param_expr(i))) {
      ret = OB_INVALID_ARGUMENT;
      LOG_WARN("invalid null param expr", K(ret));
    } else if (OB_FAIL(SMART_CALL(replace_in_or_notin_recursively(expr_factory,
                                                        session,
                                                        root_expr->get_param_expr(i),
                                                        trans_happened)))) {
      LOG_WARN("failed to replace in or notin recursively", K(ret));
    }
  }
  if (OB_SUCC(ret) &&
    (T_OP_IN == root_expr->get_expr_type() || T_OP_NOT_IN == root_expr->get_expr_type())) {
    if (OB_FAIL(check_and_transform_in_or_notin(
                expr_factory, session, root_expr, trans_happened))) {
      LOG_WARN("failed to check and transform", K(ret));
    }
  }
  return ret;
}

ObItemType ObTransformPreProcess::reverse_cmp_type_of_align_date4cmp(const ObItemType &cmp_type)
{
  ObItemType new_cmp_type = cmp_type;
  switch (cmp_type) {
    case T_OP_LE: {
      new_cmp_type = T_OP_GE;
      break;
    }
    case T_OP_LT: {
      new_cmp_type = T_OP_GT;
      break;
    }
    case T_OP_GE: {
      new_cmp_type = T_OP_LE;
      break;
    }
    case T_OP_GT: {
      new_cmp_type = T_OP_LT;
      break;
    }
    default: {
      break;
    }
  }
  return new_cmp_type;
}

int ObTransformPreProcess::replace_cast_expr_align_date4cmp(ObRawExprFactory &expr_factory,
                                                            const ObItemType &cmp_type,
                                                            ObRawExpr *&expr)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr is null.", K(ret));
  } else if (expr->get_expr_type() == T_FUN_SYS_CAST) {
    const bool is_implicit_cast = !CM_IS_EXPLICIT_CAST(expr->get_extra());
    ObExprResType cast_res_type = expr->get_result_type();
    if (is_implicit_cast && (cast_res_type.is_date() || cast_res_type.is_datetime())) {
      ObRawExpr *cast_child = expr->get_param_expr(0);
      if (OB_ISNULL(cast_child)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("cast child expr is null.", K(ret));
      } else if (ObExprAlignDate4Cmp::is_align_date4cmp_support_obj_type(cast_child->get_data_type())) {
        // create a new align_date4cmp_expr to replace const_expr
        ObSysFunRawExpr *align_date4cmp_expr = NULL;
        if (OB_FAIL(expr_factory.create_raw_expr(T_FUN_SYS_ALIGN_DATE4CMP, align_date4cmp_expr))) {
          LOG_WARN("create align_date4cmp_expr fail.", K(ret), K(align_date4cmp_expr));
        } else if (OB_ISNULL(align_date4cmp_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("align_date4cmp_expr is null.", K(ret));
        } else {
          align_date4cmp_expr->set_data_type(expr->get_data_type());
          align_date4cmp_expr->set_accuracy(expr->get_accuracy());
          align_date4cmp_expr->set_func_name("INTERNAL_FUNCTION");
          // Copy cast_mode to facilitate determining the method of handling invalid_time.
          align_date4cmp_expr->set_extra(expr->get_extra());
          // add first param_expr(just the cast_child) to align_date4cmp_expr
          if (OB_FAIL(align_date4cmp_expr->add_param_expr(cast_child))) {
            LOG_WARN("align_date4cmp_expr add param cast_expr fail.", K(ret), KPC(cast_child));
          } else {
            // create second param_expr (a ObConstRawExpr used to represent cmp_type)
            // and add it to align_date4cmp_expr.
            ObConstRawExpr *cmp_type_expr = NULL;
            if (OB_FAIL(ObRawExprUtils::build_const_int_expr(expr_factory,
                                              ObIntType, cmp_type, cmp_type_expr))) {
            LOG_WARN("failed to build const int cmp_type_expr", K(ret));
            } else if (OB_ISNULL(cmp_type_expr)) {
              ret = OB_ERR_UNEXPECTED;
              LOG_WARN("cmp_type_expr is null.", K(ret));
            } else if (OB_FAIL(align_date4cmp_expr->add_param_expr(cmp_type_expr))){
              LOG_WARN("align_date4cmp_expr add param cmp_type_expr fail.", K(ret), KPC(cmp_type_expr));
            } else {
              // create third param_expr (a ObConstRawExpr used to represent res_type)
              // and add it to align_date4cmp_expr.
              ObConstRawExpr *res_type_expr = NULL;
              ObObjType cast_res_type = expr->get_result_type().get_type();
              int64_t cast_res_type_int = cast_res_type;
              if (OB_FAIL(ObRawExprUtils::build_const_int_expr(expr_factory,
                                                  ObIntType, cast_res_type_int, res_type_expr))) {
                LOG_WARN("failed to build const int res_type_expr", K(ret));
              } else if (OB_ISNULL(res_type_expr)) {
                ret = OB_ERR_UNEXPECTED;
                LOG_WARN("res_type_expr is null.", K(ret));
              } else if (OB_FAIL(align_date4cmp_expr->add_param_expr(res_type_expr))){
                LOG_WARN("align_date4cmp_expr add param res_type_expr fail.", K(ret), KPC(res_type_expr));
              } else {
                // Change the expr pointer pointing to cast_expr
                // to point to the newly created align_date4cmp_expr.
                expr = align_date4cmp_expr;
              }
            }
          }
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::replace_op_row_expr_align_date4cmp(ObRawExprFactory &expr_factory,
                                                            const ObItemType &cmp_type,
                                                            ObRawExpr *&left_row_expr,
                                                            ObRawExpr *&right_row_expr)
{
  int ret = OB_SUCCESS;
  if (left_row_expr->get_expr_type() == T_OP_ROW &&
      right_row_expr->get_expr_type() == T_OP_ROW) {
    int64_t expr_cnt = left_row_expr->get_param_count();
    if (right_row_expr->get_param_count() != expr_cnt) {
      ret = OB_INVALID_ARGUMENT;
      LOG_WARN("invalid param cnt", K(ret), KPC(left_row_expr),
                                            KPC(right_row_expr));
    } else {
      int64_t last_expr_idx = expr_cnt - 1;
      ObRawExpr *expr0 = left_row_expr->get_param_expr(last_expr_idx);
      ObRawExpr *expr1 = right_row_expr->get_param_expr(last_expr_idx);
      if (OB_ISNULL(expr0) || OB_ISNULL(expr1)) {
        ret = OB_INVALID_ARGUMENT;
        LOG_WARN("invalid null params", K(ret), KPC(left_row_expr),
                                                KPC(right_row_expr));
      } else {
        const ObItemType reverse_cmp_type = reverse_cmp_type_of_align_date4cmp(cmp_type);
        if (OB_FAIL(replace_cast_expr_align_date4cmp(expr_factory, reverse_cmp_type, expr0))) {
          LOG_WARN("replace left cast_expr fail.", K(ret), KPC(expr0));
        } else {
          left_row_expr->get_param_expr(last_expr_idx) = expr0;
        }

        if (OB_SUCC(ret)) {
          if (OB_FAIL(replace_cast_expr_align_date4cmp(expr_factory, cmp_type, expr1))) {
            LOG_WARN("replace right cast_expr fail.", K(ret), KPC(expr1));
          } else {
            right_row_expr->get_param_expr(last_expr_idx) = expr1;
          }
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::check_and_transform_align_date4cmp(ObRawExprFactory &expr_factory,
                                                           ObRawExpr *&cmp_expr,
                                                           const ObItemType &cmp_type)
{
  int ret = OB_SUCCESS;
  if (OB_UNLIKELY(2 != cmp_expr->get_param_count())) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid param cnt", K(ret), K(cmp_expr->get_param_count()));
  } else {
    ObRawExpr *expr0 = cmp_expr->get_param_expr(0);
    ObRawExpr *expr1 = cmp_expr->get_param_expr(1);
    if (OB_ISNULL(expr0) || OB_ISNULL(expr1)) {
      ret = OB_INVALID_ARGUMENT;
      LOG_WARN("invalid null params", K(ret), K(cmp_expr->get_param_expr(0)),
              K(cmp_expr->get_param_expr(1)));
    } else if (OB_FAIL(replace_op_row_expr_align_date4cmp(expr_factory,
                                        cmp_type, expr0, expr1))){
      LOG_WARN("fail to replace op_row_expr", K(ret));
    } else {
      // By default, align_date4cmp_expr expects the first parameter to be
      // the value on the right side of the comparison operator.
      // Therefore, if you pass the value on the left side,
      // you need to reverse the comparison operator that is passed in.
      const ObItemType reverse_cmp_type = reverse_cmp_type_of_align_date4cmp(cmp_type);
      if (OB_FAIL(replace_cast_expr_align_date4cmp(expr_factory, reverse_cmp_type, expr0))) {
        LOG_WARN("replace left cast_expr fail.", K(ret), KPC(expr0));
      } else {
        cmp_expr->get_param_expr(0) = expr0;
      }

      if (OB_SUCC(ret)) {
        if (OB_FAIL(replace_cast_expr_align_date4cmp(expr_factory, cmp_type, expr1))) {
          LOG_WARN("replace right cast_expr fail.", K(ret), KPC(expr1));
        } else {
          cmp_expr->get_param_expr(1) = expr1;
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::replace_align_date4cmp_recursively(ObRawExprFactory &expr_factory,
                                                           ObRawExpr *&root_expr)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(root_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("root_expr is null.", K(ret));
  }
  // Traverse all exprs from the root.
  for (int i = 0; OB_SUCC(ret) && i < root_expr->get_param_count(); i++) {
    if (OB_ISNULL(root_expr->get_param_expr(i))) {
      ret = OB_INVALID_ARGUMENT;
      LOG_WARN("invalid null param expr", K(ret));
    } else if (OB_FAIL(SMART_CALL(replace_align_date4cmp_recursively(expr_factory,
                                                        root_expr->get_param_expr(i))))) {
      LOG_WARN("failed to replace in or notin recursively", K(ret));
    }
  }
  // If the current expression is cmp_expr, check if align_date4cmp transformation is necessary.
  if (OB_SUCC(ret) && IS_COMMON_COMPARISON_OP(root_expr->get_expr_type())) {
    if (OB_FAIL(check_and_transform_align_date4cmp(
                expr_factory, root_expr, root_expr->get_expr_type()))) {
      LOG_WARN("failed to check and transform", K(ret));
    }
  }
  return ret;
}

/*@brief ObTransformPreProcess::transformer_aggr_expr 用于将一些复杂的聚合函数展开为普通的聚合运算;
* eg:var_pop(expr) ==> SUM(expr*expr) - SUM(expr)* SUM(expr)/ COUNT(expr)) / COUNT(expr)
* 其中ObExpandAggregateUtils这个类主要涉及到相关的函数用于展开复杂的聚合函数:
*   1.ObExpandAggregateUtils::expand_aggr_expr ==> 用于处理普通的aggr函数接口
*   2.ObExpandAggregateUtils::expand_window_aggr_expr  ==> 用于处理窗口函数中的aggr的函数接口
*
 */
int ObTransformPreProcess::transformer_aggr_expr(ObDMLStmt *stmt,
                                                 bool &trans_happened)
{
  int ret = OB_SUCCESS;
  bool is_expand_aggr = false;
  bool is_expand_window_aggr = false;
  bool is_happened = false;
  //之前的逻辑保证了两者嵌套聚合及普通函数的改写顺序，传进来的trans_happened包含了是否发生嵌套聚合函数改写的信息
  bool is_trans_nested_aggr_happened = trans_happened;
  trans_happened = false;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid null allocator", K(ret));
  } else if (OB_FAIL(ObExpandAggregateUtils::expand_aggr_expr(stmt, ctx_, is_expand_aggr))) {
    LOG_WARN("failed to expand aggr expr", K(ret));
  } else if (OB_FAIL(ObExpandAggregateUtils::expand_window_aggr_expr(stmt,
                                                                     ctx_,
                                                                     is_expand_window_aggr))) {
    LOG_WARN("failed to expand window aggr expr", K(ret));
  //如果发生了嵌套聚合函数改写：
  // select max(avg(c1)) from t1 group by c2;
  // ==>
  // select max(a) from (select avg(c1) as a from t1 group by c2);
  // 需要改写view里面的聚合函数，同时需要注释的是嵌套聚合函数只有内外两层，不会生成超过2层的结构
  } else if (is_trans_nested_aggr_happened) {
    TableItem *table_item = NULL;
    if (OB_UNLIKELY(stmt->get_table_items().count() != 1) ||
        OB_ISNULL(table_item = stmt->get_table_item(0)) ||
        OB_UNLIKELY(!table_item->is_generated_table())) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get unexpected error", K(table_item), K(stmt->get_table_items().count()), K(ret));
    } else if (OB_FAIL(transformer_aggr_expr(table_item->ref_query_, is_happened))) {
      LOG_WARN("failed to transformer aggr expr", K(ret));
    } else {/*do nothing*/}
  }
  if (OB_SUCC(ret)) {
    trans_happened = is_expand_aggr | is_expand_window_aggr | is_happened;
  }
  return ret;
}

/**
 * @brief ObTransformSimplify::transform_rownum_as_limit_offset
 * 将 rownum 改写为 limit
 * select * from t where ... and rownum < ?;
 * => select * from t where ... limit ?;
 *
 * select * from (select * from t order by c) where rownum < ?;
 * => select * from (select * from t order by c limit ?);
 *
 * 将 rownum 改写为 limit / offset
 * select * from (select rownum rn, ... from t) where rn > ? and rn < ?;
 * => select * from (select rownum rn, ... from t limit ? offset ?);
 */
int ObTransformPreProcess::transform_rownum_as_limit_offset(
                                            const ObIArray<ObParentDMLStmt> &parent_stmts,
                                            ObDMLStmt *&stmt,
                                            bool &trans_happened)
{
  int ret = OB_SUCCESS;
  //bool is_rownum_gen_col_happened = false;
  bool is_rownum_happened = false;
  bool is_generated_rownum_happened = false;
  trans_happened = false;
  if (OB_FAIL(transform_common_rownum_as_limit(stmt, is_rownum_happened))) {
    LOG_WARN("failed to transform common rownum as limit", K(ret));
  } else if (OB_FAIL(transform_generated_rownum_as_limit(parent_stmts, stmt,
                                                         is_generated_rownum_happened))) {
    LOG_WARN("failed to transform rownum gen col as limit", K(ret));
  } else {
    trans_happened = is_rownum_happened || is_generated_rownum_happened;
  }
  return ret;
}

/**
 * @brief ObTransformPreProcess::transform_common_rownum_as_limit
 * 将 rownum 改写为 limit
 * select * from t where ... and rownum < ? order by c1;
 * => select * from (select * from t where ... limit ?) order by c1;
 *
**/
int ObTransformPreProcess::transform_common_rownum_as_limit(ObDMLStmt *&stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  ObRawExpr *limit_expr = NULL;
  bool is_valid = false;
  ObSelectStmt *child_stmt = NULL;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_) ||
      OB_ISNULL(ctx_->expr_factory_)|| OB_ISNULL(ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret), K(ctx_));
  } else if (stmt->is_hierarchical_query()) {//层次查询暂时无法支持
    /*do nothing*/
  } else if (is_oracle_mode() && stmt->is_select_stmt() &&
             static_cast<ObSelectStmt*>(stmt)->has_for_update()) {
    // in oracle mode, do not create view when has for update
  } else if (OB_FAIL(try_transform_common_rownum_as_limit_or_false(stmt, limit_expr, is_valid))) {
    LOG_WARN("failed to try transform rownum expr as limit", K(ret));
  } else if (!is_valid) {
    LOG_TRACE("limit expr is null", K(limit_expr), K(is_valid));
  //不含有order by的update/delete stmt不用再进行分离spj
  } else if (FALSE_IT(trans_happened = true)) {
  } else if (limit_expr == NULL) {
    //do nothing
  } else if (!stmt->is_select_stmt() && !stmt->has_order_by()) {
    stmt->set_limit_offset(limit_expr, NULL);
  } else if (OB_FAIL(ObTransformUtils::create_simple_view(ctx_, stmt, child_stmt, false))) {
    LOG_WARN("failed to create simple view", K(ret));
  } else if (OB_ISNULL(child_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(child_stmt));
  } else {
    child_stmt->set_limit_offset(limit_expr, NULL);
  }
  return ret;
}

/**
 * @brief ObTransformPreProcess::try_transform_common_rownum_as_limit
 * 满足以下条件时，stmt 中的 rownum 是可以改写 limit
 * 1. rownum 表达式位于where中，形式为： rownum < ?, rownum <= ?, rownum = ? 且参数为 int/number 型
 *    对于等值条件: rownum = 1 转化为 limit 1, 其它转化为 limit 0
 * 2. stmt 没有 distinct, groupby, order by, aggr, window function 等
 *  e.g. select rownum, * from t where rownum < 2;
 */
int ObTransformPreProcess::try_transform_common_rownum_as_limit_or_false(ObDMLStmt *stmt,
                                                                         ObRawExpr *&limit_expr,
                                                                         bool &is_valid)
{
  int ret = OB_SUCCESS;
  limit_expr = NULL;
  ObRawExpr *limit_value = NULL;
  ObItemType op_type = T_INVALID;
  ObPhysicalPlanCtx *plan_ctx = NULL;

  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_) || OB_ISNULL(ctx_->exec_ctx_)
      || OB_ISNULL(ctx_->session_info_) || OB_ISNULL(plan_ctx = ctx_->exec_ctx_->get_physical_plan_ctx())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else {
    ObIArray<ObRawExpr *> &conditions = stmt->get_condition_exprs();
    int64_t expr_idx = -1;
    bool is_eq_cond = false;
    bool is_const_filter = false;
    for (int64_t i = 0; OB_SUCC(ret) && !is_eq_cond && i < conditions.count(); ++i) {
      ObRawExpr *cond_expr = NULL;
      ObRawExpr *const_expr = NULL;
      ObItemType expr_type = T_INVALID;
      if (OB_ISNULL(cond_expr = conditions.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("condition expr is null", K(ret), K(i));
      } else if (cond_expr->has_flag(CNT_DYNAMIC_PARAM)) {
        // do nothing
      } else if (OB_FAIL(ObOptimizerUtil::get_rownum_filter_info(cond_expr,
                                                                 expr_type,
                                                                 const_expr,
                                                                 is_const_filter))) {
        LOG_WARN("failed to check is filter rownum", K(ret));
      } else if (!is_const_filter) {
        // do nothing
      } else if (T_OP_LE == expr_type || T_OP_LT == expr_type) {
        limit_value = const_expr;
        op_type = expr_type;
        expr_idx = i;
        is_valid = true;
      } else if (T_OP_EQ == expr_type) {
        limit_value = const_expr;
        expr_idx = i;
        is_valid = true;
        is_eq_cond = true;
      } else {/*do nothing*/}
    }
    for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < conditions.count(); ++i) {
      ObRawExpr *cond_expr = NULL;
      if (i == expr_idx) {
        //do nothing
      } else if (OB_ISNULL(cond_expr = conditions.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("condition expr is null", K(ret), K(i));
      } else if (cond_expr->has_flag(CNT_ROWNUM)) {
        is_valid = false;
      }
    }

    ObConstRawExpr *one_expr = NULL;
    bool is_true = false;
    if (OB_FAIL(ret) || !is_valid) {
    } else if (OB_FAIL(conditions.remove(expr_idx))) {
      LOG_WARN("failed to remove expr", K(ret));
    } else if (!is_eq_cond) {
      ObRawExpr *int_expr = NULL;
      ObRawExpr *cmp_expr = NULL;
      if (OB_FAIL(ObOptimizerUtil::convert_rownum_filter_as_limit(*ctx_->expr_factory_,
                                                                      ctx_->session_info_, op_type,
                                                                      limit_value, int_expr))) {
        LOG_WARN("failed to convert rownum filter as limit", K(ret));
      } else if (OB_FAIL(ObTransformUtils::compare_const_expr_result(ctx_, int_expr, T_OP_GE, 1, is_true))) {
        LOG_WARN("compare expr failed", K(ret));
      } else if (one_expr == NULL && OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                                                                  ObIntType,
                                                                                  1,
                                                                                  one_expr))) {
        LOG_WARN("build const expr failed", K(ret));
      } else if (OB_FAIL(ObRawExprUtils::create_double_op_expr(*ctx_->expr_factory_, ctx_->session_info_, T_OP_GE,
                                                                cmp_expr, int_expr, one_expr))) {
        LOG_WARN("create doubel op expr", K(ret));
      } else if (is_true) {
        limit_expr = int_expr;
        if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, cmp_expr, true))) {
          LOG_WARN("add cons failed", K(ret));
        }
      } else {
        ObRawExpr *b_expr = NULL;
        if (OB_FAIL(ObRawExprUtils::build_const_bool_expr(ctx_->expr_factory_, b_expr, false))) {
            LOG_WARN("build expr failed", K(ret));
        } else if (OB_ISNULL(b_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("b_Expr is null", K(ret));
        } else if (OB_FAIL(conditions.push_back(b_expr))) {
          LOG_WARN("push back failed", K(ret));
        } else if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, cmp_expr, false))) {
          LOG_WARN("add cons failed", K(ret));
        } else {
          limit_expr = NULL;
        }
      }
    } else if (is_eq_cond) {
      ObRawExpr *cmp_expr = NULL;
      if (OB_FAIL(ObTransformUtils::compare_const_expr_result(ctx_, limit_value, T_OP_EQ, 1, is_true))) {
        LOG_WARN("compare expr failed", K(ret));
      } else if (one_expr == NULL && OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                                      ObIntType,
                                                      1,
                                                      one_expr))) {
          LOG_WARN("build const expr failed", K(ret));
      } else if (OB_FAIL(ObRawExprUtils::create_double_op_expr(*ctx_->expr_factory_, ctx_->session_info_, T_OP_EQ,
                                                                cmp_expr, limit_value, one_expr))) {
        LOG_WARN("create doubel op expr", K(ret));
      } else if (is_true) {
        if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, cmp_expr, true))) {
          LOG_WARN("add cons failed", K(ret));
        } else {
          limit_expr = one_expr;
        }
      } else {
        ObRawExpr *b_expr = NULL;
        if (OB_FAIL(ObRawExprUtils::build_const_bool_expr(ctx_->expr_factory_, b_expr, false))) {
            LOG_WARN("build expr failed", K(ret));
        } else if (OB_ISNULL(b_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("b_Expr is null", K(ret));
        } else if (OB_FAIL(conditions.push_back(b_expr))) {
          LOG_WARN("push back failed", K(ret));
        } else if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, cmp_expr, false))) {
          LOG_WARN("add cons failed", K(ret));
        } else {
          limit_expr = NULL; //the limit expr must be int type or null.
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_generated_rownum_as_limit(
                                            const ObIArray<ObParentDMLStmt> &parent_stmts,
                                            ObDMLStmt *stmt,
                                            bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  ObDMLStmt *upper_stmt = NULL;
  ObSelectStmt *select_stmt = NULL;
  ObRawExpr *view_offset = NULL;
  ObRawExpr *view_limit = NULL;
  ObRawExpr *offset_expr = NULL;
  ObRawExpr *limit_expr = NULL;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (parent_stmts.empty()) {
    /*do nothing*/
  } else if (!stmt->is_select_stmt() || OB_ISNULL(select_stmt = static_cast<ObSelectStmt*>(stmt))
             || OB_ISNULL(upper_stmt = parent_stmts.at(parent_stmts.count()-1).stmt_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (select_stmt->is_hierarchical_query() || //层次查询不进行改写
             upper_stmt->is_hierarchical_query()) {
    /*do nothing*/
  } else if (OB_FAIL(try_transform_generated_rownum_as_limit_offset(upper_stmt, select_stmt,
                                                                    view_limit, view_offset))) {
    LOG_WARN("failed to try transform generated rownum as offset offset", K(ret));
  } else if (NULL == view_limit && NULL == view_offset) {
    LOG_TRACE("no limit expr");
    //if the view already has a limit or offset, then the new limit should be merged.
  } else if (OB_FAIL(ObTransformUtils::merge_limit_offset(ctx_, stmt->get_limit_expr(), view_limit,
                                                          stmt->get_offset_expr(), view_offset,
                                                          limit_expr, offset_expr))) {
    LOG_WARN("failed to merge limit offset", K(ret));
  } else {
    stmt->set_limit_offset(limit_expr, offset_expr);
    trans_happened = true;
  }
  return ret;
}

// 将 generate rownum 改写为 limit / offset
// 1. select * from (select rownum rn, ... from t) where rn > 2 and rn <= 5;
//      => select * from (select rownum rn, ... from t limit 3 offset 2);
// 2. select * from (select rownum rn, ... from t) where rn = 4;
//      => select * from (select rownum rn, ... from t limit 1 offset 3);
// 3. select * from (select rownum rn, ... from t) where rn = 4.2;
//      => select * from (select rownum rn, ... from t limit 0 offset 0);
int ObTransformPreProcess::try_transform_generated_rownum_as_limit_offset(ObDMLStmt *upper_stmt,
                                                                          ObSelectStmt *select_stmt,
                                                                          ObRawExpr *&limit_expr,
                                                                          ObRawExpr *&offset_expr)
{
  int ret = OB_SUCCESS;
  TableItem *table = NULL;
  limit_expr = NULL;
  offset_expr = NULL;
  if (OB_ISNULL(select_stmt) || OB_ISNULL(upper_stmt) || OB_ISNULL(ctx_)
      || OB_ISNULL(ctx_->expr_factory_) || OB_ISNULL(ctx_->session_info_) || OB_ISNULL(ctx_->exec_ctx_)
      || OB_ISNULL(ctx_->exec_ctx_->get_physical_plan_ctx())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (!upper_stmt->is_sel_del_upd() || !upper_stmt->is_single_table_stmt()) {
    // 仅对单表视图查询尝试提取 limit/offset
  } else if (OB_ISNULL(table = upper_stmt->get_table_item(0))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (!is_oracle_mode() || select_stmt->is_fetch_with_ties()
             || NULL != select_stmt->get_offset_expr()
             || NULL != select_stmt->get_limit_percent_expr()
             || select_stmt->has_order_by()
             || select_stmt->has_rollup()
             || select_stmt->has_group_by()
             || select_stmt->has_window_function()) {
    // oracle 模式下, 以下情况禁止转化:
    // 1. is fetch with ties / has limit percent expr / has offset expr
    // 2. order by, 即使输出 rownum 也为乱序:
    //      select * from (select rounum rn, c1 from t order by c1) where rn > 10;
    // 3. rollup/group by 无法输出非聚合列 rownum
    // 4. window func 内部可能进行排序, 不进行转化
  } else {
    bool is_eq_cond = false;
    ObRawExpr *limit_cond = NULL;
    ObRawExpr *offset_cond = NULL;
    ObRawExpr *limit_value = NULL;
    ObRawExpr *offset_value = NULL;
    ObItemType limit_cmp_type = T_INVALID;
    ObItemType offset_cmp_type = T_INVALID;
    ObRawExpr *select_expr = NULL;
    ColumnItem *column_item = NULL;
    ObRawExpr *upper_cond_expr = NULL;
    ObIArray<SelectItem> &select_items = select_stmt->get_select_items();
    ObIArray<ObRawExpr*> &upper_conds = upper_stmt->get_condition_exprs();
    for (int64_t i = 0; OB_SUCC(ret) && !is_eq_cond && i < select_items.count(); ++i) {
      if (OB_ISNULL(select_expr = select_items.at(i).expr_)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret));
      } else if (!select_expr->has_flag(IS_ROWNUM)) {
        /*do nothing*/
      } else if (OB_ISNULL(column_item = upper_stmt->get_column_item_by_id(table->table_id_,
                                                                      i + OB_APP_MIN_COLUMN_ID))) {
        /*do nothing*/
      } else {
        for (int64_t j = 0; OB_SUCC(ret) && !is_eq_cond && j < upper_conds.count(); ++j) {
          if (OB_ISNULL(upper_cond_expr = upper_conds.at(j))) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get unexpected null", K(ret));
          } else if (upper_cond_expr->is_op_expr() && 2 == upper_cond_expr->get_param_count() &&
                     (IS_RANGE_CMP_OP(upper_cond_expr->get_expr_type())
                      || T_OP_EQ == upper_cond_expr->get_expr_type())) {
            ObRawExpr *param1 = upper_cond_expr->get_param_expr(0);
            ObRawExpr *param2 = upper_cond_expr->get_param_expr(1);
            ObRawExpr *const_expr = NULL;
            ObItemType expr_type = T_INVALID;
            if (OB_ISNULL(param1) || OB_ISNULL(param2)) {
              ret = OB_ERR_UNEXPECTED;
              LOG_WARN("null expr", K(ret), K(param1), K(param2));
            } else if (param1 == column_item->expr_ &&
                       param2->is_static_scalar_const_expr()) {
              expr_type = upper_cond_expr->get_expr_type();
              const_expr = param2;
            } else if (param1->is_static_scalar_const_expr() &&
                       param2 == column_item->expr_) {
              const_expr = param1;
              ret = ObOptimizerUtil::flip_op_type(upper_cond_expr->get_expr_type(), expr_type);
            } else {/*do nothing*/}

            // 多个可转换为 limit/offset 的conds, 仅转换第一个
            if (OB_FAIL(ret) || NULL == const_expr) {
            } else if (!const_expr->get_result_type().is_integer_type()
                       && !const_expr->get_result_type().is_number()) {
              /*do nothing*/
            } else if (T_OP_EQ == expr_type) { // 有等值条件优先转化
              limit_value = const_expr;
              limit_cond = upper_cond_expr;
              is_eq_cond = true;
              offset_cond = NULL;
            } else if (NULL == limit_cond && (T_OP_LE == expr_type || T_OP_LT == expr_type)) {
              limit_value = const_expr;
              limit_cmp_type = expr_type;
              limit_cond = upper_cond_expr;
            } else if (NULL == offset_cond && (T_OP_GE == expr_type || T_OP_GT == expr_type)) {
              offset_value = const_expr;
              offset_cmp_type = expr_type;
              offset_cond = upper_cond_expr;
            }
          }
        }
      }
    }

    ObRawExpr *init_limit_expr = NULL;
    ObRawExpr *init_offset_expr = NULL;
    ObRawExpr *minus_expr = NULL;
    ObConstRawExpr *zero_expr = NULL;
    ObConstRawExpr *one_expr = NULL;
    bool limit_is_not_neg = false;
    bool offset_is_not_neg = false;
    bool minus_is_not_neg = false;
    ObRawExpr* limit_cmp_expr = NULL;
    ObRawExpr* offset_cmp_expr = NULL;
    ObRawExpr* minus_cmp_expr = NULL;
    ObSEArray<ObRawExpr *, 4> params;
    bool is_not_neg = false;
    bool is_null = false;
    bool is_not_null = false;
    ObNotNullContext not_null_ctx(*ctx_, upper_stmt);
    if (OB_FAIL(ret) || (limit_cond == NULL && offset_cond == NULL)) {
    } else if (!lib::is_oracle_mode() && OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                                      ObIntType,
                                                      0,
                                                      zero_expr))) {
        LOG_WARN("create zero expr failed", K(ret));
    } else if (!lib::is_oracle_mode() && OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                                      ObIntType,
                                                      1,
                                                      one_expr))) {
        LOG_WARN("create one expr failed", K(ret));
    } else if (lib::is_oracle_mode() && OB_FAIL(ObRawExprUtils::build_const_number_expr(*ctx_->expr_factory_,
                                                                                        ObNumberType,
                                                                                        ObNumber::get_zero(),
                                                                                        zero_expr))) {
      LOG_WARN("create zero expr failed", K(ret));
    } else if (lib::is_oracle_mode() && OB_FAIL(ObRawExprUtils::build_const_number_expr(*ctx_->expr_factory_,
                                                                                        ObNumberType,
                                                                                        ObNumber::get_positive_one(),
                                                                                        one_expr))) {
      LOG_WARN("create one expr failed", K(ret));
    } else if (limit_value != NULL && OB_FAIL(ObTransformUtils::is_const_expr_not_null(not_null_ctx, limit_value, is_not_null, is_null))) {
      LOG_WARN("check value is null failed", K(ret));
    } else if (limit_value != NULL && !is_not_null && !is_null) {
      //not calculable
    } else if (offset_value != NULL && !is_null &&
                                      OB_FAIL(ObTransformUtils::is_const_expr_not_null(not_null_ctx, offset_value, is_not_null, is_null))) {
      LOG_WARN("check value is null failed", K(ret));
    } else if (offset_value != NULL && !is_not_null && !is_null) {
      //not calculable
    } else if (NULL != limit_cond && OB_FAIL(ObOptimizerUtil::remove_item(upper_conds,
                                                                          limit_cond))) {
      LOG_WARN("failed to remove expr", K(ret));
    } else if (NULL != offset_cond && OB_FAIL(ObOptimizerUtil::remove_item(upper_conds,
                                                                           offset_cond))) {
      LOG_WARN("failed to remove expr", K(ret));
    } else if (is_null) {
      limit_expr = zero_expr;
      offset_expr = NULL;
      ObRawExpr *and_expr = NULL;
      ObRawExpr *tmp_is_not_expr = NULL;
      ObSEArray<ObRawExpr *, 2> not_null_exprs;
      if (limit_value != NULL && (OB_FAIL(ObRawExprUtils::build_is_not_null_expr(*ctx_->expr_factory_,
                                                            limit_value,
                                                            true /*is_not_null*/,
                                                            tmp_is_not_expr)) ||
                                  OB_FAIL(not_null_exprs.push_back(tmp_is_not_expr)))) {
        LOG_WARN("push back failed", K(ret));
      } else if (offset_value != NULL && (OB_FAIL(ObRawExprUtils::build_is_not_null_expr(*ctx_->expr_factory_,
                                                            offset_value,
                                                            true /*is_not_null*/,
                                                            tmp_is_not_expr)) ||
                                        OB_FAIL(not_null_exprs.push_back(tmp_is_not_expr)))) {
        LOG_WARN("push back failed", K(ret));
      } else if (OB_FAIL(ObRawExprUtils::build_and_expr(*ctx_->expr_factory_, not_null_exprs, and_expr))) {
        LOG_WARN("build and expr failed", K(ret));
      } else if (OB_FAIL(and_expr->formalize(ctx_->session_info_))) {
        LOG_WARN("formalize failed", K(ret));
      } else if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, and_expr, false))) {
        LOG_WARN("add cons failed", K(ret));
      }
    } else if (is_eq_cond) {
      if (OB_FAIL(transform_generated_rownum_eq_cond(limit_value, limit_expr, offset_expr))) {
        LOG_WARN("show limit expr", K(ret), K(limit_expr), K(offset_expr));
      }
    } else if (NULL != limit_value &&
               (OB_FAIL(ObOptimizerUtil::convert_rownum_filter_as_limit(*ctx_->expr_factory_,
                                                                        ctx_->session_info_,
                                                                        limit_cmp_type,
                                                                        limit_value,
                                                                        init_limit_expr)))) { //int > 0
      LOG_WARN("failed to create limit expr from rownum", K(ret));
    } else if (NULL != offset_value &&
              OB_FAIL(ObOptimizerUtil::convert_rownum_filter_as_offset(*ctx_->expr_factory_,
                                                                        ctx_->session_info_,
                                                                        offset_cmp_type,
                                                                        offset_value,
                                                                        init_offset_expr,
                                                                        zero_expr,
                                                                        offset_is_not_neg,
                                                                        ctx_))) {
      LOG_WARN("failed tp conver rownum as filter", K(ret));
    } else if (NULL != limit_value && OB_FAIL(ObTransformUtils::compare_const_expr_result(ctx_, init_limit_expr,
                                                                                T_OP_GE, 1,
                                                                                limit_is_not_neg))) {
      LOG_WARN("check is not neg false", K(ret));
    } else if (NULL != limit_value && OB_FAIL(ObRawExprUtils::create_double_op_expr(*ctx_->expr_factory_,
                                                                                      ctx_->session_info_,
                                                                                      T_OP_GE,
                                                                                      limit_cmp_expr,
                                                                                      init_limit_expr,
                                                                                      one_expr))) {
      LOG_WARN("check is not neg false", K(ret));
    } else if (NULL != offset_value && OB_FAIL(ObRawExprUtils::create_double_op_expr(*ctx_->expr_factory_,
                                                                                      ctx_->session_info_,
                                                                                      T_OP_GE,
                                                                                      offset_cmp_expr,
                                                                                      offset_value,
                                                                                      zero_expr))) {
      LOG_WARN("create expr failed", K(ret));
    } else if (offset_value == NULL && limit_value != NULL) {
      if (limit_is_not_neg) {
        limit_expr = init_limit_expr;
      } else {
        limit_expr = zero_expr;
      }
      if (OB_FAIL(ret)) {
      } else if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, limit_cmp_expr, limit_is_not_neg))) {
        LOG_WARN("add cons failed", K(ret));
      }
    } else if (limit_value == NULL && offset_value != NULL) {
      offset_expr = init_offset_expr;
      if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, offset_cmp_expr, offset_is_not_neg))) {
        LOG_WARN("add cons failed", K(ret));
      }
    } else if (OB_FAIL(ObRawExprUtils::create_double_op_expr(*ctx_->expr_factory_,
                                                             ctx_->session_info_,
                                                             T_OP_MINUS, minus_expr,
                                                             init_limit_expr,
                                                             init_offset_expr))) { // int - int = int
      LOG_WARN("failed to create double op expr", K(ret));
    } else if (OB_FAIL(ObTransformUtils::compare_const_expr_result(ctx_, minus_expr, T_OP_GE, 1,
                                                                        minus_is_not_neg))) {
      LOG_WARN("get const expr compare result", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::create_double_op_expr(*ctx_->expr_factory_,
                                                              ctx_->session_info_,
                                                              T_OP_GE,
                                                              minus_cmp_expr,
                                                              minus_expr,
                                                              one_expr))) {
      LOG_WARN("create expr failed", K(ret));
    } else if (OB_FAIL(params.push_back(minus_cmp_expr)) || OB_FAIL(params.push_back(limit_cmp_expr))) {
      LOG_WARN("push back failed", K(ret));
    } else if (!minus_is_not_neg || !limit_is_not_neg) {
      limit_expr = zero_expr;
      offset_expr = NULL;
      if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, offset_cmp_expr, offset_is_not_neg))) {
        LOG_WARN("add cons failed", K(ret));
      } else if (params.count() > 0) {
        ObRawExpr *and_expr = NULL;
        if (OB_FAIL(ObRawExprUtils::build_and_expr(*ctx_->expr_factory_, params, and_expr))) {
          LOG_WARN("build and expr failed", K(ret));
        } else if (OB_FAIL(and_expr->formalize(ctx_->session_info_))) {
          LOG_WARN("formalize failed", K(ret));
        } else if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, and_expr, false))) {
          LOG_WARN("add cons failed", K(ret));
        }
      }
    } else {
      limit_expr = minus_expr;
      offset_expr = init_offset_expr;
      if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, offset_cmp_expr, offset_is_not_neg))) {
        LOG_WARN("add cons failed", K(ret));
      } else if (params.count() > 0) {
        ObRawExpr *and_expr = NULL;
        if (OB_FAIL(ObRawExprUtils::build_and_expr(*ctx_->expr_factory_, params, and_expr))) {
          LOG_WARN("build and expr failed", K(ret));
        } else if (OB_FAIL(and_expr->formalize(ctx_->session_info_))) {
          LOG_WARN("formalize failed", K(ret));
        } else if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, and_expr, true))) {
          LOG_WARN("add cons failed", K(ret));
        }
      }
    }

  //添加 cast 作用:
  //  1.对于新引擎, 必须保证输出结果为 int
    ObExprResType dst_type;
    dst_type.set_int();
    ObSysFunRawExpr *cast_expr = NULL;
    if (NULL != limit_expr) {
      if (limit_expr->get_result_type().is_int()) {
        //do nothing
      } else {
        OZ(ObRawExprUtils::create_cast_expr(*ctx_->expr_factory_, limit_expr, dst_type,
                                            cast_expr, ctx_->session_info_));
        CK(NULL != cast_expr);
        if (OB_SUCC(ret)) {
          limit_expr = cast_expr;
        }
      }
    }
    if (OB_SUCC(ret) && NULL != offset_expr) {
      if (offset_expr->get_result_type().is_int()) {
        //do nothing
      } else {
        OZ(ObRawExprUtils::create_cast_expr(*ctx_->expr_factory_, offset_expr, dst_type,
                                            cast_expr, ctx_->session_info_));
        CK(NULL != cast_expr);
        if (OB_SUCC(ret)) {
          offset_expr = cast_expr;
        }
      }
    }
  }
  return ret;
}


//select * from (select rownum rn, ... from t) where rn = val;
//      => select * from (select rownum rn, ... from t limit ? offset ?);
//  val 正整数: limit 1 offset val - 1;
//        其它: limit 0 offset 0;
int ObTransformPreProcess::transform_generated_rownum_eq_cond(ObRawExpr *eq_value,
                                                              ObRawExpr *&limit_expr,
                                                              ObRawExpr *&offset_expr)
{
  int ret = OB_SUCCESS;
  limit_expr = NULL;
  offset_expr = NULL;
  ObRawExpr *minus_expr = NULL;
  ObConstRawExpr *zero_expr = NULL;
  ObConstRawExpr *one_expr = NULL;
  ObSysFunRawExpr *floor_expr = NULL;
  bool trans_limit_zero = false;
  bool eqval_is_ge_one = false;
  bool is_int = false;
  ObSEArray<ObRawExpr *, 4> params;
  ObRawExpr *ge_expr = NULL;
  ObRawExpr *eq_expr = NULL;
  if (OB_ISNULL(eq_value) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)
      || OB_ISNULL(ctx_->session_info_) || OB_ISNULL(ctx_->exec_ctx_)
      || OB_ISNULL(ctx_->exec_ctx_->get_physical_plan_ctx())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_FUN_SYS_FLOOR, floor_expr))) {
    LOG_WARN("failed to create fun sys floor", K(ret));
  } else if (OB_ISNULL(floor_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("floor expr is null", K(ret));
  } else if (OB_FAIL(floor_expr->set_param_expr(eq_value))) {
    LOG_WARN("failed to set param expr", K(ret));
  } else if (OB_FAIL(floor_expr->formalize(ctx_->session_info_))) {
    LOG_WARN("formalize failed", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                              ObIntType, 0, zero_expr))) {
    LOG_WARN("failed to build const int expr", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_,
                                              ObIntType, 1, one_expr))) {
    LOG_WARN("failed to build const int expr", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::create_double_op_expr(*ctx_->expr_factory_,
                                                          ctx_->session_info_, T_OP_MINUS,
                                                          minus_expr, eq_value, one_expr))) {
              LOG_WARN("failed to create double op expr", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::create_double_op_expr(*ctx_->expr_factory_, ctx_->session_info_, T_OP_GE,
                                                            ge_expr, eq_value, one_expr))) {
    LOG_WARN("create double op expr failed", K(ret));
  } else if (OB_FAIL(params.push_back(ge_expr))) {
    LOG_WARN("push back failed", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::create_double_op_expr(*ctx_->expr_factory_, ctx_->session_info_, T_OP_EQ,
                                                            eq_expr, eq_value, floor_expr))) {
    LOG_WARN("create double op expr failed", K(ret));
  } else if (OB_FAIL(params.push_back(eq_expr))) {
    LOG_WARN("push back failed", K(ret));
  } else if (OB_FAIL(ObTransformUtils::compare_const_expr_result(ctx_, eq_value, T_OP_GE,
                                                                1, eqval_is_ge_one))) {
    LOG_WARN("ensure expr value not neg failed", K(ret));
  } else if (OB_FAIL(ObTransformUtils::compare_const_expr_result(ctx_, eq_expr, T_OP_EQ, 1, is_int))) {
    LOG_WARN("ensure expr value not neg failed", K(ret));
  } else if (is_int && eqval_is_ge_one) {
    limit_expr = one_expr;
    offset_expr = minus_expr;
    ObRawExpr *and_expr = NULL;
    if (OB_FAIL(ObRawExprUtils::build_and_expr(*ctx_->expr_factory_, params, and_expr))) {
      LOG_WARN("build and expr failed", K(ret));
    } else if (OB_FAIL(and_expr->formalize(ctx_->session_info_))) {
      LOG_WARN("formalize failed", K(ret));
    } else if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, and_expr, true))) {
      LOG_WARN("add cons failed", K(ret));
    }
  } else {
    limit_expr = zero_expr;
    offset_expr = NULL;
    ObRawExpr *and_expr = NULL;
    if (OB_FAIL(ObRawExprUtils::build_and_expr(*ctx_->expr_factory_, params, and_expr))) {
      LOG_WARN("build and expr failed", K(ret));
    } else  if (OB_FAIL(and_expr->formalize(ctx_->session_info_))) {
      LOG_WARN("formalize failed", K(ret));
    } else if (OB_FAIL(ObTransformUtils::add_param_bool_constraint(ctx_, and_expr, false))) {
      LOG_WARN("add cons failed", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_udt_column_value_expr_inner(ObDMLStmt *stmt, ObDmlTableInfo &table_info, ObRawExpr *&old_expr, ObRawExpr *hidd_expr)
{
  // replace udt column in value expr
  int ret = OB_SUCCESS;
  if (old_expr->is_column_ref_expr()) {
    ObColumnRefRawExpr *col_ref = static_cast<ObColumnRefRawExpr *>(old_expr);
    if (col_ref->is_xml_column()) {
      bool need_transform = false;
      ObColumnRefRawExpr *hidd_col = static_cast<ObColumnRefRawExpr *>(hidd_expr);
      for (int j = 0; j < table_info.column_exprs_.count() && OB_ISNULL(hidd_col); j++) {
        if (OB_FAIL(ObTransformUtils::create_udt_hidden_columns(ctx_, stmt, *col_ref, hidd_col, need_transform))) {
          LOG_WARN("failed to create udt hidden exprs", K(ret));
        }
      }
      if (!need_transform) {
        // do nothing
      } else if (OB_ISNULL(hidd_col)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("hidden column is null", K(ret));
      } else if (!hidd_col->get_result_type().is_blob()) {
        // if column is not clob type, don't need add xml_binary
        old_expr = hidd_col;
      } else if (OB_FAIL(transform_xml_binary(hidd_col, old_expr))) {
        LOG_WARN("transform xml binary failed", K(ret));
      }
    }
  } else {
    for (int i = 0; i < old_expr->get_param_count() && OB_SUCC(ret); i++) {
      if (OB_FAIL(transform_udt_column_value_expr_inner(stmt, table_info, old_expr->get_param_expr(i), hidd_expr))) {
        LOG_WARN("transform udt column value expr failed", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_udt_column_value_expr(ObDMLStmt *stmt, ObDmlTableInfo &table_info, ObRawExpr *old_expr, ObRawExpr *&new_expr, ObRawExpr *hidd_expr)
{
  int ret = OB_SUCCESS;
  // to do: add SYS_MAKEXMLBinary
  ObSysFunRawExpr *make_xml_expr = NULL;
  ObConstRawExpr *c_expr = NULL;
  if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (OB_FAIL(transform_udt_column_value_expr_inner(stmt, table_info, old_expr, hidd_expr))) {
    LOG_WARN("replace udt column failed", K(ret));
  } else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_FUN_SYS_PRIV_MAKE_XML_BINARY, make_xml_expr))) {
    LOG_WARN("failed to create fun make xml binary expr", K(ret));
  } else if (OB_ISNULL(make_xml_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("xml expr is null", K(ret));
  } else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_INT, c_expr))) {
    LOG_WARN("create dest type expr failed", K(ret));
  } else if (OB_ISNULL(c_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("const expr is null");
  } else {
    ObObj val;
    val.set_int(0);
    c_expr->set_value(val);
    c_expr->set_param(val);
    if (OB_FAIL(make_xml_expr->set_param_exprs(c_expr, old_expr))) {
      LOG_WARN("set param expr fail", K(ret));
    } else {
      make_xml_expr->set_func_name(ObString::make_string("_make_xml_binary"));
      if (OB_FAIL(make_xml_expr->formalize(ctx_->session_info_))) {
        LOG_WARN("make xml epxr formlize fail", K(ret));
      }
      new_expr = make_xml_expr;
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_udt_column_conv_param_expr(ObDmlTableInfo &table_info, ObRawExpr *old_expr, ObRawExpr *&new_expr)
{
  int ret = OB_SUCCESS;
  // to do: add SYS_MAKEXMLBinary
  ObSysFunRawExpr *make_xml_expr = NULL;
  ObConstRawExpr *c_expr = NULL;
  if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_FUN_SYS_PRIV_MAKE_XML_BINARY, make_xml_expr))) {
    LOG_WARN("failed to create fun make xml binary expr", K(ret));
  } else if (OB_ISNULL(make_xml_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("xml expr is null", K(ret));
  } else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_INT, c_expr))) {
    LOG_WARN("create dest type expr failed", K(ret));
  } else if (OB_ISNULL(c_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("const expr is null");
  } else {
    ObObj val;
    val.set_int(0);
    c_expr->set_value(val);
    c_expr->set_param(val);
    if (OB_FAIL(make_xml_expr->set_param_exprs(c_expr, old_expr))) {
      LOG_WARN("set param expr fail", K(ret));
    } else {
      make_xml_expr->set_func_name(ObString::make_string("_make_xml_binary"));
      if (OB_FAIL(make_xml_expr->formalize(ctx_->session_info_))) {
        LOG_WARN("make xml epxr formlize fail", K(ret));
      }
      new_expr = make_xml_expr;
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_udt_column_conv_function(ObDmlTableInfo &table_info,
                                                              ObIArray<ObRawExpr*> &column_conv_exprs,
                                                              ObColumnRefRawExpr &udt_col,
                                                              ObColumnRefRawExpr &hidd_col)
{
  int ret = OB_SUCCESS;
  bool hidd_found = false;

  for (int64_t j = 0; OB_SUCC(ret) && !hidd_found && j < table_info.column_exprs_.count(); ++j) {
    ObColumnRefRawExpr *col = table_info.column_exprs_.at(j);
    if (col->get_column_id() == hidd_col.get_column_id()) {
      ObRawExpr *old_conv_expr = column_conv_exprs.at(j);
      const ObColumnRefRawExpr *tmp = ObRawExprUtils::get_column_ref_expr_recursively(old_conv_expr->get_param_expr(4));
      ObRawExpr *old_col_ref = const_cast<ObRawExpr *>(static_cast<const ObRawExpr *>(tmp));
      hidd_found = true;
      ObRawExpr *new_value_expr = NULL;
      if (OB_ISNULL(old_col_ref)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("old expr is null", K(ret));
      } else if (OB_FAIL(transform_udt_column_conv_param_expr(table_info, old_col_ref, new_value_expr))) {
        LOG_WARN("failed to transform udt value exprs", K(ret));
      } else if (OB_FAIL(static_cast<ObSysFunRawExpr*>(old_conv_expr)->replace_param_expr(4, new_value_expr))) {
        LOG_WARN("failed to push back udt hidden exprs", K(ret));
      }
    }
  }
  return ret;
}


int ObTransformPreProcess::replace_udt_assignment_exprs(ObDMLStmt *stmt,
                                                        ObDmlTableInfo &table_info,
                                                        ObIArray<ObAssignment> &assignments,
                                                        bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;

  for (int64_t j = 0; OB_SUCC(ret) && j < assignments.count(); ++j) {
    ObColumnRefRawExpr *hidd_col = NULL;
    ObRawExpr *value_expr = NULL;
    ObAssignment &assign = assignments.at(j);
    bool trigger_exist = false;
    if (OB_ISNULL(assign.column_expr_) || OB_ISNULL(assign.expr_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("assgin expr is null", K(ret));
    } else if (!assign.column_expr_->is_xml_column()) {
      // do nothins
    } else {
      for (int j = 0; j < table_info.column_exprs_.count() && OB_ISNULL(hidd_col); j++) {
        if (table_info.column_exprs_.at(j)->get_column_id() != assign.column_expr_->get_column_id() &&
            table_info.column_exprs_.at(j)->get_udt_set_id() == assign.column_expr_->get_udt_set_id()) {
            hidd_col = table_info.column_exprs_.at(j);
        }
      }
      if (OB_ISNULL(hidd_col)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("hidden column is null", K(ret));
       } else if (assign.expr_->get_expr_type() == T_FUN_SYS_WRAPPER_INNER) {
        trigger_exist = true;
        value_expr = assign.expr_->get_param_expr(0);
      } else {
        value_expr = assign.expr_;
      }

      if (OB_FAIL(ret)) {
        // do nothing
      } else if (value_expr->get_expr_type() != T_FUN_COLUMN_CONV) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpectd expr type", K(ret), K(assign.expr_->get_expr_type()));
      } else if (OB_ISNULL(value_expr = value_expr->get_param_expr(4))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("raw expr param is null");
      } else if (value_expr->get_expr_type() == T_FUN_SYS_CAST) {
        // don't need cast expr
        value_expr = value_expr->get_param_expr(0);
      } else if (value_expr->is_const_raw_expr()) {
        if (value_expr->get_expr_type() == T_QUESTIONMARK) {
          const ParamStore &param_store = ctx_->exec_ctx_->get_physical_plan_ctx()->get_param_store();
          ObConstRawExpr *param_expr = static_cast<ObConstRawExpr *>(value_expr);
          int64_t param_idx = param_expr->get_value().get_unknown();
          if (param_idx < 0 || param_idx >= param_store.count()) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("param_idx is invalid", K(ret), K(param_idx));
          } else if (param_store.at(param_idx).is_xml_sql_type() ||
                     param_store.at(param_idx).is_extend_xml_type()){
            // do nothing
          } else if (ob_is_decimal_int_tc(param_store.at(param_idx).get_type()) ||
                        ob_is_number_tc(param_store.at(param_idx).get_type())) {
            ret = OB_ERR_INVALID_TYPE_FOR_OP;
            LOG_WARN("old_expr_type invalid ObLongTextType type", K(ret), K(param_store.at(param_idx).get_type()));
          } else {
            ObExprResType res_type;
            res_type.set_varchar();
            res_type.set_collation_type(CS_TYPE_UTF8MB4_BIN);
            value_expr->set_result_type(res_type);
          }
        }
      }
    }
    if (OB_SUCC(ret) && assign.column_expr_->is_xml_column()) {
      ObRawExpr *new_value_expr = NULL;
      ObRawExpr *old_column_expr = assign.column_expr_;
      if (OB_FAIL(transform_udt_column_value_expr(stmt, table_info, value_expr, new_value_expr))){
        LOG_WARN("failed to transform udt value exprs", K(ret));
      } else if (OB_FAIL(ObRawExprUtils::build_column_conv_expr(*ctx_->expr_factory_,
                                                                *ctx_->allocator_,
                                                                *hidd_col,
                                                                new_value_expr,
                                                                ctx_->session_info_))) {
        LOG_WARN("fail to build column conv expr", K(ret), K(hidd_col));
      } else {
        trans_happened = true;
        assign.column_expr_ = hidd_col;
        if (trigger_exist) {
          if (OB_FAIL(static_cast<ObSysFunRawExpr*>(assign.expr_)->replace_param_expr(0, new_value_expr))) {
            LOG_WARN("failed to replace wrapper expr param", K(ret));
          }
        } else {
          assign.expr_ = new_value_expr;
        }
      }
      // process returning clause for update
      if (OB_SUCC(ret) && stmt->get_stmt_type() == stmt::T_UPDATE) {
        ObDelUpdStmt *update_stmt = static_cast<ObDelUpdStmt *>(stmt);
        if (update_stmt->is_returning()) {
          for (int64_t i = 0; OB_SUCC(ret) && i < update_stmt->get_returning_exprs().count(); i++) {
            ObRawExpr *sys_makexml_expr = NULL;
            if (OB_ISNULL(hidd_col)) {
              ret = OB_ERR_UNEXPECTED;
              LOG_WARN("hidden col is NULL", K(ret), K(i), K(j));
            } else if (OB_FAIL(transform_xml_binary(new_value_expr, sys_makexml_expr))) {
              LOG_WARN("fail to create sys_makexml expr", K(ret));
            } else if (OB_FAIL(ObRawExprUtils::replace_ref_column(update_stmt->get_returning_exprs().at(i),
                                                                  old_column_expr,
                                                                  sys_makexml_expr))) {
              LOG_WARN("fail to replace xml column in returning exprs", K(ret), K(i));
            }
          } // end for
        }
      } //end if: process returning clause
    }
  }

  return ret;
}

int ObTransformPreProcess::transform_xml_binary(ObRawExpr *hidden_blob_expr, ObRawExpr *&new_expr)
{
  int ret = OB_SUCCESS;
  ObSysFunRawExpr *sys_makexml = NULL;
  ObConstRawExpr *c_expr = NULL;
  ObColumnRefRawExpr *hidd_col = NULL;
  if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_) || OB_ISNULL(hidden_blob_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), KP(ctx_), KP(hidden_blob_expr));
  } else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_FUN_SYS_MAKEXML, sys_makexml))) {
    LOG_WARN("failed to create fun sys_makexml expr", K(ret));
  } else if (OB_ISNULL(sys_makexml)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("sys_makexml expr is null", K(ret));
  } else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_INT, c_expr))) {
    LOG_WARN("create dest type expr failed", K(ret));
  } else if (OB_ISNULL(c_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("const expr is null");
  } else {
    ObObj val;
    val.set_int(0);
    c_expr->set_value(val);
    c_expr->set_param(val);
    if (OB_FAIL(sys_makexml->set_param_exprs(c_expr, hidden_blob_expr))) {
      LOG_WARN("set param expr fail", K(ret));
    } else if (FALSE_IT(sys_makexml->set_func_name(ObString::make_string("SYS_MAKEXML")))) {
    } else if (OB_FAIL(sys_makexml->formalize(ctx_->session_info_))) {
      LOG_WARN("failed to formalize", K(ret));
    } else {
      new_expr = sys_makexml;
    }
  }
  return ret;
}

int ObTransformPreProcess::set_hidd_col_not_null_attr(const ObColumnRefRawExpr &udt_col, ObIArray<ObColumnRefRawExpr *> &column_exprs)
{
  int ret = OB_SUCCESS;
  bool found = false;
  for (int64_t j = 0; OB_SUCC(ret) && !found && j < column_exprs.count(); ++j) {
    ObColumnRefRawExpr *col_hidden = column_exprs.at(j);
    if (col_hidden->get_udt_set_id() == udt_col.get_udt_set_id() &&
        udt_col.get_column_id() != col_hidden->get_column_id()) {
      found = true;
      if (udt_col.get_result_type().has_result_flag(HAS_NOT_NULL_VALIDATE_CONSTRAINT_FLAG)) {
        col_hidden->set_result_flag(HAS_NOT_NULL_VALIDATE_CONSTRAINT_FLAG);
      }
      if (udt_col.get_result_type().has_result_flag(NOT_NULL_WRITE_FLAG)) {
        col_hidden->set_result_flag(NOT_NULL_WRITE_FLAG);
      }
    }
  }
  if (!found) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("failed to find hidden column", K(ret), K(udt_col.get_udt_set_id()));
  }
  return ret;
}

int ObTransformPreProcess::get_dml_view_col_exprs(const ObDMLStmt *stmt, ObIArray<ObColumnRefRawExpr*> &assign_col_exprs)
{
  int ret = OB_SUCCESS;
  if (stmt->get_stmt_type() == stmt::T_UPDATE) {
    const ObUpdateStmt *upd_stmt = static_cast<const ObUpdateStmt*>(stmt);
    for (int64_t i = 0; OB_SUCC(ret) && i < upd_stmt->get_update_table_info().count(); ++i) {
      ObUpdateTableInfo* table_info = upd_stmt->get_update_table_info().at(i);
      if (OB_ISNULL(table_info)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get null table info", K(ret));
      }
      for (int64_t j = 0; OB_SUCC(ret) && j < table_info->assignments_.count(); ++j) {
        ObAssignment &assign = table_info->assignments_.at(j);
        if (OB_ISNULL(assign.column_expr_) || OB_ISNULL(assign.expr_)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("assgin expr is null", K(ret));
        } else if (assign.column_expr_->is_xml_column() &&
                  OB_FAIL(add_var_to_array_no_dup(assign_col_exprs, assign.column_expr_))) {
          LOG_WARN("failed to push back column expr", K(ret));
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::get_update_generated_udt_in_parent_stmt(const ObIArray<ObParentDMLStmt> &parent_stmts,
                                                                   const ObDMLStmt *stmt,
                                                                   ObIArray<ObColumnRefRawExpr*> &col_exprs)
{
  int ret = OB_SUCCESS;

  const ObDMLStmt *root_stmt = NULL;
  ObSEArray<ObColumnRefRawExpr*, 8> parent_col_exprs;
  const ObSelectStmt *sel_stmt = NULL;
  const ObDMLStmt *parent_stmt = NULL;
  int64_t table_id = OB_INVALID;
  bool is_valid = false;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null stmt", K(ret));
  } else if (!stmt->is_select_stmt() || parent_stmts.empty()) {
    //do nothing
  } else if (OB_FALSE_IT(sel_stmt = static_cast<const ObSelectStmt*>(stmt))) {
  } else if (OB_ISNULL(root_stmt = parent_stmts.at(parent_stmts.count()-1).stmt_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("failed to get parent stmt", K(ret));
  } else if (OB_FAIL(ObTransformUtils::get_parent_stmt(root_stmt, stmt, parent_stmt, table_id, is_valid))) {
    LOG_WARN("failed to get parent stmt", K(ret));
  } else if (!is_valid) {
    //do nothing
  } else if (OB_ISNULL(parent_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null stmt", K(ret));
  } else if (OB_FAIL(get_dml_view_col_exprs(parent_stmt, parent_col_exprs))) {
    LOG_WARN("failed to get assignment columns", K(ret));
  } else if (!parent_col_exprs.empty()) {
    for (int64_t i = 0; OB_SUCC(ret) && i < parent_col_exprs.count(); ++i) {
      ObColumnRefRawExpr* col = parent_col_exprs.at(i);
      int64_t sel_idx = -1;
      if (OB_ISNULL(col)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null column expr", K(ret));
      } else if (OB_FALSE_IT(sel_idx = col->get_column_id() - OB_APP_MIN_COLUMN_ID)) {
      } else if (sel_idx < 0 || sel_idx >= sel_stmt->get_select_item_size()) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("select item index is incorrect", K(sel_idx), K(ret));
      } else {
        ObRawExpr *sel_expr = sel_stmt->get_select_item(sel_idx).expr_;
        ObColumnRefRawExpr *col_expr = NULL;
        if (OB_ISNULL(sel_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("unexpect null expr", K(ret));
        } else if (!sel_expr->is_column_ref_expr()) {
          //do nothing
        } else if (OB_FALSE_IT(col_expr = static_cast<ObColumnRefRawExpr*>(sel_expr))) {
        } else if (OB_FAIL(add_var_to_array_no_dup(col_exprs, col_expr))) {
          LOG_WARN("failed to push back column expr", K(ret));
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::check_skip_child_select_view(const ObIArray<ObParentDMLStmt> &parent_stmts,
                                                          ObDMLStmt *stmt, bool &skip_for_view_table)
{
  int ret = OB_SUCCESS;
  const ObSelectStmt *sel_stmt = NULL;
  const ObDMLStmt *parent_stmt = NULL;
  bool is_valid = false;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null stmt", K(ret));
  } else if (!stmt->is_select_stmt() || parent_stmts.count() != 1 ||
             stmt->get_table_size() != 1) {
    //do nothing
  } else if (OB_FALSE_IT(sel_stmt = static_cast<const ObSelectStmt*>(stmt))) {
  } else if (OB_ISNULL(parent_stmt = parent_stmts.at(0).stmt_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("failed to get parent stmt", K(ret));
  } else if (parent_stmt->get_table_size() != 1 ||
             !(parent_stmt->is_delete_stmt() || parent_stmt->is_update_stmt())) {
    // do nothing
  } else {
    const sql::TableItem *basic_table_item = stmt->get_table_item(0);
    const sql::TableItem *view_table_item = parent_stmt->get_table_item(0);
    if (OB_ISNULL(basic_table_item) || OB_ISNULL(view_table_item)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("failed to get table item", K(ret));
    } else if (basic_table_item->is_basic_table() && view_table_item->is_generated_table()) {
      if (OB_NOT_NULL(view_table_item->ref_query_) &&
          view_table_item->ref_query_->get_table_size() > 0 &&
          OB_NOT_NULL(view_table_item->ref_query_->get_table_item(0)) &&
          basic_table_item->table_id_ == view_table_item->ref_query_->get_table_item(0)->table_id_) {
        skip_for_view_table = true;
      }
    } else if (!basic_table_item->is_basic_table() || !view_table_item->is_view_table_) {
      // do nothing
    } else if (OB_ISNULL(view_table_item->view_base_item_)) {
      // do nothing
    } else if (basic_table_item->table_id_ == view_table_item->view_base_item_->table_id_) {
      skip_for_view_table = true;
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_json_object_expr_with_star(const ObIArray<ObParentDMLStmt> &parent_stmts,
                                                                ObDMLStmt *stmt, bool &trans_happened)
{
  INIT_SUCC(ret);
  ObSEArray<ObRawExpr*, 4> replace_exprs;

  JsonObjectStarChecker expr_checker(replace_exprs);
  ObStmtExprGetter visitor;
  visitor.checker_ = &expr_checker;
  if (OB_SUCC(ret) && OB_FAIL(stmt->iterate_stmt_expr(visitor))) {
    LOG_WARN("get relation exprs failed", K(ret));
  }

  //collect query udt exprs which need to be replaced
  for (int64_t i = 0; OB_SUCC(ret) && i < replace_exprs.count(); i++) {
    if (OB_ISNULL(replace_exprs.at(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("replace expr is null", K(ret));
    } else {
      ObSysFunRawExpr *func_expr = static_cast<ObSysFunRawExpr*>(replace_exprs.at(i));
      if (OB_FAIL(ObTransformUtils::expand_wild_star_to_columns(ctx_, stmt, func_expr))) {
        LOG_WARN("fail to transform star to column node", K(ret));
      } else {
        trans_happened = true;
      }
    }
  }

  return ret;
}

int ObTransformPreProcess::transform_query_udt_columns_exprs(const ObIArray<ObParentDMLStmt> &parent_stmts,
                                                             ObDMLStmt *stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObSEArray<DmlStmtScope, 4> scopes;
  ObSEArray<ObRawExpr*, 4> replace_exprs;
  ObSEArray<ObRawExpr*, 4> from_col_exprs;
  ObSEArray<ObRawExpr*, 4> to_col_exprs;
  ObSEArray<ObColumnRefRawExpr*, 8> parent_assign_xml_col_exprs;
  bool skip_for_view_table = false;

  if (OB_FAIL(get_update_generated_udt_in_parent_stmt(parent_stmts, stmt, parent_assign_xml_col_exprs))) {
    LOG_WARN("Fail to get update generated column array.", K(ret));
  } else if (OB_FAIL(check_skip_child_select_view(parent_stmts, stmt, skip_for_view_table))) {
    LOG_WARN("Fail to check if select in delete view.", K(ret));
  } else if (skip_for_view_table) {
    // do nothing
  } else {
    FastUdtExprChecker expr_checker(replace_exprs);
    if (OB_FAIL(scopes.push_back(SCOPE_DML_COLUMN)) ||
        (stmt->get_stmt_type() != stmt::T_MERGE && OB_FAIL(scopes.push_back(SCOPE_DML_VALUE))) ||
        OB_FAIL(scopes.push_back(SCOPE_DML_CONSTRAINT)) ||
        OB_FAIL(scopes.push_back(SCOPE_INSERT_DESC)) ||
        OB_FAIL(scopes.push_back(SCOPE_BASIC_TABLE)) ||
        OB_FAIL(scopes.push_back(SCOPE_DICT_FIELDS)) ||
        OB_FAIL(scopes.push_back(SCOPE_SHADOW_COLUMN)) ||
        ((stmt->get_stmt_type() == stmt::T_INSERT || stmt->get_stmt_type() == stmt::T_UPDATE) &&
          OB_FAIL(scopes.push_back(SCOPE_RETURNING))) ||
        (stmt->get_stmt_type() != stmt::T_MERGE && OB_FAIL(scopes.push_back(SCOPE_INSERT_VECTOR)))) {
      LOG_WARN("Fail to create scope array.", K(ret));
    }
    ObStmtExprGetter visitor;
    visitor.checker_ = &expr_checker;
    visitor.remove_scope(scopes);
    if (OB_SUCC(ret) && OB_FAIL(stmt->iterate_stmt_expr(visitor))) {
      LOG_WARN("get relation exprs failed", K(ret));
    }

    //collect query udt exprs which need to be replaced
    for (int64_t i = 0; OB_SUCC(ret) && i < replace_exprs.count(); i++) {
      if (OB_ISNULL(replace_exprs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("replace expr is null", K(ret));
      } else {
        ObColumnRefRawExpr *col_expr = static_cast<ObColumnRefRawExpr*>(replace_exprs.at(i));
        ObColumnRefRawExpr *hidd_col = NULL;
        ObRawExpr *sys_makexml_expr = NULL;
        bool need_transform = false;
        if (!col_expr->is_xml_column() || has_exist_in_array(parent_assign_xml_col_exprs, col_expr)) {
          // do nothing
        } else if (OB_FAIL(ObTransformUtils::create_udt_hidden_columns(ctx_,
                                                                      stmt,
                                                                      *col_expr,
                                                                      hidd_col,
                                                                      need_transform))) {
          LOG_WARN("failed to create udt hidden exprs", K(ret));
        } else if (need_transform == false) {
          // do nothing
        } else if (OB_FAIL(transform_xml_binary(hidd_col, sys_makexml_expr))) {
          LOG_WARN("failed to push back udt hidden exprs", K(ret));
        } else if (OB_FAIL(from_col_exprs.push_back(col_expr))) {
          LOG_WARN("failed to push back udt exprs", K(ret));
        } else if (OB_FAIL(to_col_exprs.push_back(sys_makexml_expr))) {
          LOG_WARN("failed to push back udt hidden exprs", K(ret));
        }
      }

      //do replace
      if (OB_SUCC(ret) && !from_col_exprs.empty()) {
        ObStmtExprReplacer replacer;
        replacer.remove_scope(scopes);
        if (OB_FAIL(replacer.add_replace_exprs(from_col_exprs, to_col_exprs))) {
          LOG_WARN("failed to add replace exprs", K(ret));
        } else if (OB_FAIL(stmt->iterate_stmt_expr(replacer))) {
          LOG_WARN("failed to iterate stmt expr", K(ret));
        } else {
          trans_happened = true;
        }
      }
    }
  }

  return ret;
}

int ObTransformPreProcess::transform_udt_columns_constraint_exprs(ObDMLStmt *stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObSEArray<DmlStmtScope, 4> scopes;
  ObSEArray<ObRawExpr*, 4> replace_exprs;
  ObSEArray<ObRawExpr*, 4> from_col_exprs;
  ObSEArray<ObRawExpr*, 4> to_col_exprs;
  FastUdtExprChecker expr_checker(replace_exprs);
  ObStmtExprGetter visitor;
  visitor.remove_all();
  visitor.add_scope(SCOPE_DML_CONSTRAINT);
  visitor.checker_ = &expr_checker;

  if (OB_SUCC(ret) && OB_FAIL(stmt->iterate_stmt_expr(visitor))) {
    LOG_WARN("get relation exprs failed", K(ret));
  }

  //collect query udt exprs which need to be replaced
  for (int64_t i = 0; OB_SUCC(ret) && i < replace_exprs.count(); i++) {
    if (OB_ISNULL(replace_exprs.at(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("replace expr is null", K(ret));
    } else {
      ObColumnRefRawExpr *col_expr = static_cast<ObColumnRefRawExpr*>(replace_exprs.at(i));
      ObColumnRefRawExpr *hidd_col = NULL;
      ObRawExpr *sys_makexml_expr = NULL;
      bool need_transform = false;
      if (!col_expr->is_xml_column()) {
        // do nothing
      } else if (OB_FAIL(ObTransformUtils::create_udt_hidden_columns(ctx_,
                                                                     stmt,
                                                                     *col_expr,
                                                                     hidd_col,
                                                                     need_transform))) {
        LOG_WARN("failed to create udt hidden exprs", K(ret));
      } else if (need_transform == false) {
        // do nothing;
      } else if (OB_FAIL(transform_xml_binary(hidd_col, sys_makexml_expr))) {
        LOG_WARN("failed to push back udt hidden exprs", K(ret));
      } else if (OB_FAIL(from_col_exprs.push_back(col_expr))) {
        LOG_WARN("failed to push back udt exprs", K(ret));
      } else if (OB_FAIL(to_col_exprs.push_back(sys_makexml_expr))) {
        LOG_WARN("failed to push back udt hidden exprs", K(ret));
      }
    }
  }

  //do replace
  if (OB_SUCC(ret) && !from_col_exprs.empty()) {
    ObStmtExprReplacer replacer;
    replacer.remove_all();
    replacer.add_scope(SCOPE_DML_CONSTRAINT);
    if (OB_FAIL(replacer.add_replace_exprs(from_col_exprs, to_col_exprs))) {
      LOG_WARN("failed to add replace exprs", K(ret));
    } else if (OB_FAIL(stmt->iterate_stmt_expr(replacer))) {
      LOG_WARN("failed to iterate stmt expr", K(ret));
    } else {
      trans_happened = true;
    }
  }
  return ret;
}


int ObTransformPreProcess::transform_udt_columns(const ObIArray<ObParentDMLStmt> &parent_stmts,
                                                 ObDMLStmt *stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  ObSEArray<ObRawExpr*, 1> udt_exprs;
  ObSEArray<ObRawExpr *, 1> from_col_exprs;
  ObSEArray<ObRawExpr *, 1> to_col_exprs;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is NULL", K(ret), K(ctx_), K(ctx_->session_info_));
  } else if (is_mysql_mode() || ctx_->session_info_->get_ddl_info().is_ddl()) {
    // do nothing
  } else if (OB_FAIL(transform_query_udt_columns_exprs(parent_stmts, stmt, trans_happened))) {
      LOG_WARN("failed to do query udt exprs transform", K(ret));
  } else if (OB_FAIL(transform_udt_columns_constraint_exprs(stmt, trans_happened))) {
    LOG_WARN("failed to do udt constraint exprs transform", K(ret));
  } else {
    // xmltype transform
    if (stmt->get_stmt_type() == stmt::T_UPDATE) {
      ObUpdateStmt *upd_stmt = static_cast<ObUpdateStmt *>(stmt);
      for (int64_t i = 0; OB_SUCC(ret) && i < upd_stmt->get_update_table_info().count(); ++i) {
        bool is_happened = false;
        ObUpdateTableInfo* table_info = upd_stmt->get_update_table_info().at(i);
        if (OB_ISNULL(table_info)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get null table info", K(ret));
        } else if (OB_FAIL(replace_udt_assignment_exprs(upd_stmt, *table_info, table_info->assignments_,
                                                        is_happened))) {
          LOG_WARN("failed to replace assignment exprs", K(ret));
        } else {
          trans_happened |= is_happened;
          LOG_TRACE("succeed to do const propagation for assignment expr", K(is_happened));
        }
      }
    } else if (stmt->get_stmt_type() == stmt::T_MERGE) {
      bool is_happened = false;
      ObMergeStmt *merge_stmt = static_cast<ObMergeStmt *>(stmt);
      ObMergeTableInfo &table_info = merge_stmt->get_merge_table_info();
      if (OB_FAIL(replace_udt_assignment_exprs(merge_stmt, table_info,
                                               table_info.assignments_,
                                               is_happened))) {
        LOG_WARN("failed to replace assignment exprs", K(ret));
      } else if (table_info.values_desc_.count() == 0) {
        // do nothing
      } else {
        trans_happened |= is_happened;
        common::ObIArray<ObRawExpr*> &value_vector = table_info.values_vector_;
        int64_t column_count =  table_info.values_desc_.count();
        int64_t row_count = value_vector.count() / column_count;

        for (int64_t i = 0; OB_SUCC(ret) && i < table_info.column_exprs_.count(); ++i) {
          ObColumnRefRawExpr *col = table_info.column_exprs_.at(i);
          if (col->is_xml_column()) {
            if (OB_FAIL(set_hidd_col_not_null_attr(*col, table_info.column_exprs_))) {
              LOG_WARN("failed to set hidden column not null attr", K(ret));
            }
          }
        }

        for (int64_t i = 0; OB_SUCC(ret) && i < table_info.values_desc_.count(); ++i) {
          ObColumnRefRawExpr *value_desc = table_info.values_desc_.at(i);
          if (value_desc->is_xml_column()) {
            ObColumnRefRawExpr *hidd_col = NULL;
            ObRawExpr *new_value_expr = NULL;
            ObRawExpr *value_expr = value_vector.at(i);
            bool need_transform = false; // not_used
            if (OB_FAIL(ObTransformUtils::create_udt_hidden_columns(ctx_, merge_stmt, *value_desc, hidd_col, need_transform))) {
              LOG_WARN("failed to create udt hidden exprs", K(ret));
            } else if (need_transform == false) {
              // do nothing
            } else {
              bool hidd_found = false;
              for (int64_t j = 0; OB_SUCC(ret) && !hidd_found && j < table_info.column_exprs_.count(); ++j) {
                ObColumnRefRawExpr *col = table_info.column_exprs_.at(j);
                if (col->get_column_id() == hidd_col->get_column_id()) {
                  ObRawExpr *old_conv_expr = merge_stmt->get_column_conv_exprs().at(j);
                  hidd_found = true;
                  if (OB_FAIL(transform_udt_column_conv_param_expr(table_info, value_expr, new_value_expr))) {
                    LOG_WARN("failed to transform udt value exprs", K(ret));
                  } else if (OB_FAIL(static_cast<ObSysFunRawExpr*>(old_conv_expr)->replace_param_expr(4, new_value_expr))) {
                    LOG_WARN("failed to push back udt hidden exprs", K(ret));
                  }
                }
              }
            }
          }
        }

        LOG_TRACE("succeed to do const propagation for assignment expr", K(is_happened));
      }
    } else if (stmt->get_stmt_type() == stmt::T_INSERT || stmt->get_stmt_type() == stmt::T_INSERT_ALL) {
      ObDelUpdStmt *insert_stmt = static_cast<ObDelUpdStmt*>(stmt);
      // common::ObIArray<ObRawExpr*> &value_vector = insert_stmt->get_values_vector();
      // int64_t column_count = insert_stmt->get_values_desc().count();
      // int64_t row_count = insert_stmt->get_values_vector().count() / column_count;
      ObInsertAllStmt *insert_all_stmt = static_cast<ObInsertAllStmt*>(stmt);
      ObInsertStmt *single_insert_stmt = static_cast<ObInsertStmt*>(stmt);
      common::ObArray<ObInsertTableInfo*> table_info_arr;
      if (stmt->get_stmt_type() == stmt::T_INSERT) {
        table_info_arr.push_back(&(single_insert_stmt->get_insert_table_info()));
      } else {
        ObIArray<ObInsertAllTableInfo*> &table_infos = insert_all_stmt->get_insert_all_table_info();
        for (int64_t i = 0; i < table_infos.count(); i++) {
          table_info_arr.push_back(table_infos.at(i));
        }
      }

      for (int64_t count = 0; OB_SUCC(ret) && count < table_info_arr.count(); ++count) {
        ObInsertTableInfo *table_info = table_info_arr.at(count);
        for (int64_t i = 0; OB_SUCC(ret) && i < table_info->column_exprs_.count(); ++i) {
          ObColumnRefRawExpr *col = table_info->column_exprs_.at(i);
          if (col->is_xml_column()) {
            if (OB_FAIL(set_hidd_col_not_null_attr(*col, table_info->column_exprs_))) {
              LOG_WARN("failed to set hidden column not null attr", K(ret));
            }
          }
        }

        for (int64_t i = 0; OB_SUCC(ret) && i < table_info->values_desc_.count(); ++i) {
          ObColumnRefRawExpr *value_desc = table_info->values_desc_.at(i);
          if (value_desc->is_xml_column()) {
            ObColumnRefRawExpr *hidd_col = NULL;
            bool need_transform = false;
            if (OB_FAIL(ObTransformUtils::create_udt_hidden_columns(ctx_,
                                                                    insert_stmt,
                                                                    *value_desc,
                                                                    hidd_col,
                                                                    need_transform))) {
              LOG_WARN("failed to create udt hidden exprs", K(ret));
            } else if (need_transform == false) {
              // do nothing
            } else if (OB_FAIL(transform_udt_column_conv_function(*table_info,
                                                                  table_info->column_conv_exprs_,
                                                                  *value_desc, *hidd_col))) {
              LOG_WARN("failed to push back column conv exprs", K(ret));
            }
          }
        }
        // process returning exprs
        if (OB_SUCC(ret) && insert_stmt->is_returning()) {
          ObIArray<ObRawExpr*> &column_convert = table_info->column_conv_exprs_;
          const ObIArray<ObColumnRefRawExpr *> &table_columns = table_info->column_exprs_;
          ObSEArray<std::pair<int64_t, int64_t>, 8> xml_col_idxs; // use pair to store xml col idx and its hidden col idx
          for (int64_t i = 0; OB_SUCC(ret) && i < table_columns.count(); i++) {
            ObColumnRefRawExpr *ref_col = table_columns.at(i);
            if (ref_col->is_xml_column()) {
              bool is_found = false;
              for (int64_t j = 0; OB_SUCC(ret) && !is_found && j < table_columns.count(); j++) {
                if (ref_col->get_column_id() != table_columns.at(j)->get_column_id() &&
                    ref_col->get_udt_set_id() == table_columns.at(j)->get_udt_set_id()) {
                  is_found = true;
                  xml_col_idxs.push_back(std::make_pair(i, j));
                }
              } // end for
              if (!is_found) {
                ret = OB_ERR_UNEXPECTED;
                LOG_WARN("failed to find hidden column", K(ret), K(i));
              }
            }
          } // end for

          CK(column_convert.count() == table_columns.count());
          for (int64_t i = 0; OB_SUCC(ret) && i < insert_stmt->get_returning_exprs().count(); i++) {
            for (int64_t j = 0; OB_SUCC(ret) && j < xml_col_idxs.count(); j++) {
              ObRawExpr *hidd_col = NULL;
              ObRawExpr *sys_makexml_expr = NULL;
              if (OB_ISNULL(hidd_col = column_convert.at(xml_col_idxs.at(j).second))) {
                ret = OB_ERR_UNEXPECTED;
                LOG_WARN("hidden col is NULL", K(ret), K(i), K(j));
              } else if (OB_FAIL(transform_xml_binary(hidd_col, sys_makexml_expr))) {
                LOG_WARN("fail to create expr sys_makexml", K(ret));
              } else if (OB_FAIL(ObRawExprUtils::replace_ref_column(insert_stmt->get_returning_exprs().at(i),
                                                                table_columns.at(xml_col_idxs.at(j).first),
                                                                sys_makexml_expr))) {
                LOG_WARN("fail to replace xml column in returning exprs", K(ret), K(i), K(j));
              }
            }
          }
        } // end if
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::transformer_rowid_expr(ObDMLStmt *stmt,
                                                  bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  ObSEArray<ObRawExpr*, 1> rowid_exprs;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is NULL", K(ret));
  } else if (is_mysql_mode()) {
    /*do nothing*/
  } else if (OB_FAIL(stmt->get_stmt_rowid_exprs(rowid_exprs))) {
    LOG_WARN("failed to get stmt rowid exprs", K(ret));
  } else if (!rowid_exprs.empty()) {
    ObSEArray<ObRawExpr*, 1> old_rowid_exprs;
    ObSEArray<ObRawExpr*, 1> new_rowid_exprs;
    //before transform pre, rowid expr just only have two expr types:
    // 1. sys calc urowid expr is used to calc rowid or sys calc urowid expr have been calculated.
    // 2. empty rowid column expr for generate table, we need transform empty rowid column expr
    //    to real sys calc urowid expr here.
    for (int i = 0; OB_SUCC(ret) && i < rowid_exprs.count(); ++i) {
      ObRawExpr *expr = NULL;
      if (OB_ISNULL(expr = rowid_exprs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret), K(expr));
      } else if (expr->get_expr_type() == T_FUN_SYS_CALC_UROWID ||
                 expr->get_expr_type() == T_QUESTIONMARK) {
        /*do nothing*/
      } else if (expr->is_column_ref_expr()) {
        ObRawExpr *new_rowid_expr = NULL;
        if (OB_FAIL(old_rowid_exprs.push_back(expr))) {
          LOG_WARN("failed to push back rowid expr", K(ret));
        } else if (OB_FAIL(do_transform_rowid_expr(*stmt,
                                                   static_cast<ObColumnRefRawExpr*>(expr),
                                                   new_rowid_expr))) {
          LOG_WARN("failed to do transform rowid expr", K(ret));
        } else if (OB_ISNULL(new_rowid_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret), K(new_rowid_expr));
        } else if (OB_FAIL(new_rowid_exprs.push_back(new_rowid_expr))) {
          LOG_WARN("failed to push back rowid expr", K(ret));
        } else if (OB_FAIL(stmt->remove_column_item(
                                        static_cast<ObColumnRefRawExpr*>(expr)->get_table_id(),
                                        static_cast<ObColumnRefRawExpr*>(expr)->get_column_id()))) {
          LOG_WARN("failed to remove column item", K(ret));
        } else {/*do nothing*/}
      } else {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected rowid expr", K(ret), KPC(expr));
      }
    }
    if (OB_SUCC(ret) && !old_rowid_exprs.empty()) {
      if (OB_UNLIKELY(old_rowid_exprs.count() != new_rowid_exprs.count())) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected error", K(old_rowid_exprs), K(new_rowid_exprs), K(ret));
      } else if (OB_FAIL(stmt->replace_relation_exprs(old_rowid_exprs, new_rowid_exprs))) {
        LOG_WARN("replace inner stmt expr failed", K(ret));
      } else {
        trans_happened = true;
        LOG_DEBUG("Succeed to transformer rowid expr", K(*stmt), K(old_rowid_exprs),
                                                       K(new_rowid_exprs));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::do_transform_rowid_expr(ObDMLStmt &stmt,
                                                   ObColumnRefRawExpr *empty_rowid_col_expr,
                                                   ObRawExpr *&new_rowid_expr)
{
  int ret = OB_SUCCESS;
  new_rowid_expr = NULL;
  if (OB_ISNULL(empty_rowid_col_expr) ||
      OB_UNLIKELY(!ObCharset::case_insensitive_equal(OB_HIDDEN_LOGICAL_ROWID_COLUMN_NAME,
                                                     empty_rowid_col_expr->get_column_name()))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected error", K(ret), KPC(empty_rowid_col_expr));
  } else {
    TableItem *table_item = NULL;
    if (OB_ISNULL(table_item = stmt.get_table_item_by_id(empty_rowid_col_expr->get_table_id()))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("table_item is NULL", K(ret), K(empty_rowid_col_expr->get_table_id()));
    } else if (OB_UNLIKELY(!table_item->is_generated_table() && !table_item->is_temp_table())) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get unexpected error", K(ret), K(*table_item));
    } else if (OB_FAIL(recursive_generate_rowid_select_item(table_item->ref_query_,
                                                            new_rowid_expr))) {
      LOG_WARN("failed to recursive generate rowid select item", K(ret));
    } else if (OB_ISNULL(new_rowid_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("new_rowid_expr cannot be NULL", K(ret));
    } else if (OB_FAIL(create_rowid_item_for_stmt(&stmt, table_item, new_rowid_expr))) {
      LOG_WARN("create rowid item for stmt failed", K(ret));
    } else {
      LOG_TRACE("succeed to do transform rowid expr", K(*new_rowid_expr), K(stmt));
    }
  }
  return ret;
}

int ObTransformPreProcess::add_rowid_constraint(ObDMLStmt &stmt)
{
  int ret = OB_SUCCESS;
  ObExecContext *exec_ctx = NULL;
  if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->allocator_) ||
      OB_ISNULL (exec_ctx = ctx_->exec_ctx_)|| OB_ISNULL(stmt.get_query_ctx())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("ctx_ or query_ctx is NULL", K(ret), KP(ctx_), KP(stmt.get_query_ctx()));
  }
  for (int i = 0; OB_SUCC(ret) && i < stmt.get_condition_size(); ++i) {
    ObRawExpr *expr = stmt.get_condition_expr(i);
    if (OB_ISNULL(expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("expr is NULL", K(ret));
    } else if (expr->get_param_count() == 2) {
      ObRawExpr *l_expr = expr->get_param_expr(0);
      ObRawExpr *r_expr = expr->get_param_expr(1);
      ObRawExpr *calc_urowid_expr = NULL;
      ObRawExpr *const_expr = NULL;
      if (OB_ISNULL(l_expr) || OB_ISNULL(r_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("expr is NULL", K(ret), KP(l_expr), KP(r_expr));
      } else if ((l_expr->get_expr_type() == T_FUN_SYS_CALC_UROWID &&
                  r_expr->is_static_scalar_const_expr())) {
        calc_urowid_expr = l_expr;
        const_expr = r_expr;
      } else if ((r_expr->get_expr_type() == T_FUN_SYS_CALC_UROWID &&
                  l_expr->is_static_scalar_const_expr())) {
        calc_urowid_expr = r_expr;
        const_expr = l_expr;
      }
      if (OB_SUCC(ret) && OB_NOT_NULL(calc_urowid_expr)) {
        void *cons_buf = NULL;
        ObRowidConstraint *rowid_cons = NULL;
        if (OB_ISNULL(cons_buf = ctx_->allocator_->alloc(sizeof(ObRowidConstraint)))) {
          ret = OB_ALLOCATE_MEMORY_FAILED;
          LOG_WARN("allocate memory failed", K(ret));
        }
        rowid_cons = new(cons_buf)ObRowidConstraint(exec_ctx->get_allocator());
        if (OB_SUCC(ret)) {
          if (OB_FAIL(rowid_cons->rowid_type_array_.init(calc_urowid_expr->get_param_count()))) {
            LOG_WARN("failed to init array", K(ret));
          }
        }
        for (int64_t i = 0; OB_SUCC(ret) && i < calc_urowid_expr->get_param_count(); ++i) {
          if (calc_urowid_expr->get_param_expr(i)->has_flag(IS_COLUMN)) {
            const ObColumnRefRawExpr *col_expr =
                       static_cast<const ObColumnRefRawExpr *>(calc_urowid_expr->get_param_expr(i));
            // pk_vals may store generated col which is partition key but not primary key
            if (!col_expr->is_rowkey_column()) {
              /*do nothing*/
            } else if OB_FAIL(rowid_cons->rowid_type_array_.push_back(col_expr->get_data_type())) {
              LOG_WARN("push back pk_column item failed", K(ret));
            }
          }
        }
        if (OB_SUCC(ret)) {
          ObPhysicalPlanCtx *plan_ctx = NULL;
          ObObj rowid_val;
          bool got_result = false;
          if (OB_ISNULL(plan_ctx = exec_ctx->get_physical_plan_ctx()) ||
              OB_ISNULL(exec_ctx->get_sql_ctx())) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("plan ctx is NULL", K(ret));
          } else if (OB_FAIL(ObSQLUtils::calc_const_or_calculable_expr(exec_ctx,
                                                                       const_expr,
                                                                       rowid_val,
                                                                       got_result,
                                                                       *ctx_->allocator_,
                                                                       false))) {
            LOG_WARN("failed to calc const or calculable expr", K(ret));
          } else if (rowid_val.is_null()) {
            //do nothing
          } else if (!rowid_val.is_urowid()) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("val should be urowid", K(ret), K(rowid_val));
          } else {
            ObSEArray<ObObj, 4> pk_vals;
            const ObURowIDData &urowid_data = rowid_val.get_urowid();
            if (OB_FAIL(urowid_data.get_pk_vals(pk_vals))) {
              LOG_WARN("get pk values failed", K(ret));
            } else {
              rowid_cons->rowid_version_ = urowid_data.get_version();
              int64_t pk_cnt = urowid_data.get_real_pk_count(pk_vals);
              if (pk_cnt != rowid_cons->rowid_type_array_.count()) {
                ret = OB_INVALID_ROWID;
                LOG_WARN("invalid rowid, table rowkey cnt and encoded row cnt mismatch", K(ret),
                                              K(pk_cnt), K(rowid_cons->rowid_type_array_.count()));
              } else {
                for (int i = 0; OB_SUCC(ret) && i < pk_cnt; i++) {
                  if (!pk_vals.at(i).is_null() &&
                      pk_vals.at(i).get_type() != rowid_cons->rowid_type_array_.at(i)) {
                    ret = OB_INVALID_ROWID;
                    LOG_WARN("invalid rowid, table rowkey type and encoded type mismatch", K(ret),
                              K(pk_vals.at(i).get_type()), K(rowid_cons->rowid_type_array_.at(i)));
                  }
                }
              }
            }
          }
          if (OB_SUCC(ret)) {
            ObStaticEngineExprCG expr_cg(exec_ctx->get_allocator(),
                                         exec_ctx->get_my_session(),
                                         exec_ctx->get_sql_ctx()->schema_guard_,
                                         plan_ctx->get_original_param_cnt(),
                                         plan_ctx->get_datum_param_store().count(),
                                         exec_ctx->get_min_cluster_version());
            rowid_cons->expect_result_ = PreCalcExprExpectResult::PRE_CALC_ROWID;
            if (OB_FAIL(expr_cg.generate_calculable_expr(const_expr,
                                                         rowid_cons->pre_calc_expr_info_))) {
              LOG_WARN("failed to generate calculable expr", K(ret));
            } else if (OB_UNLIKELY(!stmt.get_query_ctx()->all_pre_calc_constraints_.add_last(rowid_cons))) {
              LOG_WARN("failed to add rowid constraint", K(ret));
            } else {
              LOG_TRACE("Succeed to add rowid constraint", KPC(expr));
            }
          }
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::recursive_generate_rowid_select_item(ObSelectStmt *select_stmt,
                                                                ObRawExpr *&rowid_expr)
{
  int ret = OB_SUCCESS;
  bool can_gen_rowid = false;
  rowid_expr = NULL;
  if (OB_ISNULL(select_stmt) || OB_ISNULL(ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt or ctx_ is NULL", K(ret), KP(select_stmt), KP(ctx_));
  } else {
    ObIArray<TableItem*> &table_items = select_stmt->get_table_items();
    TableItem *table_item = NULL;
    ObSysFunRawExpr *rowid_func_expr = NULL;
    LOG_DEBUG("transformer rowid_expr recursively begin", KPC(select_stmt), K(table_items));
    for (int64_t i = 0; OB_SUCC(ret) && NULL == rowid_expr && i < table_items.count(); ++i) {
      if (OB_ISNULL(table_item = table_items.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("table_item is NULL", K(ret), K(i), K(table_items));
      } else if (OB_FAIL(check_can_gen_rowid_on_this_table(select_stmt,
                                                           table_item,
                                                           can_gen_rowid))) {
        LOG_WARN("check_can_gen_rowid failed", K(ret));
      } else if (!can_gen_rowid) {
        LOG_DEBUG("cannot gen rowid in this table item", K(ret), KPC(table_item));
      } else if (table_item->is_generated_table() || table_item->is_temp_table()) {
        if (OB_FAIL(SMART_CALL(recursive_generate_rowid_select_item(table_item->ref_query_,
                                                                    rowid_expr)))) {
          LOG_WARN("failed to recursive generate rowid select item", K(ret));
        } else if (NULL == rowid_expr) {
          // ignore create rowid item.
        } else if (OB_FAIL(create_rowid_item_for_stmt(select_stmt, table_item, rowid_expr))) {
          LOG_WARN("create rowid item for stmt failed", K(ret));
        } else if (ObTransformUtils::create_select_item(*(ctx_->allocator_),
                                                        rowid_expr,
                                                        select_stmt)) {
          LOG_WARN("failed to create select item", K(ret));
        } else {/*do nothing*/}
      } else if (OB_FAIL(build_rowid_expr(select_stmt, table_item, rowid_func_expr))) {
        LOG_WARN("build rowid_expr failed", K(ret), KPC(table_item));
      } else if (OB_FAIL(ObTransformUtils::create_select_item(*(ctx_->allocator_),
                                                                rowid_func_expr,
                                                                select_stmt))) {
          LOG_WARN("create_select_item failed", K(ret));
      } else {
        rowid_expr = rowid_func_expr;
      }
    } // end for
    if (OB_SUCC(ret) && OB_ISNULL(rowid_expr)) {
      ret = OB_ROWID_VIEW_NO_KEY_PRESERVED;
      LOG_WARN("rowid view no key preserved", K(ret));
      LOG_USER_ERROR(OB_ROWID_VIEW_NO_KEY_PRESERVED);
    } else {
      LOG_TRACE("succeed to recursive generate rowid select item", KPC(select_stmt), KPC(rowid_expr));
    }
  }
  return ret;
}

// select rowid from (select * from t1, t2 where t1.c1 = t2.pk;
// t1: this_table
// t2: other_table
// we check if other_table's join exprs is unique or not,
// if is unique, we can generate rowid on this_table
int ObTransformPreProcess::check_can_gen_rowid_on_this_table(ObSelectStmt *select_stmt,
                                                             TableItem *this_table,
                                                             bool &can_gen_rowid)
{
  int ret = OB_SUCCESS;
  can_gen_rowid = false;
  if (OB_ISNULL(select_stmt) || OB_ISNULL(this_table)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("stmt or table_item is null", K(ret), KP(select_stmt), KP(this_table));
  } else if (select_stmt->has_group_by() || select_stmt->has_distinct()) {
    ret = OB_ROWID_VIEW_HAS_DISTINCT_ETC;
    LOG_WARN("stmt got group by or distinct", K(ret),
        K(select_stmt->has_group_by()), K(select_stmt->has_distinct()));
    LOG_USER_ERROR(OB_ROWID_VIEW_HAS_DISTINCT_ETC);
  } else if (is_ora_sys_view_table(this_table->ref_id_)) {
    // Because the implementation of these views is differnet from oracle,
    // therefore, the check is added to prevent these views from trying to build rowid expr
    // v$sesstat,v$session_wait,v$sysstat
    ret = OB_NOT_SUPPORTED;
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "view trying to build rowid");
    LOG_WARN("stmt got system table", K(ret));
  } else {
    ObSEArray<TableItem*, 4> unique_tables;
    ObSEArray<TableItem*, 4> non_unique_tables;
    ObIArray<TableItem*> &table_items = select_stmt->get_table_items();
    for (int64_t i = 0; OB_SUCC(ret) && i < table_items.count(); ++i) {
      TableItem *item = table_items.at(i);
      if (OB_ISNULL(item)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("table item is NULL", K(ret), K(i));
      } else if (item->table_id_ == this_table->table_id_) {
        if (OB_FAIL(unique_tables.push_back(item))) {
          LOG_WARN("push table item failed", K(ret));
        }
      } else if (OB_FAIL(non_unique_tables.push_back(item))) {
        LOG_WARN("push table item failed", K(ret));
      }
    }
    if (OB_SUCC(ret) && non_unique_tables.empty()) {
      can_gen_rowid = true;
    }
    if (OB_SUCC(ret) && !can_gen_rowid) {
      bool found_unique = true;
      ObSEArray<ObRawExpr*, 4> join_exprs;
      const ObIArray<ObRawExpr*> &cond_exprs = select_stmt->get_condition_exprs();
      while (OB_SUCC(ret) && found_unique && !non_unique_tables.empty()) {
        found_unique = false;
        for (int64_t i = non_unique_tables.count() - 1; OB_SUCC(ret) && i >= 0; --i) {
          bool is_unique = false;
          join_exprs.reuse();
          TableItem *table = non_unique_tables.at(i);
          if (OB_ISNULL(table)) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("table item is NULL", K(ret));
          } else if (OB_FAIL(ObTransformUtils::get_table_joined_exprs(*select_stmt, unique_tables,
                                                                      *table, cond_exprs,
                                                                      join_exprs))) {
            LOG_WARN("get_table_joined_exprs failed", K(ret));
          } else if (join_exprs.empty()) {
          } else if (OB_FAIL(ObTransformUtils::check_exprs_unique(*select_stmt,
                                                                  table,
                                                                  join_exprs,
                                                                  ctx_->session_info_,
                                                                  ctx_->schema_checker_,
                                                                  is_unique))) {
            LOG_WARN("check exprs unique failed", K(ret));
          } else if (!is_unique) {
          } else if (OB_FAIL(unique_tables.push_back(table))) {
            LOG_WARN("push table table failed", K(ret));
          } else if (OB_FAIL(ObOptimizerUtil::remove_item(non_unique_tables, table))) {
            LOG_WARN("remove table table failed", K(ret));
          } else {
            found_unique = true;
          }
        } // for end
      } // while end
      if (OB_SUCC(ret) && non_unique_tables.empty()) {
        can_gen_rowid = true;
      }
    }
    LOG_DEBUG("check_can_gen_rowid_on_this_table done", K(ret), KPC(select_stmt),
              KPC(this_table), K(can_gen_rowid));
  }
  return ret;
}

int ObTransformPreProcess::build_rowid_expr(ObSelectStmt *select_stmt,
                                            TableItem *table_item,
                                            ObSysFunRawExpr *&rowid_expr)
{
  int ret = OB_SUCCESS;
  rowid_expr = NULL;
  if (OB_ISNULL(select_stmt) || OB_ISNULL(table_item) || OB_ISNULL(ctx_)
      || OB_ISNULL(ctx_->expr_factory_) || OB_ISNULL(ctx_->allocator_)
      || OB_ISNULL(ctx_->session_info_)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("stmt or table_item is NULL", K(ret), KP(select_stmt), KP(table_item), KP(ctx_));
  } else {
    const ObTableSchema *table_schema = NULL;
    ObSEArray<ObRawExpr*, 4> index_keys;
    uint64_t tid = table_item->ref_id_;
    ObRawExpr *same_rowid_expr = NULL;
    if (OB_FAIL(ctx_->schema_checker_->get_table_schema(ctx_->session_info_->get_effective_tenant_id(), tid, table_schema, table_item->is_link_table()))) {
      LOG_WARN("fail to get table schema", K(ret), K(tid));
    } else if (OB_ISNULL(table_schema)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("table_schema is NULL", K(ret));
    } else {
      const ObRowkeyInfo &rowkey_info = table_schema->get_rowkey_info();
      ObColumnRefRawExpr *expr = NULL;
      for (int i = 0; OB_SUCC(ret) && i < rowkey_info.get_size(); ++i) {
        uint64_t  column_id = OB_INVALID_ID;
        if (OB_FAIL(rowkey_info.get_column_id(i, column_id))) {
          LOG_WARN("Failed to get column_id from rowkey_info", K(ret));
        } else if (OB_ISNULL(expr = select_stmt->get_column_expr_by_id(table_item->table_id_,
                                                                       column_id))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("unexpected null, rowkey column not exists in stmt", K(ret),
                                                        K(table_item->table_id_), K(column_id));
        } else if (OB_FAIL(index_keys.push_back(expr))) {
          LOG_WARN("failed to add row key expr", K(ret));
        }
      }

      if (OB_FAIL(ret)) {
      } else if (OB_FAIL(ObRawExprUtils::build_rowid_expr(select_stmt,
                                                          *(ctx_->expr_factory_),
                                                          *(ctx_->allocator_),
                                                          *(ctx_->session_info_),
                                                          *table_schema,
                                                          table_item->table_id_,
                                                          index_keys,
                                                          rowid_expr))) {
        LOG_WARN("build rowid col_expr failed", K(ret));
      } else if (OB_FAIL(select_stmt->check_and_get_same_rowid_expr(rowid_expr, same_rowid_expr))) {
        LOG_WARN("failed to check and get same rowid expr", K(ret));
      } else if (same_rowid_expr != NULL) {
        rowid_expr = static_cast<ObSysFunRawExpr*>(same_rowid_expr);
      } else {/*do nothing*/}
    }
  }
  return ret;
}

int ObTransformPreProcess::create_rowid_item_for_stmt(ObDMLStmt *dml_stmt,
                                                      TableItem *table_item,
                                                      ObRawExpr *&rowid_expr)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObRawExpr*, 4> column_exprs;
  rowid_expr = NULL;
  if (OB_ISNULL(dml_stmt) || OB_ISNULL(table_item)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("stmt or item is NULL", K(ret), K(dml_stmt), K(table_item));
  } else if (OB_FAIL(ObTransformUtils::create_columns_for_view(ctx_, *table_item,
                                                               dml_stmt, column_exprs))) {
    LOG_WARN("create columns for view failed", K(ret), KPC(table_item), KPC(dml_stmt));
  } else if (column_exprs.count() < 1) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("column_expr is invalid", K(ret), K(column_exprs));
  } else {
    ObRawExpr *expr = column_exprs.at(column_exprs.count() - 1);
    if (OB_ISNULL(expr) || OB_UNLIKELY(!(expr->is_column_ref_expr()))
        || OB_UNLIKELY(!(expr->get_result_type().is_urowid()))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("last col must be rowid col", K(ret), KPC(expr));
    } else {
      rowid_expr = expr;
    }
  }
  return ret;
}

//transform batch update stmt to multiple update with nlj:
// update t1 set b=1 where a=1; update t1 set b=2 where a=2; update t1 set b=3 where a=3;...
//-> update t1, (select 1, 1 from dual ...) v set t1.b=v.b where t1.a=v.a;
// batch delete is as batch update
int ObTransformPreProcess::transform_for_upd_del_batch_stmt(ObDMLStmt *batch_stmt,
                                                            ObSelectStmt *inner_view_stmt,
                                                            bool &trans_happened)
{
  int ret = OB_SUCCESS;
  // create select list
  if (OB_FAIL(mock_select_list_for_upd_del(*batch_stmt, *inner_view_stmt))) {
    LOG_WARN("mock select list for batch stmt failed", K(ret));
  } else if (OB_FAIL(formalize_batch_stmt(batch_stmt,
                                          inner_view_stmt,
                                          batch_stmt->get_query_ctx()->ab_param_exprs_,
                                          trans_happened))) {
    LOG_WARN("fail to formalize batch stmt", K(ret), KPC(batch_stmt));
  }
  return ret;
}

int ObTransformPreProcess::transform_for_ins_batch_stmt(ObDMLStmt *batch_stmt,
                                                        bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObInsertStmt *insert_stmt = NULL;
  ObExecContext *exec_ctx = nullptr;
  ObPhysicalPlanCtx *plan_ctx = nullptr;
  ObSQLSessionInfo *session_info = NULL;
  ObSEArray<ObRawExpr*, 4> params;
  ObPseudoColumnRawExpr *stmt_id_expr = NULL;

  if (OB_ISNULL(ctx_)
      || OB_ISNULL(exec_ctx = ctx_->exec_ctx_)
      || OB_ISNULL(plan_ctx = exec_ctx->get_physical_plan_ctx())
      || OB_ISNULL(session_info = ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ctx_), K(exec_ctx), K(plan_ctx), K(ret));
  } else if (OB_ISNULL(batch_stmt) ||
             OB_UNLIKELY(!batch_stmt->is_insert_stmt())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("batch_stmt or inner_view_stmt is null", K(ret), K(batch_stmt));
  } else if (FALSE_IT(insert_stmt = static_cast<ObInsertStmt*>(batch_stmt))) {
  } else if (OB_FAIL(create_stmt_id_expr(stmt_id_expr))) {
    LOG_WARN("fail to create stmt id expr", K(ret));
  } else if (FALSE_IT(batch_stmt->get_query_ctx()->ins_values_batch_opt_ = true)) {
  } else if (FALSE_IT(static_cast<ObDelUpdStmt*>(batch_stmt)->set_ab_stmt_id_expr(stmt_id_expr))) {
  } else if (OB_FAIL(ObRawExprUtils::extract_params(insert_stmt->get_values_vector(), params))) {
    LOG_WARN("extract param expr from related exprs failed", K(ret));
  } else {
    common::ObIArray<ObRawExpr*> &value_vector = insert_stmt->get_values_vector();
    const ParamStore &param_store = plan_ctx->get_param_store();
    for (int64_t i = 0; OB_SUCC(ret) && i < params.count(); ++i) {
      ObConstRawExpr *param_expr = static_cast<ObConstRawExpr *>(params.at(i));
      ObPseudoColumnRawExpr *group_id = NULL;
      int64_t param_idx = param_expr->get_value().get_unknown();
      if (param_idx < 0 || param_idx >= param_store.count()) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("param_idx is invalid", K(ret), K(param_idx), K(param_store));
      } else if (!param_store.at(param_idx).is_batch_parameters()) {
        // 不是batch 参数, 不需要打标记
      } else {
        param_expr->set_is_batch_stmt_parameter();
      }
    }
    // 给所有的batch参数表达上边打上了标记，需要重新做表达式推导
    // 这里因为insert values的特殊性，所以只需要推导value_vector中的表达式即可
    for (int64_t i = 0; OB_SUCC(ret) && i < value_vector.count(); ++i) {
      if (OB_FAIL(value_vector.at(i)->formalize(session_info))) {
        LOG_WARN("formalize expr failed", K(ret), K(i), KPC(value_vector.at(i)));
      }
    }
  }

  return ret;
}

int ObTransformPreProcess::check_contain_param_expr(ObDMLStmt *stmt,
                                                    TableItem *table_item,
                                                    bool &contain_param)
{
  int ret = OB_SUCCESS;
  bool is_stack_overflow = false;
  if (OB_ISNULL(table_item)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item is null", K(ret));
  } else if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
    LOG_WARN("failed to check stack overflow", K(ret));
  } else if (is_stack_overflow) {
    ret = OB_SIZE_OVERFLOW;
    LOG_WARN("too deep recursive", K(ret), K(is_stack_overflow));
  } else if (contain_param) {
    // break;
  } else {
    if (table_item->is_joined_table()) {
      JoinedTable *joined_table_item = static_cast<JoinedTable *>(table_item);
      if (OB_FAIL(ObRawExprUtils::is_contain_params(joined_table_item->get_join_conditions(), contain_param))) {
        LOG_WARN("fail to get releation exprs", K(ret));
      } else if (OB_FAIL(SMART_CALL(check_contain_param_expr(stmt, joined_table_item->left_table_, contain_param)))) {
        LOG_WARN("failed to collect temp table item", K(ret));
      } else if (OB_FAIL(SMART_CALL(check_contain_param_expr(stmt, joined_table_item->right_table_, contain_param)))) {
        LOG_WARN("failed to collect temp table item", K(ret));
      }
    } else if (table_item->is_generated_table()) {
      ObDMLStmt *ref_query_stmt = NULL;
      if (OB_ISNULL(ref_query_stmt = table_item->ref_query_)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("ref_query is null", K(ret), KPC(table_item));
      } else if (OB_FAIL(check_stmt_contain_param_expr(ref_query_stmt, contain_param))) {
        LOG_WARN("fail to check contain param expr", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::check_stmt_contain_param_expr(ObDMLStmt *stmt, bool &contain)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObRawExpr*, 16> related_exprs;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else if (OB_FAIL(stmt->get_relation_exprs(related_exprs))) {
    LOG_WARN("fail to get releation exprs", K(ret), KPC(stmt));
  } else if (OB_FAIL(ObRawExprUtils::is_contain_params(related_exprs, contain))) {
    LOG_WARN("fail to get releation exprs", K(ret));
  }
  return ret;
}

int ObTransformPreProcess::check_stmt_can_batch(ObDMLStmt *batch_stmt, bool &contain_param)
{
  int ret = OB_SUCCESS;
  contain_param = false;
  if (OB_ISNULL(batch_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("batch_stmt is null", K(ret));
  } else {
    const common::ObIArray<FromItem> &from_items = batch_stmt->get_from_items();
    for (int64_t i = 0; OB_SUCC(ret) && !contain_param && i < from_items.count(); ++i) {
      TableItem *table_item = NULL;
      const FromItem &from_item = from_items.at(i);
      if (OB_ISNULL(table_item = batch_stmt->get_table_item(from_item))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("table_item is null", K(ret), K(from_item));
      } else if (OB_FAIL(check_contain_param_expr(batch_stmt, table_item, contain_param))) {
        LOG_WARN("fail to check contain param expr", K(ret), KPC(table_item));
      }
    }
  }

  return ret;
}

int ObTransformPreProcess::create_inner_view_stmt(ObDMLStmt *batch_stmt, ObSelectStmt*& inner_view_stmt)
{
  int ret = OB_SUCCESS;
  ObStmtFactory *stmt_factory = NULL;
  if (OB_ISNULL(batch_stmt) || OB_ISNULL(stmt_factory = ctx_->stmt_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(batch_stmt), K(stmt_factory), K(ret));
  } else if (OB_FAIL(stmt_factory->create_stmt<ObSelectStmt>(inner_view_stmt))) {
    LOG_WARN("failed to create stmt", K(ret));
  } else {
    inner_view_stmt->set_stmt_type(stmt::T_SELECT);
    inner_view_stmt->set_query_ctx(batch_stmt->get_query_ctx());
    stmt::StmtType stmt_type = batch_stmt->get_stmt_type();
    if (OB_FAIL(inner_view_stmt->adjust_statement_id(ctx_->allocator_,
                                                     ctx_->src_qb_name_,
                                                     ctx_->src_hash_val_))) {
      LOG_WARN("failed to recursive adjust statement id", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_for_batch_stmt(ObDMLStmt *batch_stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObSelectStmt* inner_view_stmt = NULL;
  ObExecContext *exec_ctx = nullptr;
  stmt::StmtType stmt_type = batch_stmt->get_stmt_type();
  if (OB_ISNULL(ctx_) ||
      OB_ISNULL(ctx_->allocator_) ||
      OB_ISNULL(exec_ctx = ctx_->exec_ctx_) ||
      OB_ISNULL(batch_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ctx_), K(exec_ctx), K(ret));
  } else if (!exec_ctx->get_sql_ctx()->is_batch_params_execute()) {
    //rewrite only when stmt is batch multi statement
  } else if (!batch_stmt->is_dml_write_stmt()) {
    // 非dml_stmt暂时不用处理
  } else if (stmt_type == stmt::T_UPDATE || stmt_type == stmt::T_DELETE) {
    int64_t child_size = 0;
    if (OB_FAIL(batch_stmt->get_child_stmt_size(child_size))) {
      LOG_WARN("fail to get child_stmt size", K(ret), KPC(batch_stmt));
    } else if (child_size != 0) {
      ret = OB_BATCHED_MULTI_STMT_ROLLBACK;
      LOG_TRACE("only DML Stmt without subquery supports batch execution, need to rollback",
                K(ret), K(child_size), KPC(batch_stmt));
    } else if (OB_FAIL(create_inner_view_stmt(batch_stmt, inner_view_stmt))) {
      LOG_WARN("fail to create inner_view_stmt", K(ret));
    } else if (OB_FAIL(transform_for_upd_del_batch_stmt(batch_stmt, inner_view_stmt, trans_happened))) {
      LOG_WARN("fail to transform upd or del batch stmt", K(ret));
    }
  } else if (stmt_type == stmt::T_INSERT || stmt_type == stmt::T_REPLACE) {
    // insert的改写
    int64_t child_size = 0;
    bool can_batch = false;
    ObInsertStmt *insert_stmt = static_cast<ObInsertStmt *>(batch_stmt);
    if (OB_FAIL(check_insert_can_batch(insert_stmt, can_batch))) {
      LOG_WARN("fail to check insert can batch", K(ret), KPC(insert_stmt));
    } else if (!can_batch) {
      ret = OB_BATCHED_MULTI_STMT_ROLLBACK;
      LOG_TRACE("can't support insert batch optimization", K(ret), KPC(batch_stmt));
    } else if (OB_FAIL(transform_for_ins_batch_stmt(batch_stmt, trans_happened))) {
      LOG_WARN("fail to transform ins batch stmt", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::check_insert_can_batch(ObInsertStmt *insert_stmt, bool &can_batch)
{
  int ret = OB_SUCCESS;
  can_batch = true;
  if (insert_stmt->value_from_select()) {
    can_batch = false;
    LOG_TRACE("insert select stmt not supported batch exec opt", K(ret));
  } else if (!insert_stmt->is_insert_single_value()) {
    can_batch = false;
    LOG_TRACE("multi row insert not supported batch exec opt", K(ret));
  } else {
    common::ObIArray<ObRawExpr*> &value_vector = insert_stmt->get_values_vector();
    for (int64_t i = 0; OB_SUCC(ret) && i < value_vector.count(); i++) {
      if (value_vector.at(i)->has_flag(CNT_SUB_QUERY)) {
        can_batch = false;
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::formalize_batch_stmt(ObDMLStmt *batch_stmt,
                                                ObSelectStmt* inner_view_stmt,
                                                const ObIArray<ObRawExpr *> &other_exprs,
                                                bool &trans_happened)
{
  int ret = OB_SUCCESS;
  TableItem *view_table_item = NULL;
  ObSEArray<ObRawExpr *, 4> view_columns;
  ObSQLSessionInfo *session_info = NULL;
  ObRawExpr *stmt_id_expr = NULL;
  if (OB_ISNULL(session_info = ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("session is null", K(ret));
  } else if (OB_FAIL(ObTransformUtils::add_new_table_item(ctx_,
                                                          batch_stmt,
                                                          inner_view_stmt,
                                                          view_table_item))) {
    //create generated table item for inner view
    LOG_WARN("failed to add new table item", K(ret));
  } else if (OB_ISNULL(view_table_item)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item is null", K(ret));
  } else if (OB_FAIL(batch_stmt->add_from_item(view_table_item->table_id_, false))) {
    LOG_WARN("add from item to batch stmt failed", K(ret), KPC(view_table_item));
  } else if (OB_FAIL(ObTransformUtils::create_columns_for_view(ctx_,
                                                               *view_table_item,
                                                               batch_stmt,
                                                               view_columns))) {
    LOG_WARN("failed to create columns for view", K(ret));
  } else if (OB_ISNULL(stmt_id_expr = view_columns.at(view_columns.count() - 1))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt id expr is null", K(ret), K(stmt_id_expr));
  } else if (FALSE_IT(view_columns.pop_back())) {
    // do nothing
  } else if (OB_FAIL(batch_stmt->replace_relation_exprs(other_exprs, view_columns))) {
    LOG_WARN("replace inner stmt expr failed", K(ret));
  } else if (OB_FAIL(ObTransformUtils::adjust_pseudo_column_like_exprs(*batch_stmt))) {
    LOG_WARN("failed to adjust pseudo column like exprs", K(ret));
  } else if (OB_FAIL(batch_stmt->formalize_stmt(session_info))) {
    LOG_WARN("failed to formalize stmt", K(ret));
  } else {
    trans_happened = true;
    static_cast<ObDelUpdStmt*>(batch_stmt)->set_ab_stmt_id_expr(stmt_id_expr);
    LOG_DEBUG("debug transform_for_batch_stmt",
             K(batch_stmt->get_query_ctx()->ab_param_exprs_), K(view_columns));
  }
  return ret;
}

int ObTransformPreProcess::create_stmt_id_expr(ObPseudoColumnRawExpr *&stmt_id_expr)
{
  int ret = OB_SUCCESS;
  ObRawExprFactory *expr_factory = NULL;
  if (OB_ISNULL(expr_factory = ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("assign value_vector failed", K(ret));
  } else if (OB_FAIL(expr_factory->create_raw_expr(T_PSEUDO_STMT_ID, stmt_id_expr))) {
    LOG_WARN("create pseudo column raw expr failed", K(ret));
  } else if (OB_ISNULL(stmt_id_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt id expr is null", K(ret));
  } else {
    stmt_id_expr->set_data_type(ObIntType);
    stmt_id_expr->set_accuracy(ObAccuracy::MAX_ACCURACY[ObIntType]);
    stmt_id_expr->set_table_id(OB_INVALID_ID);
    stmt_id_expr->set_explicited_reference();
    stmt_id_expr->set_expr_name(ObString::make_string("stmt_id"));
  }
  return ret;
}

int ObTransformPreProcess::create_params_expr(ObPseudoColumnRawExpr *&pseudo_param_expr,
                                              ObRawExpr *origin_param_expr,
                                              int64_t name_id)
{
  int ret = OB_SUCCESS;
  char *pseudo_name = nullptr;
  ObRawExprFactory *expr_factory = NULL;
  const int64_t buf_len = 64;
  int64_t pos = 0;
  if (OB_ISNULL(expr_factory = ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("assign value_vector failed", K(ret));
  } else if (OB_ISNULL(pseudo_name = static_cast<char*>(ctx_->allocator_->alloc(buf_len)))) {
    ret = OB_ALLOCATE_MEMORY_FAILED;
    LOG_WARN("allocate name buffer failed", K(ret));
  } else if (OB_FAIL(databuff_printf(pseudo_name, buf_len, pos,
                                     "group_param_%ld", name_id))) {
    LOG_WARN("databuff print column name failed", K(ret));
  } else if (OB_FAIL(expr_factory->create_raw_expr(T_PSEUDO_GROUP_PARAM, pseudo_param_expr))) {
    LOG_WARN("create pseudo colmn raw expr failed", K(ret));
  } else {
    pseudo_param_expr->set_expr_name(ObString(pos, pseudo_name));
    pseudo_param_expr->set_result_type(origin_param_expr->get_result_type());
    pseudo_param_expr->set_table_id(OB_INVALID_ID);
    pseudo_param_expr->set_explicited_reference();
  }
  return ret;
}

int ObTransformPreProcess::create_params_exprs(ObDMLStmt &batch_stmt,
                                              ObIArray<ObRawExpr*> &params_exprs)
{
  int ret = OB_SUCCESS;
  const ObIArray<ObRawExpr*> &ab_param_exprs = batch_stmt.get_query_ctx()->ab_param_exprs_;
  for (int64_t i = 0; OB_SUCC(ret) && i < ab_param_exprs.count(); i++) {
    ObPseudoColumnRawExpr *group_param_expr = nullptr;
    if (OB_FAIL(create_params_expr(group_param_expr, ab_param_exprs.at(i), i))) {
      LOG_WARN("create pseudo colmn raw expr failed", K(ret), K(i), K(ab_param_exprs));
    } else if (OB_ISNULL(group_param_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("group_param_expr is null", K(ret));
    } else if (OB_FAIL(params_exprs.push_back(group_param_expr))) {
      LOG_WARN("fail to push group param exprs", K(ret), KPC(group_param_expr), K(params_exprs));
    }
  }
  return ret;
}

// 1、make value_vector as select_list,then extract_calculable_expr
// 2、after pre_calc, generate the mock select_list for inner_view
int ObTransformPreProcess::mock_select_list_for_ins_values(ObDMLStmt &batch_stmt,
                                                           ObSelectStmt &inner_view,
                                                           bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObExecContext *exec_ctx = nullptr;
  ObPhysicalPlanCtx *plan_ctx = nullptr;
  const ParamStore *param_store = nullptr;
  ObSEArray<ObRawExpr *, 4> select_list;
  ObInsertStmt &insert_stmt = static_cast<ObInsertStmt &>(batch_stmt);
  ObIArray<ObRawExpr*> &value_vector = insert_stmt.get_values_vector();
  ObIArray<ObColumnRefRawExpr*> &value_descs = insert_stmt.get_values_desc();
  if (OB_ISNULL(ctx_)
      || OB_ISNULL(exec_ctx = ctx_->exec_ctx_)
      || OB_ISNULL(plan_ctx = exec_ctx->get_physical_plan_ctx())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ctx_), K(exec_ctx), K(plan_ctx), K(ret));
  } else {
    param_store = &plan_ctx->get_param_store();
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < value_vector.count(); ++i) {
    ObConstRawExpr *param_expr = static_cast<ObConstRawExpr *>(value_vector.at(i));
    ObRawExpr *value_desc = value_descs.at(i);
    int64_t param_idx = param_expr->get_value().get_unknown();
    if (param_idx < 0 || param_idx >= param_store->count()) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("param_idx is invalid", K(ret), K(param_idx), KPC(param_store));
    } else {
      ObPseudoColumnRawExpr *group_param_expr = nullptr;
      //create pseudo column for the sql array param
      if (OB_FAIL(create_params_expr(group_param_expr, value_desc, select_list.count()))) {
        LOG_WARN("fail to create group param expr", K(ret), K(value_desc));
      } else if (OB_FAIL(batch_stmt.get_query_ctx()->ab_param_exprs_.push_back(param_expr))) {
        LOG_WARN("add param expr to select list exprs failed", K(ret));
      } else if (OB_FAIL(select_list.push_back(group_param_expr))) {
        LOG_WARN("store group id expr failed", K(ret));
      }
    }
  }

  //create stmt id expr with inner view
  if (OB_SUCC(ret)) {
    ObPseudoColumnRawExpr *stmt_id_expr = NULL;
    if (OB_FAIL(create_stmt_id_expr(stmt_id_expr))) {
      LOG_WARN("fail to create stmt id expr", K(ret));
    } else if (OB_FAIL(select_list.push_back(stmt_id_expr))) {
      LOG_WARN("store select id expr failed", K(ret));
    }
  }

  if (OB_SUCC(ret)) {
    if (OB_FAIL(ObTransformUtils::create_select_item(*ctx_->allocator_, select_list, &inner_view))) {
      LOG_WARN("failed to create select items", K(ret));
    } else if (!batch_stmt.get_query_ctx()->ab_param_exprs_.empty()) {
      inner_view.set_ab_param_flag(true);
      batch_stmt.get_query_ctx()->ins_values_batch_opt_ = true;
    }
  }
  return ret;
}

int ObTransformPreProcess::mock_select_list_for_ins_select(ObDMLStmt &batch_stmt,
                                                           ObSelectStmt &inner_view,
                                                           bool &trans_happened)
{
  int ret = OB_SUCCESS;
  const ParamStore *param_store = nullptr;
  ObExecContext *exec_ctx = nullptr;
  ObPhysicalPlanCtx *plan_ctx = nullptr;
  ObSEArray<ObRawExpr*, 4> params;
  ObSEArray<ObRawExpr*, 8> related_exprs;
  ObSEArray<ObRawExpr *, 4> select_list;
  int64_t child_size = 0;
  bool need_rollback = false;
  if (OB_ISNULL(ctx_)
      || OB_ISNULL(exec_ctx = ctx_->exec_ctx_)
      || OB_ISNULL(plan_ctx = exec_ctx->get_physical_plan_ctx())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ctx_), K(exec_ctx), K(plan_ctx), K(ret));
  } else if (OB_ISNULL(param_store = &plan_ctx->get_param_store())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("param store is null", K(ret));
  } else if (OB_FAIL(batch_stmt.get_child_stmt_size(child_size))) {
    LOG_WARN("get child size failed", K(ret));
  } else if (child_size > 0) {
    ret = OB_BATCHED_MULTI_STMT_ROLLBACK;
    LOG_WARN("child size greater than 0", K(ret), K(child_size));
  } else if (OB_FAIL(check_stmt_can_batch(&batch_stmt, need_rollback))) {
    LOG_WARN("fail to check multi_batch stmt", K(ret));
  } else if (need_rollback) {
    ret = OB_BATCHED_MULTI_STMT_ROLLBACK;
  } else if (OB_FAIL(batch_stmt.get_relation_exprs(related_exprs))) {
    LOG_WARN("get relation exprs failed", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::extract_params(related_exprs, params))) {
    LOG_WARN("extract param expr from related exprs failed", K(ret));
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < params.count(); ++i) {
      ObConstRawExpr *param_expr = static_cast<ObConstRawExpr *>(params.at(i));
      ObPseudoColumnRawExpr *group_id = NULL;
      int64_t param_idx = param_expr->get_value().get_unknown();
      if (param_idx < 0 || param_idx >= param_store->count()) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("param_idx is invalid", K(ret), K(param_idx), KPC(param_store));
      } else if (param_store->at(param_idx).is_ext_sql_array()
          && !has_exist_in_array(batch_stmt.get_query_ctx()->ab_param_exprs_,
                                 static_cast<ObRawExpr*>(param_expr))) {
        ObPseudoColumnRawExpr *group_param_expr = nullptr;
        //create pseudo column for the sql array param
        if (OB_FAIL(create_params_expr(group_param_expr, param_expr, select_list.count()))) {
          LOG_WARN("fail to create group param expr", K(ret), K(param_expr));
        } else if (OB_FAIL(batch_stmt.get_query_ctx()->ab_param_exprs_.push_back(param_expr))) {
          LOG_WARN("add param expr to select list exprs failed", K(ret));
        } else if (OB_FAIL(select_list.push_back(group_param_expr))) {
          LOG_WARN("store group id expr failed", K(ret));
        }
      }
    }

    //create stmt id expr with inner view
    if (OB_SUCC(ret)) {
      ObPseudoColumnRawExpr *stmt_id_expr = NULL;
      if (OB_FAIL(create_stmt_id_expr(stmt_id_expr))) {
        LOG_WARN("fail to create stmt id expr", K(ret));
      } else if (OB_FAIL(select_list.push_back(stmt_id_expr))) {
        LOG_WARN("store select id expr failed", K(ret));
      }
    }

    // create select item
    if (OB_SUCC(ret)) {
      if (OB_FAIL(ObTransformUtils::create_select_item(*ctx_->allocator_, select_list, &inner_view))) {
        LOG_WARN("failed to create select items", K(ret));
      } else if (!batch_stmt.get_query_ctx()->ab_param_exprs_.empty()) {
        inner_view.set_ab_param_flag(true);
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::mock_select_list_for_upd_del(ObDMLStmt &batch_stmt,
                                                        ObSelectStmt &inner_view)
{
  int ret = OB_SUCCESS;
  const ParamStore *param_store = nullptr;
  ObExecContext *exec_ctx = nullptr;
  ObPhysicalPlanCtx *plan_ctx = nullptr;
  ObSEArray<ObRawExpr*, 4> params;
  ObSEArray<ObRawExpr*, 8> related_exprs;
  ObSEArray<ObRawExpr *, 4> select_list;

  if (OB_ISNULL(ctx_)
      || OB_ISNULL(exec_ctx = ctx_->exec_ctx_)
      || OB_ISNULL(plan_ctx = exec_ctx->get_physical_plan_ctx())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ctx_), K(exec_ctx), K(plan_ctx), K(ret));
  } else if (FALSE_IT(param_store = &plan_ctx->get_param_store())) {
    // do nothing
  } else if (OB_FAIL(batch_stmt.get_relation_exprs(related_exprs))) {
    LOG_WARN("get relation exprs failed", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::extract_params(related_exprs, params))) {
    LOG_WARN("extract param expr from related exprs failed", K(ret));
  } else { }

  for (int64_t i = 0; OB_SUCC(ret) && i < params.count(); ++i) {
    ObConstRawExpr *param_expr = static_cast<ObConstRawExpr *>(params.at(i));
    int64_t param_idx = param_expr->get_value().get_unknown();
    if (param_idx < 0 || param_idx >= param_store->count()) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("param_idx is invalid", K(ret), K(param_idx), KPC(param_store));
    } else if (param_store->at(param_idx).is_batch_parameters()
        && !has_exist_in_array(batch_stmt.get_query_ctx()->ab_param_exprs_,
                               static_cast<ObRawExpr*>(param_expr))) {
      ObPseudoColumnRawExpr *group_param_expr = nullptr;
      //create pseudo column for the sql array param
      if (OB_FAIL(create_params_expr(group_param_expr, param_expr, select_list.count()))) {
        LOG_WARN("fail to create group param expr", K(ret), K(param_expr));
      } else if (OB_FAIL(batch_stmt.get_query_ctx()->ab_param_exprs_.push_back(param_expr))) {
        LOG_WARN("add param expr to select list exprs failed", K(ret));
      } else if (OB_FAIL(select_list.push_back(group_param_expr))) {
        LOG_WARN("store group id expr failed", K(ret));
      }
    }
  }
  //create stmt id expr with inner view
  if (OB_SUCC(ret)) {
    ObPseudoColumnRawExpr *stmt_id_expr = NULL;
    if (OB_FAIL(create_stmt_id_expr(stmt_id_expr))) {
      LOG_WARN("fail to create stmt id expr", K(ret));
    } else if (OB_FAIL(select_list.push_back(stmt_id_expr))) {
      LOG_WARN("store select id expr failed", K(ret));
    }
  }
  if (OB_SUCC(ret)) {
    if (OB_FAIL(ObTransformUtils::create_select_item(*ctx_->allocator_, select_list, &inner_view))) {
      LOG_WARN("failed to create select items", K(ret));
    } else if (!batch_stmt.get_query_ctx()->ab_param_exprs_.empty()) {
      inner_view.set_ab_param_flag(true);
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_full_outer_join(ObDMLStmt *&stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  ObSEArray<JoinedTable*, 4> joined_tables;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(stmt));
  } else if (OB_FAIL(joined_tables.assign(stmt->get_joined_tables()))) {
    LOG_WARN("failed to assign joined table", K(ret));
  } else {
    bool is_happened = false;
    for (int64_t i = 0; OB_SUCC(ret) && i < joined_tables.count(); ++i) {
      if (OB_ISNULL(joined_tables.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpected null", K(ret), K(i), K(joined_tables));
      } else if (OB_FAIL(recursively_eliminate_full_join(*stmt, joined_tables.at(i),
                                                         is_happened))) {
        LOG_WARN("failed to recursively eliminate full join", K(ret));
      } else {
        trans_happened |= is_happened;
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::convert_join_preds_vector_to_scalar(JoinedTable &joined_table,
                                                               bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObRawExpr*, 16> new_join_cond;
  bool is_happened = false;
  if (OB_ISNULL(ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get NULL ptr", K(ret) , KP(ctx_));
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < joined_table.get_join_conditions().count(); i++) {
      if (OB_FAIL(ObTransformUtils::convert_preds_vector_to_scalar(*ctx_,
                                                           joined_table.get_join_conditions().at(i),
                                                           new_join_cond,
                                                           is_happened))) {
        LOG_WARN("failed to convert predicate vector to scalar", K(ret));
      }
    }
    if (OB_SUCC(ret) && is_happened) {
      trans_happened = true;
      joined_table.get_join_conditions().reset();
      if (OB_FAIL(append(joined_table.get_join_conditions(), new_join_cond))) {
        LOG_WARN("failed to append join conditions", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::recursively_eliminate_full_join(ObDMLStmt &stmt,
                                                           TableItem *table_item,
                                                           bool &trans_happened)
{
  int ret = OB_SUCCESS;
  bool has_euqal = false;
  bool has_subquery = false;
  JoinedTable *joined_table = static_cast<JoinedTable *>(table_item);
  TableItem *view_table = NULL;
  TableItem *from_table = table_item;
  if (OB_ISNULL(table_item) || OB_ISNULL(ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item is null", K(ret), K(table_item), K(ctx_));
  } else if (!table_item->is_joined_table()) {
    /* do nothing */
  } else if (OB_FAIL(recursively_eliminate_full_join(stmt,
                                                     joined_table->left_table_,
                                                     trans_happened))) {
    LOG_WARN("failed to transform full nl join.", K(ret));
  } else if (OB_FAIL(recursively_eliminate_full_join(stmt,
                                                     joined_table->right_table_,
                                                     trans_happened))) {
    LOG_WARN("failed to transform full nl join.", K(ret));
  } else if (!joined_table->is_full_join()) {
    /* do nothing */
  } else if (OB_FAIL(convert_join_preds_vector_to_scalar(*joined_table, trans_happened))) {
    LOG_WARN("failed to convert join preds vector to scalar", K(ret));
  } else if (OB_FAIL(check_join_condition(&stmt, joined_table, has_euqal, has_subquery))) {
    LOG_WARN("failed to check join condition", K(ret));
  } else if (has_euqal || has_subquery) {
    /* do nothing */
  } else if (OB_FAIL(ObTransformUtils::replace_with_empty_view(ctx_,
                                                               &stmt,
                                                               view_table,
                                                               from_table))) {
    LOG_WARN("failed to create empty view table", K(ret));
  } else if (OB_FAIL(ObTransformUtils::create_inline_view(ctx_,
                                                          &stmt,
                                                          view_table,
                                                          from_table))) {
    LOG_WARN("failed to create inline view", K(ret));
  } else if (OB_ISNULL(view_table)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("view table is null", K(ret), K(view_table));
  } else if (OB_FAIL(expand_full_outer_join(view_table->ref_query_))) {
    LOG_WARN("failed to create view for full nl join.", K(ret));
  } else {
    trans_happened = true;
    view_table->for_update_ = false;
  }
  return ret;
}

int ObTransformPreProcess::check_join_condition(ObDMLStmt *stmt,
                                                JoinedTable *table,
                                                bool &has_equal,
                                                bool &has_subquery)
{
  int ret = OB_SUCCESS;
  has_equal = false;
  has_subquery = false;
  ObSqlBitSet<> left_tables;
  ObSqlBitSet<> right_tables;
  if (OB_ISNULL(stmt) || OB_ISNULL(table) || OB_ISNULL(table->left_table_)
      || OB_ISNULL(table->right_table_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null param", K(ret));
  } else if (OB_FAIL(stmt->get_table_rel_ids(*table->left_table_, left_tables))) {
    LOG_WARN("failed to get table rel ids", K(ret));
  } else if (OB_FAIL(stmt->get_table_rel_ids(*table->right_table_, right_tables))) {
    LOG_WARN("failed to get table rel ids", K(ret));
  } else {
    ObRawExpr *cond = NULL;
    ObRawExpr *left_param = NULL;
    ObRawExpr *right_param = NULL;
    for (int64_t i = 0; OB_SUCC(ret) && i < table->join_conditions_.count(); i++) {
      if (OB_ISNULL(cond = table->join_conditions_.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null condition", K(ret));
      } else if (OB_FALSE_IT(has_subquery |= cond->has_flag(CNT_SUB_QUERY))) {
      } else if (cond->get_relation_ids().is_empty() || !cond->has_flag(IS_JOIN_COND)) {
        /* do nothing */
      } else if (OB_UNLIKELY(cond->get_param_count() != 2) ||
                OB_ISNULL(left_param = cond->get_param_expr(0)) ||
                OB_ISNULL(right_param = cond->get_param_expr(1))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null param", K(ret));
      } else if ((left_param->get_relation_ids().is_subset(left_tables) &&
                  right_param->get_relation_ids().is_subset(right_tables)) ||
                (right_param->get_relation_ids().is_subset(left_tables) &&
                  left_param->get_relation_ids().is_subset(right_tables))) {
        has_equal = true;
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::expand_full_outer_join(ObSelectStmt *&ref_query)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *left_stmt = NULL;
  ObSelectStmt *right_stmt = NULL;
  ObSelectStmt *union_stmt = NULL;
  JoinedTable *joined_table = NULL;
  const int64_t sub_num = 1;
  if (OB_ISNULL(left_stmt = ref_query)
      || OB_UNLIKELY(left_stmt->get_joined_tables().count() != 1)
      || OB_ISNULL(joined_table = left_stmt->get_joined_tables().at(0))
      || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->stmt_factory_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected joined table count.", K(ret), K(ctx_), K(left_stmt), K(joined_table));
  } else if (OB_FALSE_IT(joined_table->joined_type_ = LEFT_OUTER_JOIN)) {
  } else if (OB_FAIL(ctx_->stmt_factory_->create_stmt(right_stmt))) {
      LOG_WARN("failed to create select stmt", K(ret));
  } else if (OB_FAIL(SMART_CALL(right_stmt->deep_copy(*ctx_->stmt_factory_,
                                                      *ctx_->expr_factory_,
                                                      *left_stmt)))) {
      LOG_WARN("failed to deep copy select stmt", K(ret));
  } else if (OB_FAIL(right_stmt->recursive_adjust_statement_id(ctx_->allocator_,
                                                               ctx_->src_hash_val_,
                                                               sub_num))) {
    LOG_WARN("failed to recursive adjust statement id", K(ret));
  } else if (OB_FAIL(right_stmt->update_stmt_table_id(*left_stmt))) {
    LOG_WARN("failed to updatew table id in stmt.", K(ret));
  } else if (right_stmt->get_joined_tables().count() != 1) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected joined table count.", K(ret), K(right_stmt->get_joined_tables()));
  } else if (OB_FAIL(switch_left_outer_to_semi_join(right_stmt,
                                                    right_stmt->get_joined_tables().at(0),
                                                    right_stmt->get_select_items()))) {
    LOG_WARN("failed to switch join table to semi.", K(ret));
  } else if (OB_FAIL(ObTransformUtils::create_set_stmt(ctx_, ObSelectStmt::UNION, false, left_stmt,
                                                       right_stmt, union_stmt))) {
    LOG_WARN("failed to create union stmt.", K(ret));
  } else if (OB_ISNULL(union_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(union_stmt));
  } else {
    ref_query = union_stmt;
  }
  return ret;
}

int ObTransformPreProcess::switch_left_outer_to_semi_join(ObSelectStmt *&sub_stmt,
                                                          JoinedTable *joined_table,
                                                          const ObIArray<SelectItem> &select_items)
{
  int ret = OB_SUCCESS;
  SemiInfo *semi_info = NULL;
  ObSEArray<SelectItem, 4> output_select_items;
  ObSEArray<FromItem, 4> from_items;
  ObSEArray<SemiInfo *, 4> semi_infos;
  ObSEArray<JoinedTable *, 4> joined_tables;
  if (OB_ISNULL(joined_table) || OB_ISNULL(sub_stmt)
      || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->allocator_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null pointer.", K(ret));
  } else if (OB_ISNULL(joined_table->left_table_) || OB_ISNULL(joined_table->right_table_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null pointer.", K(ret));
  } else if (joined_table->left_table_->is_joined_table()) {
    TableItem *view_table = NULL;
    TableItem *push_table = joined_table->left_table_;
    if (OB_FAIL(ObTransformUtils::replace_with_empty_view(ctx_,
                                                          sub_stmt,
                                                          view_table,
                                                          push_table))) {
      LOG_WARN("failed to create empty view table", K(ret));
    } else if (OB_FAIL(ObTransformUtils::create_inline_view(ctx_,
                                                            sub_stmt,
                                                            view_table,
                                                            push_table))) {
      LOG_WARN("failed to create inline view with table", K(ret));
    } else {
      joined_table->left_table_ = view_table;
    }
  }
  if (OB_FAIL(ret)) {
  } else if (OB_ISNULL(semi_info = static_cast<SemiInfo*>(ctx_->allocator_->alloc(
                                                                    sizeof(SemiInfo))))) {
    ret = OB_ALLOCATE_MEMORY_FAILED;
    LOG_ERROR("failed to alloc semi info", K(ret));
  } else if (FALSE_IT(semi_info = new(semi_info)SemiInfo())) {
  } else if (OB_FAIL(semi_infos.push_back(semi_info))) {
    LOG_WARN("failed to push back semi info", K(ret));
  } else if (joined_table->right_table_->type_ == TableItem::JOINED_TABLE &&
      OB_FAIL(joined_tables.push_back(static_cast<JoinedTable*>(joined_table->right_table_)))) {
    LOG_WARN("failed push back joined table.", K(ret));
  } else if (OB_FAIL(create_select_items_for_semi_join(sub_stmt,
                                                       joined_table->left_table_,
                                                       select_items,
                                                       output_select_items))) {
    LOG_WARN("failed to assign to column itmes.", K(ret));
  } else if (OB_FAIL(sub_stmt->get_select_items().assign(output_select_items))) {
    LOG_WARN("failed to assign select items.", K(ret));
  } else if (OB_FAIL(semi_info->semi_conditions_.assign(joined_table->join_conditions_))) {
    LOG_WARN("failed to assign to condition exprs.", K(ret));
  } else {
    FromItem from_item;
    TableItem* right_table_item = NULL;
    from_item.is_joined_ = joined_table->right_table_->type_ == TableItem::JOINED_TABLE;
    from_item.table_id_ = joined_table->right_table_->table_id_;
    semi_info->join_type_ = LEFT_ANTI_JOIN;
    semi_info->right_table_id_ = joined_table->left_table_->table_id_;
    semi_info->semi_id_ = sub_stmt->get_query_ctx()->available_tb_id_--;
    if (OB_FAIL(from_items.push_back(from_item))) {
      LOG_WARN("failed to push back from item", K(ret));
    } else if (OB_ISNULL(right_table_item = sub_stmt->get_table_item_by_id(semi_info->right_table_id_))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null pointer.", K(ret));
    } else if (OB_FALSE_IT(right_table_item->for_update_ = false)) {
    } else if (from_item.is_joined_) {
      JoinedTable *table = static_cast<JoinedTable*>(joined_table->right_table_);
      ret = semi_info->left_table_ids_.assign(table->single_table_ids_);
    } else {
      ret = semi_info->left_table_ids_.push_back(from_item.table_id_);
    }
  }
  if (OB_FAIL(ret)) {
  } else if (OB_FAIL(sub_stmt->get_joined_tables().assign(joined_tables))) {
    LOG_WARN("failed to assign join table.", K(ret));
  } else if (OB_FAIL(sub_stmt->get_semi_infos().assign(semi_infos))) {
    LOG_WARN("failed to assign semi infos.", K(ret));
  } else if (OB_FAIL(sub_stmt->get_from_items().assign(from_items))) {
    LOG_WARN("failed to assign from items.", K(ret));
  } else if (OB_FAIL(sub_stmt->formalize_stmt(ctx_->session_info_))) {
    LOG_WARN("failed to formalize stmt", K(ret));
  }
  return ret;
}

int ObTransformPreProcess::create_select_items_for_semi_join(ObDMLStmt *stmt,
                                                            TableItem *table_item,
                                                            const ObIArray<SelectItem> &select_items,
                                                            ObIArray<SelectItem> &output_select_items)
{
  int ret = OB_SUCCESS;
  ObSqlBitSet<> index_left;
  if (OB_ISNULL(stmt) || OB_ISNULL(table_item) ||
      OB_ISNULL(ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null error.", K(ret));
  } else if (OB_FAIL(extract_idx_from_table_items(stmt,
                                                  table_item,
                                                  index_left))) {
    LOG_WARN("failed to extract idx from join table.", K(ret));
  } else if (OB_FAIL(output_select_items.assign(select_items))) {
    LOG_WARN("failed to assign select items", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < output_select_items.count(); i++) {
    if (output_select_items.at(i).expr_->get_relation_ids().overlap(index_left)) {
      ObRawExpr *null_expr = NULL;
      ObRawExpr *cast_expr = NULL;
      if (OB_FAIL(ObRawExprUtils::build_null_expr(*ctx_->expr_factory_,
                                                  null_expr))) {
        LOG_WARN("failed build null exprs.", K(ret));
      } else if (OB_ISNULL(null_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null expr", K(ret));
      } else if (OB_FAIL(ObRawExprUtils::try_add_cast_expr_above(
                            ctx_->expr_factory_,
                            ctx_->session_info_,
                            *null_expr,
                            output_select_items.at(i).expr_->get_result_type(),
                            cast_expr))) {
        LOG_WARN("try add cast expr above failed", K(ret));
      } else {
        output_select_items.at(i).expr_ = cast_expr;
      }
    } else { /*do nothing.*/ }
  }
  return ret;
}

int ObTransformPreProcess::extract_idx_from_table_items(ObDMLStmt *sub_stmt,
                                                        const TableItem *table_item,
                                                        ObSqlBitSet<> &rel_ids)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(table_item) || OB_ISNULL(sub_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null error.", K(ret));
  } else if (table_item->is_joined_table()) {
    const JoinedTable *joined_table = static_cast<const JoinedTable*>(table_item);
    if (OB_FAIL(extract_idx_from_table_items(sub_stmt,
                                             joined_table->left_table_,
                                             rel_ids))) {
      LOG_WARN("failed to extract idx from join table.", K(ret));
    } else if (OB_FAIL(extract_idx_from_table_items(sub_stmt,
                                                    joined_table->right_table_,
                                                    rel_ids))) {
      LOG_WARN("failed to extract idx from join table.", K(ret));
    } else {}
  } else {
    if (OB_FAIL(rel_ids.add_member(sub_stmt->get_table_bit_index(table_item->table_id_)))) {
      LOG_WARN("failed to add member to rel ids.", K(ret));
    } else {}
  }
  return ret;
}

int ObTransformPreProcess::transform_rollup_exprs(ObDMLStmt *stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  ObSelectStmt *sel_stmt = NULL;
  ObSEArray<ObRawExpr*, 4> static_const_exprs;
  ObSEArray<ObRawExpr*, 4> static_remove_const_exprs;
  ObSEArray<ObRawExpr*, 4> exec_param_exprs;
  ObSEArray<ObRawExpr*, 4> exec_param_remove_const_exprs;
  ObSEArray<ObRawExpr*, 4> column_ref_exprs;
  ObSEArray<ObRawExpr*, 4> column_ref_remove_const_exprs;
  ObSEArray<ObRawExpr*, 4> query_ref_exprs;
  ObSEArray<ObRawExpr*, 4> query_ref_remove_const_exprs;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null stmt", K(ret));
  } else if (!stmt->is_select_stmt()) {
    //do nothing
  } else if (OB_FALSE_IT(sel_stmt = static_cast<ObSelectStmt*>(stmt))) {
  } else if (!sel_stmt->has_rollup()) {
    //do nothing
  } else if (OB_FAIL(get_rollup_const_exprs(sel_stmt,
                                            static_const_exprs,
                                            static_remove_const_exprs,
                                            exec_param_exprs,
                                            exec_param_remove_const_exprs,
                                            column_ref_exprs,
                                            column_ref_remove_const_exprs,
                                            query_ref_exprs,
                                            query_ref_remove_const_exprs,
                                            trans_happened))) {
    LOG_WARN("failed to get rollup const exprs", K(ret));
  } else if (static_const_exprs.empty() && exec_param_exprs.empty() && query_ref_exprs.empty()) {
    //do nothing
  } else if (OB_FAIL(replace_remove_const_exprs(
                                        sel_stmt,
                                        static_const_exprs,
                                        static_remove_const_exprs,
                                        exec_param_exprs,
                                        exec_param_remove_const_exprs,
                                        column_ref_exprs,
                                        column_ref_remove_const_exprs,
                                        query_ref_exprs,
                                        query_ref_remove_const_exprs))) {
    LOG_WARN("failed to replace remove const exprs", K(ret));
  }
  return ret;
}
 int ObTransformPreProcess::get_rollup_const_exprs(ObSelectStmt *stmt,
                                                  ObIArray<ObRawExpr*> &static_const_exprs,
                                                  ObIArray<ObRawExpr*> &static_remove_const_exprs,
                                                  ObIArray<ObRawExpr*> &exec_param_exprs,
                                                  ObIArray<ObRawExpr*> &exec_params_remove_const_exprs,
                                                  ObIArray<ObRawExpr*> &column_ref_exprs,
                                                  ObIArray<ObRawExpr*> &column_ref_remove_const_exprs,
                                                  ObIArray<ObRawExpr*> &query_ref_exprs,
                                                  ObIArray<ObRawExpr*> &query_ref_remove_const_exprs,
                                                  bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObSEArray<std::pair<int64_t, ObRawExpr *>, 2> dummy_onetime_exprs;
  ObRawExpr *remove_const_expr = NULL;
  bool is_const = false;
  trans_happened = false;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_) ||
      OB_ISNULL(ctx_->expr_factory_) ||
      OB_ISNULL(ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null", K(ret));
  }
  for (int i = 0; OB_SUCC(ret) && i < stmt->get_rollup_expr_size(); ++i) {
    ObRawExpr *expr = stmt->get_rollup_exprs().at(i);
    if (OB_ISNULL(expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null expr", K(ret));
    } else if (expr->has_flag(CNT_VOLATILE_CONST) || (!expr->is_const_expr() && !expr->is_query_ref_expr())) {
      //do nothing
    } else if (expr->is_query_ref_expr()) {
      // In mysql mode, rollup expr can reference subquery which may be transformed to a static const or onetime expr
      // e.g. select (select 1) as field1, sum(id) from t1 GROUP BY field1 with rollup;
      //      select (select count(1) from t1) as field1, sum(id) from t1 GROUP BY field1 with rollup;
      if (ObOptimizerUtil::find_item(query_ref_exprs, expr)) {
        //do nothing, skip dup exprs
      } else if (OB_FAIL(ObRawExprUtils::build_remove_const_expr(
                                        *ctx_->expr_factory_,
                                        *ctx_->session_info_,
                                        expr,
                                        remove_const_expr))) {
        LOG_WARN("failed to build remove const expr", K(ret));
      } else if (OB_ISNULL(remove_const_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null expr", K(ret));
      } else if (OB_FAIL(query_ref_exprs.push_back(expr))) {
        LOG_WARN("failed to push back expr", K(ret));
      } else if (OB_FAIL(query_ref_remove_const_exprs.push_back(remove_const_expr))) {
        LOG_WARN("failed to push back expr", K(ret));
      } else {
        stmt->get_rollup_exprs().at(i) = remove_const_expr;
        trans_happened = true;
      }
    } else if (expr->is_static_const_expr()) { //static const expr
      if (ObOptimizerUtil::find_item(static_const_exprs, expr)) {
        //do nothing, skip dup exprs
      } else if (OB_FAIL(ObRawExprUtils::build_remove_const_expr(
                                        *ctx_->expr_factory_,
                                        *ctx_->session_info_,
                                        expr,
                                        remove_const_expr))) {
        LOG_WARN("failed to build remove const expr", K(ret));
      } else if (OB_ISNULL(remove_const_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null expr", K(ret));
      } else if (OB_FAIL(static_const_exprs.push_back(expr))) {
        LOG_WARN("failed to push back expr", K(ret));
      } else if (OB_FAIL(static_remove_const_exprs.push_back(remove_const_expr))) {
        LOG_WARN("failed to push back expr", K(ret));
      } else {
        stmt->get_rollup_exprs().at(i) = remove_const_expr;
        trans_happened = true;
      }
    }  else if (ObOptimizerUtil::find_item(exec_param_exprs, expr)) {
      //do nothing, skip dup exprs
    } else if (OB_FAIL(ObRawExprUtils::build_remove_const_expr(
                                      *ctx_->expr_factory_,
                                      *ctx_->session_info_,
                                      expr,
                                      remove_const_expr))) {
      LOG_WARN("failed to build remove const expr", K(ret));
    } else if (OB_ISNULL(remove_const_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null expr", K(ret));
    } else {
      stmt->get_rollup_exprs().at(i) = remove_const_expr;
      trans_happened = true;
      if (lib::is_mysql_mode() && expr->is_exec_param_expr()) {
        ObExecParamRawExpr *exec_expr = static_cast<ObExecParamRawExpr *>(expr);
        const ObRawExpr *ref_expr = exec_expr->get_ref_expr();
        if (OB_ISNULL(ref_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("unexpected null", K(ret));
        } else if (ref_expr->is_column_ref_expr()) {
          if (OB_FAIL(column_ref_exprs.push_back(expr))) {
            LOG_WARN("failed to push back expr", K(ret));
          } else if (OB_FAIL(column_ref_remove_const_exprs.push_back(remove_const_expr))) {
            LOG_WARN("failed to push back expr", K(ret));
          }
        }
      }
      if (OB_SUCC(ret)) {
        if (OB_FAIL(exec_param_exprs.push_back(expr))) {
          LOG_WARN("failed to push back expr", K(ret));
        } else if (OB_FAIL(exec_params_remove_const_exprs.push_back(remove_const_expr))) {
          LOG_WARN("failed to push back expr", K(ret));
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::replace_remove_const_exprs(ObSelectStmt *stmt,
                                                      ObIArray<ObRawExpr*> &static_const_exprs,
                                                      ObIArray<ObRawExpr*> &static_remove_const_exprs,
                                                      ObIArray<ObRawExpr*> &exec_params,
                                                      ObIArray<ObRawExpr*> &exec_params_remove_const_exprs,
                                                      ObIArray<ObRawExpr*> &column_ref_exprs,
                                                      ObIArray<ObRawExpr*> &column_ref_remove_const_exprs,
                                                      ObIArray<ObRawExpr*> &query_ref_exprs,
                                                      ObIArray<ObRawExpr*> &query_ref_remove_const_exprs)
{
  int ret = OB_SUCCESS;
  ObQueryCtx *query_ctx = NULL;
  ObStmtCompareContext compare_ctx;
  if (OB_ISNULL(stmt) || OB_ISNULL(query_ctx = stmt->get_query_ctx())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null", K(ret), K(stmt), K(query_ctx));
  } else if (static_const_exprs.count() != static_remove_const_exprs.count() ||
             exec_params.count() != exec_params_remove_const_exprs.count()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect expr size", K(ret));
  } else if (OB_FALSE_IT(compare_ctx.init(&query_ctx->calculable_items_))) {
    LOG_WARN("failed to init compare context", K(ret));
  } else {
    if (is_mysql_mode()) {
      ObStmtExprReplacer replacer;
      replacer.remove_all();
      replacer.add_scope(SCOPE_HAVING);
      replacer.add_scope(SCOPE_SELECT);
      replacer.add_scope(SCOPE_ORDERBY);
      replacer.set_recursive(false);
      replacer.set_skip_bool_param_mysql(true);
      if (OB_FAIL(replacer.add_replace_exprs(static_const_exprs, static_remove_const_exprs))) {
        LOG_WARN("failed to add replace exprs", K(ret));
      } else if (OB_FAIL(replacer.add_replace_exprs(column_ref_exprs, column_ref_remove_const_exprs))) {
        LOG_WARN("failed to add replace exprs", K(ret));
      } else if (OB_FAIL(replacer.add_replace_exprs(query_ref_exprs, query_ref_remove_const_exprs))) {
        LOG_WARN("failed to add replace exprs", K(ret));
      } else if (OB_FAIL(stmt->iterate_stmt_expr(replacer))) {
        LOG_WARN("failed to iterate stmt expr", K(ret));
      }
    } else {
      ObStmtExprReplacer replacer;
      replacer.remove_all();
      replacer.add_scope(SCOPE_HAVING);
      replacer.add_scope(SCOPE_SELECT);
      replacer.add_scope(SCOPE_ORDERBY);
      replacer.set_recursive(false);
      replacer.set_skip_bool_param_mysql(false);
      if (OB_FAIL(replacer.add_replace_exprs(exec_params, exec_params_remove_const_exprs))) {
        LOG_WARN("failed to add replace exprs", K(ret));
      } else if (OB_FAIL(stmt->iterate_stmt_expr(replacer))) {
        LOG_WARN("failed to iterate stmt expr", K(ret));
      }
    }
  }

  for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_aggr_item_size(); ++i) {
    ObAggFunRawExpr *agg_expr = NULL;
    if (OB_ISNULL(agg_expr =stmt->get_aggr_item(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get unexpected null", K(ret));
    } else if (T_FUN_GROUPING == agg_expr->get_expr_type() || T_FUN_GROUPING_ID == agg_expr->get_expr_type()) {
      for (int64_t j = 0; j < agg_expr->get_param_count(); ++j) {
        bool replaced = false;
        int64_t pos = OB_INVALID_ID;
        if (OB_ISNULL(agg_expr->get_param_expr(j))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("unexpected null", K(ret));
        } else if (!agg_expr->get_param_expr(j)->is_const_expr()) {
        } else if (ObOptimizerUtil::find_item(static_const_exprs, agg_expr->get_param_expr(j), &pos)) {
          if (OB_UNLIKELY(pos < 0 || pos >= static_remove_const_exprs.count())) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get unexpected array pos", K(ret), K(pos), K(static_remove_const_exprs.count()));
          } else {
            agg_expr->get_param_expr(j) = static_remove_const_exprs.at(pos);
          }
        } else if (ObOptimizerUtil::find_item(exec_params, agg_expr->get_param_expr(j), &pos)) {
          if (OB_UNLIKELY(pos < 0 || pos >= exec_params_remove_const_exprs.count())) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get unexpected array pos", K(ret), K(pos), K(exec_params_remove_const_exprs.count()));
          } else {
            agg_expr->get_param_expr(j) = exec_params_remove_const_exprs.at(pos);
          }
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_cast_multiset_for_stmt(ObDMLStmt *&stmt,
                                                            bool &trans_happened)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_)
      || OB_ISNULL(ctx_->expr_factory_) || OB_ISNULL(ctx_->session_info_)
      || OB_ISNULL(ctx_->allocator_) || OB_ISNULL(ctx_->schema_checker_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt or context is null", K(ret));
  } else {
    ObArray<ObRawExprPointer> relation_exprs;
    ObStmtExprGetter getter;
    if (OB_FAIL(stmt->get_relation_exprs(relation_exprs, getter))) {
      LOG_WARN("failed to get all relation exprs", K(ret));
    } else {
      for (int i = 0; OB_SUCC(ret) && i < relation_exprs.count(); i++) {
        bool is_happened = false;
        ObRawExpr *expr = NULL;
        if (OB_FAIL(relation_exprs.at(i).get(expr))) {
          LOG_WARN("failed to get expr", K(ret));
        } else if (OB_ISNULL(expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("expr is NULL", K(ret));
        } else if (OB_FAIL(transform_cast_multiset_for_expr(*stmt,
                                                            expr,
                                                            is_happened))) {
          LOG_WARN("transform expr failed", K(ret));
        } else if (OB_FAIL(relation_exprs.at(i).set(expr))) {
          LOG_WARN("failed to set expr", K(ret));
        } else {
          trans_happened |= is_happened;
        }
      }
    }
    if (OB_SUCC(ret) && trans_happened &&
        OB_FAIL(stmt->formalize_stmt(ctx_->session_info_))) {
      LOG_WARN("failed to formalize", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_cast_multiset_for_expr(ObDMLStmt &stmt,
                                                            ObRawExpr *&expr,
                                                            bool &trans_happened)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr) ||
      OB_UNLIKELY(T_FUN_SYS_CAST == expr->get_expr_type() &&
                  (expr->get_param_count() != 2 ||
                   expr->get_param_expr(0) == NULL))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected param", K(ret), KPC(expr));
  } else if (T_FUN_SYS_CAST == expr->get_expr_type() &&
             expr->get_param_expr(0)->is_multiset_expr()) {
    ObQueryRefRawExpr *subquery_expr = static_cast<ObQueryRefRawExpr *>(expr->get_param_expr(0));
    ObConstRawExpr *const_expr = static_cast<ObConstRawExpr *>(expr->get_param_expr(1));
    uint64_t udt_id = OB_INVALID_ID;
    if (OB_ISNULL(const_expr) || OB_ISNULL(subquery_expr->get_ref_stmt()) ||
       OB_UNLIKELY(!const_expr->is_const_raw_expr()) ||
       OB_UNLIKELY(OB_INVALID_ID == (udt_id = const_expr->get_udt_id()))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected params", K(ret), KPC(expr));
    } else {
      const share::schema::ObUDTTypeInfo *dest_info = NULL;
      const share::schema::ObUDTCollectionType* coll_info = NULL;
      const pl::ObUserDefinedType *pl_type = NULL;
      const pl::ObCollectionType *coll_type = NULL;
      const uint64_t dest_tenant_id = pl::get_tenant_id_by_object_id(udt_id);
      if (OB_FAIL(ctx_->schema_checker_->get_udt_info(dest_tenant_id, udt_id, dest_info))) {
        LOG_WARN("failed to get udt info", K(ret));
      } else if (OB_ISNULL(dest_info)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected dest_info", K(ret), KPC(dest_info));
      } else if (OB_FAIL(dest_info->transform_to_pl_type(*ctx_->allocator_, pl_type))) {
        LOG_WARN("failed to get pl type", K(ret));
      } else if (OB_ISNULL(coll_type = static_cast<const pl::ObCollectionType *>(pl_type)) ||
                 OB_UNLIKELY(!pl_type->is_collection_type())) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected pl type", K(ret), KPC(pl_type));
      } else if (!coll_type->get_element_type().is_obj_type()) {
        // If the element type of collection is udt,
        // add constructor to the multiset subquery.
        // e.g. create type obj1 as object(a int, b int);
        //      create type tbl1 as table of obj1;
        //      cast(multiset(select '1.1','2.2' from dual) as tbl1)
        //    =>cast(multiset(select obj1('1.1','2.2') from dual) as tbl1)
        if (OB_FAIL(add_constructor_to_multiset(stmt,
                                                subquery_expr,
                                                coll_type->get_element_type(),
                                                trans_happened))) {
          LOG_WARN("failed to add constuctor to multiset", K(ret));
        }
      } else {
        // If the element type of collection is not udt,
        // add column conv to the multiset subquery.
        if (OB_FAIL(add_column_conv_to_multiset(subquery_expr,
                                                coll_type->get_element_type(),
                                                trans_happened))) {
          LOG_WARN("failed to add constuctor to multiset", K(ret));
        }
      }
    }
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
      OZ (SMART_CALL(transform_cast_multiset_for_expr(stmt,
                                                      expr->get_param_expr(i),
                                                      trans_happened)));
    }
  }
  return ret;
}

int ObTransformPreProcess::add_constructor_to_multiset(ObDMLStmt &stmt,
                                                       ObQueryRefRawExpr *multiset_expr,
                                                       const pl::ObPLDataType &elem_type,
                                                       bool& trans_happened)
{
  int ret = OB_SUCCESS;
  uint64_t elem_udt_id = elem_type.get_user_type_id();
  ObSelectStmt *multiset_stmt = multiset_expr->get_ref_stmt();
  const share::schema::ObUDTTypeInfo *elem_info = NULL;
  const share::schema::ObUDTCollectionType* coll_info = NULL;
  const pl::ObUserDefinedType *pl_type = NULL;
  const pl::ObRecordType *object_type = NULL;
  ObObjectConstructRawExpr *object_expr = NULL;
  ObSQLSessionInfo *session = ctx_->session_info_;
  int64_t rowsize = 0;
  const uint64_t tenant_id = pl::get_tenant_id_by_object_id(elem_udt_id);
  bool add_constructor = true;
  if (multiset_stmt->get_select_item_size() == 1) {
    // do not add constructor if the select item is null or
    // the type of select item is already the target element type
    ObRawExpr *in_expr = multiset_stmt->get_select_item(0).expr_;
    if (OB_ISNULL(in_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null", K(ret));
    } else if (ObNullType == in_expr->get_data_type()) {
      add_constructor = false;
    } else if (ObExtendType == in_expr->get_data_type()) {
      if (in_expr->get_udt_id() == elem_udt_id) {
        add_constructor = false;
      }
    }
  }

  ObSelectStmt *new_stmt = NULL;
  if (OB_FAIL(ret) || !add_constructor) {
  } else if (OB_ISNULL(ctx_->exec_ctx_->get_sql_proxy()) ||
             OB_ISNULL(ctx_->schema_checker_->get_schema_mgr()) ||
             OB_UNLIKELY(OB_INVALID_ID == elem_udt_id)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected params", KPC(multiset_expr), K(elem_type));
  } else if (!multiset_stmt->is_set_stmt() && !multiset_stmt->is_distinct()) {
    // if multiset stmt is set stmt, create a view for it.
    // e.g. create type tbl_obj as table of obj
    //      cast(multiset(select 1 as a from dual union select 2 as a from dual) as tbl_obj)
    //   => cast(multiset(select a from (select 1 as a from dual union select 2 as a from dual) v) as tbl_obj)
    //   => cast(multiset(select obj(a) from (select 1 as a from dual union select 2 as a from dual) v) as tbl_obj)
  } else if (OB_FAIL(ObTransformUtils::create_stmt_with_generated_table(ctx_, multiset_stmt, new_stmt))) {
    LOG_WARN("failed to create dummy view", K(ret));
  } else if (OB_ISNULL(new_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else {
    multiset_stmt = new_stmt;
    multiset_expr->set_ref_stmt(multiset_stmt);
  }
  ObIArray<SelectItem> &select_items = multiset_stmt->get_select_items();
  if (OB_FAIL(ret) || !add_constructor) {
    // do nothing
  } else if (OB_FAIL(ctx_->schema_checker_->get_udt_info(tenant_id, elem_udt_id, elem_info))) {
    LOG_WARN("failed to get udt info", K(ret));
  } else if (OB_ISNULL(elem_info)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected info", K(ret), KPC(elem_info));
  } else if (OB_FAIL(elem_info->transform_to_pl_type(*ctx_->allocator_, pl_type))) {
    LOG_WARN("failed to get pl type", K(ret));
  } else if (OB_ISNULL(object_type = static_cast<const pl::ObRecordType *>(pl_type)) ||
             OB_UNLIKELY(!pl_type->is_record_type())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected pl type", K(ret), KPC(pl_type));
  } else if (select_items.count() != object_type->get_member_count()) {
    ret = OB_ERR_CALL_WRONG_ARG;
    LOG_WARN("unexpected select item count", K(ret));
  } else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_FUN_PL_OBJECT_CONSTRUCT, object_expr))) {
    LOG_WARN("failed to create expr", K(ret));
  } else if (OB_ISNULL(object_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get null expr", K(ret));
  } else {
    pl::ObPLINS *ns = NULL;
    pl::ObPLPackageGuard package_guard(session->get_effective_tenant_id());
    pl::ObPLResolveCtx resolve_ctx(*ctx_->allocator_,
                                   *session,
                                   *ctx_->schema_checker_->get_schema_guard(),
                                   package_guard,
                                   *ctx_->exec_ctx_->get_sql_proxy(),
                                   false);
    if (OB_FAIL(package_guard.init())) {
      LOG_WARN("failed to init package guard", K(ret));
    } else if (OB_ISNULL(ns =
        ((NULL == session->get_pl_context()) ?
        static_cast<pl::ObPLINS *>(&resolve_ctx) :
        static_cast<pl::ObPLINS *>(session->get_pl_context()->get_current_ctx())))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null", K(ret));
    } else if (OB_FAIL(object_type->get_size(*ns, pl::PL_TYPE_ROW_SIZE, rowsize))) {
      LOG_WARN("failed to get size", K(ret));
    } else if (OB_FAIL(object_expr->add_access_name(object_type->get_name()))) {
      LOG_WARN("failed to add access name", K(ret));
    } else {
      object_expr->set_rowsize(rowsize);
      ObExprResType res_type;
      res_type.set_type(ObExtendType);
      res_type.set_extend_type(pl::PL_RECORD_TYPE);
      res_type.set_udt_id(object_type->get_user_type_id());
      object_expr->set_udt_id(object_type->get_user_type_id());
      object_expr->set_result_type(res_type);
      object_expr->set_func_name(object_type->get_name());
      object_expr->set_coll_schema_version(elem_info->get_schema_version());
      // Add udt info to dependency
      if (object_expr->need_add_dependency()) {
        ObSchemaObjVersion udt_schema_version;
        if (OB_FAIL(object_expr->get_schema_object_version(udt_schema_version))) {
          LOG_WARN("failed to get schema version", K(ret));
        } else if (OB_FAIL(stmt.add_global_dependency_table(udt_schema_version))) {
          LOG_WARN("failed to add dependency", K(ret));
        }
      }
    }

    for (int64_t i = 0; OB_SUCC(ret) && i < object_type->get_member_count(); ++i) {
      const pl::ObPLDataType *pl_type = object_type->get_record_member_type(i);
      ObExprResType param_type;
      const ObDataType *data_type = NULL;
      if (OB_ISNULL(pl_type)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpected null", K(ret));
      } else if (!pl_type->is_obj_type()) {
        // if the param type is udt,
        // select item must has the same type
        if (pl_type->get_user_type_id() !=
            select_items.at(i).expr_->get_udt_id()) {
          ret = OB_ERR_INVALID_TYPE_FOR_OP;
          LOG_WARN("inconsistent datatypes", K(ret), KPC(pl_type), KPC(select_items.at(i).expr_));
        } else {
          param_type.set_ext();
          param_type.set_extend_type(pl_type->get_type());
          param_type.set_udt_id(pl_type->get_user_type_id());
        }
      } else if (ObExtendType == select_items.at(i).expr_->get_data_type()) {
        // if the param type is not udt,
        // select item should not be udt either
        ret = OB_ERR_INVALID_TYPE_FOR_OP;
        LOG_WARN("inconsistent datatypes", K(ret), KPC(pl_type), KPC(select_items.at(i).expr_));
      } else if (OB_ISNULL(data_type = pl_type->get_data_type())) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpected null", K(ret));
      } else {
        param_type.set_meta(data_type->get_meta_type());
        param_type.set_accuracy(data_type->get_accuracy());
      }
      if (OB_SUCC(ret) &&
          OB_FAIL(object_expr->add_elem_type(param_type))) {
        LOG_WARN("failed to add elem type", K(ret));
      }
    }

    for (int64_t i = 0; OB_SUCC(ret) && i < select_items.count(); ++i) {
      SelectItem &item = select_items.at(i);
      if (OB_ISNULL(item.expr_)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpected null", K(ret));
      } else if (OB_FAIL(object_expr->add_param_expr(item.expr_))) {
        LOG_WARN("failed to add param expr", K(ret));
      }
    }

    if (OB_SUCC(ret)) {
      select_items.reset();
      multiset_expr->get_column_types().reset();
      multiset_expr->set_output_column(1);
      trans_happened = true;
      if (OB_FAIL(ObTransformUtils::create_select_item(*ctx_->allocator_,
                                                       object_expr,
                                                       multiset_stmt))) {
        LOG_WARN("failed to create select item", K(ret));
      } else if (OB_FAIL(object_expr->formalize(session))) {
        LOG_WARN("failed to formalize", K(ret));
      } else if (OB_FAIL(multiset_expr->get_column_types().push_back(object_expr->get_result_type()))) {
        LOG_WARN("failed to add result type", K(ret));
      }
    }
  }

  return ret;
}

int ObTransformPreProcess::add_column_conv_to_multiset(ObQueryRefRawExpr *multiset_expr,
                                                       const pl::ObPLDataType &elem_type,
                                                       bool& trans_happened)
{
  int ret = OB_SUCCESS;
  const ObDataType *data_type = NULL;
  ObSelectStmt *multiset_stmt = multiset_expr->get_ref_stmt();
  ObSelectStmt *new_stmt = NULL;
  if (OB_ISNULL(data_type = elem_type.get_data_type())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get null element data type", K(ret), K(elem_type));
  } else if (OB_UNLIKELY(multiset_stmt->get_select_item_size() != 1) ||
            OB_UNLIKELY(multiset_expr->get_column_types().count() != 1)) {
    ret = OB_ERR_INVALID_TYPE_FOR_OP;
    LOG_WARN("unexpected column count", K(ret), KPC(multiset_stmt), KPC(multiset_expr));
  } else {
    if (!multiset_stmt->is_set_stmt() && !multiset_stmt->is_distinct()) {
      // do nothing
      // if multiset stmt is set stmt, create a view for it.
    } else if (OB_FAIL(ObTransformUtils::create_stmt_with_generated_table(ctx_, multiset_stmt, new_stmt))) {
      LOG_WARN("failed to create dummy view", K(ret));
    } else if (OB_ISNULL(new_stmt)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null", K(ret));
    } else {
      multiset_stmt = new_stmt;
      multiset_expr->set_ref_stmt(multiset_stmt);
    }
    if (OB_SUCC(ret)) {
      SelectItem &select_item = multiset_stmt->get_select_item(0);
      ObRawExpr *child = select_item.expr_;
      if (OB_FAIL(ObRawExprUtils::build_column_conv_expr(ctx_->session_info_,
                                                         *ctx_->expr_factory_,
                                                         data_type->get_obj_type(),
                                                         data_type->get_collation_type(),
                                                         data_type->get_accuracy_value(),
                                                         true,
                                                         NULL,
                                                         NULL,
                                                         child,
                                                         true))) {
        LOG_WARN("failed to build column conv expr", K(ret));
      } else {
        select_item.expr_ = child;
        multiset_expr->get_column_types().at(0) = child->get_result_type();
        trans_happened = true;
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_outerjoin_exprs(ObDMLStmt *stmt, bool &is_happened)
{
  int ret = OB_SUCCESS;
  int64_t set_size = 32;
  ObStmtExprGetter visitor;
  visitor.set_relation_scope();
  visitor.remove_scope(DmlStmtScope::SCOPE_JOINED_TABLE);
  ObArray<ObRawExpr *> relation_exprs;
  hash::ObHashSet<uint64_t> expr_set;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret), K(stmt));
  } else if (OB_FAIL(stmt->get_relation_exprs(relation_exprs, visitor))) {
    LOG_WARN("failed to get relation exprs", K(ret));
  } else if (set_size < relation_exprs.count()) {
    set_size = relation_exprs.count();
  }
  if (OB_SUCC(ret)) {
    if (OB_FAIL(expr_set.create(set_size, "RewriteExpr", "RewriteExpr"))) {
      LOG_WARN("failed to create expr set", K(ret));
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < relation_exprs.count(); ++i) {
    if (OB_FAIL(ObTransformUtils::append_hashset(relation_exprs.at(i), expr_set))) {
      LOG_WARN("failed to append hashset", K(ret));
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_from_item_size(); ++i) {
    JoinedTable *joined_table = NULL;
    if (!stmt->get_from_item(i).is_joined_) {
      // do nothing
    } else if (OB_ISNULL(joined_table = stmt->get_joined_table(stmt->get_from_item(i).table_id_))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("joined table is null", K(ret), K(joined_table));
    } else if (OB_FAIL(remove_shared_expr(stmt, joined_table, expr_set, false))) {
      LOG_WARN("failed to remove shared expr", K(ret));
    }
  }
  if (expr_set.created()) {
    int tmp_ret = OB_SUCCESS;
    if (OB_SUCCESS != (tmp_ret = expr_set.destroy())) {
      LOG_WARN("failed to destroy expr set", K(ret));
      ret = COVER_SUCC(tmp_ret);
    }
  }
  return ret;
}

int ObTransformPreProcess::remove_shared_expr(ObDMLStmt *stmt,
                                              JoinedTable *joined_table,
                                              hash::ObHashSet<uint64_t> &expr_set,
                                              bool is_nullside)
{
  int ret = OB_SUCCESS;
  TableItem *left = NULL;
  TableItem *right = NULL;
  TableItem *nullside_table = NULL;
  ObArray<ObRawExpr *> padnull_exprs;
  if (OB_ISNULL(joined_table) ||
      OB_ISNULL(left = joined_table->left_table_) ||
      OB_ISNULL(right = joined_table->right_table_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("joined table is null", K(ret), K(joined_table));
  } else if (joined_table->is_full_join()) {
    nullside_table = joined_table;
  } else if (joined_table->is_left_join()) {
    nullside_table = right;
  } else if (joined_table->is_right_join()) {
    nullside_table = left;
  }
  if (OB_SUCC(ret) && NULL != nullside_table) {
    ObArray<uint64_t> table_ids;
    if (nullside_table->is_joined_table()) {
      if (OB_FAIL(append(table_ids, static_cast<JoinedTable *>(nullside_table)->single_table_ids_))) {
        LOG_WARN("failed to append single table ids", K(ret));
      }
    } else if (OB_FAIL(table_ids.push_back(nullside_table->table_id_))) {
      LOG_WARN("failed to push back table id", K(ret));
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < table_ids.count(); ++i) {
      if (OB_FAIL(stmt->get_column_exprs(table_ids.at(i), padnull_exprs))) {
        LOG_WARN("failed to get column exprs", K(ret));
      }
    }
  }
  if (!padnull_exprs.empty() || is_nullside) {
    for (int64_t i = 0; OB_SUCC(ret) && i < joined_table->join_conditions_.count(); ++i) {
      bool has = false;
      if (OB_FAIL(do_remove_shared_expr(expr_set,
                                        padnull_exprs,
                                        is_nullside,
                                        joined_table->join_conditions_.at(i),
                                        has))) {
        LOG_WARN("failed to remove shared expr", K(ret));
      }
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < joined_table->join_conditions_.count(); ++i) {
    if (OB_FAIL(ObTransformUtils::append_hashset(joined_table->join_conditions_.at(i),
                                                 expr_set))) {
      LOG_WARN("failed to append expr into hashset", K(ret));
    }
  }
  if (OB_SUCC(ret) && left->is_joined_table()) {
    bool left_is_nullside = is_nullside || (joined_table->is_right_join() ||
                                            joined_table->is_full_join());
    if (OB_FAIL(remove_shared_expr(stmt,
                                   static_cast<JoinedTable *>(left),
                                   expr_set,
                                   left_is_nullside))) {
      LOG_WARN("failed to remove shared expr", K(ret));
    }
  }
  if (OB_SUCC(ret) && right->is_joined_table()) {
    bool right_is_nullside = is_nullside || (joined_table->is_left_join() ||
                                             joined_table->is_full_join());
    if (OB_FAIL(remove_shared_expr(stmt,
                                   static_cast<JoinedTable *>(right),
                                   expr_set,
                                   right_is_nullside))) {
      LOG_WARN("failed to remove shared expr", K(ret));
    }
  }
  return ret;
}

int ObTransformPreProcess::do_remove_shared_expr(hash::ObHashSet<uint64_t> &expr_set,
                                                 ObIArray<ObRawExpr *> &padnull_exprs,
                                                 bool is_nullside,
                                                 ObRawExpr *&expr,
                                                 bool &has_padnull_column)
{
  int ret = OB_SUCCESS;
  bool need_copy = false;
  uint64_t key = reinterpret_cast<uint64_t>(expr);
  has_padnull_column = false;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr is null", K(ret));
  } else if (expr->is_column_ref_expr()) {
    has_padnull_column = ObOptimizerUtil::find_item(padnull_exprs, expr);
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
    bool has = false;
    if (OB_FAIL(do_remove_shared_expr(expr_set,
                                      padnull_exprs,
                                      is_nullside,
                                      expr->get_param_expr(i),
                                      has))) {
      LOG_WARN("failed to remove shared expr", K(ret));
    } else if (has) {
      has_padnull_column = true;
    }
  }
  if (OB_SUCC(ret) &&
      OB_HASH_EXIST == expr_set.exist_refactored(key) &&
      !expr->is_column_ref_expr() &&
      !expr->is_query_ref_expr() &&
      !expr->is_const_raw_expr() &&
      !expr->is_exec_param_expr() &&
      !expr->is_pseudo_column_expr()) {
    bool bret = false;
    ObRawExpr *new_expr = NULL;
    if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("params have null", K(ret));
    } else if (padnull_exprs.empty() || !has_padnull_column) {
      // do nothing
    } else if (OB_FAIL(ObTransformUtils::is_null_propagate_expr(expr, padnull_exprs, bret))) {
      LOG_WARN("failed to check is null propogate expr", K(ret));
    } else if (!bret) {
      need_copy = true;
    }
    if (OB_SUCC(ret) && !need_copy && is_nullside) {
      if (OB_FAIL(check_nullside_expr(expr, bret))) {
        LOG_WARN("failed to check nullside expr", K(ret));
      } else if (!bret) {
        need_copy = true;
      }
    }
    if (OB_SUCC(ret) && need_copy) {
      if (OB_FAIL(ObRawExprCopier::copy_expr_node(*ctx_->expr_factory_,
                                                  expr,
                                                  new_expr))) {
        LOG_WARN("failed to copy expr node", K(ret));
      } else {
        expr = new_expr;
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::check_nullside_expr(ObRawExpr *expr, bool &bret)
{
  int ret = OB_SUCCESS;
  ObArray<ObRawExpr *> column_exprs;
  bret = false;
  if (OB_FAIL(ObRawExprUtils::extract_column_exprs(expr, column_exprs))) {
    LOG_WARN("failed to extract column exprs", K(ret));
  } else if (OB_FAIL(ObTransformUtils::is_null_propagate_expr(expr, column_exprs, bret))) {
    LOG_WARN("failed to check is null propagate expr", K(ret));
  }
  return ret;
}

int ObTransformPreProcess::check_pre_aggregate(const ObSelectStmt &select_stmt,
                                               bool &can_pre_aggr)
{
  int ret = OB_SUCCESS;
  can_pre_aggr = false;
  if (!select_stmt.has_group_by() || select_stmt.get_aggr_item_size() == 0) {
  } else {
    can_pre_aggr = true;
    const ObIArray<ObAggFunRawExpr*> &aggr_items = select_stmt.get_aggr_items();
    int64_t cnt_group_func = 0;
    for (int64_t i = 0; OB_SUCC(ret) && can_pre_aggr && i < aggr_items.count(); ++i) {
      const ObAggFunRawExpr *aggr_expr = aggr_items.at(i);
      if (OB_ISNULL(aggr_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret));
      } else if (aggr_expr->get_expr_type() == T_FUN_MAX ||
                 aggr_expr->get_expr_type() == T_FUN_MIN ||
                 (!aggr_expr->is_param_distinct() &&
                  (aggr_expr->get_expr_type() == T_FUN_SUM ||
                   aggr_expr->get_expr_type() == T_FUN_COUNT ||
                   aggr_expr->get_expr_type() == T_FUN_COUNT_SUM))) {
      } else if (aggr_expr->get_expr_type() == T_FUN_GROUPING ||
                 aggr_expr->get_expr_type() == T_FUN_GROUPING_ID ||
                 aggr_expr->get_expr_type() == T_FUN_GROUP_ID) {
        cnt_group_func++;
      } else {
        can_pre_aggr = false;
      }
    }
    if (OB_SUCC(ret) && cnt_group_func == aggr_items.count()) {
      can_pre_aggr = false;
    }
  }
  return ret;
}

int ObTransformPreProcess::transform_for_last_insert_id(ObDMLStmt *stmt, bool &trans_happened) {
  int ret = OB_SUCCESS;
  trans_happened = false;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(stmt));
  } else if (stmt->is_select_stmt()) {
    ObSelectStmt *sel_stmt = static_cast<ObSelectStmt*>(stmt);
    bool is_happened = false;
    if (OB_FAIL(expand_for_last_insert_id(*stmt, sel_stmt->get_having_exprs(), is_happened))) {
      LOG_WARN("fail to expand having exprs",K(ret));
    } else {
      trans_happened |= is_happened;
    }
    if (OB_FAIL(ret)) {
    } else if (OB_FAIL(expand_for_last_insert_id(*stmt, sel_stmt->get_condition_exprs(), is_happened))) {
      LOG_WARN("fail to expand condition exprs",K(ret));
    } else {
      trans_happened |= is_happened;
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < sel_stmt->get_joined_tables().count(); ++i) {
      if (OB_FAIL(expand_last_insert_id_for_join(*stmt, sel_stmt->get_joined_tables().at(i), is_happened))) {
        LOG_WARN("failed to expand join conditions", K(ret));
      } else {
        trans_happened |= is_happened;
      }
    }
  } else if (stmt->is_delete_stmt() || stmt->is_update_stmt()) {
    bool is_happened = false;
    if (OB_FAIL(expand_for_last_insert_id(*stmt, stmt->get_condition_exprs(), is_happened))) {
      LOG_WARN("fail to expand having exprs",K(ret));
    } else {
      trans_happened |= is_happened;
    }
  }
  return ret;
}

int ObTransformPreProcess::expand_last_insert_id_for_join(ObDMLStmt &stmt, JoinedTable *join_table, bool &has_happened) {
  int ret = OB_SUCCESS;
  bool is_happened = false;
  has_happened = false;
  if (OB_ISNULL(join_table) || OB_ISNULL(join_table->left_table_) || OB_ISNULL(join_table->right_table_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(join_table));
  } else if (OB_FAIL(expand_for_last_insert_id(stmt, join_table->join_conditions_, has_happened))) {
    LOG_WARN("failed to expand join conditions", K(ret));
  } else if (join_table->left_table_->is_joined_table() &&
            OB_FAIL(expand_last_insert_id_for_join(stmt, static_cast<JoinedTable*>(join_table->left_table_), is_happened))) {
    LOG_WARN("fail to expand last_insert_id in left join table", K(ret));
  } else if (FALSE_IT(has_happened |= is_happened)) {
  } else if (join_table->right_table_->is_joined_table() &&
            OB_FAIL(expand_last_insert_id_for_join(stmt, static_cast<JoinedTable*>(join_table->right_table_), is_happened))) {
    LOG_WARN("fail to expand last_insert_id in right join table", K(ret));
  } else {
    has_happened |= is_happened;
  }
  return ret;
}

int ObTransformPreProcess::expand_for_last_insert_id(ObDMLStmt &stmt, ObIArray<ObRawExpr*> &exprs, bool &is_happended) {
  int ret = OB_SUCCESS;
  ObSEArray<ObRawExpr *, 4> new_exprs;
  is_happended = false;
  for (int64_t i = 0; OB_SUCC(ret) && i < exprs.count(); ++i) {
    ObRawExpr *expr = exprs.at(i);
    if (OB_ISNULL(expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null", K(ret), K(expr), K(i));
    } else if (expr->has_flag(CNT_LAST_INSERT_ID) &&
          (IS_RANGE_CMP_OP(expr->get_expr_type()) || T_OP_EQ == expr->get_expr_type()) &&
          !expr->has_flag(CNT_RAND_FUNC) &&
          !expr->has_flag(CNT_SUB_QUERY) &&
          !expr->has_flag(CNT_ROWNUM) &&
          !expr->has_flag(CNT_SEQ_EXPR) &&
          !expr->has_flag(CNT_DYNAMIC_USER_VARIABLE)) {
      bool removable = false;
      ObRawExpr *left = expr->get_param_expr(0);
      ObRawExpr *right = expr->get_param_expr(1);
      ObRawExpr *check_expr = NULL;
      if (OB_ISNULL(left) || OB_ISNULL(right)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpected null", K(ret), K(left), K(right));
      } else if (left->has_flag(CNT_LAST_INSERT_ID) && !left->has_flag(CNT_COLUMN) && right->has_flag(CNT_COLUMN)) {
        check_expr = right;
      } else if (right->has_flag(CNT_LAST_INSERT_ID) && !right->has_flag(CNT_COLUMN) && left->has_flag(CNT_COLUMN)) {
        check_expr = left;
      }
      if (OB_FAIL(ret) || NULL == check_expr) {
        //do nothing
      } else if (OB_FAIL(ObTransformUtils::check_is_index_part_key(*ctx_, stmt, check_expr, removable))) {
        LOG_WARN("fail to check if it's a index/part condition", K(ret));
      } else if (!removable) {
        //do nothing if the param which does not contain last_insert_id is not a index key with lossless cast or a index key.
      } else if (OB_FAIL(check_last_insert_id_removable(expr, removable))) {
        LOG_WARN("fail to check whether last_insert_id can be removed", K(ret));
      } else if (removable) {
        ObRawExpr *param_expr = check_expr == left ? right : left;
        ObRawExpr *new_expr = NULL;
        if (OB_FAIL(ObRawExprCopier::copy_expr(
                            *ctx_->expr_factory_,
                            param_expr,
                            param_expr))) {
          LOG_WARN("failed to copy expr", K(ret));
        } else if (OB_ISNULL(param_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("new param is invalid", K(ret));
        } else if (OB_FAIL(remove_last_insert_id(param_expr))) {
          LOG_WARN("failed to remove last insert id exprs", K(ret));
        } else if (OB_FAIL(param_expr->formalize(ctx_->session_info_))) {
          LOG_WARN("failed to formalize expr", K(ret));
        } else if (!param_expr->is_const_expr()) {
          //do nothing
        } else if (OB_FAIL(ObRawExprCopier::copy_expr_node(*ctx_->expr_factory_,
                                                  expr,
                                                  new_expr))) {
          LOG_WARN("failed to copy expr", K(ret));
        } else if (OB_ISNULL(new_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("failed to build new expr", K(ret));
        } else if (new_expr->get_param_expr(0) == check_expr) {
          new_expr->get_param_expr(1) = param_expr;
        } else {
          new_expr->get_param_expr(0) = param_expr;
        }
        if (OB_SUCC(ret) && NULL != new_expr) {
          if (OB_FAIL(new_expr->formalize(ctx_->session_info_))) {
            LOG_WARN("failed to formalize expr", K(ret));
          } else if (OB_FAIL(exprs.push_back(new_expr))) {
            LOG_WARN("failed to push back new pred", K(ret));
          } else {
            is_happended = true;
          }
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::check_last_insert_id_removable(const ObRawExpr *expr, bool &is_removable) {
  int ret = OB_SUCCESS;
  is_removable = true;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(expr));
  } else if (expr->has_flag(IS_LAST_INSERT_ID)) {
    if (1 != expr->get_param_count()) {
      is_removable = false;
    } else {
      const ObRawExpr *param = expr->get_param_expr(0);
      if (OB_ISNULL(param)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpected null", K(ret), K(param));
      } else if (!param->has_flag(IS_CONST) && !param->has_flag(IS_CONST_EXPR)) {
        is_removable = false;
      }
    }
  } else if (expr->has_flag(CNT_LAST_INSERT_ID)) {
    bool flag = true;
    for (int64_t i = 0; OB_SUCC(ret) && is_removable && i < expr->get_param_count(); ++i) {
      if (OB_FAIL(check_last_insert_id_removable(expr->get_param_expr(i), flag))) {
        LOG_WARN("fail to check whether last insert id expr is removable", K(ret));
      } else {
        is_removable = is_removable & flag;
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::remove_last_insert_id(ObRawExpr *&expr) {
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (expr->has_flag(IS_LAST_INSERT_ID)) {
    if (1 == expr->get_param_count()) {
      ObRawExpr *new_expr = expr->get_param_expr(0);
      if (OB_ISNULL(new_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpected null", K(ret), K(new_expr));
      } else if (new_expr->has_flag(IS_CONST) || new_expr->has_flag(IS_CONST_EXPR)) {
        expr = new_expr;
      }
    }
  } else if (expr->has_flag(CNT_LAST_INSERT_ID)) {
    for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
      if (OB_FAIL(remove_last_insert_id(expr->get_param_expr(i)))) {
        LOG_WARN("fail to check whether last insert id expr is removable", K(ret));
      }
    }
  } else {}
  return ret;
}

int ObTransformPreProcess::expand_correlated_cte(ObDMLStmt *stmt, bool& trans_happened)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObDMLStmt::TempTableInfo, 8> temp_table_infos;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is NULL", K(ret));
  } else if (OB_FAIL(stmt->collect_temp_table_infos(temp_table_infos))) {
    LOG_WARN("failed to collect temp table infos", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < temp_table_infos.count(); i ++) {
    bool is_correlated = false;
    ObSEArray<ObSelectStmt *, 4> dummy;
    if (OB_FAIL(check_is_correlated_cte(temp_table_infos.at(i).temp_table_query_, dummy, is_correlated))) {
      LOG_WARN("failed to check is correlated cte", K(ret));
    } else if (!is_correlated) {
      //do nothing
    } else if (OB_FAIL(ObTransformUtils::expand_temp_table(ctx_, temp_table_infos.at(i)))) {
      LOG_WARN("failed to extend temp table", K(ret));
    } else {
      trans_happened = true;
    }
  }
  return ret;
}

int ObTransformPreProcess::check_exec_param_correlated(const ObRawExpr *expr, bool &is_correlated)
{
  int ret = OB_SUCCESS;
  is_correlated = false;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr is null", K(ret), K(expr));
  } else if (expr->is_exec_param_expr()) {
    if (!expr->has_flag(BE_USED)) {
      is_correlated = true;
    }
  } else if (expr->has_flag(CNT_DYNAMIC_PARAM)) {
    for (int64_t i = 0; OB_SUCC(ret) && !is_correlated && i < expr->get_param_count(); ++i) {
      if (OB_FAIL(SMART_CALL(check_exec_param_correlated(expr->get_param_expr(i),
                                                        is_correlated)))) {
        LOG_WARN("failed to check exec param correlated", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::check_is_correlated_cte(ObSelectStmt *stmt, ObIArray<ObSelectStmt *> &visited_cte, bool &is_correlated)
{
  int ret = OB_SUCCESS;
  ObArray<ObSelectStmt *> child_stmts;
  ObArray<ObRawExpr *> relation_exprs;
  is_correlated = false;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is NULL", K(ret));
  } else if (OB_FAIL(stmt->get_relation_exprs(relation_exprs))) {
    LOG_WARN("failed to get relation exprs", K(ret));
  } else if (OB_FAIL(stmt->get_child_stmts(child_stmts))) {
    LOG_WARN("failed to get child stmts", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && !is_correlated && i < relation_exprs.count(); ++i) {
    ObRawExpr *expr = relation_exprs.at(i);
    if (OB_FAIL(check_exec_param_correlated(expr, is_correlated))) {
      LOG_WARN("failed to check exec param level", K(ret));
    }
  }
  if (!is_correlated) {
    // add flag to mark the exec param refer the same table
    for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_subquery_expr_size(); ++i) {
      ObQueryRefRawExpr *query_ref = stmt->get_subquery_exprs().at(i);
      if (OB_ISNULL(query_ref)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("query ref is null", K(ret), K(query_ref));
      }
      for (int64_t j = 0; OB_SUCC(ret) && j < query_ref->get_exec_params().count(); ++j) {
        ObRawExpr *exec_param = query_ref->get_exec_params().at(j);
        if (OB_ISNULL(exec_param)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("exec param is null", K(ret));
        } else if (OB_FAIL(exec_param->add_flag(BE_USED))) {
          LOG_WARN("failed to add flag", K(ret));
        }
      }
    }

    for (int64_t i = 0; OB_SUCC(ret) && !is_correlated && i < child_stmts.count(); ++i) {
      if (OB_FAIL(SMART_CALL(check_is_correlated_cte(child_stmts.at(i), visited_cte, is_correlated)))) {
        LOG_WARN("failed to get non correlated subquery", K(ret));
      }
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_table_size(); ++i) {
      TableItem *table = stmt->get_table_item(i);
      if (OB_ISNULL(table)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null table item", K(ret));
      } else if (!table->is_temp_table()) {
        //do nothing
      } else if (ObOptimizerUtil::find_item(visited_cte, table->ref_query_)) {
        //do nothing
      } else if (OB_FAIL(visited_cte.push_back(table->ref_query_))) {
        LOG_WARN("failed to push back stmt", K(ret));
      } else if (OB_FAIL(SMART_CALL(check_is_correlated_cte(table->ref_query_, visited_cte, is_correlated)))) {
        LOG_WARN("failed to get non correlated subquery", K(ret));
      }
    }

    // clear flag
    for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_subquery_expr_size(); ++i) {
      ObQueryRefRawExpr *query_ref = stmt->get_subquery_exprs().at(i);
      if (OB_ISNULL(query_ref)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("query ref is null", K(ret), K(query_ref));
      }
      for (int64_t j = 0; OB_SUCC(ret) && j < query_ref->get_exec_params().count(); ++j) {
        ObRawExpr *exec_param = query_ref->get_exec_params().at(j);
        if (OB_ISNULL(exec_param)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("exec param is null", K(ret));
        } else if (OB_FAIL(exec_param->clear_flag(BE_USED))) {
          LOG_WARN("failed to clear flag", K(ret));
        }
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::check_can_transform_insert_only_merge_into(const ObMergeStmt *merge_stmt,
                                                                      bool &is_valid)
{
  int ret = OB_SUCCESS;
  is_valid = true;
  if (OB_ISNULL(merge_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret));
  } else if (merge_stmt->has_update_clause() || !merge_stmt->has_insert_clause()) {
    is_valid = false;
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < merge_stmt->get_values_vector().count(); ++i) {
      const ObRawExpr *expr = merge_stmt->get_values_vector().at(i);
      if (OB_ISNULL(expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret));
      } else if (expr->is_static_const_expr()) {
        is_valid = false;
      }
    }
  }
  return ret;
}

} // end namespace sql
} // end namespace oceanbase