/**
 * 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/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_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/rewrite/ob_expand_aggregate_utils.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 (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;
        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("faield to elinimate having", K(ret));
      } else {
        trans_happened |= 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;
        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;
        LOG_TRACE("succeed to replace function", K(is_happened));
      }
    }
    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;
        LOG_TRACE("succeed to transform for temporary 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;
        LOG_TRACE("succeed to transform for merge into", 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;
        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;
        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;
        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;
          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;
        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;
        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;
        LOG_TRACE("succeed to transform rownum as limit", K(is_happened));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(transform_for_grouping_sets_and_multi_rollup(stmt, is_happened))) {
        LOG_WARN("failed to transform for transform for grouping sets and multi rollup.", K(ret));
      } else {
        trans_happened |= is_happened;
        LOG_TRACE("succeed to transform for grouping sets and multi rollup",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_and_levels(stmt.get_current_level()))) {
        LOG_WARN("failed to pullup relation ids", K(ret));
      }
    }
  }
  return ret;
}

/*@brief,ObTransformPreProcess::transform_for_grouping_sets_and_multi_rollup, 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_for_grouping_sets_and_multi_rollup(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 or ctx is null.", K(ret));
  } else if (!stmt->is_select_stmt()) {
    /* do nothing.*/
  } else {
    ObSelectStmt *select_stmt = static_cast<ObSelectStmt *>(stmt);
    ObIArray<ObGroupingSetsItem> &grouping_sets_items = select_stmt->get_grouping_sets_items();
    ObIArray<ObMultiRollupItem> &multi_rollup_items = select_stmt->get_multi_rollup_items();
    if (!select_stmt->has_grouping_sets() && multi_rollup_items.count() == 0) {
      /* do nothing.*/
    } else if (OB_UNLIKELY(grouping_sets_items.count() == 0 && multi_rollup_items.count() == 0)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get unexpected error", K(select_stmt->has_grouping_sets()),
                                       K(multi_rollup_items.count()),
                                       K(grouping_sets_items.count()));
    } else if (grouping_sets_items.count() == 1 &&
               grouping_sets_items.at(0).grouping_sets_exprs_.count() == 1 &&
               grouping_sets_items.at(0).multi_rollup_items_.count() == 0 &&
               multi_rollup_items.count() == 0) {
      //if grouping sets expr has only one,we can remove grouping sets directly.
      if (OB_FAIL(append(select_stmt->get_group_exprs(),
                         grouping_sets_items.at(0).grouping_sets_exprs_.at(0).groupby_exprs_))) {
        LOG_WARN("failed to append group exprs", K(ret));
      } else {
        grouping_sets_items.reset();
        bool is_happened = false;
        if (!select_stmt->has_group_by() &&
            OB_FAIL(ObTransformUtils::set_limit_expr(select_stmt, ctx_))) {
          LOG_WARN("add limit expr failed", K(ret));
        } else if (!select_stmt->has_group_by() &&
                   OB_FAIL(eliminate_having(select_stmt, is_happened))) {
          LOG_WARN("failed to eliminate having", K(ret));
        } else {
          trans_happened = true;
          LOG_TRACE("eliminate having", K(is_happened));
        }
      }
    } else {
      //as following steps to transform grouping sets stmt to set stmt:
      // 1. Creating spj stmt from origin stmt;
      // 2. According to the spj stmt separated in the previous step, creating temp table and add it
      //    to origin stmt
      // 3. According to grouping sets items or multi rollup items and stmt created in the previous
      //    step,creating set stmt
      // 4. Merging set stmt created in the previous step and origin stmt into transform stmt.
      ObSelectStmt *view_stmt = NULL;
      ObSelectStmt *transform_stmt = NULL;
      ObSelectStmt *set_view_stmt = NULL;
      bool is_correlated = false;
      int32_t stmt_level = select_stmt->get_current_level();
      //step 1, creating spj stmt
      if (OB_FAIL(ObTransformUtils::create_simple_view(ctx_, select_stmt, view_stmt))) {
        LOG_WARN("failed to create spj view.", K(ret));
      //step 2, creating temp table
      } else if (OB_ISNULL(view_stmt)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("view stmt is null", K(ret), K(view_stmt));
      } else if (stmt_level > 0 &&
                 OB_FAIL(ObTransformUtils::is_correlated_subquery(*view_stmt, is_correlated))) {
        LOG_WARN("failed to check is correlated subquery", K(ret));
      } else if (is_correlated) {
        ret = OB_NOT_SUPPORTED;
        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_, select_stmt))) {
        LOG_WARN("failed to add generated table as temp table", K(ret));
      //setp 3, creating set stmt
      } else if (OB_FAIL(create_set_view_stmt(select_stmt,
                                              set_view_stmt))) {
        LOG_WARN("failed to create grouping sets view.", K(ret));
      //step 4, merge stmt
      } else if (OB_FAIL(replace_with_set_stmt_view(select_stmt,
                                                    set_view_stmt,
                                                    transform_stmt))) {
        LOG_WARN("failed to create union view for grouping sets.", K(ret));
      } else {
        stmt = transform_stmt;
        trans_happened = true;
        LOG_TRACE("succeed to transform transform for grouping sets and multi rollup", K(*stmt));
      }
    }
  }
  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;
}

/*@brief, ObTransformPreProcess::create_select_list_from_grouping_sets, 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::create_select_list_from_grouping_sets(
                                                       ObSelectStmt *stmt,
                                                       ObIArray<ObGroupbyExpr> &groupby_exprs_list,
                                                       int64_t cur_index,
                                                       ObIArray<ObRawExpr*> &old_exprs,
                                                       ObIArray<ObRawExpr*> &new_exprs,
                                                       int64_t origin_groupby_num /* = -1 */)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null.", K(ret), K(stmt), K(ctx_));
  } else {
    common::ObSEArray<SelectItem, 4> select_items;
    ObRelIds rel_ids;
    for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_select_item_size(); i++) {
      if (OB_FAIL(extract_select_expr_and_replace_expr(stmt->get_select_item(i).expr_,
                                                       stmt->get_group_exprs(),
                                                       stmt->get_rollup_exprs(),
                                                       stmt->get_aggr_items(),
                                                       groupby_exprs_list,
                                                       cur_index,
                                                       select_items,
                                                       old_exprs,
                                                       new_exprs,
                                                       rel_ids,
                                                       origin_groupby_num))) {
        LOG_WARN("failed to extract select expr and replace expr", K(ret));
      } else {/*do nothing*/}
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_column_size(); ++i) {
      ObRawExpr *expr = stmt->get_column_items().at(i).expr_;
      if (OB_ISNULL(expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret));
      } else if (ObOptimizerUtil::find_item(stmt->get_group_exprs(), expr) ||
                 ObOptimizerUtil::find_item(stmt->get_rollup_exprs(), expr) ||
                 expr->get_relation_ids().is_subset2(rel_ids)) {
        /*do nothing*/
      } else {
        ObRawExpr *null_expr = NULL;
        ObSysFunRawExpr *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_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 expr", K(ret));
        } else if (OB_FAIL(new_exprs.push_back(cast_expr))) {
          LOG_WARN("failed to push back expr", K(ret));
        } else {/*do nothing*/}
      }
    }
    if (OB_SUCC(ret)) {
      if (select_items.empty()) {
        stmt->get_select_items().reset();
        if (OB_FAIL(ObTransformUtils::create_dummy_select_item(*stmt, ctx_))) {
          LOG_WARN("failed to create dummy select item", K(ret));
        } else {/*do nothing*/}
      } else if (OB_FAIL(stmt->get_select_items().assign(select_items))) {
        LOG_WARN("failed to assign to select items.", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::replace_aggr_exprs_in_select_and_having(
                                              ObRawExpr *&expr,
                                              ObIArray<ObRawExpr*> &groupby_exprs,
                                              ObIArray<ObRawExpr*> &rollup_exprs,
                                              ObIArray<ObAggFunRawExpr*> &aggr_items,
                                              ObIArray<ObGroupbyExpr> &groupby_exprs_list,
                                              int64_t cur_index,
                                              ObIArray<ObRawExpr*> &old_exprs,
                                              ObIArray<ObRawExpr*> &new_exprs,
                                              ObRelIds &rel_ids,
                                              int64_t origin_groupby_num /*default -1*/,
                                              bool using_rel_ids/*default true*/)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(expr));
  } else if (expr->get_expr_type() == T_FUN_GROUPING &&
      OB_FAIL(calc_grouping_in_grouping_sets(expr,
                                             groupby_exprs,
                                             rollup_exprs,
                                             aggr_items,
                                             old_exprs,
                                             new_exprs,
                                             rel_ids,
                                             using_rel_ids))) {
    LOG_WARN("fail to calculate grouping");
  } else if (expr->get_expr_type() == T_FUN_GROUPING_ID &&
             OB_FAIL(calc_grouping_id_in_grouping_sets(expr,
                                                       groupby_exprs,
                                                       rollup_exprs,
                                                       aggr_items,
                                                       old_exprs,
                                                       new_exprs,
                                                       rel_ids,
                                                       using_rel_ids))) {
    LOG_WARN("fail to calculate grouping_id");
  } else if (expr->get_expr_type() == T_FUN_GROUP_ID &&
             OB_FAIL(calc_group_id_in_grouping_sets(expr,
                                                    groupby_exprs,
                                                    rollup_exprs,
                                                    aggr_items,
                                                    groupby_exprs_list,
                                                    cur_index,
                                                    old_exprs,
                                                    new_exprs,
                                                    rel_ids,
                                                    origin_groupby_num,
                                                    using_rel_ids))) {
    LOG_WARN("fail to calculate group_id");
  } else {
    //do nothing.
  }
  return ret;
}

int ObTransformPreProcess::calc_grouping_in_grouping_sets(
                                              ObRawExpr *&expr,
                                              ObIArray<ObRawExpr*> &groupby_exprs,
                                              ObIArray<ObRawExpr*> &rollup_exprs,
                                              ObIArray<ObAggFunRawExpr*> &aggr_items,
                                              ObIArray<ObRawExpr*> &old_exprs,
                                              ObIArray<ObRawExpr*> &new_exprs,
                                              ObRelIds &rel_ids,
                                              bool using_rel_ids/*default true*/) {
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr) || expr->get_expr_type() != T_FUN_GROUPING) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null expr");
  } else if (OB_UNLIKELY(expr->get_param_count() != 1)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected error", K(*expr), K(ret));
  } 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 {
    ObConstRawExpr *one_expr = NULL;
    ObSysFunRawExpr *cast_expr = NULL;
    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 if (OB_FAIL(old_exprs.push_back(expr))) {
      LOG_WARN("failed to push back expr", K(ret));
    } else if (using_rel_ids && OB_FAIL(rel_ids.add_members2(expr->get_relation_ids()))) {
      LOG_WARN("failed to get relation ids", K(ret));
    } else if (OB_FAIL(new_exprs.push_back(cast_expr))) {
      LOG_WARN("failed to push back expr", K(ret));
    } else if (OB_FAIL(ObOptimizerUtil::remove_item(aggr_items,
                                                    static_cast<ObAggFunRawExpr*>(expr)))) {
      LOG_WARN("failed to remove item", K(ret));
    } else {
      if (!using_rel_ids) {
        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(
                                              ObRawExpr *&expr,
                                              ObIArray<ObRawExpr*> &groupby_exprs,
                                              ObIArray<ObRawExpr*> &rollup_exprs,
                                              ObIArray<ObAggFunRawExpr*> &aggr_items,
                                              ObIArray<ObRawExpr*> &old_exprs,
                                              ObIArray<ObRawExpr*> &new_exprs,
                                              ObRelIds &rel_ids,
                                              bool using_rel_ids/*default true*/) {
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr) || expr->get_expr_type() != T_FUN_GROUPING_ID) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null expr");
  } 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 {
    uint64_t new_value = 0;
    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++;
      }
    }
    ObConstRawExpr *int_expr = NULL;
    ObSysFunRawExpr *cast_expr = NULL;
    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 if (OB_FAIL(old_exprs.push_back(expr))) {
      LOG_WARN("failed to push back expr", K(ret));
    } else if (using_rel_ids && OB_FAIL(rel_ids.add_members2(expr->get_relation_ids()))) {
      LOG_WARN("failed to get relation ids", K(ret));
    } else if (OB_FAIL(new_exprs.push_back(cast_expr))) {
      LOG_WARN("failed to push back expr", K(ret));
    } else if (OB_FAIL(ObOptimizerUtil::remove_item(aggr_items,
                                                    static_cast<ObAggFunRawExpr*>(expr)))) {
      LOG_WARN("failed to remove item", K(ret));
    } else {
      if (!using_rel_ids) {
        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(
                                              ObRawExpr *&expr,
                                              ObIArray<ObRawExpr*> &groupby_exprs,
                                              ObIArray<ObRawExpr*> &rollup_exprs,
                                              ObIArray<ObAggFunRawExpr*> &aggr_items,
                                              ObIArray<ObGroupbyExpr> &groupby_exprs_list,
                                              int64_t cur_index,
                                              ObIArray<ObRawExpr*> &old_exprs,
                                              ObIArray<ObRawExpr*> &new_exprs,
                                              ObRelIds &rel_ids,
                                              int64_t origin_groupby_num /*default -1*/,
                                              bool using_rel_ids/*default true*/) {
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr) || expr->get_expr_type() != T_FUN_GROUP_ID) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null expr");
  } 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) {
    int64_t duplicated_groupby_num = 0;
    for (int64_t i = 0; i < cur_index; i++) {
      bool match = true;
      for(int64_t j = origin_groupby_num; match && j < groupby_exprs.count(); j++) {
        if (ObOptimizerUtil::find_item(groupby_exprs_list.at(i).groupby_exprs_, groupby_exprs.at(j))) {
        } else {
          match = false;
        }
      } 
      for (int64_t j = 0; match && j< groupby_exprs_list.at(i).groupby_exprs_.count(); j++) {
        if (ObOptimizerUtil::find_item(groupby_exprs, groupby_exprs_list.at(i).groupby_exprs_.at(j))) {

        } else {
          match = false;
        }
      }
      if (match) {
        //if match inc the duplciated count.
        duplicated_groupby_num++;
      }
    }
    // the group id is duplicated_groupby_num;
    ObConstRawExpr *int_expr = NULL;
    ObSysFunRawExpr *cast_expr = NULL;
    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 if (OB_FAIL(old_exprs.push_back(expr))) {
      LOG_WARN("failed to push back expr", K(ret));
    } else if (using_rel_ids && OB_FAIL(rel_ids.add_members2(expr->get_relation_ids()))) {
      LOG_WARN("failed to get relation ids", K(ret));
    } else if (OB_FAIL(new_exprs.push_back(cast_expr))) {
      LOG_WARN("failed to push back expr", K(ret));
    } else if (OB_FAIL(ObOptimizerUtil::remove_item(aggr_items,
                                                    static_cast<ObAggFunRawExpr*>(expr)))) {
      LOG_WARN("failed to remove item", K(ret));                                                
    } else {
      if (!using_rel_ids) {
        expr = cast_expr;
      }
    }
  } else {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("group_id doesn't support coexisting grouping sets and rollup", K(ret));
  }
  return ret;
}

int ObTransformPreProcess::extract_select_expr_and_replace_expr(
                                                       ObRawExpr *expr,
                                                       ObIArray<ObRawExpr*> &groupby_exprs,
                                                       ObIArray<ObRawExpr*> &rollup_exprs,
                                                       ObIArray<ObAggFunRawExpr*> &aggr_items,
                                                       ObIArray<ObGroupbyExpr> &groupby_exprs_list,
                                                       int64_t cur_index,
                                                       ObIArray<SelectItem> &select_items,
                                                       ObIArray<ObRawExpr*> &old_exprs,
                                                       ObIArray<ObRawExpr*> &new_exprs,
                                                       ObRelIds &rel_ids,
                                                       int64_t origin_groupby_num /* = -1 */)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(ctx_));
  } else if (expr->is_aggr_expr() ||
             ObOptimizerUtil::find_item(groupby_exprs, expr) ||
             ObOptimizerUtil::find_item(rollup_exprs, expr)) {
    if (!is_expr_in_select_item(select_items, expr)) {
      SelectItem select_item;
      select_item.expr_ = expr;
      select_item.expr_name_ = expr->get_expr_name();
      select_item.alias_name_ = expr->get_expr_name();
      if (OB_FAIL(select_items.push_back(select_item))) {
        LOG_WARN("failed to push back into select items.", K(ret));
      } else if (OB_FAIL(replace_aggr_exprs_in_select_and_having(expr,
                                                                 groupby_exprs,
                                                                 rollup_exprs,
                                                                 aggr_items,
                                                                 groupby_exprs_list,
                                                                 cur_index,
                                                                 old_exprs,
                                                                 new_exprs,
                                                                 rel_ids,
                                                                 origin_groupby_num))) {
        LOG_WARN("failed to place aggr expr", K(ret));
      } else {
        //do nothing
      } 
    }
  } else if (is_select_expr_in_other_groupby_exprs(expr,
                                                   groupby_exprs_list,
                                                   cur_index)) {
      if (!ObOptimizerUtil::find_item(old_exprs, expr)) {
        ObRawExpr *null_expr = NULL;
        ObSysFunRawExpr *cast_expr = NULL;
        SelectItem select_item;
        select_item.expr_ = expr;
        select_item.expr_name_ = expr->get_expr_name();
        select_item.alias_name_ = expr->get_expr_name();
        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 expr", K(ret));
        } else if (OB_FAIL(rel_ids.add_members2(expr->get_relation_ids()))) {
          LOG_WARN("failed to get relation ids", K(ret));
        } else if (OB_FAIL(new_exprs.push_back(cast_expr))) {
          LOG_WARN("failed to push back expr", K(ret));
        } else if (OB_FAIL(select_items.push_back(select_item))) {
          LOG_WARN("failed to push back into select items.", K(ret));
        } else {/*do nothing*/}
      }
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
      if (OB_FAIL(SMART_CALL(extract_select_expr_and_replace_expr(expr->get_param_expr(i),
                                                                  groupby_exprs,
                                                                  rollup_exprs,
                                                                  aggr_items,
                                                                  groupby_exprs_list,
                                                                  cur_index,
                                                                  select_items,
                                                                  old_exprs,
                                                                  new_exprs,
                                                                  rel_ids,
                                                                  origin_groupby_num)))) {
        LOG_WARN("failed to extract select expr and replace expr", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::replace_select_and_having_exprs(ObSelectStmt *select_stmt,
                                                           ObIArray<ObRawExpr*> &old_exprs,
                                                           ObIArray<ObRawExpr*> &new_exprs,
                                                           ObIArray<ObGroupbyExpr> &groupby_exprs_list,
                                                           int64_t cur_index/*default -1*/,
                                                           int64_t origin_groupby_num/*default -1*/)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(select_stmt));
  } else {
    //replace select expr
    for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_select_item_size(); ++i) {
      SelectItem &select_item = select_stmt->get_select_item(i);
      if (OB_ISNULL(select_item.expr_)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret), K(select_item.expr_));
      } else if (OB_FAIL(replace_stmt_special_exprs(select_stmt,
                                                    select_item.expr_,
                                                    old_exprs,
                                                    new_exprs,
                                                    groupby_exprs_list,
                                                    false,
                                                    cur_index,
                                                    origin_groupby_num))) {
        LOG_WARN("failed to replace exception aggr exprs", K(ret));
      }
    }
    //replace having expr into null
    if (OB_SUCC(ret)) {
      ObIArray<ObRawExpr*> &having_exprs = select_stmt->get_having_exprs();
      for (int64_t i = 0; OB_SUCC(ret) && i < having_exprs.count(); ++i) {
        if (OB_ISNULL(having_exprs.at(i))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret), K(having_exprs.at(i)));
        } else if (OB_FAIL(replace_stmt_special_exprs(select_stmt,
                                                      having_exprs.at(i),
                                                      old_exprs,
                                                      new_exprs,
                                                      groupby_exprs_list,
                                                      true,
                                                      cur_index,
                                                      origin_groupby_num))) {
          LOG_WARN("failed to replace exception aggr exprs", K(ret));
        }
      }
    }
  }
  return ret;
}



bool ObTransformPreProcess::is_select_expr_in_other_groupby_exprs(
                                                        ObRawExpr *expr,
                                                        ObIArray<ObGroupbyExpr> &groupby_exprs_list,
                                                        int64_t cur_index)
{
  bool is_true = false;
  for (int64_t i = 0; !is_true && i < groupby_exprs_list.count(); ++i) {
    if (i == cur_index) {
      /*do nothing */
    } else {
      is_true = ObOptimizerUtil::find_equal_expr(groupby_exprs_list.at(i).groupby_exprs_, expr);
    }
  }
  return is_true;
}

bool ObTransformPreProcess::is_expr_in_select_item(ObIArray<SelectItem> &select_items,
                                                   ObRawExpr *expr)
{
  bool is_true = false;
  for (int64_t i = 0; !is_true && i < select_items.count(); ++i) {
    is_true = (select_items.at(i).expr_ == expr);
  }
  return is_true;
}

int ObTransformPreProcess::replace_stmt_special_exprs(ObSelectStmt *select_stmt,
                                                      ObRawExpr *&expr,
                                                      ObIArray<ObRawExpr*> &old_exprs,
                                                      ObIArray<ObRawExpr*> &new_exprs,
                                                      ObIArray<ObGroupbyExpr> &groupby_exprs_list,
                                                      bool ignore_const/*default false*/,
                                                      int64_t cur_index/*default -1*/,
                                                      int64_t origin_groupby_num/*default -1*/)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(expr));
  } else if (ignore_const && expr->is_const_expr()) {
    /*do nothing*/
  } else if (ObOptimizerUtil::find_item(select_stmt->get_group_exprs(), expr) ||
             ObOptimizerUtil::find_item(select_stmt->get_rollup_exprs(), expr)) {
    /*do nothing*/
  } else {
    int64_t idx = -1;
    ObRelIds rel_ids;
    if (!ObOptimizerUtil::find_item(old_exprs, expr, &idx)) {
      if (expr->is_aggr_expr()) {
        if (OB_FAIL(replace_aggr_exprs_in_select_and_having(expr,
                                                            select_stmt->get_group_exprs(),
                                                            select_stmt->get_rollup_exprs(),
                                                            select_stmt->get_aggr_items(),
                                                            groupby_exprs_list,
                                                            cur_index,
                                                            old_exprs,
                                                            new_exprs,
                                                            rel_ids,
                                                            origin_groupby_num,
                                                            false))) {
          LOG_WARN("failed to replace aggr expr");
        }
      } else {
        for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
          if (OB_FAIL(SMART_CALL(replace_stmt_special_exprs(select_stmt,
                                                            expr->get_param_expr(i),
                                                            old_exprs,
                                                            new_exprs,
                                                            groupby_exprs_list,
                                                            ignore_const,
                                                            cur_index,
                                                            origin_groupby_num)))) {
            LOG_WARN("failed to replace exception aggr exprs", K(ret));
          } else {/*do nothing */}
        }
      }
    } else if (OB_UNLIKELY(idx < 0 || idx >= new_exprs.count()) ||
               OB_ISNULL(new_exprs.at(idx))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("invalid index", K(ret), K(idx), K(new_exprs.count()), K(new_exprs));
    } else {
      expr = new_exprs.at(idx);
    }
  }
  return ret;
}

int ObTransformPreProcess::replace_with_set_stmt_view(ObSelectStmt *origin_stmt,
                                                      ObSelectStmt *set_view_stmt,
                                                      ObSelectStmt *&union_stmt)
{
  int ret = OB_SUCCESS;
  ObSqlBitSet<> rel_ids;
  TableItem *view_table_item = NULL;
  ObSEArray<ObRawExpr *, 4> old_exprs;
  ObSEArray<ObRawExpr *, 4> new_exprs;
  ObSEArray<ColumnItem, 4> temp_column_items;
  if (OB_ISNULL(origin_stmt) || OB_ISNULL(set_view_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("origin stmt is null", K(ret));
  } else if (OB_FAIL(origin_stmt->get_from_tables(rel_ids))) {
    LOG_WARN("failed to get from tables.", K(ret));
  } else if (FALSE_IT(origin_stmt->get_table_items().reset())) {
  } else if (FALSE_IT(origin_stmt->get_from_items().reset())) {
  } else if (OB_FAIL(ObTransformUtils::add_new_table_item(ctx_,
                                                          origin_stmt,
                                                          set_view_stmt,
                                                          view_table_item))) {
    LOG_WARN("failed to add new table item.", K(ret));
  } else if (OB_FAIL(origin_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,
                                                               origin_stmt,
                                                               new_exprs))) {
    LOG_WARN("failed to get select exprs from grouping sets view.", K(ret));
  } else { /* do nothing. */ }
  for (int64_t i = 0; OB_SUCC(ret) && i < origin_stmt->get_column_size(); i++) {
    if (!origin_stmt->get_column_item(i)->expr_->get_relation_ids().overlap(rel_ids)) {
      if (OB_FAIL(temp_column_items.push_back(*origin_stmt->get_column_item(i)))) {
        LOG_WARN("faield to push back into column items.", K(ret));
      } else { /* do nothing. */ }
    } else { /* do nothing. */ }
  }
  if (OB_FAIL(ret)) {
  } else if (OB_FAIL(origin_stmt->get_column_items().assign(temp_column_items))) {
    LOG_WARN("failed to assign column items.", K(ret));
  } else if (OB_FAIL(extract_stmt_replace_expr(origin_stmt, old_exprs))) {
    LOG_WARN("failed to extract stmt replace expr", K(ret));
  } else if (OB_UNLIKELY(old_exprs.count() != 0 && old_exprs.count() != new_exprs.count())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected error", K(ret), K(old_exprs), K(new_exprs));
  } else {
    origin_stmt->get_grouping_sets_items().reset();
    origin_stmt->get_multi_rollup_items().reset();
    origin_stmt->get_aggr_items().reset();
    origin_stmt->get_group_exprs().reset();
    origin_stmt->get_rollup_exprs().reset();
    origin_stmt->get_having_exprs().reset();
    origin_stmt->get_table_items().reset();
    if (old_exprs.count() != 0 &&
        OB_FAIL(origin_stmt->replace_inner_stmt_expr(old_exprs, new_exprs))) {
      LOG_WARN("failed to replace inner stmt exprs.", K(ret));
    } else if (OB_FAIL(origin_stmt->get_table_items().push_back(view_table_item))) {
      LOG_WARN("add table item failed", K(ret));
    } else if (OB_FAIL(origin_stmt->rebuild_tables_hash())) {
      LOG_WARN("failed to rebuild tables hash.", K(ret));
    } else if (OB_FAIL(origin_stmt->update_column_item_rel_id())) {
      LOG_WARN("failed to update column items rel id.", K(ret));
    } else if (OB_FAIL(origin_stmt->formalize_stmt(ctx_->session_info_))) {
      LOG_WARN("failed to formalized stmt.", K(ret));
    } else {
      union_stmt = origin_stmt;
    }
  }
  return ret;
}

int ObTransformPreProcess::extract_stmt_replace_expr(ObSelectStmt *select_stmt,
                                                     ObIArray<ObRawExpr*> &old_exprs)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(select_stmt));
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_select_item_size(); i++) {
      if (OB_FAIL(extract_replace_expr_from_select_expr(select_stmt->get_select_item(i).expr_,
                                                        select_stmt,
                                                        old_exprs))) {
        LOG_WARN("failed to extract replace expr from select expr", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformPreProcess::extract_replace_expr_from_select_expr(ObRawExpr *expr,
                                                                 ObSelectStmt *select_stmt,
                                                                 ObIArray<ObRawExpr*> &old_exprs)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(expr));
  } else if (expr->is_aggr_expr() ||
             ObOptimizerUtil::find_item(select_stmt->get_group_exprs(), expr) ||
             ObOptimizerUtil::find_item(select_stmt->get_rollup_exprs(), expr) ||
             select_stmt->is_expr_in_groupings_sets_item(expr) ||
             select_stmt->is_expr_in_multi_rollup_items(expr)) {
    //here use find_equal_expr function, because same exprs in groupings set item have different ptr
    if (!ObOptimizerUtil::find_equal_expr(old_exprs, expr)) {
      if (OB_FAIL(old_exprs.push_back(expr))) {
        LOG_WARN("failed to push back expr", K(ret));
      } else {/*do nothing*/}
    }
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
      if (OB_FAIL(SMART_CALL(extract_replace_expr_from_select_expr(expr->get_param_expr(i),
                                                                   select_stmt,
                                                                   old_exprs)))) {
        LOG_WARN("failed to extract replace expr from select expr", K(ret));
      } else {/*do nothing*/}
    }
  }
  return ret;
}

int ObTransformPreProcess::create_set_view_stmt(ObSelectStmt *origin_stmt,
                                                ObSelectStmt *&set_view_stmt)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *groupby_stmt = NULL;
  ObSelectStmt *part_union_stmt = NULL;
  ObSelectStmt *temp_stmt = NULL;
  if (OB_ISNULL(origin_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("origin stmt is null", K(ret));
  } else if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->stmt_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("ctx or ctx stmt factory is null", K(ret));
  } else {
    /* as following to create set stmt:
     * 1. get total group by stmt count(grouping sets + multi rollup)
     * 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.
     */
    int64_t count = get_total_count_of_groupby_stmt(origin_stmt->get_grouping_sets_items(),
                                                    origin_stmt->get_multi_rollup_items());
    int64_t origin_groupby_num = origin_stmt->get_group_expr_size();
    if (OB_UNLIKELY(count < 1)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get unexpected error", K(ret), K(count));
    } else {
      // for grouping sets, we do the following transform. 
      /*
        T_OP_ADD           T_OP_ADD
        /  \       ->       /   \
      xxx  -1             xxx   T_OP_NEG
                                  \
                                  1
      so that 1 in  "select c1-1 from t1 group by grouping sets(c1,1);" share same expr.
      */
      if (OB_FAIL(ObTransformUtils::replace_stmt_expr_with_groupby_exprs(origin_stmt, ctx_))) {
          LOG_WARN("failed to replace stmt expr with groupby columns", K(ret));
      }
      for (int64_t i = 0; OB_SUCC(ret) && i < count; i++) {
        ObSEArray<ObGroupbyExpr, 4> groupby_exprs_list;
        bool is_happened = false;
        if (OB_FAIL(ctx_->stmt_factory_->create_stmt<ObSelectStmt>(groupby_stmt))) {
          LOG_WARN("failed to create stmt from ctx.", K(ret));
        } else if (OB_ISNULL(groupby_stmt)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("groupby stmt is null", K(ret));
        } else if (FALSE_IT(groupby_stmt->set_query_ctx(origin_stmt->get_query_ctx()))) {
        } else if (OB_FAIL(groupby_stmt->deep_copy(*ctx_->stmt_factory_,
                                                   *ctx_->expr_factory_,
                                                   *origin_stmt))) {
          LOG_WARN("failed to deep copy from stmt.", K(ret));
        } else if (OB_FAIL(get_groupby_exprs_list(groupby_stmt->get_grouping_sets_items(),
                                                  groupby_stmt->get_multi_rollup_items(),
                                                  groupby_exprs_list))) {
          LOG_WARN("failed to get groupby exprs list", K(ret));
        } else if (OB_UNLIKELY(i >= groupby_exprs_list.count())) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected error", K(i), K(groupby_exprs_list.count()), K(ret));
        } else if (OB_FAIL(append_array_no_dup(groupby_stmt->get_group_exprs(),
                                               groupby_exprs_list.at(i).groupby_exprs_))) {
          LOG_WARN("failed to assign the group exprs.", K(ret));
        } else {
          //stmt only reserve group by、having and aggr info
          groupby_stmt->get_order_items().reset();
          groupby_stmt->set_limit_offset(NULL, NULL);
          groupby_stmt->set_limit_percent_expr(NULL);
          groupby_stmt->set_fetch_with_ties(false);
          groupby_stmt->set_has_fetch(false);
          groupby_stmt->clear_sequence();
          groupby_stmt->set_select_into(NULL);
          groupby_stmt->get_grouping_sets_items().reset();
          groupby_stmt->get_multi_rollup_items().reset();
          groupby_stmt->get_window_func_exprs().reset();
          ObSEArray<ObRawExpr*, 4> old_exprs;
          ObSEArray<ObRawExpr*, 4> new_exprs;
          if (OB_FAIL(ObTransformUtils::replace_stmt_expr_with_groupby_exprs(groupby_stmt))) {
            LOG_WARN("failed to replace stmt expr with groupby columns", K(ret));
          } else if (OB_FAIL(create_select_list_from_grouping_sets(groupby_stmt,
                                                                   groupby_exprs_list,
                                                                   i,
                                                                   old_exprs,
                                                                   new_exprs,
                                                                   origin_groupby_num))) {
            LOG_WARN("failed to create select list from grouping sets.", K(ret));
          //why not use replace_inner_stmt_expr?, see this example:
          //select nvl(c1,1), c1, max(c1) from t1 grouping sets(nvl(c1,1), c1);
          } else if (OB_FAIL(replace_select_and_having_exprs(groupby_stmt,
                                                             old_exprs,
                                                             new_exprs,
                                                             groupby_exprs_list,
                                                             i,
                                                             origin_groupby_num))) {
             LOG_WARN("failed to replace select and having expr", K(ret));
          //select c1 from t1 group by grouping sets(c1, ());
          //<==>
          //select c1 from t1 group by c1 union all select NULL from t1 limit 1;
          } else if (!groupby_stmt->has_group_by() &&
                     OB_FAIL(ObTransformUtils::set_limit_expr(groupby_stmt, ctx_))) {
            LOG_WARN("add limit expr failed", K(ret));
          } else if (!groupby_stmt->has_group_by() &&
                     OB_FAIL(eliminate_having(groupby_stmt, is_happened))) {
            LOG_WARN("failed to eliminate having", 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 (i >= 1) {
            if (OB_FAIL(ObTransformUtils::create_set_stmt(ctx_, ObSelectStmt::UNION, false,
                                                          part_union_stmt, groupby_stmt,
                                                          temp_stmt))) {
              LOG_WARN("failed to create union stmt.", K(ret));
            } else if (OB_ISNULL(temp_stmt)) {
              ret = OB_ERR_UNEXPECTED;
              LOG_WARN("unexpected null", K(ret), K(temp_stmt));
            } else if (FALSE_IT(temp_stmt->set_query_ctx(origin_stmt->get_query_ctx()))) {
            } else if (OB_FAIL(temp_stmt->formalize_stmt(ctx_->session_info_))) {
              LOG_WARN("failed to formalize stmt.", K(ret));
            } else {
              part_union_stmt = temp_stmt;
            }
          } else if (i == 0) {
            part_union_stmt = groupby_stmt;
          } else { /*do nothing.*/ }
        }
      }
      set_view_stmt = part_union_stmt;
    }
  }
  if (OB_SUCC(ret)) {
    ObSEArray<ObRawExpr *, 4> select_exprs;
    /* 这里为了将union的select item命名，因为改写union之后的stmt的select item不会带名字
     * create select item中会将SEL_*的命名赋值给select item。
     */
    if (OB_FAIL(set_view_stmt->get_select_exprs(select_exprs))) {
      LOG_WARN("failed to get select exprs.", K(ret));
    } else if (FALSE_IT(set_view_stmt->get_select_items().reset())){
    } else if (OB_FAIL(ObTransformUtils::create_select_item(*ctx_->allocator_,
                                                            select_exprs,
                                                            set_view_stmt))) {
      LOG_WARN("failed to create select items.", K(ret));
    } else { /*do nothing.*/}
  }
  return ret;
}

int64_t ObTransformPreProcess::get_total_count_of_groupby_stmt(
                                                  ObIArray<ObGroupingSetsItem> &grouping_sets_items,
                                                  ObIArray<ObMultiRollupItem> &multi_rollup_items)
{
  int64_t cnt_grouping_sets = 1;
  int64_t cnt_multi_rollup = 1;
  for (int64_t i = 0; i < grouping_sets_items.count(); ++i) {
    int64_t tmp_count = 1;
    ObIArray<ObMultiRollupItem> &rollup_items = grouping_sets_items.at(i).multi_rollup_items_;
    for (int64_t j = 0; j < rollup_items.count(); ++j) {
      tmp_count = tmp_count * (rollup_items.at(j).rollup_list_exprs_.count() + 1);
    }
    cnt_grouping_sets = cnt_grouping_sets * (grouping_sets_items.at(i).grouping_sets_exprs_.count()
                                               + (tmp_count > 1 ? tmp_count : 0));
  }
  for (int64_t i = 0; i < multi_rollup_items.count(); ++i) {
    cnt_multi_rollup = cnt_multi_rollup * (multi_rollup_items.at(i).rollup_list_exprs_.count() + 1);
  }
  return cnt_grouping_sets * cnt_multi_rollup;
}

int ObTransformPreProcess::get_groupby_exprs_list(ObIArray<ObGroupingSetsItem> &grouping_sets_items,
                                                  ObIArray<ObMultiRollupItem> &multi_rollup_items,
                                                  ObIArray<ObGroupbyExpr> &groupby_exprs_list)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObGroupbyExpr, 4> grouping_sets_exprs_list;
  ObSEArray<ObGroupbyExpr, 4> multi_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_multi_rollup_items(multi_rollup_items, multi_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,
                                                 multi_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(multi_rollup_exprs_list),
                                                   K(groupby_exprs_list));
  }
  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;
  int64_t total_cnt = 1;
  typedef ObSEArray<ObGroupingSetsItem, 4> GroupingSetsArray;
  SMART_VAR(GroupingSetsArray, tmp_grouping_sets_items) {
    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).multi_rollup_items_.count());
    }
    if (OB_UNLIKELY(total_cnt < 1)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get unexpected error", K(ret), K(total_cnt), K(grouping_sets_items));
    } else if (OB_FAIL(tmp_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.multi_rollup_items_.count();
          index = bit_count % (item_count);
          bit_count = bit_count / (item_count);
          if (index < item.grouping_sets_exprs_.count()) {
            if (OB_FAIL(tmp_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 (OB_UNLIKELY(index - item.grouping_sets_exprs_.count() >=
                                                                  item.multi_rollup_items_.count())) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get unexpected error", K(ret));
          } else if (OB_FAIL(tmp_grouping_sets_items.at(i).multi_rollup_items_.push_back(
                          item.multi_rollup_items_.at(index - item.grouping_sets_exprs_.count())))) {
            LOG_WARN("failed to push back item", K(ret));
          } else {/*do nothing*/}
        }
      }
      if (OB_SUCC(ret)) {
        for (int64_t i = 0; OB_SUCC(ret) && i < total_cnt; ++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*/}
          }
          if (tmp_grouping_sets_items.at(i).multi_rollup_items_.count() > 0) {
            ObSEArray<ObGroupbyExpr, 4> groupby_exprs_list;
            if (OB_FAIL(expand_multi_rollup_items(tmp_grouping_sets_items.at(i).multi_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;
}

int ObTransformPreProcess::expand_multi_rollup_items(
                                                    ObIArray<ObMultiRollupItem> &multi_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 < multi_rollup_items.count(); ++i) {
    ObMultiRollupItem &multi_rollup_item = multi_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 < multi_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_,
                                  multi_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);
    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(create_connect_by_view(*select_stmt))) {
      LOG_WARN("failed to create connect by view", K(ret));
    } else if (OB_UNLIKELY(select_stmt->get_table_size() != 1)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect table size after create connect by view", K(select_stmt->get_table_size()), K(ret));
    } else if (OB_ISNULL(table = select_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 if (OB_FAIL(create_and_mock_join_view(*table->ref_query_))) {
      LOG_WARN("failed to transform from item", K(ret));
    } else {
      trans_happened = 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: https://code.aone.alibaba-inc.com/oceanbase/oceanbase/codereview/7518289 
    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(ObTransformUtils::extract_shared_expr(&stmt,
                                                             view_stmt,
                                                             shared_exprs))) {
      LOG_WARN("failed to extract shared expr", K(ret));
    } else if (OB_FAIL(append(select_list, shared_exprs))) {
      LOG_WARN("failed to append shared 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(view_stmt->adjust_subquery_list())) {
      LOG_WARN("failed to adjust subquery list", K(ret));
    } else if (OB_FAIL(view_stmt->adjust_subquery_stmt_parent(&stmt, view_stmt))) {
      LOG_WARN("failed to adjust sbuquery stmt parent", 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)) {
    stmt.get_table_items().pop_back();  //view的expr不递归替换
    if (OB_FAIL(stmt.replace_inner_stmt_expr(select_list, columns))) {
      LOG_WARN("failed to replace inner stmt expr", K(ret));
    } else if (OB_FAIL(stmt.get_table_items().push_back(table_item))) {
      LOG_WARN("failed to push back view table item", 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)) {
    if (OB_FAIL(left_view_stmt->get_condition_exprs().assign(stmt.get_condition_exprs()))) {
      LOG_WARN("failed to assign conditions", K(ret));
    } else {
      stmt.get_condition_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_start_with_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(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 (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));
    }
  }
  // 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)) {
    //为左右视图创建from item、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(stmt.add_from_item(left_table_item->table_id_))) {
      LOG_WARN("failed to add from item", 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(stmt.add_from_item(right_table_item->table_id_))) {
      LOG_WARN("failed to add from item", 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)) {
    ObRawExprCopier copier(*expr_factory);
    ReplaceRownumRowidExpr replacer(left_view_stmt);
    if (OB_FAIL(copier.copy_on_replace(stmt.get_start_with_exprs(),
                                       stmt.get_start_with_exprs(),
                                       &replacer))) {
      LOG_WARN("failed to copy on replace start with exprs", K(ret));
    } else if (OB_FAIL(left_view_stmt->add_condition_exprs(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(left_view_stmt->adjust_subquery_stmt_parent(&stmt,
                                                                   left_view_stmt))) {
      LOG_WARN("failed to adjust sbuquery stmt parent", 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(right_view_stmt->adjust_subquery_stmt_parent(&stmt,
                                                                    right_view_stmt))) {
      LOG_WARN("failed to adjust sbuquery stmt parent", 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 {
      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. do replace and formalize
  if (OB_SUCC(ret)) {
    stmt.get_table_items().pop_back();
    stmt.get_table_items().pop_back();
    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 (OB_FAIL(stmt.replace_inner_stmt_expr(select_list, right_columns))) {
      LOG_WARN("failed to replace inner stmt expr", K(ret));
    } else if (OB_FAIL(stmt.get_table_items().push_back(left_table_item))) {
      LOG_WARN("failed to push back view table item", K(ret));
    } else if (OB_FAIL(stmt.get_table_items().push_back(right_table_item))) {
      LOG_WARN("failed to push back view table item", 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));
    }
  }
  // 10. 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;
}

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_and_levels())) {
        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)) {
                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))) {
              LOG_WARN("add filter for temporary table failed", K(ret));
            } else {
              trans_happened = true;
            }
          } else if(OB_FAIL(ObTransformUtils::create_view_with_table(stmt, ctx_, table_item,
                                                                     view_table))) {
            LOG_WARN("failed to create view with table", 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))) {
            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)
{
  int ret = OB_SUCCESS;
  ObRawExpr *equal_expr = NULL;
  ObConstRawExpr *expr_const = NULL;
  ObColumnRefRawExpr *expr_col = 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_));
  }
   else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_UINT64, expr_const))) {
    LOG_WARN("create const raw expr failed", K(ret));
  } else if (OB_ISNULL(expr_const)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr is null", K(expr_col), K(expr_const), K(ret));
  } else {
    ObObj sid_obj;
    ColumnItem *exist_col_item = NULL;
    sid_obj.set_int(ctx_->session_info_->get_sessid_for_table());
    expr_const->set_value(sid_obj);
    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_SYSCONST);
        expr_col->set_result_type(result_type);
        expr_col->set_expr_level(stmt.get_current_level());
        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_FAIL(ret)) {
      //do nothing
    } else if (OB_FAIL(ObRawExprUtils::create_equal_expr(*(ctx_->expr_factory_),
                                                        ctx_->session_info_,
                                                        expr_const,
                                                        expr_col,
                                                        equal_expr))) {
      LOG_WARN("Creation of equal expr for outer stmt fails", K(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;
}

//递归收集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;
}


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;
  ObSEArray<SelectItem, 4> select_item_array;
  ObSEArray<ObAggFunRawExpr *, 4> aggr_expr_array;
  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_current_level(),
                                                    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(sub_stmt->get_current_level(),
                                                    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_for_grouping_sets_and_multi_rollup:
    //  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_for_grouping_sets_and_multi_rollup(dml_stmt, is_happened))) {
      LOG_WARN("failed to transform for transform for grouping sets and multi rollup.", K(ret));
    } else if (is_happened) {
      sub_stmt = static_cast<ObSelectStmt *>(dml_stmt);
      LOG_TRACE("succeed to transform for grouping sets and multi 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_having_exprs().reset();
    select_stmt->get_order_items().reset();
    select_stmt->get_group_exprs().reset();
    select_stmt->get_rollup_exprs().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_grouping_sets_items().reset();
    select_stmt->get_multi_rollup_items().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_inner_stmt_expr(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);
    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 (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 {
      merge_stmt->get_match_condition_exprs().reset();
      trans_happened = true;
    }
  }
  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;
    if (OB_FAIL(stmt->get_relation_exprs(relation_exprs))) {
      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));
    }
  }
  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(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
  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;
}

/*@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;
  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(stmt, limit_expr))) {
    LOG_WARN("failed to try transform rownum expr as limit", K(ret));
  } else if (NULL == limit_expr) {
    /*do nothing */
  //不含有order by的update/delete stmt不用再进行分离spj
  } else if (!stmt->is_select_stmt() && !stmt->has_order_by()) {
    stmt->set_limit_offset(limit_expr, NULL);
    trans_happened = true;
  } 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);
    trans_happened = true;
  }
  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(ObDMLStmt *stmt, ObRawExpr *&limit_expr)
{
  int ret = OB_SUCCESS;
  limit_expr = NULL;
  ObRawExpr *limit_value = NULL;
  ObItemType op_type = T_INVALID;
  bool is_valid = false;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)
      || OB_ISNULL(ctx_->session_info_)) {
    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;
      }
    }

    if (OB_SUCC(ret) && is_valid) {
      ObRawExpr *eq_expr = NULL;
      ObConstRawExpr *zero_expr = NULL;
      ObConstRawExpr *one_expr = NULL;
      if (OB_UNLIKELY(expr_idx < 0 || expr_idx >= conditions.count())) {
        ret = OB_INVALID_ARGUMENT;
        LOG_WARN("expr index is invalid", K(ret), K(expr_idx), K(conditions.count()));
      } 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;
        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(ObRawExprUtils::build_case_when_expr_for_limit(*ctx_->expr_factory_,
                                                                          int_expr, limit_expr))) {
          LOG_WARN("failed to build case when expr for limit", 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::build_common_binary_op_expr(*ctx_->expr_factory_,
                                                                     T_OP_EQ,
                                                                     limit_value,
                                                                     one_expr,
                                                                     eq_expr))) {
        LOG_WARN("failed to build common binary op expr", K(ret));
      } else if (OB_FAIL(ObRawExprUtils::build_case_when_expr(*ctx_->expr_factory_,
                                                              eq_expr,
                                                              one_expr,
                                                              zero_expr,
                                                              limit_expr))) {
        LOG_WARN("failed to build case when expr", K(ret));
      }
    }
    if (OB_SUCC(ret) && NULL != limit_expr) {
      //添加 cast 作用:
      //  1.对于新引擎, 必须保证输出结果为 int
      //  2.目前单独的 case when 无法预计算, 分配了 cast 后能够进行预计算
      ObExprResType dst_type;
      dst_type.set_int();
      ObSysFunRawExpr *cast_expr = NULL;
      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;
      }
    }
  }
  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 *upper_offset = NULL;
  ObRawExpr *upper_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,
                                                                    upper_limit, upper_offset))) {
    LOG_WARN("failed to try transform generated rownum as offset offset", K(ret));
  } else if (NULL == upper_limit && NULL == upper_offset) {
    /*do nothing*/
  } else if (OB_FAIL(ObTransformUtils::merge_limit_offset(ctx_, stmt->get_limit_expr(), upper_limit,
                                                          stmt->get_offset_expr(), upper_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_)) {
    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 *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(cond_expr = upper_conds.at(j))) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get unexpected null", K(ret));
          } else if (cond_expr->is_op_expr() && 2 == cond_expr->get_param_count() &&
                     (IS_RANGE_CMP_OP(cond_expr->get_expr_type())
                      || T_OP_EQ == cond_expr->get_expr_type())) {
            ObRawExpr *param1 = cond_expr->get_param_expr(0);
            ObRawExpr *param2 = 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 = 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(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 = 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 = 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 = cond_expr;
            }
          }
        }
      }
    }

    ObRawExpr *init_limit_expr = NULL;
    ObRawExpr *init_offset_expr = NULL;
    ObRawExpr *minus_expr = NULL;
    if (OB_FAIL(ret)) {
    } 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_eq_cond) {
      ret = transform_generated_rownum_eq_cond(limit_value, limit_expr, 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))) {
      LOG_WARN("failed to create limit expr from rownum", K(ret));
    } else if (NULL != limit_value &&
               OB_FAIL(ObRawExprUtils::build_case_when_expr_for_limit(*ctx_->expr_factory_,
                                                                      init_limit_expr,
                                                                      init_limit_expr))) {
      LOG_WARN("failed to build case when expr for limit", 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))) {
      LOG_WARN("failed to create limit expr from rownum", K(ret));
    } else if (NULL != offset_value &&
               OB_FAIL(ObRawExprUtils::build_case_when_expr_for_limit(*ctx_->expr_factory_,
                                                                      init_offset_expr,
                                                                      init_offset_expr))) {
      LOG_WARN("failed to build case when expr for limit", K(ret));
    } else if (NULL == init_offset_expr || NULL == init_limit_expr) {
      limit_expr = init_limit_expr;
      offset_expr = init_offset_expr;
    } 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))) {
      LOG_WARN("failed to create double op expr", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::build_case_when_expr_for_limit(*ctx_->expr_factory_,
                                                                      minus_expr,
                                                                      limit_expr))) {
      LOG_WARN("failed to build case when expr for limit", K(ret));
    } else {
      offset_expr = init_offset_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;
  ObRawExpr *cmp_gt_expr = NULL;
  ObRawExpr *cmp_eq_expr = NULL;
  ObRawExpr *and_expr = NULL;
  ObConstRawExpr *zero_expr = NULL;
  ObConstRawExpr *one_expr = NULL;
  ObSysFunRawExpr *floor_expr = NULL;
  if (OB_ISNULL(eq_value) || 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 (!eq_value->get_result_type().is_integer_type()
             && !eq_value->get_result_type().is_number()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected eq_value", K(ret), K(*eq_value));
  } 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(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(ObRawExprUtils::build_common_binary_op_expr(*ctx_->expr_factory_, T_OP_GT,
                                                                 eq_value, zero_expr,
                                                                 cmp_gt_expr))) {
    LOG_WARN("failed to build common binary op expr", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::build_common_binary_op_expr(*ctx_->expr_factory_, T_OP_EQ,
                                                                 eq_value, floor_expr,
                                                                 cmp_eq_expr))) {
    LOG_WARN("failed to build common binary op expr", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::build_common_binary_op_expr(*ctx_->expr_factory_, T_OP_AND,
                                                                 cmp_gt_expr, cmp_eq_expr,
                                                                 and_expr))) {
    LOG_WARN("failed to build common binary op expr", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::build_case_when_expr(*ctx_->expr_factory_, and_expr,
                                                          one_expr, zero_expr, limit_expr))) {
    LOG_WARN("failed to build case when expr", K(ret));
  } else if (OB_FAIL(ObRawExprUtils::build_case_when_expr(*ctx_->expr_factory_, and_expr,
                                                          minus_expr, zero_expr, offset_expr))) {
    LOG_WARN("failed to build case when expr", K(ret));
  }
  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_inner_stmt_expr(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());
            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;

  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 (insert_stmt->is_insert_up() || insert_stmt->is_replace()) {
    ret = OB_BATCHED_MULTI_STMT_ROLLBACK;
    LOG_WARN("insert on duplicate key and replace is not support batch now", K(ret), KPC(batch_stmt));
  } else if (insert_stmt->value_from_select()) {
    ret = OB_BATCHED_MULTI_STMT_ROLLBACK;
    LOG_TRACE("insert select stmt not supported batch exec opt", K(ret), KPC(batch_stmt));
  } else {
    // insert values stmt
    ObSEArray<ObRawExpr*, 4> params;
    ObPseudoColumnRawExpr *stmt_id_expr = NULL;
    common::ObIArray<ObColumnRefRawExpr*> &value_desc = insert_stmt->get_values_desc();
    common::ObIArray<ObRawExpr*> &value_vector = insert_stmt->get_values_vector();
    int64_t row_count = value_vector.count() / value_desc.count();
    if (row_count > 1) {
      ret = OB_BATCHED_MULTI_STMT_ROLLBACK;
      LOG_TRACE("insert stmt with multi rows not supported batch exec", K(ret), KPC(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(value_vector, params))) {
      LOG_WARN("extract param expr from related exprs failed", K(ret));
    } else {
      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(stmt_factory = ctx_->stmt_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ctx_), 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_current_level(batch_stmt->get_current_level());
    inner_view_stmt->set_parent_namespace_stmt(batch_stmt->get_parent_namespace_stmt());
    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()->multi_stmt_item_.is_batched_multi_stmt()) {
    //rewrite only when stmt is batch multi statement
  } else if (!batch_stmt->is_dml_write_stmt()) {
    ret = OB_BATCHED_MULTI_STMT_ROLLBACK;
    LOG_TRACE("only DML Stmt without subquery supports batch execution, need to rollback",
              K(ret), K(batch_stmt->get_stmt_type()));
  } else if (stmt_type == stmt::T_UPDATE || stmt_type == stmt::T_DELETE) {
    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) {
    // insert的改写
    ObSQLSessionInfo *session_info = NULL;
    if (OB_ISNULL(session_info = ctx_->session_info_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("session is null", K(ret));
    } 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::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;
  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_FAIL(batch_stmt->replace_inner_stmt_expr(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;
    ObRawExpr *ab_stmt_id = view_columns.at(view_columns.count() - 1);
    static_cast<ObDelUpdStmt*>(batch_stmt)->set_ab_stmt_id_expr(ab_stmt_id);
    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 (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;
  int64_t child_stmts_size = 0;

  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_FAIL(batch_stmt.get_child_stmt_size(child_stmts_size))) {
    LOG_WARN("get child_stmt size failed", K(ret));
  } else if (child_stmts_size != 0) {
    ret = OB_BATCHED_MULTI_STMT_ROLLBACK;
    LOG_WARN("for delete or update batch exec, child_stmt_size != 0", K(ret), K(child_stmts_size));
  } else {
    param_store = &plan_ctx->get_param_store();
    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));
    }
  }
  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_batch_parameters()
        && !has_exist_in_array(batch_stmt.get_query_ctx()->ab_param_exprs_,
                               static_cast<ObRawExpr*>(param_expr))) {
      ObPseudoColumnRawExpr *group_param_expr = nullptr;
      ObSqlArrayObj *array_obj = reinterpret_cast<ObSqlArrayObj*>(param_store->at(param_idx).get_ext());
      //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::recursively_eliminate_full_join(ObDMLStmt &stmt,
                                                          TableItem &table_item,
                                                          bool &trans_happened)
{
  int ret = OB_SUCCESS;
  JoinedTable *joined_table = NULL;
  TableItem *view_table = NULL;
  bool has_euqal = false;
  bool has_subquery = false;
  if (!table_item.is_joined_table()) {
    /* do nothing */
  } else if (OB_FALSE_IT(joined_table = static_cast<JoinedTable*>(&table_item))) {
  } else if (OB_ISNULL(joined_table->left_table_) || OB_ISNULL(joined_table->right_table_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null.", K(ret));
  } 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(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::create_view_with_table(&stmt, ctx_, joined_table,
                                                              view_table))) {
    LOG_WARN("failed to create view with table", K(ret));
  } 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;
  }
  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;
  TableItem *view_item = NULL;
  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() &&
             OB_FAIL(ObTransformUtils::create_view_with_table(sub_stmt, ctx_,
                                              joined_table->left_table_, view_item))) {
    LOG_WARN("failed to create view with table", K(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;
    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 (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;
}

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