/**
 * 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 "ob_transform_temp_table.h"
#include "lib/allocator/ob_allocator.h"
#include "lib/hash/ob_hashmap.h"
#include "lib/oblog/ob_log_module.h"
#include "common/ob_common_utility.h"
#include "sql/resolver/expr/ob_raw_expr.h"
#include "sql/resolver/expr/ob_raw_expr_util.h"
#include "sql/resolver/dml/ob_dml_stmt.h"
#include "sql/resolver/dml/ob_select_stmt.h"
#include "sql/optimizer/ob_optimizer_util.h"
#include "sql/rewrite/ob_predicate_deduce.h"
#include "common/ob_smart_call.h"
#include "sql/optimizer/ob_optimizer.h"
#include "sql/optimizer/ob_optimizer_context.h"
#include "sql/optimizer/ob_log_plan.h"
#include "ob_transform_min_max.h"

using namespace oceanbase::common;

namespace oceanbase
{
namespace sql
{

typedef ObDMLStmt::TempTableInfo TempTableInfo;

ObTransformTempTable::~ObTransformTempTable()
{
  if (OB_NOT_NULL(trans_param_)) {
    trans_param_->~TempTableTransParam();
    trans_param_ = NULL;
  }
}

int ObTransformTempTable::transform_one_stmt(common::ObIArray<ObParentDMLStmt> &parent_stmts,
                                             ObDMLStmt *&stmt,
                                             bool &trans_happened)
{
  int ret = OB_SUCCESS;
  bool is_happened = false;
  //当前stmt是root stmt时才改写
  if (parent_stmts.empty()) {
    is_happened = false;
    void *buf = NULL;
    if (OB_UNLIKELY(NULL != trans_param_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected trans param", K(ret));
    } else if(OB_ISNULL(buf = allocator_.alloc(sizeof(TempTableTransParam)))) {
      ret = OB_ALLOCATE_MEMORY_FAILED;
      LOG_WARN("failed to allocate memory", K(ret));
    } else {
      trans_param_ = new(buf)TempTableTransParam;
    }

    if (OB_SUCC(ret)) {
      if (OB_FAIL(generate_with_clause(stmt, is_happened))) {
        LOG_WARN("failed to generate with clause", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("generate with clause:", is_happened);
        LOG_TRACE("succeed to generate with clause",  K(is_happened));
      }
    }

    ObArray<TempTableInfo> temp_table_infos;
    if (OB_SUCC(ret)) {
      if (OB_FAIL(stmt->collect_temp_table_infos(temp_table_infos))) {
        LOG_WARN("failed to collect temp table infos", K(ret));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(project_pruning(temp_table_infos, is_happened))) {
        LOG_WARN("failed to do project pruning for temp table", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("project pruning for temp table:", is_happened);
        LOG_TRACE("succeed to do project pruning for temp table", K(temp_table_infos),  K(is_happened));
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(expand_temp_table(temp_table_infos, is_happened))) {
        LOG_WARN("failed to expand temp table", K(ret));
      } else {
        trans_happened |= is_happened;
        OPT_TRACE("expand temp table:", is_happened);
        LOG_TRACE("succeed to expand temp table",  K(is_happened));
      }
    }
  }
  return ret;
}

int ObTransformTempTable::check_stmt_size(ObDMLStmt *stmt, int64_t &total_size, bool &stmt_oversize)
{
  int ret = OB_SUCCESS;
  int64_t size = 0;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("check stmt size failed", K(ret));
  } else if (stmt->is_select_stmt() &&
      static_cast<const ObSelectStmt *>(stmt)->is_set_stmt() &&
        OB_FAIL(static_cast<const ObSelectStmt *>(stmt)->get_set_stmt_size(size))) {
    LOG_WARN("failed to get set stm size", K(ret));
  } else if (OB_FALSE_IT(total_size = total_size + size)) {
  } else if (total_size > common::OB_MAX_SET_STMT_SIZE) {
    stmt_oversize = true;
  } else {
    ObSEArray<ObSelectStmt*, 16> child_stmts;
    if (OB_FAIL(stmt->get_child_stmts(child_stmts))) {
      LOG_WARN("get child stmt failed", K(ret));
    }
    for (int64_t i = 0; OB_SUCC(ret) && !stmt_oversize && i < child_stmts.count(); i++) {
      if (OB_FAIL(SMART_CALL(check_stmt_size(child_stmts.at(i), total_size, stmt_oversize)))) {
        LOG_WARN("check stmt size failed", K(ret));
      }
    }
  }
  return ret;
}
int ObTransformTempTable::generate_with_clause(ObDMLStmt *&stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObSelectStmt*, 8> child_stmts;
  ObSEArray<ObSelectStmt*, 8> non_correlated_stmts;
  ObArray<TempTableInfo> temp_table_infos;
  hash::ObHashMap<uint64_t, ObParentDMLStmt> parent_map;
  trans_happened = false;
  bool enable_temp_table_transform = false;
  bool force_temp_table_inline = false;
  bool has_hint = false;
  bool is_hint_enabled = false;
  ObSQLSessionInfo *session_info = NULL;
  if (OB_ISNULL(ctx_) || OB_ISNULL(stmt) || OB_ISNULL(stmt->get_query_ctx()) ||
      OB_ISNULL(session_info = ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null param", K(ctx_), K(ret));
  } else if (OB_FAIL(session_info->is_temp_table_transformation_enabled(enable_temp_table_transform))) {
    LOG_WARN("failed to check temp table transform enabled", K(ret));
  } else if (OB_FAIL(session_info->is_force_temp_table_inline(force_temp_table_inline))) {
    LOG_WARN("failed to check temp table force inline", K(ret));
  } else if (OB_FAIL(stmt->get_query_ctx()->get_global_hint().opt_params_.get_bool_opt_param(
              ObOptParamHint::XSOLAPI_GENERATE_WITH_CLAUSE, is_hint_enabled, has_hint))) {
    LOG_WARN("failed to check has opt param", K(ret));
  } else if (has_hint) {
    enable_temp_table_transform = is_hint_enabled;
  }
  if (OB_FAIL(ret)) {
  } else if (ctx_->is_set_stmt_oversize_) {
    OPT_TRACE("stmt containt oversize set stmt");
  } else if (!enable_temp_table_transform || force_temp_table_inline) {
    OPT_TRACE("session variable disable temp table transform");
  } else if (OB_FAIL(parent_map.create(128, "TempTable"))) {
    LOG_WARN("failed to init stmt map", K(ret));
  } else if (OB_FAIL(ObTransformUtils::get_all_child_stmts(stmt, child_stmts, &parent_map))) {
    LOG_WARN("failed to get all child stmts", K(ret));
  } else if (OB_FAIL(get_non_correlated_subquery(stmt, non_correlated_stmts))) {
    LOG_WARN("failed to get non correlated subquery", K(ret));
  } else if (OB_FAIL(ObOptimizerUtil::intersect(child_stmts, non_correlated_stmts, child_stmts))) {
    LOG_WARN("failed to intersect child stmts", K(ret));
  } else if (OB_FAIL(extract_common_subquery_as_cte(stmt, child_stmts, parent_map, trans_happened))) {
    LOG_WARN("failed to extract common subquery as cte", K(ret));
  } else if (OB_FAIL(parent_map.destroy())) {
    LOG_WARN("failed to destroy map", K(ret));
  }
  return ret;
}

/**
 * @brief expand_temp_table
 * 如果temp table只被引用一次或者temp table是一个简单的查询
 * 例如单表查询，那么需要展开temp table，还原成generate table
 */
int ObTransformTempTable::expand_temp_table(ObIArray<TempTableInfo> &temp_table_info,
                                            bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  bool system_force_inline_cte = false;
  bool system_force_materialize_cte = false;
  ObSQLSessionInfo *session_info = NULL;
  if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->stmt_factory_) ||
      OB_ISNULL(ctx_->allocator_) || OB_ISNULL(ctx_->expr_factory_) ||
      OB_ISNULL(session_info = ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null param", K(ctx_), K(ret));
  } else if (OB_FAIL(session_info->is_force_temp_table_inline(system_force_inline_cte))) {
    LOG_WARN("failed to check temp table force inline", K(ret));
  } else if (OB_FAIL(session_info->is_force_temp_table_materialize(system_force_materialize_cte))) {
    LOG_WARN("failed to check temp table force materialize", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < temp_table_info.count(); ++i) {
    TempTableInfo &helper = temp_table_info.at(i);
    bool can_materia = false;
    bool force_materia = false;
    bool force_inline = false;
    bool is_oversize_stmt = false;
    int64_t stmt_size = 0;
    bool need_expand = false;
    OPT_TRACE("try to expand temp table:", helper.temp_table_query_);
    if (OB_ISNULL(helper.temp_table_query_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null ref query", K(helper), K(ret));
    } else if (OB_FAIL(check_stmt_size(helper.temp_table_query_, stmt_size, is_oversize_stmt))) {
      LOG_WARN("check stmt size failed", K(ret));
    } else if (OB_FAIL(check_hint_allowed_trans(*helper.temp_table_query_,
                                                force_inline,
                                                force_materia))) {
      LOG_WARN("failed to check force materialize", K(ret));
    } else if (force_inline) {
      need_expand = true;
      OPT_TRACE("hint force inline CTE");
    } else if (force_materia) {
      //do nothing
      OPT_TRACE("hint force materialize CTE");
    } else if (is_oversize_stmt) {
      //do nothing
      OPT_TRACE("CTE too large to expand");
    } else if (system_force_materialize_cte) {
      //do nothing
      OPT_TRACE("system variable force materialize CTE");
    } else if (system_force_inline_cte) {
      need_expand = true;
      OPT_TRACE("system variable force inline CTE");
    } else if (1 == helper.table_items_.count()) {
      need_expand = true;
      OPT_TRACE("CTE`s refer once, force inline");
    } else if (OB_FAIL(check_stmt_can_materialize(helper.temp_table_query_, true, can_materia))) {
      LOG_WARN("failed to check extract cte valid", K(ret));
    } else if (!can_materia) {
      need_expand = true;
      OPT_TRACE("transform rule force inline CTE");
    }
    if (OB_SUCC(ret) && need_expand) {
      //深拷贝每一份查询，还原成generate table
      ObDMLStmt *orig_stmt = helper.temp_table_query_;
      if (OB_FAIL(ObTransformUtils::expand_temp_table(ctx_, helper))) {
        LOG_WARN("failed to extend temp table", K(ret));
      } else if (OB_FAIL(add_normal_temp_table_trans_hint(*orig_stmt, T_INLINE))) {
        LOG_WARN("failed to add transform hint", K(ret));
      } else {
        trans_happened = true;
      }
    }
  }
  return ret;
}

int ObTransformTempTable::check_stmt_can_materialize(ObSelectStmt *stmt, bool is_existing_cte, bool &is_valid)
{
  int ret = OB_SUCCESS;
  is_valid = true;
  bool has_cross_product = false;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null", K(ret));
  } else if (0 == stmt->get_table_items().count() &&
             !stmt->is_set_stmt()) {
    //expression stmt不允许物化
    is_valid = false;
    OPT_TRACE("expression stmt can not materialize")
  } else if (1 == stmt->get_table_items().count()) {
    if (is_existing_cte) {
      TableItem *table = stmt->get_table_item(0);
      if (stmt->has_group_by() ||
          stmt->has_limit() ||
          stmt->has_window_function() ||
          table->is_generated_table()) {
        is_valid = true;
      } else {
        is_valid = false;
        OPT_TRACE("single table cte will not be materialized");
      }
    } else {
      // Currently, we will not push `limit` in stmt into cte
      ObAggFunRawExpr *dummy = NULL;
      bool can_use_fast_min_max = false;
      STOP_OPT_TRACE;
      if (ObTransformMinMax::check_transform_validity(*ctx_, stmt, dummy, can_use_fast_min_max)) {
        LOG_WARN("failed to check fast min max", K(ret));
      }
      RESUME_OPT_TRACE;
      if (OB_FAIL(ret)) {
      } else if (can_use_fast_min_max) {
        is_valid = false;
        OPT_TRACE("fast min max query will not be materialized");
      } else if (stmt->has_group_by() ||
                 stmt->has_window_function()) {
        is_valid = true;
      } else {
        is_valid = false;
        OPT_TRACE("single table query without aggr/win will not be materialized");
      }
    }
  } else if (OB_FAIL(check_stmt_has_cross_product(stmt, has_cross_product))) {
    LOG_WARN("failed to check has cross product", K(ret));
  } else if (has_cross_product) {
    is_valid = false;
    OPT_TRACE("stmt has cross produce, will not be materialized");
  }
  return ret;
}

int ObTransformTempTable::check_stmt_has_cross_product(ObSelectStmt *stmt, bool &has_cross_product)
{
  int ret = OB_SUCCESS;
  has_cross_product = false;
  ObSEArray<ObRawExpr*, 4> on_conditions;
  ObSqlBitSet<> table_ids;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null stmt", K(ret));
  } else if (stmt->is_set_stmt()) {
    ObIArray<ObSelectStmt*> &set_query = stmt->get_set_query();
    //继续检查set op的每个分支
    for (int64_t i = 0; OB_SUCC(ret) && !has_cross_product && i < set_query.count(); ++i) {
      if (OB_FAIL(SMART_CALL(check_stmt_has_cross_product(set_query.at(i),
                                                          has_cross_product)))) {
        LOG_WARN("failed to check stmt condition", K(ret));
      }
    }
  } else if (stmt->is_hierarchical_query()) {
    //层次查询在post process之前都是笛卡尔积，可忽略
  } else if (0 == stmt->get_table_items().count()) {
    has_cross_product = true;
  } else if (1 == stmt->get_table_items().count()) {
    //do nothing
  } else if (OB_FAIL(ObTransformUtils::get_on_conditions(*stmt, on_conditions))) {
    LOG_WARN("failed to get on conditions", K(ret));
  } else {
    ObIArray<ObRawExpr*> &where_conditions = stmt->get_condition_exprs();
    //收集连接条件引用的所有表
    for (int64_t i = 0; OB_SUCC(ret) && i < where_conditions.count(); ++i) {
      ObRawExpr *expr = where_conditions.at(i);
      if (OB_ISNULL(expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null expr", K(ret));
      } else if (!expr->has_flag(IS_JOIN_COND)) {
        //do nothing
      } else if (OB_FAIL(table_ids.add_members(expr->get_relation_ids()))) {
        LOG_WARN("failed to add relation ids", K(ret));
      }
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < on_conditions.count(); ++i) {
      ObRawExpr *expr = on_conditions.at(i);
      if (OB_ISNULL(expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null expr", K(ret));
      } else if (expr->get_relation_ids().num_members() < 2) {
        //do nothing
      } else if (OB_FAIL(table_ids.add_members(expr->get_relation_ids()))) {
        LOG_WARN("failed to add relation ids", K(ret));
      }
    }
    const ObIArray<SemiInfo*> &semi_infos = stmt->get_semi_infos();
    for (int64_t i = 0; OB_SUCC(ret) && i < semi_infos.count(); ++i) {
      const SemiInfo *info = semi_infos.at(i);
      if (OB_ISNULL(info)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null semi info", K(ret));
      }
      for (int64_t j = 0; OB_SUCC(ret) && j < info->semi_conditions_.count(); ++j) {
        const ObRawExpr *expr = info->semi_conditions_.at(j);
        if (OB_ISNULL(expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("unexpect null expr", K(ret));
        } else if (expr->get_relation_ids().num_members() < 2) {
          //do nothing
        } else if (OB_FAIL(table_ids.add_members(expr->get_relation_ids()))) {
          LOG_WARN("failed to add relation ids", K(ret));
        }
      }
    }
    //如果有表没有被连接条件引用，说明有笛卡尔积出现
    for (int64_t i = 0; OB_SUCC(ret) && !has_cross_product && i < stmt->get_table_items().count(); ++i) {
      TableItem *table = stmt->get_table_item(i);
      if (OB_ISNULL(table)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null table item", K(ret));
      } else if (!table_ids.has_member(stmt->get_table_bit_index(table->table_id_))) {
        //has cross product
        has_cross_product = true;
      } else if (!table->is_generated_table()) {
        //do nothing
      } else if (OB_FAIL(SMART_CALL(check_stmt_has_cross_product(table->ref_query_,
                                                                 has_cross_product)))) {
        LOG_WARN("failed to check stmt condition", K(ret));
      }
    }
  }
  return ret;
}

/**
 * @brief extract_common_subquery_as_cte
 * 比较当前stmt的所有child stmt，
 * 把所有相似的stmt分为一组，抽离最大的公共部分作为temp table
 */
int ObTransformTempTable::extract_common_subquery_as_cte(ObDMLStmt *stmt,
                                                         ObIArray<ObSelectStmt*> &stmts,
                                                         hash::ObHashMap<uint64_t, ObParentDMLStmt> &parent_map,
                                                         bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  ObSEArray<StmtClassifyHelper, 8> stmt_groups;
  const ObQueryHint *query_hint = NULL;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_) || OB_ISNULL(trans_param_)
      || OB_ISNULL(query_hint = stmt->get_stmt_hint().query_hint_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null stmt", K(ret));
  } else if (OB_FAIL(remove_simple_stmts(stmts))) {
    LOG_WARN("failed to remove simple stmts", K(ret));
  } else if (OB_FAIL(classify_stmts(stmts, stmt_groups))) {
    LOG_WARN("failed to sort stmts", K(ret));
  }
  //对每一组stmt抽离公共部分
  for (int64_t i = 0; OB_SUCC(ret) && i < stmt_groups.count(); ++i) {
    bool is_happened = false;
    if (OB_FAIL(inner_extract_common_subquery_as_cte(*stmt,
                                                     stmt_groups.at(i).stmts_, 
                                                     parent_map,
                                                     is_happened))) {
      LOG_WARN("failed to convert temp table", K(ret));
    } else {
      trans_happened |= is_happened;
    }
  }
  if (OB_SUCC(ret) && trans_happened) {
    trans_param_->trans_type_ = T_MATERIALIZE;
    if (OB_FAIL(add_transform_hint(*stmt, trans_param_))) {
      LOG_WARN("failed to add hint", K(ret));
    } else if (query_hint->has_outline_data()) {
      ++ctx_->trans_list_loc_;
    }
  }
  return ret;
}

/**
 * @brief inner_extract_common_subquery_as_cte
 * stmt之间两两比较，分成多个相似组，
 * 对每组相似stmt创建temp table
 */
int ObTransformTempTable::inner_extract_common_subquery_as_cte(ObDMLStmt &root_stmt,
                                                               ObIArray<ObSelectStmt*> &stmts,
                                                               hash::ObHashMap<uint64_t, ObParentDMLStmt> &parent_map,
                                                               bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObStmtMapInfo map_info;
  QueryRelation relation;
  typedef ObSEArray<StmtCompareHelper, 8> StmtCompareHelperArray;
  SMART_VAR(StmtCompareHelperArray, compare_info) {
    //计算相似stmt分组
    if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->allocator_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null param", K(ret));
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < stmts.count(); ++i) {
      bool find_similar = false;
      ObSelectStmt *stmt = stmts.at(i);
      if (OB_ISNULL(stmt)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null stmt ", K(ret));
      }
      for (int64_t j = 0; OB_SUCC(ret) && !find_similar && j < compare_info.count(); ++j) {
        map_info.reset();
        bool has_stmt = false;
        bool is_valid = false;
        StmtCompareHelper &helper = compare_info.at(j);
        bool check_basic_similarity = !helper.hint_force_stmt_set_.empty() &&
                                      helper.hint_force_stmt_set_.has_qb_name(stmt);
        if (OB_FAIL(check_has_stmt(helper.similar_stmts_,
                                   stmt,
                                   parent_map,
                                   has_stmt))) {
          LOG_WARN("failed to check has stmt", K(ret));
        } else if (has_stmt) {
          //do nothing
        } else if (OB_FAIL(ObStmtComparer::check_stmt_containment(helper.stmt_,
                                                                  stmt,
                                                                  map_info,
                                                                  relation))) {
          LOG_WARN("failed to check stmt containment", K(ret));
        } else if (OB_FAIL(check_stmt_can_extract_temp_table(helper.stmt_,
                                                             stmt,
                                                             map_info,
                                                             relation,
                                                             check_basic_similarity,
                                                             is_valid))) {
          LOG_WARN("failed to check is similar stmt");
        } else if (!is_valid) {
          //do nothing
        } else if (OB_FAIL(helper.similar_stmts_.push_back(stmt))) {
          LOG_WARN("failed to push back stmt", K(ret));
        } else if (OB_FAIL(helper.stmt_map_infos_.push_back(map_info))) {
          LOG_WARN("failed to push back map info", K(ret));
        } else {
          find_similar = true;
        }
      }
      if (OB_SUCC(ret) && !find_similar) {
        SMART_VAR(StmtCompareHelper, helper) {
          map_info.reset();
          bool force_no_trans = false;
          QbNameList qb_names;
          if (OB_FAIL(get_hint_force_set(root_stmt,
                                         *stmt, 
                                         qb_names, 
                                         force_no_trans))) {
            LOG_WARN("failed to get hint set", K(ret));
          } else if (force_no_trans) {
            //do nothing
            OPT_TRACE("hint reject materialize:", stmt);
          } else if (OB_FAIL(ObStmtComparer::check_stmt_containment(stmt,
                                                                    stmt,
                                                                    map_info,
                                                                    relation))) {
            LOG_WARN("failed to check stmt containment", K(ret));
          } else if (OB_FAIL(helper.similar_stmts_.push_back(stmt))) {
            LOG_WARN("failed to push back stmt", K(ret));
          } else if (OB_FAIL(helper.stmt_map_infos_.push_back(map_info))) {
            LOG_WARN("failed to push back map info", K(ret));
          } else if (OB_FAIL(helper.hint_force_stmt_set_.assign(qb_names))) {
            LOG_WARN("failed to assign qb names", K(ret));
          } else if (OB_FALSE_IT(helper.stmt_ = stmt)) {
          } else if (OB_FAIL(compare_info.push_back(helper))) {
            LOG_WARN("failed to push back compare info", K(ret));
          }
        }
      }
    }
    //对每组相似stmt创建temp table
    for (int64_t i = 0; OB_SUCC(ret) && i < compare_info.count(); ++i) {
      StmtCompareHelper &helper = compare_info.at(i);
      bool is_happened = false;
      OPT_TRACE("try to materialize:", helper.stmt_);
      if (!helper.hint_force_stmt_set_.empty() &&
          !helper.hint_force_stmt_set_.is_subset(helper.similar_stmts_)) {
        //hint forbid, do nothing
        OPT_TRACE("hint reject transform");
      } else if (helper.hint_force_stmt_set_.empty() && 
                (helper.similar_stmts_.count() < 2)) {
        OPT_TRACE("no other similar stmts");
        //do nothing
      } else if (OB_FAIL(create_temp_table(root_stmt, helper, parent_map, is_happened))) {
        LOG_WARN("failed to create temp table", K(ret));
      } else {
        trans_happened |= is_happened;
      }
    }
  }
  return ret;
}

int ObTransformTempTable::add_materialize_stmts(const ObIArray<ObSelectStmt*> &stms)
{
  int ret = OB_SUCCESS;
  MaterializeStmts *new_stmts = NULL;
  if (OB_ISNULL(trans_param_) ||
      OB_ISNULL(new_stmts = (MaterializeStmts *) allocator_.alloc(sizeof(MaterializeStmts)))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("failed to allocate stmts array", K(ret));
  } else {
    new_stmts = new (new_stmts) MaterializeStmts();
    if (OB_FAIL(new_stmts->assign(stms))) {
      LOG_WARN("failed to assign array", K(ret));
    } else if (OB_FAIL(trans_param_->materialize_stmts_.push_back(new_stmts))) {
      LOG_WARN("failed to push back stmts", K(ret));
    }
  }
  return ret;
}

int ObTransformTempTable::check_has_stmt(ObSelectStmt *left_stmt,
                                         ObSelectStmt *right_stmt,
                                         hash::ObHashMap<uint64_t, ObParentDMLStmt> &parent_map,
                                         bool &has_stmt)
{
  int ret = OB_SUCCESS;
  has_stmt = false;
  ObDMLStmt *current = left_stmt;
  ObParentDMLStmt parent_stmt;
  bool get_temp_table = false;
  while (OB_SUCC(ret) && current != right_stmt && NULL != current && !get_temp_table) {
    uint64_t key = reinterpret_cast<uint64_t>(current);
    if (OB_FAIL(parent_map.get_refactored(key, parent_stmt))) {
      if (ret == OB_HASH_NOT_EXIST) {
        current = NULL;
        ret = OB_SUCCESS;
      } else {
        LOG_WARN("failed to get value", K(ret));
      }
    } else if (NULL != parent_stmt.stmt_) {
      current = parent_stmt.stmt_;
    } else {
      // current is a temp table query, and might has multi parents
      get_temp_table = true;
    }
  }
  if (OB_SUCC(ret)) {
    if (current == right_stmt) {
      has_stmt = true;
    } else if (get_temp_table) {
      // reverse the search direction
      // ret = check_has_stmt(right_stmt, left_stmt, has_stmt);
      ObDMLStmt *tmp = NULL;
      if (OB_ISNULL(right_stmt)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("null stmt", K(ret));
      } else if (OB_FAIL(right_stmt->get_stmt_by_stmt_id(current->get_stmt_id(), tmp))) {
        LOG_WARN("failed to get stmt by stmt id", K(ret), K(current->get_stmt_id()), KPC(right_stmt));
      } else if (current == tmp) {
        has_stmt = true;
      }
    }

  }
  return ret;
}

int ObTransformTempTable::check_has_stmt(const ObIArray<ObSelectStmt *> &stmts,
                                         ObSelectStmt *right_stmt,
                                         hash::ObHashMap<uint64_t, ObParentDMLStmt> &parent_map,
                                         bool &has_stmt)
{
  int ret = OB_SUCCESS;
  has_stmt = false;
  for (int64_t i = 0; OB_SUCC(ret) && !has_stmt && i < stmts.count(); i ++) {
    if (OB_FAIL(check_has_stmt(stmts.at(i), right_stmt, parent_map, has_stmt))) {
      LOG_WARN("failed to check has stmt", K(ret));
    } else if (has_stmt) {
      //do nothing
    } else if (OB_FAIL(check_has_stmt(right_stmt, stmts.at(i), parent_map, has_stmt))) {
      LOG_WARN("failed to check has stmt", K(ret));
    }
  }
  return ret;
}

int ObTransformTempTable::check_stmt_can_extract_temp_table(ObSelectStmt *first,
                                                            ObSelectStmt *second,
                                                            const ObStmtMapInfo &map_info,
                                                            QueryRelation relation,
                                                            bool check_basic_similarity,
                                                            bool &is_valid)
{
  int ret = OB_SUCCESS;
  is_valid = false;
  if (OB_ISNULL(first) || OB_ISNULL(second)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else if (first->is_scala_group_by() ^ second->is_scala_group_by()) {
    is_valid = false;
  } else if (second->is_set_stmt()) {
    is_valid = QueryRelation::QUERY_EQUAL == relation && map_info.is_order_equal_;
  } else if (second->get_table_size() < 2) {
    if (second->get_group_expr_size() > 0 ||
        second->get_rollup_expr_size() > 0) {
      is_valid = map_info.is_group_equal_ && map_info.is_cond_equal_;
    } else if (second->get_aggr_item_size() > 0) {
      is_valid = map_info.is_table_equal_ && map_info.is_from_equal_ && map_info.is_semi_info_equal_ && map_info.is_cond_equal_;
    }
  } else if (map_info.is_table_equal_ && map_info.is_from_equal_ && map_info.is_semi_info_equal_) {
    is_valid = true;
    if (map_info.is_cond_equal_ || check_basic_similarity) {
      // do nothing
    } else if (OB_FAIL(check_equal_join_condition_match(*first, *second, map_info, is_valid))) {
      LOG_WARN("failed to check condition", K(ret));
    } else if (!is_valid) {
      // do nothing
    } else if (OB_FAIL(check_index_condition_match(*first, *second, map_info, is_valid))) {
      LOG_WARN("failed to check condition", K(ret));
    }
  }
  return ret;
}

int ObTransformTempTable::check_equal_join_condition_match(ObSelectStmt &first,
                                                           ObSelectStmt &second,
                                                           const ObStmtMapInfo &map_info,
                                                           bool &is_match)
{
  int ret = OB_SUCCESS;
  // Check equal join condition
  ObSqlBitSet<> map_join_conds;
  is_match = true;
  for (int64_t i = 0; OB_SUCC(ret) && is_match && i < first.get_condition_size(); ++i) {
    ObRawExpr *expr = first.get_condition_expr(i);
    if (OB_ISNULL(expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null expr", K(ret));
    } else if (expr->has_flag(IS_JOIN_COND)) {
      int64_t cond_pos_in_other = map_info.cond_map_.at(i);
      if (OB_INVALID_ID == cond_pos_in_other) {
        // Equal join conds of first stmt not in second stmt
        is_match = false;
      } else if (OB_FAIL(map_join_conds.add_member(cond_pos_in_other))) {
        LOG_WARN("failed to add member", K(ret));
      }
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && is_match && i < second.get_condition_size(); ++i) {
    ObRawExpr *expr = second.get_condition_expr(i);
    if (OB_ISNULL(expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null expr", K(ret));
    } else if (expr->has_flag(IS_JOIN_COND) && !map_join_conds.has_member(i)) {
      // Equal join conds of second stmt not in first stmt
      is_match = false;
    }
  }
  return ret;
}

int ObTransformTempTable::check_index_condition_match(ObSelectStmt &first,
                                                      ObSelectStmt &second,
                                                      const ObStmtMapInfo &map_info,
                                                      bool &is_match)
{
  int ret = OB_SUCCESS;
  is_match = true;
  ObSqlBitSet<> map_index_conds;
  for (int64_t i = 0; OB_SUCC(ret) && is_match && i < first.get_condition_size(); ++i) {
    ObRawExpr *cond = NULL;
    bool index_match = false;
    if (OB_ISNULL(cond = first.get_condition_expr(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("condition expr is null", K(ret));
    } else if (cond->has_flag(IS_SIMPLE_COND) ||
               cond->has_flag(IS_RANGE_COND) ||
               T_OP_IS == cond->get_expr_type()) {
      ObSEArray<ObRawExpr*, 2> column_exprs;
      ObColumnRefRawExpr *col_expr = NULL;
      if (OB_FAIL(ObRawExprUtils::extract_column_exprs(cond, column_exprs))) {
        LOG_WARN("failed to extrace column exprs", K(ret));
      } else if (1 != column_exprs.count()) {
        //do nothing
      } else if (OB_ISNULL(column_exprs.at(0))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null expr", K(ret));
      } else if (!column_exprs.at(0)->is_column_ref_expr()) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("expect column ref expr", K(*column_exprs.at(0)), K(ret));
      } else if (FALSE_IT(col_expr = static_cast<ObColumnRefRawExpr*>(column_exprs.at(0)))) {
      } else if (OB_ISNULL(first.get_table_item_by_id(col_expr->get_table_id()))) {
        //do nothing
      } else if (OB_FAIL(ObTransformUtils::is_match_index(ctx_->sql_schema_guard_,
                                                          &first,
                                                          col_expr,
                                                          index_match))) {
        LOG_WARN("failed to check is match index", K(ret));
      } else if (index_match) {
        int64_t cond_pos_in_other = map_info.cond_map_.at(i);
        if (OB_INVALID_ID == cond_pos_in_other) {
          // Index conds of first stmt not in second stmt
          is_match = false;
        } else if (OB_FAIL(map_index_conds.add_member(cond_pos_in_other))) {
          LOG_WARN("failed to add member", K(ret));
        }
      }
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && is_match && i < second.get_condition_size(); ++i) {
    ObRawExpr *cond = NULL;
    bool index_match = false;
    if (OB_ISNULL(cond = second.get_condition_expr(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("condition expr is null", K(ret));
    } else if (cond->has_flag(IS_SIMPLE_COND) ||
               cond->has_flag(IS_RANGE_COND) ||
               T_OP_IS == cond->get_expr_type()) {
      ObSEArray<ObRawExpr*, 2> column_exprs;
      ObColumnRefRawExpr *col_expr = NULL;
      if (OB_FAIL(ObRawExprUtils::extract_column_exprs(cond, column_exprs))) {
        LOG_WARN("failed to extrace column exprs", K(ret));
      } else if (1 != column_exprs.count()) {
        //do nothing
      } else if (OB_ISNULL(column_exprs.at(0))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null expr", K(ret));
      } else if (!column_exprs.at(0)->is_column_ref_expr()) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("expect column ref expr", K(*column_exprs.at(0)), K(ret));
      } else if (FALSE_IT(col_expr = static_cast<ObColumnRefRawExpr*>(column_exprs.at(0)))) {
      } else if (OB_ISNULL(second.get_table_item_by_id(col_expr->get_table_id()))) {
        //do nothing
      } else if (OB_FAIL(ObTransformUtils::is_match_index(ctx_->sql_schema_guard_,
                                                          &second,
                                                          col_expr,
                                                          index_match))) {
        LOG_WARN("failed to check is match index", K(ret));
      } else if (index_match && !map_index_conds.has_member(i)) {
        is_match = false;
      }
    }
  }
  return ret;
}

/**
 * @brief ObTransformTempTable::get_non_correlated_subquery
 * @param stmt
 * @param non_correlated_stmts
 * @return
 */
int ObTransformTempTable::get_non_correlated_subquery(ObDMLStmt *stmt, ObIArray<ObSelectStmt *> &non_correlated_stmts)
{
  int ret = OB_SUCCESS;
  hash::ObHashMap<uint64_t, uint64_t> param_level;
  uint64_t min_param_level = 0;
  ObArray<TempTableInfo> temp_table_infos;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret), K(stmt));
  } else if (OB_FAIL(param_level.create(128, "TempTable"))) {
    LOG_WARN("failed to init expr map", K(ret));
  } else if (OB_FAIL(get_non_correlated_subquery(stmt, 0, param_level, non_correlated_stmts, min_param_level))) {
    LOG_WARN("failed to get non correlated subquery", K(ret));
  } else if (OB_FAIL(stmt->collect_temp_table_infos(temp_table_infos))) {
    LOG_WARN("failed to collect temp table infos", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < temp_table_infos.count(); i ++) {
    min_param_level = 0;
    if (OB_FAIL(param_level.reuse())) {
      LOG_WARN("failed to reuse hash map", K(ret));
    } else if (OB_FAIL(get_non_correlated_subquery(temp_table_infos.at(i).temp_table_query_,
                                                   0,
                                                   param_level,
                                                   non_correlated_stmts,
                                                   min_param_level))) {
      LOG_WARN("failed to get non correlated subquery", K(ret));
    }
  }
  if (OB_SUCC(ret) && OB_FAIL(param_level.destroy())) {
    LOG_WARN("failed to destroy map", K(ret));
  }
  return ret;
}

int ObTransformTempTable::get_non_correlated_subquery(ObDMLStmt *stmt,
                                                      const uint64_t recursive_level,
                                                      hash::ObHashMap<uint64_t, uint64_t> &param_level,
                                                      ObIArray<ObSelectStmt *> &non_correlated_stmts,
                                                      uint64_t &min_param_level)
{
  int ret = OB_SUCCESS;
  ObArray<ObSelectStmt *> child_stmts;
  ObArray<ObRawExpr *> relation_exprs;
  min_param_level = recursive_level;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret), K(stmt));
  } else if (OB_FAIL(stmt->get_relation_exprs(relation_exprs))) {
    LOG_WARN("failed to get relation exprs", K(ret));
  } else if (OB_FAIL(stmt->get_child_stmts(child_stmts))) {
    LOG_WARN("failed to get child stmts", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < relation_exprs.count(); ++i) {
    ObRawExpr *expr = relation_exprs.at(i);
    if (OB_FAIL(check_exec_param_level(expr, param_level, min_param_level))) {
      LOG_WARN("failed to check exec param level", K(ret));
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_subquery_expr_size(); ++i) {
    ObQueryRefRawExpr *query_ref = stmt->get_subquery_exprs().at(i);
    if (OB_ISNULL(query_ref)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("query ref is null", K(ret), K(query_ref));
    }
    for (int64_t j = 0; OB_SUCC(ret) && j < query_ref->get_exec_params().count(); ++j) {
      ObRawExpr *exec_param = query_ref->get_exec_params().at(j);
      uint64_t key = reinterpret_cast<uint64_t>(exec_param);
      if (OB_ISNULL(exec_param)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("exec param is null", K(ret));
      } else if (OB_FAIL(param_level.set_refactored(key, recursive_level))) {
        if (ret == OB_HASH_EXIST) {
          ret = OB_SUCCESS;
        } else {
          LOG_WARN("failed to add exec param into map", K(ret));
        }
      }
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < child_stmts.count(); ++i) {
    uint64_t child_min_param_level = recursive_level + 1;
    if (OB_FAIL(SMART_CALL(get_non_correlated_subquery(child_stmts.at(i),
                                                       recursive_level + 1,
                                                       param_level,
                                                       non_correlated_stmts,
                                                       child_min_param_level)))) {
      LOG_WARN("failed to get non correlated subquery", K(ret));
    } else if (child_min_param_level < min_param_level) {
      min_param_level = child_min_param_level;
    }
  }
  if (OB_SUCC(ret) && min_param_level == recursive_level && stmt->is_select_stmt()) {
    if (OB_FAIL(non_correlated_stmts.push_back(static_cast<ObSelectStmt *>(stmt)))) {
      LOG_WARN("failed to push back non correlated stmt", K(ret));
    }
  }
  return ret;
}

int ObTransformTempTable::check_exec_param_level(const ObRawExpr *expr,
                                                 const hash::ObHashMap<uint64_t, uint64_t> &param_level,
                                                 uint64_t &min_param_level)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr is null", K(ret), K(expr));
  } else if (expr->is_exec_param_expr()) {
    uint64_t key = reinterpret_cast<uint64_t>(expr);
    uint64_t level = UINT64_MAX;
    if (OB_FAIL(param_level.get_refactored(key, level))) {
      LOG_WARN("failed to get level", K(ret), K(*expr));
    } else if (level < min_param_level) {
      min_param_level = level;
    }
  } else if (expr->has_flag(CNT_DYNAMIC_PARAM)) {
    for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
      if (OB_FAIL(SMART_CALL(check_exec_param_level(expr->get_param_expr(i),
                                                    param_level,
                                                    min_param_level)))) {
        LOG_WARN("failed to check exec param level", K(ret));
      }
    }
  }
  return ret;
}

int ObTransformTempTable::remove_simple_stmts(ObIArray<ObSelectStmt*> &stmts)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObSelectStmt*, 8> new_stmts;
  bool has_rownum = false;
  bool is_valid = false;
  for (int64_t i = 0; OB_SUCC(ret) && i < stmts.count(); ++i) {
    ObSelectStmt *subquery = stmts.at(i);
    bool force_inline = false;
    bool force_materia = false;
    if (OB_ISNULL(subquery)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null stmt", K(ret));
    } else if (OB_FAIL(check_hint_allowed_trans(*subquery,
                                                force_inline,
                                                force_materia))) {
      LOG_WARN("failed to check force materialize", K(ret));
    } else if (force_inline) {
      // do nothing
    } else if (OB_FAIL(subquery->has_rownum(has_rownum))) {
      LOG_WARN("failed to check has rownum", K(ret));
    } else if (has_rownum) {
      //do nothing
    } else if (ObOptimizerUtil::find_item(ctx_->temp_table_ignore_stmts_, subquery)) {
      //do nothing
    } else if (OB_FAIL(check_stmt_can_materialize(subquery, false, is_valid))) {
      LOG_WARN("failed to check stmt is valid", K(ret));
    } else if (!is_valid) {
      //do nothing
    } else if (OB_FAIL(new_stmts.push_back(subquery))) {
      LOG_WARN("failed to push back stmt", K(ret));
    }
  }
  if (OB_SUCC(ret)) {
    if (OB_FAIL(stmts.assign(new_stmts))) {
      LOG_WARN("failed to assign stmts", K(ret));
    }
  }
  return ret;
}

/**
 * @classify_stmts
 * 为了降低stmt比较的代价，
 * 把stmt按照table size、generate table size分组，
 * 每组stmt的basic table item size和generate table size相同
 * 因为不同table item的stmt之间一定不相似
 */
int ObTransformTempTable::classify_stmts(ObIArray<ObSelectStmt*> &stmts,
                                        ObIArray<StmtClassifyHelper> &stmt_groups)
{
  int ret = OB_SUCCESS;
  for (int64_t i = 0; OB_SUCC(ret) && i < stmts.count(); ++i) {
    ObSelectStmt *stmt = stmts.at(i);
    int64_t table_size = 0;
    int64_t generate_table_size = 0;
    if (OB_ISNULL(stmt)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null stmt", K(ret));
    } else {
      table_size = stmt->get_table_size();
    }
    for (int64_t j = 0; OB_SUCC(ret) && j < table_size; ++j) {
      const TableItem *table_item = stmt->get_table_item(j);
      if (OB_ISNULL(table_item)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("table_item is null", K(j));
      } else if (table_item->is_generated_table()) {
        ++generate_table_size;
      }
    }
    bool find = false;
    for (int64_t j = 0; OB_SUCC(ret) && !find && j < stmt_groups.count(); ++j) {
      if (stmt_groups.at(j).table_size_ == table_size &&
          stmt_groups.at(j).generate_table_size_ == generate_table_size) {
        if (OB_FAIL(stmt_groups.at(j).stmts_.push_back(stmt))) {
          LOG_WARN("failed to push back stmt", K(ret));
        } else {
          find = true;
        }
      }
    }
    if (OB_SUCC(ret) && !find) {
      StmtClassifyHelper helper;
      helper.table_size_ = table_size;
      helper.generate_table_size_ = generate_table_size;
      if (OB_FAIL(helper.stmts_.push_back(stmt))) {
        LOG_WARN("failed to push back stmt", K(ret));
      } else if (OB_FAIL(stmt_groups.push_back(helper))) {
        LOG_WARN("failed to push back stmt", K(ret));
      }
    }
  }
  return ret;
}

/**
 * @create_temp_table
 * 把相似stmt的公共部分抽离成temp table
 */

int ObTransformTempTable::create_temp_table(ObDMLStmt &root_stmt,
                                            StmtCompareHelper& compare_info,
                                            hash::ObHashMap<uint64_t, ObParentDMLStmt> &parent_map,
                                            bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObStmtMapInfo common_map_info;
  TableItem *table = NULL;
  TableItem *temp_table = NULL;
  ObSelectStmt *temp_table_query = NULL;
  ObSEArray<ObSelectStmt *, 2> origin_stmts;
  ObSEArray<ObSelectStmt *, 2> trans_stmts;
  ObSEArray<int64_t, 2> compare_info_map;
  ObTryTransHelper try_trans_helper;
  if (OB_ISNULL(compare_info.stmt_) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->allocator_)
      || OB_ISNULL(ctx_->stmt_factory_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null param", K(ret));
  } else if (OB_FAIL(try_trans_helper.fill_helper(root_stmt.get_query_ctx()))) {
    LOG_WARN("failed to fill try trans helper", K(ret));
  } else if (OB_FAIL(compute_common_map_info(compare_info.stmt_map_infos_, common_map_info))) {
    LOG_WARN("failed to compute common map info", K(ret));
  } else if (compare_info.stmt_map_infos_.count() != compare_info.similar_stmts_.count()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect compare info", K(compare_info), K(ret));
  }
  // check whether the stmt is valid
  bool is_valid = true;
  // int valid_stmt_cnt = compare_info.similar_stmts_.count();
  for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < compare_info.similar_stmts_.count(); ++i) {
    ObSelectStmt *similar_stmt = compare_info.similar_stmts_.at(i);
    ObDMLStmt *current_stmt = NULL;
    if (OB_ISNULL(similar_stmt)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null stmt", K(ret));
    } else if (OB_FAIL(root_stmt.get_stmt_by_stmt_id(similar_stmt->get_stmt_id(), current_stmt))) {
      LOG_WARN("failed to get stmt by stmt id", K(ret), K(similar_stmt->get_stmt_id()), KPC(similar_stmt));
    } else if (similar_stmt != current_stmt) {
      // similar stmt might has been rewrite,
      // and do not exists in root stmt
      // e.g.
      //    select * from
      //      (select * from t1,t2 where a=b union select * from t1,t2 where c=d) A,
      //      (select * from t1,t2 where a=b union select * from t1,t2 where c=d) B
      // => with cte1 as (select * from t1,t2 where a=b union select * from t1,t2 where c=d)
      //       select * from cte1 A, cte1 B;
      //   Stmt (select * from t1,t2 where a=b) is different after extract cte1
      is_valid = false;
      OPT_TRACE("Similar stmts are invalid");
    } else if (!compare_info.hint_force_stmt_set_.empty() &&
               !compare_info.hint_force_stmt_set_.has_qb_name(similar_stmt)) {
      // not in hint, do not transform
    } else if (OB_FAIL(origin_stmts.push_back(similar_stmt))) {
      LOG_WARN("failed to push back stmt", K(ret));
    } else if (OB_FAIL(compare_info_map.push_back(i))) {
      LOG_WARN("failed to push back", K(ret));
    }
  }
  if (is_valid && compare_info.hint_force_stmt_set_.empty() && origin_stmts.count() <= 1) {
    is_valid = false;
    OPT_TRACE("Only one valid stmt, do not transform");
  }
  //把stmt的公共部分封装成generate table
  for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < origin_stmts.count(); ++i) {
    ObSelectStmt *similar_stmt = origin_stmts.at(i);
    ObDMLStmt *dml_stmt = NULL;
    if (OB_FAIL(ObTransformUtils::deep_copy_stmt(*ctx_->stmt_factory_, *ctx_->expr_factory_,
                                                 similar_stmt, dml_stmt))) {
      LOG_WARN("failed to deep copy stmt", K(ret));
    } else if (FALSE_IT(similar_stmt = static_cast<ObSelectStmt *>(dml_stmt))) {
    } else if (OB_FAIL(trans_stmts.push_back(similar_stmt))) {
      LOG_WARN("failed to push back stmt", K(ret));
    } else if (OB_FAIL(inner_create_temp_table(similar_stmt,
                                        compare_info.stmt_map_infos_.at(compare_info_map.at(i)),
                                        common_map_info))) {
      LOG_WARN("failed to replace temp table", K(ret));
    }
  }
  //把generate table转成temp table
  for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < trans_stmts.count(); ++i) {
    ObSelectStmt *stmt = trans_stmts.at(i);
    if (OB_ISNULL(stmt)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null stmt", K(ret));
    } else if (1 != stmt->get_table_size()) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("expect one table item in stmt", KPC(stmt), K(ret));
    } else if (OB_ISNULL(table = stmt->get_table_item(0))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null table item", K(ret));
    } else if (!table->is_generated_table()) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("expect generate table item", KPC(table), K(ret));
    } else if (OB_ISNULL(table->ref_query_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null ref query", K(ret));
    } else {
      if (0 == i) {
        temp_table = table;
        ObDMLStmt *temp_table_stmt = NULL;
        if (OB_FAIL(ObTransformUtils::deep_copy_stmt(*ctx_->stmt_factory_, *ctx_->expr_factory_,
                                                     table->ref_query_, temp_table_stmt))) {
          LOG_WARN("failed to deep copy stmt", K(ret));
        } else if (OB_FAIL(temp_table_stmt->update_stmt_table_id(ctx_->allocator_, *table->ref_query_))) {
          LOG_WARN("failed to update table id", K(ret));
        } else if (OB_FAIL(stmt->generate_view_name(*ctx_->allocator_,
                                            temp_table->table_name_,
                                            true))) {
          LOG_WARN("failed to generate view name", K(ret));
        } else {
          temp_table_query = static_cast<ObSelectStmt *>(temp_table_stmt);
          table->ref_query_ = temp_table_query;
        }
      } else if (OB_FAIL(apply_temp_table(stmt,
                                          table,
                                          temp_table_query,
                                          compare_info.stmt_map_infos_.at(compare_info_map.at(i))))) {
        LOG_WARN("failed to apply temp table", K(ret));
      } else {
        table->ref_query_ = temp_table_query;
        table->table_name_ = temp_table->table_name_;
      }
      table->type_ = TableItem::TEMP_TABLE;
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < trans_stmts.count(); ++i) {
    ObSelectStmt *stmt = trans_stmts.at(i);
    if (OB_ISNULL(stmt)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null stmt", K(ret));
    } else if (OB_FAIL(stmt->formalize_stmt_expr_reference(ctx_->expr_factory_,
                                                           ctx_->session_info_))) {
      LOG_WARN("failed to formalize stmt reference", K(ret));
    }
  }
  
  if (OB_SUCC(ret) && is_valid && OB_NOT_NULL(temp_table_query)) {
    if (OB_FAIL(ObTransformUtils::adjust_pseudo_column_like_exprs(*temp_table_query))) {
      LOG_WARN("failed to adjust pseudo column like exprs", K(ret));
    } else if (OB_FAIL(temp_table_query->formalize_stmt(ctx_->session_info_))) {
      LOG_WARN("failed to formalize stmt", K(ret));
    } else if (OB_FAIL(temp_table_query->formalize_stmt_expr_reference(ctx_->expr_factory_,
                                                                       ctx_->session_info_))) {
      LOG_WARN("failed to formalize stmt reference", K(ret));
    }
  }

  if (OB_SUCC(ret) && is_valid) {
    trans_happened = false;
    common::ObSEArray<ObSelectStmt *, 2> accept_stmts;
    if (OB_FAIL(accept_cte_transform(root_stmt, temp_table,
                                     origin_stmts, trans_stmts,
                                     accept_stmts, parent_map,
                                     !compare_info.hint_force_stmt_set_.empty(),
                                     trans_happened))) {
      LOG_WARN("failed to accept transform", K(ret));
    } else if (!trans_happened) {
      if (OB_FAIL(try_trans_helper.recover(root_stmt.get_query_ctx()))) {
        LOG_WARN("failed to recover params", K(ret));
      }
    } else if (OB_FAIL(append(ctx_->equal_param_constraints_, common_map_info.equal_param_map_))) {
      LOG_WARN("failed to append equal param constraints", K(ret));
    } else if (OB_FAIL(add_materialize_stmts(accept_stmts))) {
      LOG_WARN("failed to add stmts", K(ret));
    } else {
      for (int64_t i = 0; OB_SUCC(ret) && i < compare_info.stmt_map_infos_.count(); i ++) {
        if (OB_FAIL(append(ctx_->equal_param_constraints_,
                           compare_info.stmt_map_infos_.at(i).equal_param_map_))) {
          LOG_WARN("failed to append equal param constraints", K(ret));
        }
      }
      LOG_TRACE("succeed to create temp table", KPC(temp_table_query));
    }
  }

  return ret;
}

/**
 * @brief compute_common_map_info
 * 计算相似stmt的最大公共部分
 */
int ObTransformTempTable::compute_common_map_info(ObIArray<ObStmtMapInfo>& map_infos,
                                                  ObStmtMapInfo &common_map_info)
{
  int ret = OB_SUCCESS;
  for (int64_t i = 0; OB_SUCC(ret) && i < map_infos.count(); ++i) {
    ObStmtMapInfo &map_info = map_infos.at(i);
    if (0 == i) {
      if (OB_FAIL(common_map_info.assign(map_info))) {
        LOG_WARN("failed to assign map info", K(ret));
      }
    } else if (OB_FAIL(append(common_map_info.equal_param_map_, map_info.equal_param_map_))) {
      LOG_WARN("failed to append equal param", K(ret));
    } else {
      //compute common condi map
      if (OB_FAIL(compute_common_map(map_info.cond_map_, common_map_info.cond_map_))) {
        LOG_WARN("failed to compute common map info", K(ret));
      } else {
        common_map_info.is_cond_equal_ &= map_info.is_cond_equal_;
      }
      //compute common group by map
      if (OB_SUCC(ret)) {
        //只有当where condition完全相同时才能考虑下压group by到temp table
        //TODO:当前不相同的condition可以推迟到having执行时也可以下压group by
        if (common_map_info.is_cond_equal_) {
          if (OB_FAIL(compute_common_map(map_info.group_map_, common_map_info.group_map_))) {
            LOG_WARN("failed to compute common map info", K(ret));
          } else {
            common_map_info.is_group_equal_ &= map_info.is_group_equal_;
          }
        } else {
          common_map_info.group_map_.reset();
          common_map_info.having_map_.reset();
          common_map_info.select_item_map_.reset();
          common_map_info.is_distinct_equal_ = false;
        }
      }
      //compute common having map
      if (OB_SUCC(ret)) {
        if (common_map_info.is_group_equal_) {
          if (OB_FAIL(compute_common_map(map_info.having_map_, common_map_info.having_map_))) {
            LOG_WARN("failed to compute common map info", K(ret));
          } else {
            common_map_info.is_having_equal_ &= map_info.is_having_equal_;
          }
        } else {
          common_map_info.having_map_.reset();
          common_map_info.select_item_map_.reset();
          common_map_info.is_distinct_equal_ = false;
        }
      }
      //compute common select item map
      if (OB_SUCC(ret)) {
        if (common_map_info.is_having_equal_) {
          if (OB_FAIL(compute_common_map(map_info.select_item_map_, common_map_info.select_item_map_))) {
            LOG_WARN("failed to compute common map info", K(ret));
          } else {
            common_map_info.is_select_item_equal_ &= map_info.is_select_item_equal_;
          }
        } else {
          common_map_info.select_item_map_.reset();
          common_map_info.is_distinct_equal_ = false;
        }
      }
      //compute common distinct map
      if (OB_SUCC(ret)) {
        if (common_map_info.is_select_item_equal_) {
          common_map_info.is_distinct_equal_ = map_info.is_distinct_equal_;
        }
      }
    }
  }
  return ret;
}

int ObTransformTempTable::compute_common_map(ObIArray<int64_t> &source_map,
                                             ObIArray<int64_t> &common_map)
{
  int ret = OB_SUCCESS;
  if (source_map.count() != common_map.count()) {
    common_map.reset();
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < source_map.count(); ++i) {
      if (OB_INVALID_ID == source_map.at(i)) {
        common_map.at(i) = OB_INVALID_ID;
      }
    }
  }
  return ret;
}

/**
 * @brief inner_create_temp_table
 * 把stmt的公共部分封装在generate table内
 */
int ObTransformTempTable::inner_create_temp_table(ObSelectStmt *parent_stmt,
                                                  ObStmtMapInfo& map_info,
                                                  ObStmtMapInfo& common_map_info)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(parent_stmt) || OB_ISNULL(ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null stmt", K(ret));
  } else if (parent_stmt->is_set_stmt()) {
    if (OB_FAIL(ObTransformUtils::pack_stmt(ctx_, parent_stmt))) {
      LOG_WARN("failed to create temp table for set stmt", K(ret));
    } else {
      LOG_TRACE("succeed to create temp table", KPC(parent_stmt));
    }
  } else {
    TableItem *view_table = NULL;
    ObSEArray<TableItem *, 8> from_tables;
    ObSEArray<SemiInfo *, 4> semi_infos;
    ObSEArray<ObRawExpr *, 8> pushdown_select;
    ObSEArray<ObRawExpr *, 8> pushdown_where;
    ObSEArray<ObRawExpr *, 8> pushdown_groupby;
    ObSEArray<ObRawExpr *, 8> pushdown_rollup;
    ObSEArray<ObRawExpr *, 8> pushdown_having;

    if (parent_stmt->get_condition_size() > 0 &&
              OB_FAIL(pushdown_conditions(parent_stmt,
                                          map_info.cond_map_,
                                          common_map_info.cond_map_,
                                          pushdown_where))) {
      LOG_WARN("failed to pushdown conditions", K(ret));
    } else if (!common_map_info.is_cond_equal_ ||
              !common_map_info.is_group_equal_) {
      //do nothing
      //下压group by
    } else if (parent_stmt->has_group_by() &&
              OB_FAIL(ObTransformUtils::pushdown_group_by(parent_stmt,
                                                          pushdown_groupby,
                                                          pushdown_rollup,
                                                          pushdown_select))) {
      LOG_WARN("failed to pushdown group by", K(ret));
      //下压having
    } else if (parent_stmt->get_having_expr_size() > 0 &&
              OB_FAIL(pushdown_having_conditions(parent_stmt,
                                                  map_info.having_map_,
                                                  common_map_info.having_map_,
                                                  pushdown_having))) {
      LOG_WARN("failed to pushdown having conditions", K(ret));
    }

    ObSEArray<TableItem *, 8> origin_tables;
    if (OB_FAIL(ret)) {
    } else if (OB_FAIL(ObTransformUtils::pushdown_pseudo_column_like_exprs(*parent_stmt,
                                                                           false,
                                                                           pushdown_select))) {
      LOG_WARN("failed to pushdown pseudo column like exprs", K(ret));
    } else if (OB_FAIL(origin_tables.assign(parent_stmt->get_table_items()))) {
      LOG_WARN("failed to get table items", K(ret));
    } else if (OB_FAIL(parent_stmt->get_from_tables(from_tables))) {
      LOG_WARN("failed to get from tables", K(ret));
    } else if (OB_FAIL(semi_infos.assign(parent_stmt->get_semi_infos()))) {
      LOG_WARN("failed to assign semi info", K(ret));
    } else if (OB_FAIL(ObTransformUtils::replace_with_empty_view(ctx_,
                                                                 parent_stmt,
                                                                 view_table,
                                                                 from_tables,
                                                                 &semi_infos))) {
      LOG_WARN("failed to create empty view", K(ret));
    } else if (OB_FAIL(ObTransformUtils::create_inline_view(ctx_,
                                                            parent_stmt,
                                                            view_table,
                                                            from_tables,
                                                            &pushdown_where,
                                                            &semi_infos,
                                                            &pushdown_select,
                                                            &pushdown_groupby,
                                                            &pushdown_rollup,
                                                            &pushdown_having))) {
      LOG_WARN("failed to create inline view", K(ret));
    } else if (OB_ISNULL(view_table->ref_query_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("null view query", K(ret));

    // recover the order of table items,
    // the table_map in ObStmtMapInfo will be used in apply_temp_table
    } else if (OB_FAIL(view_table->ref_query_->get_table_items().assign(origin_tables))) {
      LOG_WARN("failed to adjust table map", K(ret));
    } else if (OB_FAIL(view_table->ref_query_->rebuild_tables_hash())) {
      LOG_WARN("failed to rebuild table hash", K(ret));
    } else if (OB_FAIL(view_table->ref_query_->update_column_item_rel_id())) {
      LOG_WARN("failed to update column item by id", K(ret));
    } else if (OB_FAIL(view_table->ref_query_->formalize_stmt(ctx_->session_info_))) {
      LOG_WARN("failed to formalize stmt", K(ret));
    }
  }
  return ret;
}

/**
 * @brief pushdown_conditions
 * 把公共的where condition重命名后下压到视图内
 * 不同的where condition保留在原stmt中，等待谓词推导下压
 */
int ObTransformTempTable::pushdown_conditions(ObSelectStmt *parent_stmt,
                                              const ObIArray<int64_t> &cond_map,
                                              const ObIArray<int64_t> &common_cond_map,
                                              ObIArray<ObRawExpr*> &pushdown_conds)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObRawExpr*, 8> keep_conds;
  if (OB_ISNULL(parent_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null param", K(ret));
  } else if (cond_map.count() != common_cond_map.count()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect map info", K(cond_map), K(common_cond_map), K(ret));
  } else {
    ObIArray<ObRawExpr*> &conditions = parent_stmt->get_condition_exprs();
    //找到相同的condition
    for (int64_t i = 0; OB_SUCC(ret) && i < cond_map.count(); ++i) {
      int64_t idx = cond_map.at(i);
      if (OB_INVALID_ID == common_cond_map.at(i)) {
        //do nothing
      } else if (idx < 0 || idx > conditions.count()) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect cond index", K(idx), K(ret));
      } else if (OB_FAIL(pushdown_conds.push_back(conditions.at(idx)))) {
        LOG_WARN("failed to push back expr", K(ret));
      }
    }
    //找到不同的condition
    for (int64_t i = 0; OB_SUCC(ret) && i < conditions.count(); ++i) {
      if (ObOptimizerUtil::find_item(pushdown_conds, conditions.at(i))) {
        //do nothing
      } else if (OB_FAIL(keep_conds.push_back(conditions.at(i)))) {
        LOG_WARN("failed to push back expr", K(ret));
      }
    }
    if (OB_SUCC(ret) && !pushdown_conds.empty()) {
      if (OB_FAIL(parent_stmt->get_condition_exprs().assign(keep_conds))) {
        LOG_WARN("failed to assign exprs", K(ret));
      }
    }
  }
  return ret;
}

/**
 * @brief pushdown_having_conditions
 * 下推相同的having condition到视图中
 */
int ObTransformTempTable::pushdown_having_conditions(ObSelectStmt *parent_stmt,
                                                    const ObIArray<int64_t> &having_map,
                                                    const ObIArray<int64_t> &common_having_map,
                                                    ObIArray<ObRawExpr*> &pushdown_conds)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObRawExpr*, 8> keep_conds;

  if (OB_ISNULL(parent_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null param", K(ret));
  } else if (having_map.count() != common_having_map.count()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect map info", K(having_map), K(common_having_map), K(ret));
  } else {
    ObIArray<ObRawExpr*> &conditions = parent_stmt->get_having_exprs();
    //找到相同的having condition
    for (int64_t i = 0; OB_SUCC(ret) && i < having_map.count(); ++i) {
      int64_t idx = having_map.at(i);
      if (OB_INVALID_ID == common_having_map.at(i)) {
        //do nothing
      } else if (idx < 0 || idx > conditions.count()) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect cond index", K(idx), K(ret));
      } else if (OB_FAIL(pushdown_conds.push_back(conditions.at(idx)))) {
        LOG_WARN("failed to push back expr", K(ret));
      }
    }
    //找到不同的having condition
    for (int64_t i = 0; OB_SUCC(ret) && i < conditions.count(); ++i) {
      if (ObOptimizerUtil::find_item(pushdown_conds, conditions.at(i))) {
        //do nothing
      } else if (OB_FAIL(keep_conds.push_back(conditions.at(i)))) {
        LOG_WARN("failed to push back expr", K(ret));
      }
    }
    if (OB_SUCC(ret) && !conditions.empty()) {
      parent_stmt->get_having_exprs().reset();
      if (OB_FAIL(append(parent_stmt->get_condition_exprs(), keep_conds))) {
        LOG_WARN("failed to assign exprs", K(ret));
      }
    }
  }
  return ret;
}

/**
 * @brief apply_temp_table
 * 把视图view替换成temp table query，
 * 已知条件：view与temp table query仅仅只是select item不同
 * view与temp table query的基表映射关系存在于map info中
 * 只需要把view中与temp table query不同的select item转换成temp table的select item
 * 并且更新parent stmt的column item，引用temp table 的select item
 * 如果有聚合函数，需要添加到temp table query中
 */
int ObTransformTempTable::apply_temp_table(ObSelectStmt *parent_stmt,
                                          TableItem *view_table,
                                          ObSelectStmt *temp_table_query,
                                          ObStmtMapInfo& map_info)
{
  int ret = OB_SUCCESS;
  ObStmtCompareContext context;
  //视图的select items
  ObSEArray<ObRawExpr*, 16> view_select_list;
  //视图的select items转换为temp table对应的select items
  ObSEArray<ObRawExpr*, 16> new_select_list;
  //temp table的select items
  ObSEArray<ObRawExpr*, 16> temp_table_select_list;
  //视图的column items
  ObSEArray<ObRawExpr*, 16> view_column_list;
  //temp table的column items
  ObSEArray<ObRawExpr*, 16> temp_table_column_list;
  //视图的column item转换为temp table对应的column items
  ObSEArray<ObRawExpr*, 16> new_column_list;
  //不存在于temp table中的column item
  ObSEArray<ColumnItem, 16> new_column_items;
  ObSEArray<ObRawExpr*, 16> old_column_exprs;
  ObSelectStmt *view = NULL;
  if (OB_ISNULL(parent_stmt) || OB_ISNULL(temp_table_query) ||
      OB_ISNULL(view_table)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null param", K(ret));
  } else if (!view_table->is_generated_table()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expect generate table", KPC(view_table), K(ret));
  } else if (OB_ISNULL(view = view_table->ref_query_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null ref query", KPC(view_table), K(ret));
  } else if (OB_FAIL(view->get_select_exprs(view_select_list))) {
    LOG_WARN("failed to get select exprs", K(ret));
  } else if (OB_FAIL(view->get_column_exprs(view_column_list))) {
    LOG_WARN("failed to get column exprs", K(ret));
  } else if (OB_FAIL(temp_table_query->get_select_exprs(temp_table_select_list))) {
    LOG_WARN("failed to get select exprs", K(ret));
  } else if (OB_FAIL(temp_table_query->get_column_exprs(temp_table_column_list))) {
    LOG_WARN("failed to get column exprs", K(ret));
  } else {
    context.init(temp_table_query, view, map_info,
                 &parent_stmt->get_query_ctx()->calculable_items_);
  }
  //找到对应的column item，不存在于temp table的column需要添加到temp table
  for (int64_t i = 0; OB_SUCC(ret) && i < view_column_list.count(); ++i) {
    ObRawExpr *view_column = view_column_list.at(i);
    bool find = false;
    if (OB_ISNULL(view_column)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null column expr", K(ret));
    }
    //column item是否存在于temp table中
    for (int64_t j = 0; OB_SUCC(ret) && !find && j < temp_table_column_list.count(); ++j) {
      ObRawExpr *temp_table_column = temp_table_column_list.at(j);
      if (OB_ISNULL(temp_table_column)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null column expr", K(ret));
      } else if (!temp_table_column->same_as(*view_column, &context)) {
        //do nothing
      } else if (OB_FAIL(new_column_list.push_back(temp_table_column))) {
        LOG_WARN("failed to push back expr", K(ret));
      } else {
        find = true;
      }
    }
    //不存在于temp table中的column需要添加到temp table中
    if (OB_SUCC(ret) && !find) {
      TableItem *table = NULL;
      ColumnItem *column_item = NULL;
      ObColumnRefRawExpr *col_ref = static_cast<ObColumnRefRawExpr*>(view_column);
      uint64_t table_id = OB_INVALID_ID;
      if (!view_column->is_column_ref_expr()) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("expect column ref expr", KPC(view_column), K(ret));
      } else if (OB_ISNULL(column_item = view->get_column_item_by_id(col_ref->get_table_id(),
                                                                     col_ref->get_column_id()))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null column item", K(ret));
      } else if (OB_FAIL(get_map_table_id(view,
                                          temp_table_query,
                                          map_info,
                                          col_ref->get_table_id(),
                                          table_id))) {
        LOG_WARN("failed to get map table id", K(ret));
      } else if (OB_FALSE_IT(column_item->table_id_ = table_id)) {
      } else if (OB_FALSE_IT(col_ref->set_table_id(table_id))) {
      } else if (OB_FAIL(new_column_items.push_back(*column_item))) {
        LOG_WARN("failed to push back column item", K(ret));
      } else if (OB_FAIL(new_column_list.push_back(view_column))) {
        LOG_WARN("failed to push back expr", K(ret));
      } else if (OB_ISNULL(table = temp_table_query->get_table_item_by_id(table_id))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null table item", K(ret));
      } else {
        col_ref->set_table_name(table->get_table_name());
      }
    }
  }
  //添加新的column item
  if (OB_SUCC(ret) && !new_column_items.empty()) {
    if (OB_FAIL(temp_table_query->add_column_item(new_column_items))) {
      LOG_WARN("failed to add table item", K(ret));
    }
  }
  //找到不同的select item
  for (int64_t i = 0; OB_SUCC(ret) && i < view_select_list.count(); ++i) {
    ObRawExpr *view_select = view_select_list.at(i);
    ObColumnRefRawExpr *col_expr = NULL;
    bool find = false;
    if (OB_ISNULL(view_select)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null select expr", K(ret));
    } else if (NULL == (col_expr = parent_stmt->get_column_expr_by_id(view_table->table_id_,
                                                                      i + OB_APP_MIN_COLUMN_ID))) {
      // unused select item, skip following procedure
      find = true;
    } else if (OB_FAIL(old_column_exprs.push_back(col_expr))) {
      LOG_WARN("failed to push back expr", K(ret));
    }
    //select item是否存在于temp table中
    for (int64_t j = 0; OB_SUCC(ret) && !find && j < temp_table_select_list.count(); ++j) {
      ObRawExpr *temp_table_select = temp_table_select_list.at(j);
      if (OB_ISNULL(temp_table_select)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null select expr", K(ret));
      } else if (!temp_table_select->same_as(*view_select, &context)) {
        //do nothing
      } else if (OB_FAIL(new_select_list.push_back(temp_table_select))) {
        LOG_WARN("failed to push back expr", K(ret));
      } else {
        find = true;
      }
    }
    //不存在于temp table中的select expr需要转换成temp table的select item
    if (OB_SUCC(ret) && !find) {
      ObSEArray<ObAggFunRawExpr*, 8> aggr_items;
      ObSEArray<ObWinFunRawExpr*, 8> win_func_exprs;
      if (ObTransformUtils::replace_expr(view_column_list, new_column_list, view_select)) {
        LOG_WARN("failed to replace expr", K(ret));
      } else if (OB_FAIL(new_select_list.push_back(view_select))) {
        LOG_WARN("failed to push back expr", K(ret));
      } else if (OB_FAIL(ObTransformUtils::extract_aggr_expr(view_select, aggr_items))) {
        LOG_WARN("failed to extract aggr expr", K(ret));
      } else if (OB_FAIL(append(temp_table_query->get_aggr_items(), aggr_items))) {
        LOG_WARN("failed to append aggr items", K(ret));
      } else if (OB_FAIL(ObTransformUtils::extract_winfun_expr(view_select, win_func_exprs))) {
        LOG_WARN("failed to extract win func exprs", K(ret));
      } else if (OB_FAIL(append(temp_table_query->get_window_func_exprs(), win_func_exprs))) {
        LOG_WARN("failed to append win func exprs", K(ret));
      }
    }
  }
  //为temp table创建新的select item，并替换parent stmt的引用
  if (OB_SUCC(ret)) {
    ObSEArray<ObRawExpr*, 16> new_column_exprs;
    view_table->ref_query_ = temp_table_query;
    if (OB_FALSE_IT(parent_stmt->clear_column_items())) {
    } else if (OB_FAIL(ObTransformUtils::create_columns_for_view(ctx_,
                                                                *view_table,
                                                                parent_stmt,
                                                                new_select_list,
                                                                new_column_exprs))) {
      LOG_WARN("failed to create column for view", K(ret));
    } else if (OB_FAIL(parent_stmt->replace_relation_exprs(old_column_exprs, new_column_exprs))) {
      LOG_WARN("failed to replace inner stmt expr", K(ret));
    } else if (OB_FAIL(temp_table_query->adjust_subquery_list())) {
      LOG_WARN("failed to adjust subquery list", K(ret));
    }
  }
  return ret;
}

/**
 * @brief get_map_table_id
 * 找到视图中的table id对应temp table中的table id
 */
int ObTransformTempTable::get_map_table_id(ObSelectStmt *view,
                                          ObSelectStmt *temp_table_query,
                                          ObStmtMapInfo& map_info,
                                          const uint64_t &view_table_id,
                                          uint64_t &table_id)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(view) || OB_ISNULL(temp_table_query)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null stmt", K(ret));
  }
  bool find = false;
  int64_t idx = OB_INVALID_ID;
  for (int64_t i = 0; OB_SUCC(ret) && !find && i < view->get_table_size(); ++i) {
    TableItem *table = view->get_table_item(i);
    if (OB_ISNULL(table)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null table item", K(ret));
    } else if (view_table_id == table->table_id_) {
      find =  true;
      idx = i;
    }
  }
  if (OB_SUCC(ret) && (!find || OB_INVALID_ID == idx)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table shoud be found in view" ,K(view_table_id), K(ret));
  }
  find = false;
  for (int64_t i = 0; OB_SUCC(ret) && !find && i < map_info.table_map_.count(); ++i) {
    if (idx == map_info.table_map_.at(i)) {
      idx = i;
      find = true;
    }
  }
  if (OB_SUCC(ret) && (!find || OB_INVALID_ID == idx ||
      idx < 0 || idx > temp_table_query->get_table_size())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("incorrect table idx" ,K(idx), K(ret));
  }
  if (OB_SUCC(ret)) {
    TableItem *table = temp_table_query->get_table_item(idx);
    if (OB_ISNULL(table)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null table item", K(ret));
    } else {
      table_id = table->table_id_;
    }
  }
  return ret;
}

int ObTransformTempTable::project_pruning(ObIArray<TempTableInfo> &temp_table_infos,
                                          bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  ObSqlBitSet<> removed_idx;
  bool is_valid = false;
  if (OB_ISNULL(trans_param_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null trans param", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < temp_table_infos.count(); i++) {
    removed_idx.reuse();
    TempTableInfo &info = temp_table_infos.at(i);
    trans_param_->trans_stmt_ = info.temp_table_query_;
    trans_param_->trans_type_ = T_PROJECT_PRUNE;
    OPT_TRACE("try to prune project for:",info.temp_table_query_);
    if (OB_ISNULL(info.temp_table_query_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null stmt", K(ret));
    } else if (OB_FAIL(check_hint_allowed_trans(*info.temp_table_query_,
                                                T_PROJECT_PRUNE,
                                                is_valid))) {
      LOG_WARN("failed to check hint allowed prune", K(ret));
    } else if (!is_valid) {
      //do nothing
      OPT_TRACE("hint reject transform");
    } else if (OB_FAIL(ObTransformUtils::check_project_pruning_validity(*info.temp_table_query_,
                                                                        is_valid))) {
      LOG_WARN("failed to check project pruning valid", K(ret));
    } else if (!is_valid) {
      //do nothing
      OPT_TRACE("can not prune project");
    } else if (OB_FAIL(get_remove_select_item(info,
                                              removed_idx))) {
      LOG_WARN("failed to get remove select item", K(ret));
    } else if (removed_idx.is_empty()) {
      //do nothing
    } else if (OB_FAIL(remove_select_items(info, removed_idx))) {
      LOG_WARN("failed to rempve select item", K(ret));
    } else if (OB_FAIL(add_normal_temp_table_trans_hint(*info.temp_table_query_, T_PROJECT_PRUNE))) {
      LOG_WARN("failed to add transform hint", K(ret));
    } else {
      trans_happened = true;
    }
  }
  return ret;
}

int ObTransformTempTable::get_remove_select_item(TempTableInfo &info,
                                                 ObSqlBitSet<> &removed_idx)
{
  int ret = OB_SUCCESS;
  ObSqlBitSet<> column_ids;
  if (OB_ISNULL(info.temp_table_query_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null stmt", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < info.table_items_.count(); ++i) {
    ObSqlBitSet<> table_column_ids;
    if (OB_ISNULL(info.table_items_.at(i)) ||
        OB_ISNULL(info.upper_stmts_.at(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null info", K(ret));
    } else if (OB_FAIL(info.upper_stmts_.at(i)->get_column_ids(info.table_items_.at(i)->table_id_,
                                                               table_column_ids))) {
      LOG_WARN("failed to get column ids", K(ret));
    } else if (OB_FAIL(column_ids.add_members(table_column_ids))) {
      LOG_WARN("failed to add members", K(ret));
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < info.temp_table_query_->get_select_item_size(); i++) {
    bool need_remove = false;
    if (column_ids.has_member(i + OB_APP_MIN_COLUMN_ID)) {
      //do nothing
    } else if (OB_FAIL(ObTransformUtils::check_select_item_need_remove(info.temp_table_query_,
                                                                       i,
                                                                       need_remove))) {
      LOG_WARN("fail to check column in set ordrt by", K(ret));
    } else if (need_remove) {
      ret = removed_idx.add_member(i);
    } else { /*do nothing*/ }
  }
  return ret;
}

int ObTransformTempTable::remove_select_items(TempTableInfo &info,
                                              ObSqlBitSet<> &removed_idxs)
{
  int ret = OB_SUCCESS;
  int64_t count = 0;
  ObSEArray<uint64_t, 16> new_column_ids;
  ObArray<SelectItem> new_select_items;
  ObSEArray<ColumnItem, 16> new_column_items;
  ObSelectStmt *child_stmt = info.temp_table_query_;
  if (OB_ISNULL(ctx_) || OB_ISNULL(child_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("argument invalid", K(ctx_), K(ret));
  } else if (OB_FAIL(new_column_ids.prepare_allocate(child_stmt->get_select_item_size()))) {
    LOG_WARN("failed to preallocate", K(ret));
  }
  //计算老的column id对应的新column id关系
  for (int64_t i = 0; OB_SUCC(ret) && i < child_stmt->get_select_item_size(); i++) {
    new_column_ids.at(i) =  OB_INVALID_ID;
    if (!removed_idxs.has_member(i) ) {
      if (OB_FAIL(new_select_items.push_back(child_stmt->get_select_item(i)))) {
        LOG_WARN("failed to push back select item", K(ret));
      } else {
        new_column_ids.at(i) = count + OB_APP_MIN_COLUMN_ID;
        count++;
      }
    }
  }

  //更新upper stmt的column item
  for (int64_t i = 0; OB_SUCC(ret) && i < info.table_items_.count(); ++i) {
    new_column_items.reuse();
    ObDMLStmt *upper_stmt = info.upper_stmts_.at(i);
    TableItem *table = info.table_items_.at(i);
    if (OB_ISNULL(upper_stmt) || OB_ISNULL(table)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null param", K(ret));
    } else if (OB_FAIL(upper_stmt->get_column_items(table->table_id_, new_column_items))) {
      LOG_WARN("failed to get column items", K(ret));
    }
    for (int64_t j = 0; OB_SUCC(ret) && j < new_column_items.count(); ++j) {
      ColumnItem &column = new_column_items.at(j);
      uint64_t column_id = column.column_id_;
      if (column_id - OB_APP_MIN_COLUMN_ID >= new_column_ids.count()) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect column id", K(column), K(ret));
      } else {
        column.set_ref_id(table->table_id_, new_column_ids.at(column_id - OB_APP_MIN_COLUMN_ID));
      }
    }
    if (OB_FAIL(ret)) {
    } else if (OB_FAIL(upper_stmt->remove_column_item(table->table_id_))) {
      LOG_WARN("failed to remove column item", K(ret));
    } else if (OB_FAIL(upper_stmt->add_column_item(new_column_items))) {
      LOG_WARN("failed to add column item", K(ret));
    }
  }
  //消除child stmt的select item
  if (OB_SUCC(ret)) {
    if (child_stmt->is_set_stmt()) {
      if (OB_FAIL(ObTransformUtils::remove_select_items(ctx_,
                                                        *child_stmt,
                                                        removed_idxs))) {
        LOG_WARN("failed to remove select item", K(ret));
      }
    } else if (OB_FAIL(child_stmt->get_select_items().assign(new_select_items))) {
      LOG_WARN("failed to assign select item", K(ret));
    } else if (child_stmt->get_select_items().empty() &&
              OB_FAIL(ObTransformUtils::create_dummy_select_item(*child_stmt, ctx_))) {
      LOG_WARN("failed to create dummy select item", K(ret));
    } else {/*do nothing*/}
  }
  return ret;
}

// add hint about temp table transform: expand temp table, project pruning, filter pushdown
int ObTransformTempTable::add_normal_temp_table_trans_hint(ObDMLStmt &stmt, ObItemType type)
{
  int ret = OB_SUCCESS;
  ObString qb_name;
  const ObQueryHint *query_hint = NULL;
  ObMaterializeHint *hint = NULL;
  ObItemType real_type = T_INLINE == type ? T_MATERIALIZE : type;
  const ObHint *used_hint = stmt.get_stmt_hint().get_normal_hint(real_type);
  if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->allocator_) ||
      OB_ISNULL(query_hint = stmt.get_stmt_hint().query_hint_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(ctx_), K(query_hint));
  } else if (OB_FAIL(stmt.get_qb_name(qb_name))) {
    LOG_WARN("failed to get qb name", K(ret), K(stmt.get_stmt_id()));
  } else if (OB_FAIL(ObQueryHint::create_hint(ctx_->allocator_, type, hint))) {
    LOG_WARN("failed to create hint", K(ret));
  } else if (OB_FAIL(ctx_->outline_trans_hints_.push_back(hint))) {
    LOG_WARN("failed to push back hint", K(ret));
  } else if (NULL != used_hint && OB_FAIL(ctx_->add_used_trans_hint(used_hint))) {
    LOG_WARN("failed to add used trans hint", K(ret));
  } else if (OB_FAIL(ctx_->add_src_hash_val(qb_name))) {
    LOG_WARN("failed to add src hash val", K(ret));
  } else if (OB_FAIL(stmt.adjust_qb_name(ctx_->allocator_,
                                         ctx_->src_qb_name_,
                                         ctx_->src_hash_val_))) {
    LOG_WARN("failed to add used trans hint", K(ret));
  } else {
    ctx_->src_hash_val_.pop_back();
    hint->set_qb_name(qb_name);
    if (query_hint->has_outline_data()) {
      ++ctx_->trans_list_loc_;
    }
  }
  return ret;
}

//  create and add T_MATERIALIZE hint
int ObTransformTempTable::construct_transform_hint(ObDMLStmt &stmt, void *trans_params)
{
  int ret = OB_SUCCESS;
  ObMaterializeHint *hint = NULL;
  TempTableTransParam *params = static_cast<TempTableTransParam *>(trans_params);
  if (OB_ISNULL(params) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->allocator_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(params), K(ctx_));
  } else if (OB_UNLIKELY(T_MATERIALIZE != params->trans_type_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect transform type", K(ret), "type", get_type_name(params->trans_type_));
  } else if (OB_FAIL(ObQueryHint::create_hint(ctx_->allocator_, T_MATERIALIZE, hint))) {
    LOG_WARN("failed to create hint", K(ret));
  } else if (OB_FAIL(sort_materialize_stmts(params->materialize_stmts_))) {
    LOG_WARN("failed to sort stmts", K(ret));
  } else {
    Ob2DArray<MaterializeStmts *> &child_stmts = params->materialize_stmts_;
    ObSelectStmt* subquery = NULL;
    bool use_hint = false;
    const ObMaterializeHint *myhint = static_cast<const ObMaterializeHint*>(get_hint(stmt.get_stmt_hint()));
    for (int64_t i = 0; OB_SUCC(ret) && i < child_stmts.count(); ++i) {
      MaterializeStmts *subqueries = child_stmts.at(i);
      QbNameList qb_names;
      if (OB_ISNULL(subqueries)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null stmts", K(ret));
      }
      for (int j = 0; OB_SUCC(ret) && j < subqueries->count(); ++j) {
        ObString subquery_qb_name;
        ObSelectStmt *subquery = NULL;
        if (OB_ISNULL(subquery = subqueries->at(j))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("unexpected null", K(ret), K(subquery));
        } else if (OB_FAIL(subquery->get_qb_name(subquery_qb_name))) {
          LOG_WARN("failed to get qb name", K(ret), K(stmt.get_stmt_id()));
        } else if (OB_FAIL(qb_names.qb_names_.push_back(subquery_qb_name))) {
          LOG_WARN("failed to push back qb name", K(ret));
        } else if (OB_FAIL(ctx_->add_src_hash_val(subquery_qb_name))) {
          LOG_WARN("failed to add src hash val", K(ret));
        }
      }
      if (OB_FAIL(ret)) {
      } else if (OB_FAIL(hint->add_qb_name_list(qb_names))) {
        LOG_WARN("failed to add qb names", K(ret));
      } else if (NULL != myhint && myhint->enable_materialize_subquery(qb_names.qb_names_)) {
        use_hint = true;
      }
    }
    if (OB_FAIL(ret)) {
    } else if (OB_FAIL(ctx_->outline_trans_hints_.push_back(hint))) {
      LOG_WARN("failed to push back hint", K(ret));
    } else if (use_hint && OB_FAIL(ctx_->add_used_trans_hint(myhint))) {
      LOG_WARN("failed to add used trans hint", K(ret));
    } else {
      hint->set_qb_name(ctx_->src_qb_name_);
    }
  }
  return ret;
}

int ObTransformTempTable::need_transform(const common::ObIArray<ObParentDMLStmt> &parent_stmts,
                                          const int64_t current_level,
                                          const ObDMLStmt &stmt,
                                          bool &need_trans)
{
  int ret = OB_SUCCESS;
  need_trans = false;
  const ObQueryHint *query_hint = NULL;
  const ObHint *trans_hint = NULL;
  if (OB_ISNULL(ctx_) || OB_ISNULL(query_hint = stmt.get_stmt_hint().query_hint_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(ctx_), K(query_hint));
  } else if (!parent_stmts.empty() || current_level != 0 ||
             is_normal_disabled_transform(stmt)) {
    need_trans = false;
  } else if (!query_hint->has_outline_data()) {
    need_trans = true;
  } else if (NULL == (trans_hint = query_hint->get_outline_trans_hint(ctx_->trans_list_loc_))) {
    /*do nothing*/
    OPT_TRACE("outline reject transform");
  } else {
    const ObItemType hint_type = trans_hint->get_hint_type();
    need_trans = T_MATERIALIZE == hint_type
                 || T_PUSH_PRED_CTE == hint_type
                 || T_PROJECT_PRUNE == hint_type;
  }
  return ret;
}

// check hint T_MATERIALIZE for expand temp table
int ObTransformTempTable::check_hint_allowed_trans(const ObSelectStmt &subquery,
                                                   bool &force_inline,
                                                   bool &force_materialize) const
{
  int ret = OB_SUCCESS;
  force_inline = false;
  force_materialize = false;
  const ObQueryHint *query_hint = NULL;
  const ObMaterializeHint *myhint = static_cast<const ObMaterializeHint*>(get_hint(subquery.get_stmt_hint()));
  if (OB_ISNULL(ctx_) ||
      OB_ISNULL(query_hint = subquery.get_stmt_hint().query_hint_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(ctx_), K(query_hint));
  } else if (!query_hint->has_outline_data()) {
    if (NULL == myhint) {
      /* do nothing */
    } else if (OB_FAIL(ctx_->add_used_trans_hint(myhint))) {
      LOG_WARN("failed to add used trans hint", K(ret));
    } else {
      force_inline = myhint->enable_inline();
      force_materialize = myhint->enable_materialize();
    }
  } else {
    force_inline = NULL != myhint && myhint->enable_inline()
                   && query_hint->is_valid_outline_transform(ctx_->trans_list_loc_, myhint);
    force_materialize = !force_inline;
  }
  return ret;
}

int ObTransformTempTable::get_hint_force_set(const ObDMLStmt &stmt,
                                             const ObSelectStmt &subquery,
                                             QbNameList &qb_names,
                                             bool &hint_force_no_trans)

{
  int ret = OB_SUCCESS;
  hint_force_no_trans = false;
  const ObQueryHint *query_hint = NULL;
  ObString qb_name;
  if (OB_ISNULL(ctx_) ||
      OB_ISNULL(query_hint = stmt.get_stmt_hint().query_hint_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(ctx_), K(query_hint));
  } else if (OB_FAIL(subquery.get_qb_name(qb_name))) {
    LOG_WARN("failed to get qb name", K(ret));
  } else {
    const ObHint *myhint = get_hint(stmt.get_stmt_hint());
    const ObMaterializeHint *hint = static_cast<const ObMaterializeHint*>(myhint);
    if (!query_hint->has_outline_data()) {
      if (NULL == myhint ||
          !hint->has_qb_name_list()) {
        const ObHint *no_rewrite_hint = stmt.get_stmt_hint().get_no_rewrite_hint();
        if (NULL != no_rewrite_hint) {
          if (OB_FAIL(ctx_->add_used_trans_hint(no_rewrite_hint))) {
            LOG_WARN("failed to add used transform hint", K(ret));
          } else {
            hint_force_no_trans = true;
          }
        }
      } else if (OB_FAIL(hint->get_qb_name_list(qb_name, qb_names))) {
        LOG_WARN("failed to get qb name list", K(ret));
      }
    } else {
      bool is_valid = query_hint->is_valid_outline_transform(ctx_->trans_list_loc_,
                                                        myhint);
      if (!is_valid) {
        hint_force_no_trans = true;
      } else if (OB_ISNULL(myhint)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null hint", K(ret));
      } else if (OB_FAIL(hint->get_qb_name_list(qb_name, qb_names))) {
        LOG_WARN("failed to get qb name list", K(ret));
      } else if (qb_names.empty()) {
        hint_force_no_trans = true;
      }
    }
  }
  return ret;
}

int ObTransformTempTable::sort_materialize_stmts(Ob2DArray<MaterializeStmts *> &materialize_stmts)
{
  int ret = OB_SUCCESS;
  ObSEArray<std::pair<int, int>, 4> index_map;
  Ob2DArray<MaterializeStmts *> new_stmts;
  auto cmp_func1 = [](ObSelectStmt* l_stmt, ObSelectStmt* r_stmt){
    if (OB_ISNULL(l_stmt) || OB_ISNULL(r_stmt)) {
      return false;
    } else {
      return l_stmt->get_stmt_id() < r_stmt->get_stmt_id();
    }
  };
  auto cmp_func2 = [](std::pair<int,int> &lhs, std::pair<int,int> &rhs){
    return lhs.second < rhs.second;
  };
  for (int64_t i = 0; OB_SUCC(ret) && i < materialize_stmts.count(); ++i) {
    MaterializeStmts *subqueries = materialize_stmts.at(i);
    if (OB_ISNULL(subqueries)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null stmts", K(ret));
    } else {
      std::sort(subqueries->begin(), subqueries->end(), cmp_func1);
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < materialize_stmts.count(); ++i) {
    MaterializeStmts *subqueries = materialize_stmts.at(i);
    if (OB_ISNULL(subqueries)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null stmts", K(ret));
    } else if (subqueries->empty() || OB_ISNULL(subqueries->at(0))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect null stmts", K(ret));
    } else if (OB_FAIL(index_map.push_back(std::pair<int,int>(i, subqueries->at(0)->get_stmt_id())))) {
      LOG_WARN("failed to push back index", K(ret));
    }
  }
  std::sort(index_map.begin(), index_map.end(), cmp_func2);
  for (int64_t i = 0; OB_SUCC(ret) && i < index_map.count(); ++i) {
    int index = index_map.at(i).first;
    if (index < 0 || index >= materialize_stmts.count()) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("index out of range", K(ret));
    } else if (OB_FAIL(new_stmts.push_back(materialize_stmts.at(index)))) {
      LOG_WARN("failed to push back stmts", K(ret));
    }
  }
  if (OB_SUCC(ret)) {
    if (OB_FAIL(materialize_stmts.assign(new_stmts))) {
      LOG_WARN("failed to assign array", K(ret));
    }
  }
  return ret;
}

// check hint for T_PUSH_PRED_CTE and T_PROJECT_PRUNE
int ObTransformTempTable::check_hint_allowed_trans(const ObSelectStmt &ref_query,
                                                   const ObItemType check_hint_type,
                                                   bool &allowed) const
{
  int ret = OB_SUCCESS;
  const ObQueryHint *query_hint = NULL;
  const ObHint *myhint = ref_query.get_stmt_hint().get_normal_hint(check_hint_type);
  bool is_enable = (NULL != myhint && myhint->is_enable_hint());
  bool is_disable = (NULL != myhint && myhint->is_disable_hint());
  allowed = false;
  if (OB_ISNULL(ctx_) ||
      OB_ISNULL(query_hint = ref_query.get_stmt_hint().query_hint_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(ctx_), K(query_hint));
  } else if (OB_UNLIKELY(T_PUSH_PRED_CTE != check_hint_type
                         && T_PROJECT_PRUNE != check_hint_type)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect hint type", K(ret), "type", get_type_name(check_hint_type));
  } else if (!query_hint->has_outline_data()) {
    const ObHint *no_rewrite_hint = ref_query.get_stmt_hint().get_no_rewrite_hint();
    if (is_enable) {
      allowed = true;
    } else if (NULL != no_rewrite_hint || is_disable) {
      if (OB_FAIL(ctx_->add_used_trans_hint(no_rewrite_hint))) {
        LOG_WARN("failed to add used transform hint", K(ret));
      } else if (is_disable && OB_FAIL(ctx_->add_used_trans_hint(myhint))) {
        LOG_WARN("failed to add used transform hint", K(ret));
      }
    } else {
      allowed = true;
    }
  } else if (query_hint->is_valid_outline_transform(ctx_->trans_list_loc_, myhint)) {
    allowed = true;
  }
  return ret;
}

int ObTransformTempTable::get_stmt_pointers(ObDMLStmt &root_stmt,
                                            ObIArray<ObSelectStmt *> &stmts,
                                            hash::ObHashMap<uint64_t, ObParentDMLStmt> &parent_map,
                                            ObIArray<ObSelectStmtPointer> &stmt_ptrs)
{
  int ret = OB_SUCCESS;
  ObArray<TempTableInfo> temp_table_infos;
  if (OB_FAIL(root_stmt.collect_temp_table_infos(temp_table_infos))) {
    LOG_WARN("failed to collect temp table infos", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < stmts.count(); i ++) {
    uint64_t key = reinterpret_cast<uint64_t>(stmts.at(i));
    ObSelectStmtPointer stmt_ptr;
    ObParentDMLStmt parent_stmt;
    bool is_find = false;
    if (OB_FAIL(parent_map.get_refactored(key, parent_stmt))) {
      LOG_WARN("failed to get value", K(ret));
    } else if (NULL != parent_stmt.stmt_) {
      int64_t pos = 0;
      ObDMLStmt* stmt = parent_stmt.stmt_;
      if (stmt->is_select_stmt()) {
        ObSelectStmt *sel_stmt = static_cast<ObSelectStmt *>(stmt);
        if (parent_stmt.pos_ < sel_stmt->get_set_query().count()) {
          is_find = true;
          OZ(stmt_ptr.add_ref(&sel_stmt->get_set_query().at(parent_stmt.pos_)));
        } else {
          pos += sel_stmt->get_set_query().count();
        }
      }
      for (int64_t j = 0; OB_SUCC(ret) && !is_find && j < stmt->get_table_size(); ++j) {
        TableItem *table_item = stmt->get_table_item(j);
        if (OB_ISNULL(table_item)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("table_item is null", K(i));
        } else if (table_item->is_generated_table()) {
          if (parent_stmt.pos_ == pos) {
            is_find = true;
            OZ(stmt_ptr.add_ref(&table_item->ref_query_));
          } else {
            pos++;
          }
        } else { /*do nothing*/ }
      }
      for (int64_t j = 0; OB_SUCC(ret) && !is_find && j < stmt->get_subquery_expr_size(); ++j) {
        ObQueryRefRawExpr *subquery_ref = stmt->get_subquery_exprs().at(j);
        if (OB_ISNULL(subquery_ref)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("subquery reference is null", K(subquery_ref));
        } else if (parent_stmt.pos_ == pos) {
          is_find = true;
          OZ(stmt_ptr.add_ref(&subquery_ref->get_ref_stmt()));
        } else {
          pos++;
        }
      }
    } else {
      for (int64_t j = 0; OB_SUCC(ret) && !is_find && j < temp_table_infos.count(); ++j) {
        if (stmts.at(i) == temp_table_infos.at(j).temp_table_query_) {
          is_find = true;
          for (int64_t k = 0; OB_SUCC(ret) && k < temp_table_infos.at(j).table_items_.count(); ++k) {
            OZ(stmt_ptr.add_ref(&temp_table_infos.at(j).table_items_.at(k)->ref_query_));
          }
        }
      }
    }
    if (!is_find) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("not find stmt", K(parent_stmt), KPC(stmts.at(i)));
    }
    OZ(stmt_ptrs.push_back(stmt_ptr));
  }

  return ret;
}

int ObTransformTempTable::adjust_transformed_stmt(ObIArray<ObSelectStmtPointer> &stmt_ptrs,
                                                  ObIArray<ObSelectStmt *> &stmts,
                                                  ObIArray<ObSelectStmt *> *origin_stmts)
{
  int ret = OB_SUCCESS;
  if (stmts.count() != stmt_ptrs.count()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected count", K(ret));
  } else if (origin_stmts != NULL) {
    origin_stmts->reuse();
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < stmt_ptrs.count(); i ++) {
    ObSelectStmt *origin_stmt = NULL;
    if (OB_ISNULL(stmts.at(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null stmt", K(ret));
    } else if (NULL != origin_stmts && OB_FAIL(stmt_ptrs.at(i).get(origin_stmt))) {
      LOG_WARN("failed to get ptr", K(ret));
    } else if (NULL != origin_stmts && OB_FAIL(origin_stmts->push_back(origin_stmt))) {
      LOG_WARN("failed to push back", K(ret));
    } else if (OB_FAIL(stmt_ptrs.at(i).set(stmts.at(i)))) {
      LOG_WARN("failed to set ptr", K(ret));
    }
  }
  return ret;
}

int ObTransformTempTable::accept_cte_transform(ObDMLStmt &origin_root_stmt,
                                               TableItem *temp_table,
                                               common::ObIArray<ObSelectStmt *> &origin_stmts,
                                               common::ObIArray<ObSelectStmt *> &trans_stmts,
                                               common::ObIArray<ObSelectStmt *> &accept_stmts,
                                               hash::ObHashMap<uint64_t, ObParentDMLStmt> &parent_map,
                                               bool force_accept,
                                               bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  cost_based_trans_tried_ = true;
  ObSEArray<double, 2> origin_costs;
  ObSEArray<double, 2> trans_costs;
  ObSEArray<bool, 2> do_use_cte;
  ObSEArray<ObSelectStmtPointer, 2> stmt_ptrs;
  double temp_table_costs = 0.0;
  double dummy = 0.0;
  double temp_table_profit = 0.0;
  STOP_OPT_TRACE;
  if (OB_ISNULL(ctx_) || OB_UNLIKELY(origin_stmts.count() != trans_stmts.count())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected param", K(ret), K(ctx_));
  } else if (OB_FAIL(do_use_cte.prepare_allocate(origin_stmts.count()))) {
    LOG_WARN("failed to prepare allocate", K(ret));
  } else if (OB_FAIL(get_stmt_pointers(origin_root_stmt, origin_stmts, parent_map, stmt_ptrs))) {
    LOG_WARN("failed to get stmt pointers", K(ret));
  } else if (force_accept) {
    trans_happened = true;
  } else if (ctx_->is_set_stmt_oversize_) {
    LOG_TRACE("not accept transform because large set stmt", K(ctx_->is_set_stmt_oversize_));
  } else if (OB_FAIL(evaluate_cte_cost(origin_root_stmt, false, origin_stmts, stmt_ptrs, origin_costs, NULL, dummy))) {
    LOG_WARN("failed to evaluate cost for the origin stmt", K(ret));
  } else if (OB_FAIL(evaluate_cte_cost(origin_root_stmt, true, trans_stmts, stmt_ptrs, trans_costs, temp_table, temp_table_costs))) {
    LOG_WARN("failed to evaluate cost for the transform stmt", K(ret));
  } else if (OB_UNLIKELY(origin_costs.count() != trans_costs.count()) ||
             OB_UNLIKELY(origin_costs.count() != do_use_cte.count())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected array size", K(origin_costs), K(trans_costs), K(trans_happened));
  }
  RESUME_OPT_TRACE;
  if (OB_SUCC(ret)) {
    if (!force_accept) {
      // Only consider stmt whose cost is reduced after extracting cte.
      int64_t accept_cte_cnt = 0;
      for (int64_t i = 0; i < origin_costs.count(); i ++) {
        if (origin_costs.at(i) > trans_costs.at(i)) {
          do_use_cte.at(i) = true;
          temp_table_profit += origin_costs.at(i) - trans_costs.at(i);
          accept_cte_cnt ++;
        }
      }

      // Extract CTE if the profit is greater than the cost
      trans_happened = (temp_table_profit > temp_table_costs) && (accept_cte_cnt > 1);
    } else {
      for (int64_t i = 0; i < do_use_cte.count(); i ++) {
        do_use_cte.at(i) = true;
      }
    }
  }

  if (OB_FAIL(ret)) {
  } else if (!trans_happened) {
    OPT_TRACE("reject transform because the cost is increased");
    OPT_TRACE("The cost of extract cte :", temp_table_costs);
    OPT_TRACE("The profit of extract cte :", temp_table_profit);
    LOG_TRACE("reject transform because the cost is increased",
                     K_(ctx_->is_set_stmt_oversize), K(temp_table_costs),
                     K(temp_table_profit), K(origin_costs), K(trans_costs));
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < origin_stmts.count(); i ++) {
      if (do_use_cte.at(i)) {
        // root stmt will not extract cte
        if (OB_FAIL(stmt_ptrs.at(i).set(trans_stmts.at(i)))) {
          LOG_WARN("failed to set ptr", K(ret));
        } else if (OB_FAIL(accept_stmts.push_back(origin_stmts.at(i)))) {
          LOG_WARN("failed to push back", K(ret));
        }
        OPT_TRACE("Materialize stmt :", trans_stmts.at(i));
      }
    }
    if (force_accept) {
      OPT_TRACE("accept cte because of the hint");
    } else {
      OPT_TRACE("accept cte because the cost is decreased");
      OPT_TRACE("The cost of extract cte :", temp_table_costs);
      OPT_TRACE("The profit of extract cte :", temp_table_profit);
      LOG_TRACE("accept transform because the cost is decreased",
                     K_(ctx_->is_set_stmt_oversize), K(temp_table_costs),
                     K(temp_table_profit), K(origin_costs), K(trans_costs));
    }
  }
  return ret;
}

int ObTransformTempTable::evaluate_cte_cost(ObDMLStmt &root_stmt,
                                            bool is_trans_stmt,
                                            ObIArray<ObSelectStmt *> &stmts,
                                            ObIArray<ObSelectStmtPointer> &stmt_ptrs,
                                            ObIArray<double> &costs,
                                            TableItem *temp_table,
                                            double &temp_table_cost)
{
  int ret = OB_SUCCESS;
  ObEvalCostHelper eval_cost_helper;
  temp_table_cost = 0.0;
  if (OB_ISNULL(ctx_) || OB_UNLIKELY(!ctx_->is_valid())
      || OB_ISNULL(ctx_->exec_ctx_->get_physical_plan_ctx())
      || OB_ISNULL(ctx_->exec_ctx_->get_stmt_factory())
      || OB_ISNULL(ctx_->exec_ctx_->get_stmt_factory()->get_query_ctx())
      || OB_ISNULL(root_stmt.get_query_ctx())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("params are invalid", K(ret), K(ctx_), K(root_stmt));
  } else if (OB_FAIL(eval_cost_helper.fill_helper(*ctx_->exec_ctx_->get_physical_plan_ctx(),
                                                  *root_stmt.get_query_ctx(), *ctx_))) {
    LOG_WARN("failed to fill eval cost helper", K(ret));
  } else {
    ctx_->eval_cost_ = true;
    ParamStore &param_store = ctx_->exec_ctx_->get_physical_plan_ctx()->get_param_store_for_update();
    lib::ContextParam param;
    ObArray<ObParentDMLStmt> dummy;
    ObDMLStmt *copy_root_stmt = NULL;
    ObSEArray<ObSelectStmt*, 2> origin_stmts;
    param.set_mem_attr(ctx_->session_info_->get_effective_tenant_id(),
                       "TempTableCost",
                       ObCtxIds::DEFAULT_CTX_ID)
       .set_properties(lib::USE_TL_PAGE_OPTIONAL)
       .set_page_size(OB_MALLOC_NORMAL_BLOCK_SIZE);
    ObSelectStmt * copy_cte_stmt = NULL;
    common::ObSEArray<ObSelectStmt *, 2> copy_stmts;
    if (OB_FAIL(prepare_eval_cte_cost_stmt(root_stmt,
                                           stmts,
                                           NULL != temp_table ? temp_table->ref_query_ : NULL,
                                           stmt_ptrs,
                                           copy_root_stmt,
                                           copy_stmts,
                                           copy_cte_stmt,
                                           is_trans_stmt))) {
      LOG_WARN("failed to prepare eval cost stmt", K(ret));
    } else {
      CREATE_WITH_TEMP_CONTEXT(param) {
        ObRawExprFactory tmp_expr_factory(CURRENT_CONTEXT->get_arena_allocator());
        HEAP_VAR(ObOptimizerContext, optctx,
                ctx_->session_info_,
                ctx_->exec_ctx_,
                ctx_->sql_schema_guard_,
                ctx_->opt_stat_mgr_,
                CURRENT_CONTEXT->get_arena_allocator(),
                &ctx_->exec_ctx_->get_physical_plan_ctx()->get_param_store(),
                *ctx_->self_addr_,
                GCTX.srv_rpc_proxy_,
                root_stmt.get_query_ctx()->get_global_hint(),
                tmp_expr_factory,
                copy_root_stmt,
                false,
                ctx_->exec_ctx_->get_stmt_factory()->get_query_ctx()) {
          // optctx.set_only_ds_basic_stat(true);
          ObOptimizer optimizer(optctx);
          if (OB_FAIL(optimizer.get_cte_optimization_cost(*copy_root_stmt,
                                                          copy_cte_stmt,
                                                          copy_stmts,
                                                          temp_table_cost,
                                                          costs))) {
            LOG_WARN("failed to get cost", K(ret));
          }
        }
        if (OB_SUCC(ret)) {
          if (OB_FAIL(eval_cost_helper.recover_context(*ctx_->exec_ctx_->get_physical_plan_ctx(),
                                                      *ctx_->exec_ctx_->get_stmt_factory()->get_query_ctx(),
                                                      *ctx_))) {
            LOG_WARN("failed to recover context", K(ret));
          } else if (OB_FAIL(ObTransformUtils::free_stmt(*ctx_->stmt_factory_, copy_root_stmt))) {
            LOG_WARN("failed to free stmt", K(ret));
          }
        }
      }
    }
  }
  return ret;
}

int ObTransformTempTable::prepare_eval_cte_cost_stmt(ObDMLStmt &root_stmt,
                                                     ObIArray<ObSelectStmt *> &trans_stmts,
                                                     ObSelectStmt *cte_query,
                                                     ObIArray<ObSelectStmtPointer> &stmt_ptrs,
                                                     ObDMLStmt *&copied_stmt,
                                                     ObIArray<ObSelectStmt *> &copied_trans_stmts,
                                                     ObSelectStmt *&copied_cte_query,
                                                     bool is_trans_stmt)
{
  int ret = OB_SUCCESS;
  ObSEArray<ObSelectStmt*, 2> old_temp_table_stmts;
  ObSEArray<ObSelectStmt*, 2> new_temp_table_stmts;
  ObSEArray<ObSelectStmt*, 2> origin_stmts;
  ObDMLStmt *copied_trans_stmt = NULL;
  ObString cur_qb_name;
  ObDMLStmt *temp = NULL;
  hash::ObHashMap<uint64_t, ObDMLStmt *> copy_stmt_map;
  ObDMLStmt *dml_stmt_val = NULL;
  if (OB_ISNULL(ctx_) || OB_UNLIKELY(!ctx_->is_valid()) || OB_ISNULL(root_stmt.get_query_ctx())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("params are invalid", K(ret), K(ctx_), K(root_stmt.get_query_ctx()));
  } else if (OB_FAIL(adjust_transformed_stmt(stmt_ptrs, trans_stmts, &origin_stmts))) {
    LOG_WARN("failed to adjust transformed stmt", K(ret));
  } else if (OB_FAIL(ObTransformUtils::deep_copy_stmt(*ctx_->stmt_factory_, *ctx_->expr_factory_,
                                                      &root_stmt, copied_stmt))) {
    LOG_WARN("failed to deep copy stmt", K(ret));
  } else if (OB_FAIL(deep_copy_temp_table(*copied_stmt,
                                          *ctx_->stmt_factory_,
                                          *ctx_->expr_factory_,
                                          old_temp_table_stmts,
                                          new_temp_table_stmts))) {
    LOG_WARN("failed to deep copy temp table", K(ret));
  } else if (OB_FAIL(copy_stmt_map.create(128, "TempTable"))) {
    LOG_WARN("failed to init stmt map", K(ret));
  } else if (OB_FAIL(ObTransformUtils::get_stmt_map_after_copy(&root_stmt, copied_stmt, copy_stmt_map))) {
    LOG_WARN("failed to get stmt map", K(ret));
  } else if (NULL != cte_query) {
    uint64_t key = reinterpret_cast<uint64_t>(cte_query);
    if (OB_FAIL(copy_stmt_map.get_refactored(key, dml_stmt_val))) {
      LOG_WARN("failed to get hash map", K(ret));
    } else if (OB_ISNULL(dml_stmt_val) || OB_UNLIKELY(!dml_stmt_val->is_select_stmt())) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected stmt", K(ret), KPC(dml_stmt_val));
    } else {
      copied_cte_query = static_cast<ObSelectStmt *>(dml_stmt_val);
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < trans_stmts.count(); i ++) {
    dml_stmt_val = NULL;
    uint64_t key = reinterpret_cast<uint64_t>(trans_stmts.at(i));
    if (OB_FAIL(copy_stmt_map.get_refactored(key, dml_stmt_val))) {
      LOG_WARN("failed to get stmt from hash map", K(ret));
    } else if (OB_ISNULL(dml_stmt_val) || OB_UNLIKELY(!dml_stmt_val->is_select_stmt())) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected stmt", K(ret), KPC(dml_stmt_val));
    } else if (OB_FAIL(copied_trans_stmts.push_back(static_cast<ObSelectStmt *>(dml_stmt_val)))) {
      LOG_WARN("failed to push back", K(ret));
    }
  }
  if (OB_FAIL(ret)) {
  } else if (OB_FAIL(copy_stmt_map.destroy())) {
    LOG_WARN("failed to destroy map", K(ret));
  } else if (OB_FAIL(adjust_transformed_stmt(stmt_ptrs, origin_stmts, NULL))) {
      LOG_WARN("failed to adjust transformed stmt", K(ret));
  } else if (is_trans_stmt) {
    for (int64_t i = 0; OB_SUCC(ret) && i < trans_stmts.count(); i ++) {
      ObSelectStmt *stmt = trans_stmts.at(i);
      if (OB_ISNULL(stmt)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("null stmt", K(ret));
      } else if (OB_FAIL(stmt->get_qb_name(cur_qb_name))) {
        LOG_WARN("failed to get qb name", K(ret));
      } else if (OB_FAIL(ObTransformRule::construct_transform_hint(*stmt, NULL))) {
        // To get happended transform rule by outline_trans_hints_ during evaluating cost,
        // here construct and add hint for cost based transform rule.
        // Added hint only filled qb name parameter.
        LOG_WARN("failed to construct transform hint", K(ret), K(stmt->get_stmt_id()),
                                                      K(ctx_->src_qb_name_), K(get_transformer_type()));
      } else if (cur_qb_name != ctx_->src_qb_name_) {
        ctx_->src_qb_name_ = cur_qb_name;
      } else if (OB_FAIL(copied_stmt->get_stmt_by_stmt_id(stmt->get_stmt_id(), copied_trans_stmt))) {
        LOG_WARN("failed to get stmt by stmt id", K(ret), K(stmt->get_stmt_id()), K(*copied_stmt));
      } else if(OB_ISNULL(copied_trans_stmt)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null stmt", K(ret), K(stmt->get_stmt_id()), K(*copied_stmt));
      } else if (OB_FAIL(copied_trans_stmt->adjust_qb_name(ctx_->allocator_,
                                                           ctx_->src_qb_name_,
                                                           ctx_->src_hash_val_))) {
        LOG_WARN("failed to adjust statement id", K(ret));
      }
    }
  }

  if (OB_FAIL(ret)) {
  } else if (OB_FAIL(copied_stmt->formalize_stmt(ctx_->session_info_))) {
    LOG_WARN("failed to formalize stmt", K(ret));
  } else if (OB_FAIL(copied_stmt->formalize_stmt_expr_reference(ctx_->expr_factory_,
                                                                ctx_->session_info_))) {
    LOG_WARN("failed to formalize stmt", K(ret));
  }
  return ret;
}

}//namespace sql
}//namespace oceanbase