ob_select_resolver.cpp

/**
 * 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_RESV
#include "sql/resolver/dml/ob_select_resolver.h"
#include "lib/oblog/ob_log_module.h"
#include "lib/json/ob_json_print_utils.h"  // for SJ
#include "lib/time/ob_time_utility.h"
#include "lib/profile/ob_perf_event.h"
#include "lib/string/ob_sql_string.h"
#include "common/sql_mode/ob_sql_mode_utils.h"
#include "share/ob_time_utility2.h"
#include "share/inner_table/ob_inner_table_schema.h"
#include "sql/ob_sql_utils.h"
#include "sql/resolver/expr/ob_raw_expr_info_extractor.h"
#include "sql/resolver/expr/ob_raw_expr_canonicalizer_impl.h"
#include "sql/resolver/dml/ob_aggr_expr_push_up_analyzer.h"
#include "sql/resolver/dml/ob_group_by_checker.h"
#include "sql/resolver/expr/ob_raw_expr.h"
#include "sql/session/ob_sql_session_info.h"
#include "sql/resolver/ob_resolver_utils.h"
#include "sql/engine/expr/ob_expr_version.h"
#include "sql/optimizer/ob_optimizer_util.h"
#include "share/object/ob_obj_cast.h"
#include "sql/rewrite/ob_stmt_comparer.h"
#include "sql/rewrite/ob_transform_utils.h"
#include "common/ob_smart_call.h"
#include "sql/engine/expr/ob_expr_regexp_context.h"
namespace oceanbase
{
using namespace common;
using namespace share;
using namespace share::schema;
using namespace jit::expr;
namespace sql
{

ObSelectResolver::ObSelectResolver(ObResolverParams &params)
  : ObDMLResolver(params),
    current_recursive_cte_table_item_(NULL),
    current_cte_involed_stmt_(NULL),
    has_calc_found_rows_(false),
    has_top_limit_(false),
    in_set_query_(false),
    is_sub_stmt_(false),
    standard_group_checker_(),
    transpose_item_(NULL),
    is_left_child_(false),
    having_has_self_column_(false),
    has_grouping_(false),
    has_group_by_clause_(false),
    has_nested_aggr_(false)
{
  params_.is_from_create_view_ = params.is_from_create_view_;
  params_.is_from_create_table_ = params.is_from_create_table_;
  params_.is_specified_col_name_ = params.is_specified_col_name_;
  auto_name_id_ = 1;
}

ObSelectResolver::~ObSelectResolver()
{
}

ObSelectStmt *ObSelectResolver::get_select_stmt()
{
  return static_cast<ObSelectStmt*>(stmt_);
}

int ObSelectResolver::resolve_set_query(const ParseNode &parse_tree)
{
  int ret = OB_SUCCESS;
  bool recursive_union = false;
  bool need_swap_child = false;

  if (cte_ctx_.is_with_resolver() && OB_FAIL(check_query_is_recursive_union(parse_tree, recursive_union, need_swap_child))) {
    LOG_WARN("failed to do resolve set query", K(ret));
  } else if (recursive_union) {
    if (OB_FAIL(do_resolve_set_query_in_cte(parse_tree, need_swap_child))) {
      LOG_WARN("failed to do resolve set query in cte", K(ret));
    }
  } else if (OB_FAIL(do_resolve_set_query(parse_tree))) {
    LOG_WARN("failed to do resolve set query", K(ret));
  }
  return ret;
}

int ObSelectResolver::do_check_basic_table_in_cte_recursive_union(const ParseNode &parse_tree, bool &recursive_union)
{
  int ret = OB_SUCCESS;
  const ParseNode *table_node = &parse_tree;
  bool no_defined_database_name = true;

  if (T_ORG == parse_tree.type_) {
    table_node = parse_tree.children_[0];
  } else if (T_ALIAS == parse_tree.type_) {
    table_node = parse_tree.children_[0];
  }
  no_defined_database_name = (table_node->children_[0] == NULL);
  // compare current table name is equal to current cte table name
  ObString tblname(table_node->str_len_, table_node->str_value_);
  if (cte_ctx_.is_with_resolver()
      && ObCharset::case_insensitive_equal(cte_ctx_.current_cte_table_name_, tblname)
      && tblname.length()
      && no_defined_database_name) {
    recursive_union = true;
  }
  return ret;
}


// recursive test node to find a cte table
int ObSelectResolver::do_check_node_in_cte_recursive_union(const ParseNode* current_node, bool &recursive_union) 
{
  int ret = OB_SUCCESS;
  while (OB_NOT_NULL(current_node) && current_node->type_ != T_RELATION_FACTOR && current_node->num_child_ == 1) {
    // the current node with only one child node expands immediately to prevent the recursive level from being too high
    current_node = current_node->children_[0];
  }

  if (OB_ISNULL(current_node)) {
  } else if (current_node->type_ == T_RELATION_FACTOR) {
    // find relation factor, check it
    if (OB_FAIL(do_check_basic_table_in_cte_recursive_union(*current_node, recursive_union))) {
      LOG_WARN("failed to do check basic table is in cte recursive union", K(ret));
    } 
  } else {
    for (int32_t i = 0; OB_SUCC(ret) && i < current_node->num_child_ && !recursive_union; i += 1) {
      if (OB_FAIL(SMART_CALL(do_check_node_in_cte_recursive_union(current_node->children_[i], recursive_union)))) {
        LOG_WARN("failed to do check node is in cte recursive union", K(ret));
      }
    }
  }

  return ret;
}

// test if a query node contains recursive nodes
int ObSelectResolver::check_query_is_recursive_union(const ParseNode &parse_tree, bool &recursive_union, bool &need_swap_child)
{
  int ret = OB_SUCCESS;
  ParseNode *left_node = NULL;
  ParseNode *right_node = NULL;
  
  bool left_recursive_union = false;
  bool right_recursive_union = false;

  if (OB_ISNULL(left_node = parse_tree.children_[PARSE_SELECT_FORMER])
      || OB_ISNULL(right_node = parse_tree.children_[PARSE_SELECT_LATER])
      || OB_ISNULL(parse_tree.children_[PARSE_SELECT_SET])) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (OB_FAIL(do_check_node_in_cte_recursive_union(left_node, left_recursive_union))) {
    //test left branch
    LOG_WARN("failed to check set query in cte is recursive union", K(ret));
  } else if (OB_FAIL(do_check_node_in_cte_recursive_union(right_node, right_recursive_union))) {
    //test right branch
    LOG_WARN("failed to check set query in cte is recursive union", K(ret));
  }
  
  recursive_union = left_recursive_union || right_recursive_union;

  /**
    *  为什么需要交换左右支？
    *  with cte(c1) as (select 1 from dual union all select c1+1 from cte where c1 < 100)
    *  select * from cte;
    *
    *  with cte(c1) as (select c1+1 from cte where c1 < 100 && select 1 from dual)
    *  select * from cte;
    *
    *  oracle支持这两种写法。之前在cte的实现时是误判了，认为只能左边是anchor member。
    *  对于recursive cte的revolber解析来说，左右支解析是敏感的，右边的解析依赖于左边先被
    *  解析。为什么呢？因为假设在没有解析左边的时候就开始解析右边，我们完全不知道cte这张表
    *  的c1列是什么类型。所以这里先判断是否需要交换左右支。
    */
  if (is_oracle_mode() && left_recursive_union && !right_recursive_union) {
    need_swap_child = true;
  }

  return ret;
}

// resolve 对于非cte, union, check child 能否展平（limit、order、fetch）
int ObSelectResolver::do_resolve_set_query_in_cte(const ParseNode &parse_tree, bool swap_branch)
{
  int ret = OB_SUCCESS;
  bool need_swap_child = false;
  ObSelectStmt *select_stmt = get_select_stmt();
  SelectParserOffset left_member = PARSE_SELECT_FORMER;
  SelectParserOffset right_member = PARSE_SELECT_LATER;
  ObSelectResolver left_resolver(params_);
  ObSelectResolver right_resolver(params_);
  ObSelectStmt *left_select_stmt = NULL;
  ObSelectStmt *right_select_stmt = NULL;

  left_resolver.set_current_level(current_level_);
  left_resolver.set_current_view_level(current_view_level_);
  left_resolver.set_in_set_query(true);
  left_resolver.set_parent_namespace_resolver(parent_namespace_resolver_);
  left_resolver.set_calc_found_rows(has_calc_found_rows_);

  right_resolver.set_current_level(current_level_);
  right_resolver.set_current_view_level(current_view_level_);
  right_resolver.set_in_set_query(true);
  right_resolver.set_parent_namespace_resolver(parent_namespace_resolver_);

  OC( (left_resolver.set_cte_ctx)(cte_ctx_) );
  OC( (right_resolver.set_cte_ctx)(cte_ctx_) );

  left_resolver.cte_ctx_.set_recursive_left_branch();

  if (swap_branch) {
    left_member = PARSE_SELECT_LATER;
    right_member = PARSE_SELECT_FORMER;
  }

  if (OB_FAIL(ret)) {
  } else if (OB_ISNULL(select_stmt) || OB_ISNULL(parse_tree.children_[PARSE_SELECT_FORMER])
      || OB_ISNULL(parse_tree.children_[PARSE_SELECT_LATER])) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(select_stmt),
        K(parse_tree.children_[PARSE_SELECT_FORMER]), K(parse_tree.children_[PARSE_SELECT_LATER]));
  } else if (parse_tree.children_[PARSE_SELECT_LATER]->value_ == 1) {
    ret = OB_ERR_ILLEGAL_ID;
    LOG_WARN("Select for update statement can not process set query");
  } else if (OB_FAIL(set_stmt_set_type(select_stmt, parse_tree.children_[PARSE_SELECT_SET]))) {
    LOG_WARN("failed to set stmt set type", K(ret));
  } else if (OB_FAIL(resolve_with_clause(parse_tree.children_[PARSE_SELECT_WITH]))) {
    LOG_WARN("failed to resolve with clause", K(ret));
  } else if (OB_FAIL(add_cte_table_to_children(left_resolver)) ||
             OB_FAIL(add_cte_table_to_children(right_resolver))) {
    LOG_WARN("failed to add cte table to children", K(ret));
  } else if (OB_FAIL(left_resolver.resolve_child_stmt(*(parse_tree.children_[left_member])))) {
    if (OB_ERR_NEED_INIT_BRANCH_IN_RECURSIVE_CTE == ret) {
      if (is_oracle_mode()){
        /* do nothing */
        LOG_WARN("Failed to resolve child stmt", K(ret));
      } else if (params_.has_recursive_word_) {
        ret = OB_ERR_CTE_NEED_QUERY_BLOCKS;  // mysql error: Recursive Common Table Expression 'cte' should have one or
                                             // more non-recursive query blocks followed by one or more recursive ones
        LOG_WARN("Failed to resolve child stmt", K(ret));
      } else {
        ret = OB_TABLE_NOT_EXIST;
        LOG_WARN("cte table shows in left union stmt without recursive keyword", K(ret));
      }
    } else {
      LOG_WARN("Failed to find anchor member", K(ret));
    }
  } else {
    left_select_stmt = left_resolver.get_child_stmt();

    if (swap_branch) {
      select_stmt->set_children_swapped();
    }
  } 
  
  if (OB_SUCC(ret)) {
    if (!params_.has_cte_param_list_ && 
        !left_resolver.cte_ctx_.cte_col_names_.empty()) {
      right_resolver.cte_ctx_.cte_col_names_.reset();
      cte_ctx_.cte_col_names_.reset();
      for (int64_t i = 0; OB_SUCC(ret) && i < left_resolver.cte_ctx_.cte_col_names_.count(); ++i) {
        // to right resolver
        if (OB_FAIL(right_resolver.cte_ctx_.cte_col_names_.push_back(
                left_resolver.cte_ctx_.cte_col_names_.at(i)))) {
          LOG_WARN("pass cte column name to child resolver failed", K(ret));
        // to parent resolver
        } else if (OB_FAIL(cte_ctx_.cte_col_names_.push_back(
                left_resolver.cte_ctx_.cte_col_names_.at(i)))) {
          LOG_WARN("pass cte column name to child resolver failed", K(ret));
        }
      }
    }
  }

  if (OB_FAIL(ret)) {
  } else if (OB_FALSE_IT(right_resolver.cte_ctx_.set_recursive_right_branch(left_select_stmt,
                            parse_tree.children_[left_member], !select_stmt->is_set_distinct()))) {
  } else if (OB_FAIL(right_resolver.resolve_child_stmt(*parse_tree.children_[right_member]))) {
    LOG_WARN("failed to resolve child stmt", K(ret));
  } else if (OB_FAIL(resolve_into_clause(ObResolverUtils::get_select_into_node(parse_tree)))) {
    LOG_WARN("failed to resolve into clause", K(ret));
  } else if (OB_ISNULL(right_select_stmt = right_resolver.get_child_stmt())
             || OB_ISNULL(left_select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(left_select_stmt), K(right_select_stmt));
  } else {
    select_stmt->add_set_query(left_select_stmt);
    select_stmt->add_set_query(right_select_stmt);
    select_stmt->set_calc_found_rows(left_select_stmt->is_calc_found_rows());
    if (OB_FAIL(ObOptimizerUtil::gen_set_target_list(allocator_, session_info_,
                                                     params_.expr_factory_, *left_select_stmt,
                                                     *right_select_stmt, select_stmt,
                                                     !is_oracle_mode()))) {
      LOG_WARN("failed to gen set target list.", K(ret));
    } else if (!right_resolver.cte_ctx_.is_recursive()) {
      /*do nothing*/
    } else if (OB_FAIL(check_cte_set_types(*left_select_stmt, *right_select_stmt))) {
      LOG_WARN("check cte set types", K(ret));
    } else if (select_stmt->is_set_distinct() || ObSelectStmt::UNION != select_stmt->get_set_op()) {
      // 必须是union all
      ret = OB_NOT_SUPPORTED;
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "recursive WITH clause using operation not union all");
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "recursive WITH clause using union (distinct) operation");
    } else if (OB_FAIL(check_recursive_cte_limited())) {
      LOG_WARN("failed to check recursive cte limited", K(ret));
    } else if (OB_NOT_NULL(parse_tree.children_[PARSE_SELECT_LIMIT])) {
      ret = OB_ERR_CTE_ILLEGAL_RECURSIVE_BRANCH;
      LOG_WARN("use limit clause in the recursive cte is not allowed", K(ret));
    } else {
      /**
      * 设置这个一个set query是否是with clause中的递归类型
      * 这个带有set op 为union的stmt，被标记为递归union，在后续展开时，平常的union all算子将被R union算子取代
      */
      select_stmt->set_recursive_union(true);
    }
  }

  if (OB_FAIL(ret)) {
  } else if (parse_tree.children_[PARSE_SELECT_FOR_UPD] != NULL && is_oracle_mode()) {
    ret = OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED;
    LOG_WARN("set stmt can not have for update clause", K(ret));
  } else if (OB_FAIL(resolve_order_clause(parse_tree.children_[PARSE_SELECT_ORDER]))) {
    LOG_WARN("failed to resolve order clause", K(ret));
  } else if (OB_FAIL(resolve_limit_clause(parse_tree.children_[PARSE_SELECT_LIMIT]))) {
    LOG_WARN("failed to resolve limit clause", K(ret));
  } else if (OB_FAIL(resolve_fetch_clause(parse_tree.children_[PARSE_SELECT_FETCH]))) {
    LOG_WARN("failed to resolve fetch clause", K(ret));
  } else if (OB_FAIL(resolve_check_option_clause(parse_tree.children_[PARSE_SELECT_WITH_CHECK_OPTION]))) {
    LOG_WARN("failed to resolve check option clause", K(ret));
  } else if (OB_FAIL(resolve_set_query_hint())) {
    LOG_WARN("failed to resolve set query hint", K(ret));
  } else if (OB_FAIL(select_stmt->formalize_stmt(session_info_))) {
    LOG_WARN("failed to formalize stmt", K(ret));
  } else if (OB_FAIL(check_order_by())) {
    LOG_WARN("failed to check order by", K(ret));
  } else if (OB_FAIL(check_udt_set_query())) {
    LOG_WARN("failed to check udt set query", K(ret));
  } else if (has_top_limit_) {
    has_top_limit_ = false;
    select_stmt->set_has_top_limit(NULL != parse_tree.children_[PARSE_SELECT_LIMIT]);
  }
  return ret;
}

// just add id name pair to generate qb name.
int ObSelectResolver::resolve_set_query_hint()
{
  int ret = OB_SUCCESS;
  ObDMLStmt *stmt = NULL;
  ObQueryCtx *query_ctx = NULL;
  ObString qb_name;
  if (OB_ISNULL(stmt = get_stmt()) || OB_ISNULL(query_ctx = stmt->get_query_ctx())) {
    ret = OB_NOT_INIT;
    LOG_WARN("Stmt and query ctx should not be NULL. ", K(ret), K(stmt), K(query_ctx));
  } else if (OB_FAIL(query_ctx->get_query_hint_for_update().set_stmt_id_map_info(*stmt, qb_name))) {
    LOG_WARN("failed to add id name pair", K(ret));
  }
  return ret;
}

int ObSelectResolver::do_resolve_set_query(const ParseNode &parse_tree)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  ParseNode *left_node = NULL;
  ParseNode *right_node = NULL;
  ObSEArray<ObSelectStmt*, 2> left_child_stmts;
  ObSEArray<ObSelectStmt*, 2> right_child_stmts;
  if (OB_ISNULL(left_node = parse_tree.children_[PARSE_SELECT_FORMER])
      || OB_ISNULL(right_node = parse_tree.children_[PARSE_SELECT_LATER])
      || OB_ISNULL(parse_tree.children_[PARSE_SELECT_SET]) || OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (right_node->value_ == 1) {
    ret = OB_ERR_ILLEGAL_ID;
    LOG_WARN("Select for update statement can not process set query", K(ret));
  } else if (OB_FAIL(set_stmt_set_type(select_stmt, parse_tree.children_[PARSE_SELECT_SET]))) {
    LOG_WARN("failed to set stmt set type", K(ret));
  } else if (OB_FAIL(resolve_into_clause(ObResolverUtils::get_select_into_node(parse_tree)))) {
    LOG_WARN("failed to resolve into clause", K(ret));
  } else if (parse_tree.children_[PARSE_SELECT_FOR_UPD] != NULL && is_oracle_mode()) {
    ret = OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED;
    LOG_WARN("set stmt can not have for update clause", K(ret));
  } else if (OB_FAIL(resolve_with_clause(parse_tree.children_[PARSE_SELECT_WITH]))) {
    LOG_WARN("failed to resolve with clause", K(ret));
  } else if (T_SET_UNION == parse_tree.children_[PARSE_SELECT_SET]->type_) {
    // union 进行展平
    if (OB_FAIL(SMART_CALL(do_resolve_set_query(*left_node, left_child_stmts, true)))) {
      LOG_WARN("failed to do resolve set query", K(ret));
    } else if (OB_FAIL(SMART_CALL(do_resolve_set_query(*right_node, right_child_stmts)))) {
      LOG_WARN("failed to do resolve set query", K(ret));
    }
  } else {
    // union 以外 set 不进行展平
    ObSelectStmt *left_child_stmt = NULL;
    ObSelectStmt *right_child_stmt= NULL;
    if (OB_FAIL(SMART_CALL(do_resolve_set_query(*left_node, left_child_stmt, true)))) {
      LOG_WARN("failed to do resolve set query", K(ret));
    } else if (OB_FAIL(SMART_CALL(do_resolve_set_query(*right_node, right_child_stmt)))) {
      LOG_WARN("failed to do resolve set query", K(ret));
    } else if (OB_FAIL(left_child_stmts.push_back(left_child_stmt)) ||
               OB_FAIL(right_child_stmts.push_back(right_child_stmt))) {
      LOG_WARN("failed set child stmts", K(ret));
    }
  }

  if (OB_SUCC(ret)) {
    select_stmt->get_set_query().reuse();
    if (OB_FAIL(select_stmt->get_set_query().assign(left_child_stmts)) ||
        OB_FAIL(append(select_stmt->get_set_query(), right_child_stmts))) {
      LOG_WARN("failed add child stmts", K(ret));
    } else if (OB_FAIL(ObOptimizerUtil::gen_set_target_list(allocator_, session_info_,
                                                            params_.expr_factory_,
                                                            left_child_stmts, right_child_stmts,
                                                            select_stmt))) {
      LOG_WARN("failed to get set target list", K(ret));
    } else {
      select_stmt->set_calc_found_rows(select_stmt->get_set_query(0)->is_calc_found_rows());
    }
  }

  if (OB_FAIL(ret)) {
  } else if (parse_tree.children_[PARSE_SELECT_FOR_UPD] != NULL && is_oracle_mode()) {
    ret = OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED;
    LOG_WARN("set stmt can not have for update clause", K(ret));
  } else if (OB_FAIL(resolve_order_clause(parse_tree.children_[PARSE_SELECT_ORDER]))) {
    LOG_WARN("failed to resolve order clause", K(ret));
  } else if (OB_FAIL(resolve_limit_clause(parse_tree.children_[PARSE_SELECT_LIMIT]))) {
    LOG_WARN("failed to resolve limit clause", K(ret));
  } else if (OB_FAIL(resolve_fetch_clause(parse_tree.children_[PARSE_SELECT_FETCH]))) {
    LOG_WARN("failed to resolve fetch clause", K(ret));
  } else if (OB_FAIL(resolve_check_option_clause(parse_tree.children_[PARSE_SELECT_WITH_CHECK_OPTION]))) {
    LOG_WARN("failed to resolve check option clause", K(ret));
  } else if (OB_FAIL(resolve_set_query_hint())) {
    LOG_WARN("failed to resolve set query hint", K(ret));
  } else if (OB_FAIL(select_stmt->formalize_stmt(session_info_))) {
    LOG_WARN("failed to formalize stmt", K(ret));
  } else if (OB_FAIL(check_order_by())) {
    LOG_WARN("failed to check order by", K(ret));
  } else if (OB_FAIL(check_udt_set_query())) {
    LOG_WARN("failed to check udt set query", K(ret));
  } else if (has_top_limit_) {
    has_top_limit_ = false;
    select_stmt->set_has_top_limit(NULL != parse_tree.children_[PARSE_SELECT_LIMIT]);
  }
  return ret;
}

int ObSelectResolver::check_udt_set_query()
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (select_stmt->is_set_stmt()) {
    if (select_stmt->get_set_op() == ObSelectStmt::UNION && !select_stmt->is_set_distinct()) {
      // UNION ALL
      // do nothing
    } else {
      for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_select_item_size(); i++) {
        ObRawExpr *expr = select_stmt->get_select_item(i).expr_;
        if (OB_ISNULL(expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("unexpected null", K(ret));
        } else if (expr->get_result_type().is_ext()) {
          ret = OB_NOT_SUPPORTED;
          LOG_WARN("set operator for udt not supported", K(ret));
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "set operator for udt");
        }
      }
    }
  }
  return ret;
}

// resolve 对于非cte, union, check child 能否展平（limit、order、fetch）
int ObSelectResolver::do_resolve_set_query(const ParseNode &parse_tree,
                                           common::ObIArray<ObSelectStmt*> &child_stmts,
                                           const bool is_left_child) /*default false*/
{
  int ret = OB_SUCCESS;
  bool can_flatten = false;
  bool is_type_same = false;
  ObSelectStmt *select_stmt = NULL;
  if (OB_ISNULL(select_stmt = get_select_stmt())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret), K(select_stmt));
  } else if (parse_tree.children_[PARSE_SELECT_FOR_UPD] != NULL && is_oracle_mode()) {
    ret = OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED;
    LOG_WARN("set stmt can not have for update clause", K(ret));
  } else if (OB_FAIL(is_set_type_same(select_stmt, parse_tree.children_[PARSE_SELECT_SET],
                                      is_type_same))) {
    LOG_WARN("failed to check is set type same", K(ret));
  } else if (!is_type_same) {
    // select_stmt 与待 resolve set stmt 类型不同, 无法展平
    can_flatten = false;
  } else if (NULL != parse_tree.children_[PARSE_SELECT_ORDER] ||
             NULL != parse_tree.children_[PARSE_SELECT_LIMIT] ||
             NULL != parse_tree.children_[PARSE_SELECT_FETCH]) {
    // 待 resolve set stmt 有 order by / limit / fetch, 无法展平
    can_flatten = false;
  } else if (ObSelectStmt::UNION == select_stmt->get_set_op()) {
    // 仅对 union 进行展平
    can_flatten = true;
  }

  if (OB_FAIL(ret)) {
  } else if (can_flatten) {
    ObSEArray<ObSelectStmt*, 2> left_child_stmts;
    ObSEArray<ObSelectStmt*, 2> right_child_stmts;
    ParseNode *left_node = NULL;
    ParseNode *right_node = NULL;
    if (OB_ISNULL(left_node = parse_tree.children_[PARSE_SELECT_FORMER])
        || OB_ISNULL(right_node = parse_tree.children_[PARSE_SELECT_LATER])) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null", K(ret));
    } else if (right_node->value_ == 1) {
      ret = OB_ERR_ILLEGAL_ID;
      LOG_WARN("Select for update statement can not process set query", K(ret));
    } else if (lib::is_oracle_mode() && OB_NOT_NULL(parse_tree.children_[PARSE_SELECT_WITH])) {
      ret = OB_ERR_UNSUPPORTED_USE_OF_CTE;
      LOG_WARN("oracle not support use of cte", K(ret));
    } else if (OB_FAIL(resolve_into_clause(ObResolverUtils::get_select_into_node(parse_tree)))) {
      LOG_WARN("failed to resolve into clause", K(ret));
    } else if (OB_FAIL(resolve_with_clause(parse_tree.children_[PARSE_SELECT_WITH]))) {
      LOG_WARN("failed to resolve with clause", K(ret));
    } else if (OB_FAIL(SMART_CALL(do_resolve_set_query(*left_node, left_child_stmts,
                                                       is_left_child)))) {
      LOG_WARN("failed to do resolve set query", K(ret));
    } else if (OB_FAIL(SMART_CALL(do_resolve_set_query(*right_node, right_child_stmts)))) {
      LOG_WARN("failed to do resolve set query", K(ret));
    } else if (OB_FAIL(ObOptimizerUtil::try_add_cast_to_set_child_list(allocator_, session_info_,
                                          params_.expr_factory_, select_stmt->is_set_distinct(),
                                          left_child_stmts, right_child_stmts, NULL))) {
      LOG_WARN("failed to try add cast to set child list", K(ret));
    } else if (OB_FAIL(append(child_stmts, left_child_stmts)) ||
               OB_FAIL(append(child_stmts, right_child_stmts))) {
      LOG_WARN("failed to append stmts", K(ret));
    }
  } else {
    ObSelectStmt *child_stmt = NULL;
    if (OB_FAIL(do_resolve_set_query(parse_tree, child_stmt, is_left_child))) {
      LOG_WARN("failed to do resolve set query", K(ret));
    } else if (OB_FAIL(child_stmts.push_back(child_stmt))) {
      LOG_WARN("failed to push back", K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::do_resolve_set_query(const ParseNode &parse_tree,
                                           ObSelectStmt *&child_stmt,
                                           const bool is_left_child) /*default false*/
{
  int ret = OB_SUCCESS;
  child_stmt = NULL;
  ObSelectResolver child_resolver(params_);

  child_resolver.set_current_level(current_level_);
  child_resolver.set_current_view_level(current_view_level_);
  child_resolver.set_in_set_query(true);
  child_resolver.set_parent_namespace_resolver(parent_namespace_resolver_);
  child_resolver.set_calc_found_rows(is_left_child && has_calc_found_rows_);
  child_resolver.set_is_left_child(is_left_child);

  if (OB_FAIL(child_resolver.set_cte_ctx(cte_ctx_))) {
    LOG_WARN("failed to set cte ctx", K(ret));
  } else if (OB_FAIL(add_cte_table_to_children(child_resolver))) {
    LOG_WARN("failed to add cte table to children", K(ret));
  } else if (OB_FAIL(child_resolver.resolve_child_stmt(parse_tree))) {
    LOG_WARN("failed to resolve child stmt", K(ret));
  } else if (OB_ISNULL(child_stmt = child_resolver.get_child_stmt())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get null child stmt", K(ret));
  }

  return ret;
}

int ObSelectResolver::set_stmt_set_type(ObSelectStmt *select_stmt,
                                        ParseNode *set_node)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(select_stmt) || OB_ISNULL(set_node)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else {
    // assign set type
    switch (set_node->type_) {
    case T_SET_UNION:
      select_stmt->assign_set_op(ObSelectStmt::UNION);
      break;
    case T_SET_INTERSECT:
      select_stmt->assign_set_op(ObSelectStmt::INTERSECT);
      break;
    case T_SET_EXCEPT:
      select_stmt->assign_set_op(ObSelectStmt::EXCEPT);
      break;
    default:
      ret = OB_ERR_OPERATOR_UNKNOWN;
      LOG_WARN("unknown set operator of set clause");
      break;
    }
    // check distinct and all
    if (OB_FAIL(ret)) {
    } else if (1 != set_node->num_child_) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("wrong num_child_", K(set_node->num_child_));
    } else if (NULL == set_node->children_[0]) {
      select_stmt->assign_set_distinct();
    } else {
      switch (set_node->children_[0]->type_) {
      case T_ALL:
        select_stmt->assign_set_all();
        break;
      case T_DISTINCT:
        select_stmt->assign_set_distinct();
        break;
      default:
        ret = OB_ERR_OPERATOR_UNKNOWN;
        LOG_WARN("unknown set operator of set option");
        break;
      }
    }
  }
  return ret;
}

int ObSelectResolver::is_set_type_same(const ObSelectStmt *select_stmt,
                                       ParseNode *set_node,
                                       bool &is_type_same)
{
  int ret = OB_SUCCESS;
  is_type_same = false;
  if (OB_ISNULL(set_node)) {
    /*do nothing*/
  } else if ((ObSelectStmt::INTERSECT == select_stmt->get_set_op()
              && T_SET_INTERSECT == set_node->type_)
             || (ObSelectStmt::EXCEPT == select_stmt->get_set_op()
                 && T_SET_EXCEPT == set_node->type_)) {
    is_type_same = true;
  } else if (ObSelectStmt::UNION == select_stmt->get_set_op() && T_SET_UNION == set_node->type_) {
    if (1 != set_node->num_child_) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("wrong num_child_", K(set_node->num_child_));
    } else if (NULL == set_node->children_[0] || T_DISTINCT == set_node->children_[0]->type_) {
      is_type_same = select_stmt->is_set_distinct();
    } else if (T_ALL == set_node->children_[0]->type_) {
      is_type_same = !select_stmt->is_set_distinct();
    } else {
      ret = OB_ERR_OPERATOR_UNKNOWN;
      LOG_WARN("unknown set operator of set option");
    }
  } else {
    is_type_same = false;
  }
  return ret;
}

int ObSelectResolver::check_recursive_cte_limited()
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = NULL;
  ObSelectStmt *right_stmt = NULL;
  if (OB_ISNULL(select_stmt = get_select_stmt()) ||
      OB_ISNULL(right_stmt = select_stmt->get_set_query(1))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("the recursive union stmt/right subquery is null", K(ret));
  } else if (OB_UNLIKELY(right_stmt->has_group_by())) {
    ret = OB_NOT_SUPPORTED;
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "group by in recursive with clause");
  } else if (OB_UNLIKELY(right_stmt->has_limit())){
    ret = OB_NOT_SUPPORTED;
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "limit in recursive with clause");
  } else if (OB_UNLIKELY(right_stmt->has_top_limit())) {
    ret = OB_NOT_SUPPORTED;
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "limit in recursive with clause");
  } else if (OB_UNLIKELY(right_stmt->has_distinct())) {
    ret = OB_NOT_SUPPORTED;
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "distinct in recursive with clause");
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < right_stmt->get_select_items().count(); ++i) {
      SelectItem& item = right_stmt->get_select_items().at(i);
      if (OB_UNLIKELY(jit::expr::ObIRawExpr::EXPR_AGGR == item.expr_->get_expr_class())) {
        ret = OB_NOT_SUPPORTED;
        LOG_USER_ERROR(OB_NOT_SUPPORTED, "aggregation in recursive with clause");
      }
    }
  }
  return ret;
}

int ObSelectResolver::check_cte_set_types(ObSelectStmt &left_stmt, ObSelectStmt &right_stmt)
{
  int ret = OB_SUCCESS;
  ObExprResType res_type;
  int64_t num = left_stmt.get_select_item_size();
  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(params_.expr_factory_) || OB_ISNULL(select_stmt)) {
    ret = OB_NOT_INIT;
    LOG_WARN("params is invalid", K(ret), K(select_stmt), K(params_.expr_factory_));
  } else if (left_stmt.get_select_item_size() != right_stmt.get_select_item_size()) {
    ret = OB_ERR_COLUMN_SIZE;
    LOG_WARN("The used SELECT statements have a different number of columns", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < num; i++) {
    SelectItem &left_select_item = left_stmt.get_select_item(i);
    SelectItem &right_select_item = right_stmt.get_select_item(i);
    ObExprResType l_type = left_select_item.expr_->get_result_type();
    ObExprResType r_type = right_select_item.expr_->get_result_type();
    if (l_type != r_type) {
      if (((ObObjMeta)l_type) == ((ObObjMeta)r_type)) {
        //类型相等，不考虑精度
      } else if (l_type.is_character_type() && r_type.is_character_type()) {
        //都是char大类型
      } else if (l_type.is_integer_type() && r_type.is_integer_type()) {
        //都是integer类型
      } else if (is_oracle_mode() && l_type.is_numeric_type() && r_type.is_numeric_type()) {
        //both numeric on oralce mode
      } else {
        //union all两边的类型不一样，不能强转
        ret = OB_NOT_SUPPORTED;
        LOG_USER_ERROR(OB_NOT_SUPPORTED, "different types from different recursive cte union all branchs");
        LOG_WARN("different type in recursive cte not supported", K(ret));
      }
    }
  }
  return ret;
}

// checker is different between mysql and oracle mode
// oracle mode:
//   resolve path: from -> where -> connect by -> group by -> having -> select_items -> order by
//   so after group by, exprs in having, select items and order by must exists on group by exprs
// mysql mode
//   resolve path: from -> where -> select_items -> group by -> having -> order by
int ObSelectResolver::check_group_by()
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  CK(OB_NOT_NULL(select_stmt), OB_NOT_NULL(session_info_));
  CK(OB_NOT_NULL(select_stmt->get_query_ctx()));
  bool only_need_constraints = true;
  if (is_only_full_group_by_on(session_info_->get_sql_mode()) &&
      !select_stmt->get_query_ctx()->is_prepare_stmt()) {
    if (is_oracle_mode()) {
      only_need_constraints = false;
      for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_group_expr_size(); i++) {
        ObRawExpr *group_by_expr = NULL;
        if (OB_ISNULL(group_by_expr = select_stmt->get_group_exprs().at(i))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("group by expr is null", K(ret));
        } else if (ObLongTextType == group_by_expr->get_data_type()
                  || ObLobType == group_by_expr->get_data_type()
                  || ObJsonType == group_by_expr->get_data_type()
                  || ObGeometryType == group_by_expr->get_data_type()
                  || ObExtendType == group_by_expr->get_data_type()) {
          ret = (lib::is_oracle_mode() && ObJsonType == group_by_expr->get_data_type())
                  ? OB_ERR_INVALID_CMP_OP : OB_ERR_INVALID_TYPE_FOR_OP;
          LOG_WARN("group by lob expr is not allowed", K(ret));
        }
      }
      for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_rollup_expr_size(); i++) {
        ObRawExpr *rollup_expr = NULL;
        if (OB_ISNULL(rollup_expr = select_stmt->get_rollup_exprs().at(i))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("rollup expr is null", K(ret));
        } else if (ObLongTextType == rollup_expr->get_data_type()
                  || ObLobType == rollup_expr->get_data_type()
                  || ObExtendType == rollup_expr->get_data_type()) {
          ret = OB_ERR_INVALID_TYPE_FOR_OP;
          LOG_WARN("group by lob or udt expr is not allowed", K(ret));
        }
      }
      for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_grouping_sets_items_size(); i++) {
        const ObIArray<ObGroupbyExpr> &grouping_sets_exprs =
                                  select_stmt->get_grouping_sets_items().at(i).grouping_sets_exprs_;
        if (OB_FAIL(check_multi_rollup_items_valid(
                               select_stmt->get_grouping_sets_items().at(i).multi_rollup_items_))) {
          LOG_WARN("failed to check multi rollup items valid", K(ret));
        } else {
          for (int64_t j = 0; OB_SUCC(ret) && j < grouping_sets_exprs.count(); ++j) {
            const ObIArray<ObRawExpr*> &groupby_exprs = grouping_sets_exprs.at(j).groupby_exprs_;
            for (int64_t k = 0; OB_SUCC(ret) && k < groupby_exprs.count(); ++k) {
              ObRawExpr *groupby_expr = NULL;
              if (OB_ISNULL(groupby_expr = groupby_exprs.at(k))) {
                ret = OB_ERR_UNEXPECTED;
                LOG_WARN("rollup expr is null", K(ret));
              } else if (ObLongTextType == groupby_expr->get_data_type()
                        || ObLobType == groupby_expr->get_data_type()
                        || ObJsonType == groupby_expr->get_data_type()
                        || ObGeometryType == groupby_expr->get_data_type()
                        || ObExtendType == groupby_expr->get_data_type()) {
                ret = OB_ERR_INVALID_TYPE_FOR_OP;
                LOG_WARN("group by lob or udt expr is not allowed", K(ret));
              }
            }
          }
        }
      }
      if (OB_SUCC(ret)) {
        if (OB_FAIL(check_multi_rollup_items_valid(select_stmt->get_multi_rollup_items()))) {
          LOG_WARN("failed to check multi rollup items valid", K(ret));
        } else {/*do nothing*/}
      }
    } else {
      //在解析过程中，standard group checker会记录需要检查的column和expr,在所有语句都解析完成后
      if (OB_FAIL(standard_group_checker_.check_only_full_group_by())) {
        LOG_WARN("failed to check group by");
      }
    }
  }

  if (OB_SUCC(ret)) {
    // skip add const constraint during prepare stage in PL
    const ParamStore *param_store = (NULL != params_.secondary_namespace_) ? NULL : params_.param_list_;
    if (OB_FAIL(ObGroupByChecker::check_group_by(param_store,
                                                 select_stmt,
                                                 having_has_self_column_,
                                                 has_group_by_clause(),
                                                 only_need_constraints))) {
      LOG_WARN("failed to check group by in oracle mode");
    }
  }

  // replace with same group by columns.
  // groupby之上的计算我们放在这里统一处理：
  // 1. select item/having/order item中的表达式树(子树)需要每个都在group by列中找到
  // 2. 递归查找是否在groupby列中，将在groupby的列的指针替换。
  if (OB_SUCC(ret)) {
    if (OB_FAIL(ObTransformUtils::replace_stmt_expr_with_groupby_exprs(select_stmt, NULL))) {
      LOG_WARN("failed to replace stmt expr with groupby columns", K(ret));
    }
  }
  return ret;
}

// 1. lob or udt type can't be ordered
// 2. the order item should be exists in select items if has distinct
int ObSelectResolver::check_order_by()
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select stmt is null", K(ret));
  } else if (is_oracle_mode() && select_stmt->has_order_by()) {
    bool has_distinct = select_stmt->has_distinct();
    // If sql return single row, then don't check order by
    // eg: select distinct count(*) from t1 order by c1; -- return single row,then don't check
    bool need_check = !select_stmt->is_single_set_query();
    if (need_check) {
      // 1. check lob type or udt
      common::ObArray<ObRawExpr*> order_item_exprs;
      common::ObIArray<OrderItem> &order_items = select_stmt->get_order_items();
      // special case: select count(*) from t1 order by c1; --c1 is blob, but optimized to be remove
      for (int64_t i = 0; OB_SUCC(ret) && i < order_items.count(); ++i) {
        if (ob_is_text_tc(order_items.at(i).expr_->get_data_type())
            || ob_is_lob_tc(order_items.at(i).expr_->get_data_type())
            || ob_is_json_tc(order_items.at(i).expr_->get_data_type())
            || ob_is_geometry_tc(order_items.at(i).expr_->get_data_type())
            || ob_is_extend(order_items.at(i).expr_->get_data_type())) {
          ret = (lib::is_oracle_mode() && ob_is_json_tc(order_items.at(i).expr_->get_data_type()))
            ? OB_ERR_INVALID_CMP_OP : OB_ERR_INVALID_TYPE_FOR_OP;
          LOG_WARN("lob or json expr can't order", K(ret), K(*order_items.at(i).expr_));
        } else if (has_distinct) {
          if (OB_FAIL(order_item_exprs.push_back(order_items.at(i).expr_))) {
            LOG_WARN("fail to push back expr", K(ret));
          }
        }
      }
      // 2. check if has distinct
      if (OB_SUCC(ret) && has_distinct) {
        common::ObArray<ObRawExpr*> select_item_exprs;
        common::ObIArray<SelectItem> &select_items = select_stmt->get_select_items();
        for (int64_t i = 0; OB_SUCC(ret) && i < select_items.count(); ++i) {
          ObRawExpr *expr = select_items.at(i).expr_;
          if (OB_FAIL(select_item_exprs.push_back(expr))) {
            LOG_WARN("fail to push back expr", K(ret));
          }
        }
        if (OB_SUCC(ret)) {
          // skip add const constraint during prepare stage in PL
          const ParamStore *param_store = (NULL != params_.secondary_namespace_) ? NULL : params_.param_list_;
          if (OB_FAIL(ObGroupByChecker::check_by_expr(param_store,
                                                      select_stmt,
                                                      select_item_exprs,
                                                      order_item_exprs,
                                                      OB_ERR_NOT_SELECTED_EXPR,
                                                      true))) {
            LOG_WARN("fail to check order by", K(ret));
          }
        }
      }
    }
  }
  return ret;
}

int ObSelectResolver::check_field_list()
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (! is_oracle_mode()) {
  } else if (OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select stmt is null", K(ret));
  } else if (select_stmt->has_distinct()) {
    common::ObIArray<SelectItem> &select_items = select_stmt->get_select_items();
    for (int64_t i = 0; OB_SUCC(ret) && i < select_items.count(); i++) {
      ObRawExpr *expr = NULL;
      if (OB_ISNULL(expr = select_items.at(i).expr_)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("select expr is null", K(ret));
      } else if (ObLongTextType == expr->get_data_type() || ObLobType == expr->get_data_type()) {
        ret = OB_ERR_INVALID_TYPE_FOR_OP;
        LOG_WARN("select distinct lob not allowed", K(ret));
      } else if (lib::is_oracle_mode() && ObJsonType == expr->get_data_type()) {
        ret = OB_ERR_INVALID_CMP_OP;
        LOG_WARN("select distinct json not allowed", K(ret));
      }
    }
  }
  return ret;
}

int ObSelectResolver::search_connect_group_by_clause(const ParseNode &parent,
                                   const ParseNode *&start_with,
                                   const ParseNode *&connect_by,
                                   const ParseNode *&group_by,
                                   const ParseNode *&having)
{
  int ret = OB_SUCCESS;
  if (is_oracle_mode()) {
    start_with = NULL;
    connect_by = NULL;
    group_by = NULL;
    having = NULL;
    const ParseNode *node = NULL;
    for (int64_t i = PARSE_SELECT_DYNAMIC_SW_CBY;
         i <= PARSE_SELECT_DYNAMIC_HAVING && OB_SUCC(ret);
         i++) {
      if (NULL == (node = parent.children_[i])) {
        // do nothing
      } else {
        switch (node->type_) {
          case T_START_WITH : {
            start_with = node->children_[0];
            break;
          }
          case T_CONNECT_BY_CLAUSE : {
            connect_by = node;
            break;
          }
          case T_GROUPBY_CLAUSE : {
            group_by = node;
            break;
          }
          case T_HAVING : {
            having = node->children_[0];
            break;
          }
          default : {
            ret = OB_INVALID_ARGUMENT;
            LOG_WARN("unexpected node type", K(ret), K(node->type_));
          }
        }
      }
    }
    if (OB_SUCC(ret) && OB_UNLIKELY(NULL == connect_by && NULL != start_with)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpect connect by is null while start with is not null", K(ret));
    }
  } else {
    start_with = NULL;
    connect_by = NULL;
    group_by = parent.children_[PARSE_SELECT_DYNAMIC_GROUP];
    having = parent.children_[PARSE_SELECT_DYNAMIC_HAVING];
  }
  return ret;
}

int ObSelectResolver::resolve_normal_query(const ParseNode &parse_tree)
{
  int ret = OB_SUCCESS;
  // ObStmt *st = NULL;
  // ObSelectStmt *s_t = static_cast<ObSelectStmt *>(st);
  // used to record name win expr count
  int64_t count_name_win_expr = 0;
  const ParseNode *start_with = NULL;
  const ParseNode *connect_by = NULL;
  const ParseNode *group_by = NULL;
  const ParseNode *having = NULL;
  ObSelectStmt *select_stmt = get_select_stmt();
  bool has_rollup = false;
  CK(OB_NOT_NULL(select_stmt),
     OB_NOT_NULL(session_info_),
     OB_NOT_NULL(select_stmt->get_query_ctx()));

  set_in_exists_subquery(2 == parse_tree.value_);

  /**
   * @muhang.zb
   * 定义了一个cte，无论最终是否在主句使用，都必须要进行解析
   */
  OZ( resolve_with_clause(parse_tree.children_[PARSE_SELECT_WITH]) );

  /* normal select */
  select_stmt->assign_set_op(ObSelectStmt::NONE);
  OZ( resolve_query_options(parse_tree.children_[PARSE_SELECT_DISTINCT]) );
  if (OB_SUCC(ret) && is_only_full_group_by_on(session_info_->get_sql_mode())) {
    OZ( standard_group_checker_.init() );
  }
  OZ( search_connect_group_by_clause(parse_tree, start_with, connect_by, group_by, having) );
  if (OB_SUCC(ret) && OB_NOT_NULL(group_by)) {
    set_has_group_by_clause();
    OZ (check_rollup_clause(group_by, has_rollup));
  }
  if (OB_SUCC(ret) && (start_with != NULL || connect_by != NULL)) {
    select_stmt->set_hierarchical_query(true);
  }
  /* resolve from clause */
  OZ( resolve_from_clause(parse_tree.children_[PARSE_SELECT_FROM]) );
  /* resolve start with clause */
  OZ( resolve_start_with_clause(start_with) );
  /* resolve connect by clause */
  OZ( resolve_connect_by_clause(connect_by) );
  /* resolve where clause */
  OZ( resolve_where_clause(parse_tree.children_[PARSE_SELECT_WHERE]) );

  if (OB_SUCC(ret) && !is_oracle_mode()) {
    /* resolve named window clause */
    OZ( resolve_named_windows_clause(parse_tree.children_[PARSE_SELECT_NAMED_WINDOWS]) );
  }
  /* resolve select clause */
  if (!is_oracle_mode()) {
    // mysql resolve: from->where->select_item->group by->having->order by
    count_name_win_expr = select_stmt->get_window_func_count();
    if (has_rollup) {
      expr_resv_ctx_.set_new_scope();
    }
    OZ( resolve_field_list(*(parse_tree.children_[PARSE_SELECT_SELECT])));
  }

  /* resolve group by clause */
  OZ( resolve_group_clause(group_by) );

  if (has_rollup && is_oracle_mode()) {
    expr_resv_ctx_.set_new_scope();
  }

  /* resolve having clause */
  OZ( resolve_having_clause(having) );

  if (is_oracle_mode()) {
    // oracle resolve: from->where->connect by->group by->having->select_item->order by
    OZ( resolve_field_list(*(parse_tree.children_[PARSE_SELECT_SELECT])) );
  }
  OZ( resolve_order_clause(parse_tree.children_[PARSE_SELECT_ORDER]) );
  OZ( resolve_limit_clause(parse_tree.children_[PARSE_SELECT_LIMIT]) );
  OZ( resolve_fetch_clause(parse_tree.children_[PARSE_SELECT_FETCH]) );
  OZ( resolve_check_option_clause(parse_tree.children_[PARSE_SELECT_WITH_CHECK_OPTION]) );
  OZ( resolve_into_clause(ObResolverUtils::get_select_into_node(parse_tree)) );
  OZ( resolve_for_update_clause(parse_tree.children_[PARSE_SELECT_FOR_UPD]) );

  if (OB_SUCC(ret)) {
    bool has_flashback_query = false;
    //select for update要求stmt中任何一处都不能出现flashback query相关属性
    if (select_stmt->has_for_update() &&
        OB_FAIL(check_stmt_has_flashback_query(select_stmt, true, has_flashback_query))) {
      LOG_WARN("failed to check stmt has flashback query", K(ret));
    } else if (has_flashback_query) {
      ret = OB_ERR_FLASHBACK_QUERY_WITH_UPDATE;
      LOG_WARN("select for update and flashback query exists", K(ret));
    }
  }

  if (OB_SUCC(ret) && select_stmt->has_for_update() && select_stmt->is_hierarchical_query()) {
    ret = OB_NOT_SUPPORTED;
    LOG_WARN("for update with hierarchical not support", K(ret));
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "for update with hierarchical");
  }

  if (OB_SUCC(ret) && has_top_limit_) {
    has_top_limit_ = false;
    select_stmt->set_has_top_limit(NULL != parse_tree.children_[PARSE_SELECT_LIMIT]);
  }
  OZ( resolve_hints(parse_tree.children_[PARSE_SELECT_HINTS]) );

  //bug:https://work.aone.alibaba-inc.com/issue/28716121
  //由于支持mysql模式下的name window,需要提前解析name window保存下来，然后再解析引用的win expr的表达式,当前实现
  //方式是保存在select stmt中,但是在全部解析完之后没有把那些name window的对应win_expr去除掉,导致生成的计划有问题
  //因此，这里在全部解析完stmt各个部分之后需要根据之前记录的name winexpr个数去除stmt中无用的name win expr
  if (OB_SUCC(ret) && count_name_win_expr > 0) {
    ObSEArray<ObWinFunRawExpr*, 4> new_win_func_exprs;
    for (int64_t i = count_name_win_expr;
          OB_SUCC(ret) && i < select_stmt->get_window_func_count();
          ++i) {
      if (OB_FAIL(new_win_func_exprs.push_back(select_stmt->get_window_func_expr(i)))) {
        LOG_WARN("failed to push back win exprs", K(ret));
      } else {/*do nothing*/}
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(select_stmt->get_window_func_exprs().assign(new_win_func_exprs))) {
        LOG_WARN("failed to assign win exprs", K(ret));
      } else { /*do nothing*/ }
    }
  }

  OZ( select_stmt->formalize_stmt(session_info_) );

  //统一为本层的表达式进行only full group by验证，避免检查的逻辑过于分散
  OZ( check_field_list() );
  OZ( check_group_by() );
  OZ( check_order_by() );
  OZ( check_pseudo_columns() );
  OZ( check_window_exprs() );
  OZ( check_sequence_exprs() );
  OZ( check_unsupported_operation_in_recursive_branch() );
  if (OB_SUCC(ret)) {
    //for topk, 在这里需要标示select 语句是否符合使用近似计算的要求，有group by，有order by且有limit
    //并且使用了topk的hint 且不是select for update 语句，且 from base table 且不需要calc found rows。
    //查询语句中没有distinct 且 查询中不涉及子查询
    //由于fetch clause利用limit设计，同时考虑到需要支持百分比及with ties功能，因此这里分配topn需要考虑这一情形
    if (select_stmt->get_query_ctx()->get_global_hint().is_topk_specified()
        && (1 == select_stmt->get_from_item_size())
        && (!select_stmt->is_calc_found_rows())
        && select_stmt->get_group_expr_size() > 0
        && !select_stmt->has_rollup()
        && select_stmt->get_window_func_exprs().empty()
        && select_stmt->has_order_by()
        && !select_stmt->has_sequence()
        && !select_stmt->has_select_into()
        && (select_stmt->has_limit() && !select_stmt->is_fetch_with_ties() &&
            select_stmt->get_limit_percent_expr() == NULL)
        && (!select_stmt->has_distinct())
        && (!select_stmt->has_subquery())) {
      const FromItem from_item = select_stmt->get_from_item(0);
      TableItem *table_item = select_stmt->get_table_item_by_id(from_item.table_id_);
      if (OB_ISNULL(table_item)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("got table item is NULL", K(from_item), K(ret));
      } else if (table_item->is_basic_table() && (!table_item->for_update_)) {
        select_stmt->set_match_topk(true);
      } else {
        select_stmt->set_match_topk(false);
      }
    }
  }

  // rowscn伪列不能再flashback query和view中使用
  if (OB_SUCC(ret)) {
    bool has_ora_rowscn = false;
    const common::ObIArray<SelectItem> &items = select_stmt->get_select_items();
    for (int64_t i = 0; i < items.count(); i++) {
      const SelectItem item = items.at(i);
      if (nullptr != item.expr_
          && (item.expr_->has_flag(IS_ORA_ROWSCN_EXPR)
              || item.expr_->has_flag(CNT_ORA_ROWSCN_EXPR))) {
        has_ora_rowscn = true;
      }
    }

    if (has_ora_rowscn) {
      bool has_flashback_query = false;
      if (OB_FAIL(check_stmt_has_flashback_query(select_stmt, false, has_flashback_query))) {
        LOG_WARN("failed to check stmt has flashback query", K(ret));
      } else if (has_flashback_query) {
        ret = OB_NOT_SUPPORTED;
        LOG_USER_ERROR(OB_NOT_SUPPORTED, "rowscn used with flashback query");
        LOG_WARN("rowscn can't use with flashback query", K(ret));
      }
    }
  }
  
  // add table_name for anonymous view(view in from)
  if (OB_SUCC(ret) && OB_FAIL(add_name_for_anonymous_view())) {
    LOG_WARN("fail to add name for anonymous view", K(ret));
  }
  return ret;
}

int ObSelectResolver::resolve(const ParseNode &parse_tree)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = NULL;
  bool is_stack_overflow = false;
  if (NULL == (select_stmt = create_stmt<ObSelectStmt>())) {
    ret = OB_SQL_RESOLVER_NO_MEMORY;
    LOG_WARN("failed to create select stmt");
  } else if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
    LOG_WARN("check stack overflow failed", K(ret), K(is_stack_overflow));
  } else if (is_stack_overflow) {
    ret = OB_SIZE_OVERFLOW;
    LOG_WARN("too deep recursive", K(ret), K(is_stack_overflow));
  } else {
    if (OB_INVALID_TENANT_ID != params_.show_tenant_id_) {
      select_stmt->set_tenant_id(params_.show_tenant_id_);
    }
    select_stmt->set_show_seed(params_.show_seed_);
    /* -----------------------------------------------------------------
     * The later resolve may need some information resolved by the former one,
     * so please follow the resolving orders:
     *
     * 0. with clause
     * 1. set clause
     * 2. from clause
     * 3. start with clause
     * 4. connect by clause
     * 5. where clause
     * 6. select clause
     * 7. group by clause
     * 8. having clause
     * 9. order by clause
     * 10.limit clause
     * 11.fetch clause(oracle mode)
     * -----------------------------------------------------------------
     */

    // resolve outline data hint first
    if (OB_FAIL(resolve_outline_data_hints())) {
      LOG_WARN("resolve outline data hints failed", K(ret));
    } else if (parse_tree.children_[PARSE_SELECT_SET] != NULL) {
      /* resolve set clause */
      if (OB_FAIL(SMART_CALL(resolve_set_query(parse_tree)))) {
        LOG_WARN("resolve set query failed", K(ret));
      }
    } else {
      if (OB_FAIL(SMART_CALL(resolve_normal_query(parse_tree)))) {
        LOG_WARN("resolve normal query failed", K(ret));
      }
    }
  }

  return ret;
}

int ObSelectResolver::resolve_query_options(const ParseNode *node)
{
  int ret = OB_SUCCESS;
  bool is_set_distinct = false;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(select_stmt)) {
    ret = OB_NOT_INIT;
    LOG_WARN("select stmt is null");
  } else if (NULL == node) {
    //nothing to do
  } else if (node->type_ != T_QEURY_EXPRESSION_LIST) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid argument", K(node->type_));
  } else {
    ParseNode *option_node = NULL;
    for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; i++) {
      option_node = node->children_[i];
      if (option_node->type_ == T_DISTINCT) {
        is_set_distinct = true;
      } else if (option_node->type_ == T_FOUND_ROWS) {
        if (has_calc_found_rows_) {
          has_calc_found_rows_ = false;
          select_stmt->set_calc_found_rows(true);
        } else {
          ret = OB_ERR_CANT_USE_OPTION_HERE;
          LOG_USER_ERROR(OB_ERR_CANT_USE_OPTION_HERE, "SQL_CALC_FOUND_ROWS");
        }
      }
    }
  }
  if (OB_SUCC(ret)) {
    //默认为all
    if (is_set_distinct) {
      select_stmt->assign_distinct();
    } else {
      select_stmt->assign_all();
    }
  }
  return ret;
}

int ObSelectResolver::resolve_for_update_clause(const ParseNode *node)
{
  int ret = OB_SUCCESS;
  if (NULL == node) {
    // do nothing
  } else if (is_oracle_mode()) {
    OZ (resolve_for_update_clause_oracle(*node));
  } else {
    OZ (resolve_for_update_clause_mysql(*node));
  }
  return ret;
}

int ObSelectResolver::resolve_for_update_clause_mysql(const ParseNode &node)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = NULL;
  int64_t wait_us = -1;
  if (OB_ISNULL(select_stmt = get_select_stmt())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("fail to get select stmt", K(ret));
  } else if (T_SFU_INT != node.type_ && T_SFU_DECIMAL != node.type_) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("for update wait info is wrong", K(ret));
  } else if (T_SFU_INT == node.type_) {
    wait_us = node.value_ < 0 ? -1 : node.value_ * 1000000LL;
  } else if (T_SFU_DECIMAL == node.type_) {
    ObString time_str(node.str_len_, node.str_value_);
    if (OB_FAIL(ObTimeUtility2::str_to_time(
                  time_str, wait_us, ObTimeUtility2::DIGTS_SENSITIVE))) {
      LOG_WARN("str to time failed", K(ret));
    }
  }
  if (OB_SUCC(ret) && OB_FAIL(set_for_update_mysql(*select_stmt, wait_us))) {
    LOG_WARN("failed to set for update", K(ret));
  }
  return ret;
}

int ObSelectResolver::set_for_update_mysql(ObSelectStmt &stmt, const int64_t wait_us)
{
  int ret = OB_SUCCESS;
  TableItem *table_item = NULL;
  for (int64_t idx = 0; OB_SUCC(ret) && idx < stmt.get_table_size(); ++idx) {
    if (OB_ISNULL(table_item = stmt.get_table_item(idx))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("Table item is NULL", K(ret));
    } else if (table_item->is_basic_table()) {
      table_item->for_update_ = true;
      table_item->for_update_wait_us_ = wait_us;
    }
  }
  return ret;
}

int ObSelectResolver::resolve_for_update_clause_oracle(const ParseNode &node)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *stmt = NULL;
  const ParseNode *of_node = NULL;
  const ParseNode *wait_or_skip_node = NULL;
  int64_t wait_us = -1;
  bool skip_locked = false;
  current_scope_ = T_FIELD_LIST_SCOPE;
  if (current_level_ > 0) {
    ret = OB_ERR_PARSER_SYNTAX;
    LOG_WARN("for update is not allowed in subquery", K(ret));
  } else if (OB_UNLIKELY(node.type_ != T_FOR_UPDATE) ||
             OB_UNLIKELY(node.num_child_ != 2) ||
             FALSE_IT(of_node = node.children_[0]) ||
             FALSE_IT(wait_or_skip_node = node.children_[1]) ||
             OB_ISNULL(stmt = get_select_stmt()) ||
             OB_ISNULL(session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("invalid for update parse node", K(ret), K(node.type_), K(node.num_child_), K(stmt));
  }

  if (OB_SUCC(ret)) {
    if (NULL != wait_or_skip_node) {
      if (wait_or_skip_node->type_ == T_SKIP_LOCKED) {
        // skip locked
        skip_locked = true;
        wait_us = 0;
      } else if (wait_or_skip_node->type_ == T_SFU_INT) {
        // wait INTNUM or no wait
        // nowait  wait_us = 0;
        wait_us = wait_or_skip_node->value_ * 1000000LL;
        skip_locked = false;
      }
    } else {
      wait_us = -1;
      skip_locked = false;
    }
  }

  if (OB_SUCC(ret) && NULL != of_node) {
    for (int64_t i = 0; OB_SUCC(ret) && i < of_node->num_child_; ++i) {
      const ParseNode *column_node = NULL;
      ObRawExpr *expr = NULL;
      if (OB_ISNULL(column_node = of_node->children_[i])) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("of node is null", K(ret));
      } else if (OB_FAIL(resolve_sql_expr(*column_node, expr))) {
        LOG_WARN("failed to resolve sql expr", K(ret));
      } else if (OB_ISNULL(expr) || OB_UNLIKELY(!expr->is_column_ref_expr())) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("expr is invalid", K(ret), K(expr));
      } else {
        ObColumnRefRawExpr *col = static_cast<ObColumnRefRawExpr*>(expr);
        if (OB_FAIL(set_for_update_oracle(*stmt, wait_us, skip_locked, col))) {
          LOG_WARN("failed to set for update table", K(ret));
        } else if (OB_FAIL(stmt->get_for_update_columns().push_back(col))) {
          LOG_WARN("failed to push back lock column", K(ret));
        }
      }
    }
  }

  //如果是PL里的可更新游标，增加rowid属性
  if (OB_SUCC(ret) && ((NULL != params_.secondary_namespace_ && params_.is_cursor_)
                       || (session_info_->is_client_return_rowid()
                           && NULL == params_.secondary_namespace_))) {
    SelectItem rowid_item;
    ObSelectStmt *select_stmt = stmt;
    TableItem *table_item = NULL;
    TableItem *add_rowid_table_item = NULL;
    const ObTableSchema *table_schema = NULL;
    int64_t for_update_cnt = 0;
    CK (OB_NOT_NULL(params_.schema_checker_));
    for (int64_t i = 0; OB_SUCC(ret) && for_update_cnt <= 1 && i < select_stmt->get_table_size(); i++) {
      // 1. 单表的for update, 需要把表的rowid加入到 select_item中
      // 2. 多表join for update, 不能加入rowid,因为不确定要加哪个表的rowid
      // 3. 多表join for update of t1.c1, of 后面指定更新的表时,需要把指定的表的rowid加入到select_item中
      CK (OB_NOT_NULL(table_item = select_stmt->get_table_item(i)));
      if (OB_SUCC(ret) && (table_item->for_update_ || 1 == select_stmt->get_table_size())) {
        for_update_cnt++;
        if (for_update_cnt > 1) {
          add_rowid_table_item = NULL;
        } else if (table_item->is_basic_table()) {
          OX (add_rowid_table_item = table_item);
        }
      }
    }
    if (OB_SUCC(ret) && add_rowid_table_item != NULL) {
      ObRawExpr *rowid_expr = NULL;
      OZ (params_.schema_checker_->get_table_schema(session_info_->get_effective_tenant_id(), 
                                                    add_rowid_table_item->ref_id_,
                                                    table_schema,
                                                    add_rowid_table_item->is_link_table()));
      if (OB_FAIL(resolve_rowid_expr(select_stmt, *add_rowid_table_item, rowid_expr))) {
        LOG_WARN("resolve rowid expr failed", K(ret));
      } else {
        OX (rowid_item.expr_name_ = ObString(OB_HIDDEN_LOGICAL_ROWID_COLUMN_NAME));
        OX (rowid_item.alias_name_ = ObString(OB_HIDDEN_LOGICAL_ROWID_COLUMN_NAME));
        OX (rowid_item.expr_ = rowid_expr);
        OX (rowid_item.is_hidden_rowid_ = true);
        OZ (set_select_item(rowid_item, false/* is_auto_gen*/));
      }
    }
  }
  if (OB_SUCC(ret) && NULL == of_node) {
    // lock all tables
    if (OB_FAIL(set_for_update_oracle(*stmt, wait_us, skip_locked))) {
      LOG_WARN("failed to set for update", K(ret));
    }
  }

  if (OB_SUCC(ret)) {
    if (is_in_set_query() ||
        stmt->has_group_by() ||
        stmt->has_distinct()) {
      ret = OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED;
      LOG_WARN("for update can not exists in stmt with distinct, group", K(ret));
    } else if (stmt->has_fetch()) {//fetch 和 for update不能同时出现
      ret = OB_ERR_FOR_UPDATE_SELECT_VIEW_CANNOT;
      LOG_WARN("for update stmt can't have fetch clause", K(ret));
    }
  }
  return ret;
}

/**
 * @brief ObSelectResolver::set_for_update_oracle
 * @param stmt: the targe stmt
 * @param wait_us: for update wait ts
 * @param skip_locked: skip locked
 * @param col: the column of table which should be locked,
 *             if col = NULL, all tables in the stmt should be locked
 * @return
 */
int ObSelectResolver::set_for_update_oracle(ObSelectStmt &stmt,
                                            const int64_t wait_us,
                                            bool skip_locked,
                                            ObColumnRefRawExpr *col)
{
  int ret = OB_SUCCESS;
  if (stmt.is_set_stmt()) {
    ret = OB_ERR_FOR_UPDATE_SELECT_VIEW_CANNOT;
    LOG_WARN("invalid for update", K(ret));
  } else if (col != NULL && col->get_data_type() == ObURowIDType &&
             ObCharset::case_insensitive_equal(to_cstring(col->get_column_name()), OB_HIDDEN_LOGICAL_ROWID_COLUMN_NAME)) {
    ret = OB_NOT_SUPPORTED;
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "invalid user.table.column, table.column, or column specification");
    LOG_WARN("pseudo_column rowid is not supported for update", K(col->get_column_name()), K(col->get_data_type()));
  }

  for (int64_t i = 0; OB_SUCC(ret) && i < stmt.get_table_size(); ++i) {
    TableItem *table = NULL;
    if (OB_ISNULL(table = stmt.get_table_item(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("table item is null", K(ret));
    } else if (col != NULL && col->get_table_id() != table->table_id_) {
      // does not lock this table, skip here
    } else {
      table->for_update_ = true;
      table->for_update_wait_us_ = wait_us;
      table->skip_locked_ = skip_locked;
      if (table->is_basic_table()) {
        ObSEArray<ObColumnRefRawExpr *, 4> rowkeys;
        if (OB_FAIL(add_all_rowkey_columns_to_stmt(*table, rowkeys, &stmt))) {
          LOG_WARN("failed to add rowkey columns to stmt", K(ret));
        }
        for (int64_t j = 0; OB_SUCC(ret) && j < rowkeys.count(); ++j) {
          if (OB_ISNULL(rowkeys.at(j))) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("rowkey expr is null", K(ret));
          } else {
            rowkeys.at(j)->set_explicited_reference();
          }
        }
      } else if (table->is_generated_table() || table->is_temp_table()) {
        ObSelectStmt *view = NULL;
        ObColumnRefRawExpr *view_col = NULL;
        if (OB_ISNULL(view = table->ref_query_)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("view is invalid", K(ret), K(*table));
        } else if (NULL != col) {
          int64_t sel_id = col->get_column_id() - OB_APP_MIN_COLUMN_ID;
          ObRawExpr *sel_expr = NULL;
          if (OB_UNLIKELY(sel_id < 0 || sel_id >= view->get_select_item_size()) ||
              OB_ISNULL(sel_expr = view->get_select_item(sel_id).expr_)) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("column id is invalid", K(ret), K(*col), K(sel_expr));
          } else if (OB_UNLIKELY(!sel_expr->is_column_ref_expr())) {
            ret = OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED;
            LOG_WARN("invalid for update", K(ret));
          } else {
            view_col = static_cast<ObColumnRefRawExpr*>(sel_expr);
          }
        }
        if (OB_SUCC(ret) && OB_FAIL(set_for_update_oracle(*view, wait_us, skip_locked, view_col))) {
          LOG_WARN("failed to set for update", K(ret));
        }
      }
    }
  }
  return ret;
}

// If expr is literal and type is numeric, then cast to int, find the referred select item
// special case:
// 1) negetive numeric value
//    select 1 from dual order by -0; --ok
//    select 1 from dual order by +0; --error
//    select 1 from dual order by -0E0;  --ok
//    select 1 from dual order by +0E0;  --error
// 2) value to floor
//    select c1 from t1 order by 1.3;  --ok
//    select c1 from t1 order by 1.9;  --ok
//    select c1 from t1 order by 2.3;  --error
//    select c1 from t1 order by 2.1;  --error
int ObSelectResolver::resolve_literal_order_item(const ParseNode &sort_node, ObRawExpr *expr, OrderItem &order_item, ObSelectStmt *select_stmt)
{
  int ret = OB_SUCCESS;
  if (!is_oracle_mode()) {
    // nothing to do
  } else if (T_OBJ_ACCESS_REF == sort_node.type_) {
    //do nothing
  } else if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr is null", K(ret));
  } else if (expr->is_const_raw_expr()) {
    const ObObj &value = static_cast<ObConstRawExpr*>(expr)->get_value();
    if (!value.is_numeric_type()) {
      // not numeric type
    } else if (sort_node.str_len_ > 0 && '-' == sort_node.str_value_[0]) {
      // skip negative value, like -0, -0E0
      LOG_DEBUG("sort node is negative", K(ret), K(sort_node.str_value_[0]), K(sort_node.str_len_), K(value));
    } else {
      // 1. cast to number. if be cast to int type, it will be round, it's unexpected, like 1.9 round to 2
      // 2. get int value
      ObObjMeta number_type;
      number_type.set_number();
      number_type.set_scale(NUMBER_SCALE_UNKNOWN_YET);
      int64_t pos = -1;
      int64_t scale = -1;
      ObObj number_obj;
      number::ObNumber number_value;
      const ObDataTypeCastParams dtc_params = ObBasicSessionInfo::create_dtc_params(session_info_);
      ObCastCtx cast_ctx(allocator_, &dtc_params, CM_NONE, ObCharset::get_system_collation());
      if (OB_FAIL(ObObjCaster::to_type(number_type.get_type(), cast_ctx, value, number_obj))) {
        LOG_WARN("fail to cast int object", K(ret), K(value));
      } else if (OB_FAIL(number_obj.get_number(number_value))) {
        LOG_WARN("fail to get number value", K(ret), K(value));
      } else if (number_value.is_negative()) {
        // if value < 0, then don't cast to int value
        // eg: select * from t1 order by -0.1; --it's ok
        // but select * from t1 order by 0.1; --it's error
        LOG_DEBUG("const value is negative", K(number_value));
      } else if (!number_value.is_int_parts_valid_int64(pos, scale)) {
        ret = OB_ERR_ORDER_BY_ITEM_NOT_IN_SELECT_LIST;
        LOG_WARN("value is invalid", K(ret), K(number_value), K(value));
      } else if (OB_FAIL(resolve_order_item_by_pos(pos, order_item, select_stmt))) {
        LOG_WARN("fail to get order item", K(ret));
      }
      LOG_DEBUG("sort node", K(ret), K(sort_node.str_value_[0]), K(sort_node.str_len_), K(value));
    }
  }
  return ret;
}

int ObSelectResolver::resolve_order_item_by_pos(int64_t pos, OrderItem &order_item, ObSelectStmt *select_stmt)
{
  int ret = OB_SUCCESS;
  if (pos <= 0 || pos > select_stmt->get_select_item_size()) {
    // for SELECT statement, we need to make sure the column positions are valid
    if (is_oracle_mode()) {
      ret = OB_ERR_ORDER_BY_ITEM_NOT_IN_SELECT_LIST;
      LOG_WARN("ORDER BY item must be the number of a SELECT-list expression", K(ret), K(pos));
    } else {
      ret = OB_ERR_BAD_FIELD_ERROR;
      char buff[OB_MAX_ERROR_MSG_LEN];
      snprintf(buff, OB_MAX_ERROR_MSG_LEN, "%d", static_cast<int32_t>(pos));
      ObString scope_name = ObString::make_string(get_scope_name(current_scope_));
      LOG_USER_ERROR(OB_ERR_BAD_FIELD_ERROR, (int)strlen(buff), buff, scope_name.length(), scope_name.ptr());
    }
  } else {
    // create expression
    const SelectItem &select_item = select_stmt->get_select_item(pos - 1);
    order_item.expr_ = select_item.expr_;
  }
  return ret;
}

int ObSelectResolver::resolve_order_item(const ParseNode &sort_node, OrderItem &order_item)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = NULL;
  if (OB_ISNULL(select_stmt = get_select_stmt())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("got an unexpected null", K(ret));
  } else if (OB_FAIL(ObResolverUtils::set_direction_by_mode(sort_node, order_item))) {
    LOG_WARN("failed to set order type by mode", K(ret));
  } else if (!is_oracle_mode()
             && OB_UNLIKELY(sort_node.children_[0]->type_ == T_INT && sort_node.children_[0]->value_ >= 0)) {
    // The order-by item is specified using column position
    // ie. ORDER BY 1 DESC
    int32_t pos = static_cast<int32_t>(sort_node.children_[0]->value_);
    if (OB_FAIL(resolve_order_item_by_pos(pos, order_item, select_stmt))) {
      LOG_WARN("fail to get order item", K(ret));
    }
  } else if (params_.is_prepare_protocol_ 
             && !params_.is_prepare_stage_
             && sort_node.children_[0]->type_ == T_QUESTIONMARK) {
    ObRawExpr *null_expr = NULL;
    if (OB_ISNULL(params_.expr_factory_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("params is invalid", K(params_.expr_factory_));
    } else if (OB_FAIL(ObRawExprUtils::build_null_expr(*params_.expr_factory_, null_expr))) {
      LOG_WARN("fail to build null expr", K(ret));
    } else {
      order_item.expr_ = null_expr;
    }
  } else if (T_QUESTIONMARK == sort_node.children_[0]->type_ && !params_.is_prepare_protocol_) {
    ret = OB_ERR_PARSE_SQL;
    LOG_WARN("'?' can't after 'order by", K(ret));
  } else {
    if (is_oracle_mode()) {
      field_list_first_ = true;
    }
    if (OB_FAIL(resolve_sql_expr(*(sort_node.children_[0]), order_item.expr_))) {
       LOG_WARN("resolve sql expression failed", K(ret));
    } else if (OB_FAIL(resolve_literal_order_item(*(sort_node.children_[0]), order_item.expr_, order_item, select_stmt))) {
      LOG_WARN("fail to resolve literal order item", K(ret), K(*order_item.expr_));
    } else { }
  }
  if (OB_SUCC(ret) && is_only_full_group_by_on(session_info_->get_sql_mode())) {
    if (OB_FAIL(standard_group_checker_.add_unsettled_expr(order_item.expr_))) {
      LOG_WARN("add unsettled expr to standard group checker failed", K(ret));
    }
  }

  //oracle mode, check set query order by item
  if (OB_SUCC(ret) && select_stmt->is_set_stmt() && is_oracle_mode()) {
    ObSEArray<ObRawExpr*, 4> select_exprs;
    if (OB_FAIL(select_stmt->get_select_exprs(select_exprs))) {
      LOG_WARN("failed to get select exprs", K(ret));
    } else if (ObOptimizerUtil::find_item(select_exprs, order_item.expr_)) {
      /*do nothing*/
    } else {
      ret = OB_ERR_ORDER_BY_ITEM_NOT_IN_SELECT_LIST;
      LOG_WARN("ORDER BY item must be the number of a SELECT-list expression", K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::resolve_field_list(const ParseNode &node)
{
  int ret = OB_SUCCESS;
  ParseNode *project_node = NULL;
  ParseNode *alias_node = NULL;
  bool is_bald_star = false;
  ObSelectStmt *select_stmt = NULL;
  //LOG_INFO("resolve_select_1", "usec", ObSQLUtils::get_usec());
  current_scope_ = T_FIELD_LIST_SCOPE;
  if (OB_ISNULL(session_info_) || OB_ISNULL(select_stmt = get_select_stmt())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(session_info_),
        K(select_stmt), K(ret));
  }
  for (int32_t i = 0; OB_SUCC(ret) && i < node.num_child_; ++i) {
    alias_node = NULL;
    project_node = NULL;
    SelectItem select_item;
    // Rule for expr_name and alias_name
    // expr_name is filled with expr name, both ref_expr and other complex expr.
    // alias_name is filled with expr_name for default, but updated with real alias name if exists.
    // the special case is the column ref, which expr_name will be replaced with unqualified column name.
    select_item.expr_name_.assign_ptr(node.children_[i]->str_value_,
                                      static_cast<int32_t>(node.children_[i]->str_len_));
    // In Oracle ps mode, the alias name of the bind variable is ":" + num, not the actual value. As follows:
    // PREPARE STMT FROM 'SELECT ?, ?, ? FROM DUAL';
    // SET @I1 = 1;
    // EXECUTE STMT USING @I1, @I1, @I1;
    // col_name1 is ":1", col_name2 is ":2", col_name3 is ":3"
    if (is_oracle_mode()
        && params_.is_prepare_protocol_
        && 1 == node.children_[i]->num_child_
        && T_QUESTIONMARK == node.children_[i]->children_[0]->type_) {
      ObString alias_name;
      char temp_str_buf[OB_MAX_COLUMN_NAME_LENGTH];
      if (snprintf(temp_str_buf, sizeof(temp_str_buf), ":%ld", node.children_[i]->children_[0]->value_ + 1) < 0) {
        ret = OB_SIZE_OVERFLOW;
        LOG_WARN("failed to generate buffer for temp_str_buf", K(ret));
      }
      if (OB_SUCC(ret)) {
        alias_name = ObString::make_string(temp_str_buf);
        if (OB_FAIL(ob_write_string(*allocator_, alias_name, select_item.alias_name_))) {
          LOG_WARN("Can not malloc space for alias name", K(ret));
        }
      }
    } else {
      select_item.alias_name_.assign_ptr(node.children_[i]->str_value_,
                                      static_cast<int32_t>(node.children_[i]->str_len_));
    }

    project_node = node.children_[i]->children_[0];
    if (project_node->type_ == T_STAR
        || (project_node->type_ == T_COLUMN_REF && project_node->children_[2]->type_ == T_STAR)) {
      if (project_node->type_ == T_STAR) {
        if (is_bald_star) {
          ret = OB_ERR_STAR_DUPLICATE;
          LOG_WARN("Wrong usage of '*'");
          break;
        } else {
          is_bald_star = true;
        }
      }
      //oracle不允许有同表名的基表时select item引用其列,比如:
      //select * from t1,t1 ==> NO
      //select 1 from t1,t1 ==> YES
      //select * from (select * from t1), (select * from t1) ==> YES
      if (OB_FAIL(ret)) {
      } else if (params_.have_same_table_name_) {
        ret = OB_NON_UNIQ_ERROR;
        LOG_WARN("column in all tables is ambiguous", K(ret));
      } else if (OB_FAIL(resolve_star(project_node))) {
        LOG_WARN("resolve star failed", K(ret));
      }
      continue;
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(ObCharset::charset_convert(*allocator_,
                                             select_item.expr_name_,
                                             session_info_->get_local_collation_connection(),
                                             CS_TYPE_UTF8MB4_BIN,
                                             select_item.expr_name_,
                                             ObCharset::REPLACE_UNKNOWN_CHARACTER))) {
        LOG_WARN("fail to charset convert", K(ret));
      } else if (OB_FAIL(ObCharset::charset_convert(*allocator_,
                                                    select_item.alias_name_,
                                                    session_info_->get_local_collation_connection(),
                                                    CS_TYPE_UTF8MB4_BIN,
                                                    select_item.alias_name_,
                                                    ObCharset::REPLACE_UNKNOWN_CHARACTER))) {
        LOG_WARN("fail to charset convert", K(ret));
      }
    }
    bool is_auto_gen = false;
    if (OB_SUCC(ret)) {
      //处理alias
      ObCollationType cs_type = CS_TYPE_INVALID;
      if (OB_FAIL(session_info_->get_collation_connection(cs_type))) {
        LOG_WARN("fail to get collation_connection", K(ret));
      } else if (project_node->type_ == T_ALIAS) {
        alias_node = project_node->children_[1];
        project_node = project_node->children_[0];
        select_item.is_real_alias_ = true;
        /* check if the alias name is legal */
        select_item.alias_name_.assign_ptr(const_cast<char *>(alias_node->str_value_),
                                           static_cast<int32_t>(alias_node->str_len_));
        if (OB_UNLIKELY(alias_node->str_len_ > OB_MAX_COLUMN_NAME_LENGTH && is_oracle_mode())) {
          ret = OB_ERR_TOO_LONG_IDENT;
          LOG_WARN("alias name too long", K(ret), K(select_item.alias_name_));
        }
      } else if (OB_UNLIKELY((params_.is_from_create_view_ || params_.is_from_create_table_)
                             && !params_.is_specified_col_name_
                             && 0 == select_item.expr_name_.case_compare(
                                     OB_HIDDEN_LOGICAL_ROWID_COLUMN_NAME))) {
        // must name alias for rowid
        //  eg: create view/table as select rowid from t1;
        ret = OB_NO_COLUMN_ALIAS;
        LOG_WARN("no column alias for rowid pseudo column", K(ret));
        LOG_USER_ERROR(OB_NO_COLUMN_ALIAS, select_item.expr_name_.length(),
                       select_item.expr_name_.ptr());
      }
    }

    if (OB_SUCC(ret)) {
      ObRawExpr *sel_expr = NULL;
      if (OB_FAIL(resolve_sql_expr(*project_node, select_item.expr_))) {
        LOG_WARN("resolve sql expr failed", K(ret));
        if (OB_EER_WINDOW_NO_REDEFINE_ORDER_BY == ret
            && OB_NOT_NULL(project_node)
            && OB_NOT_NULL(project_node->children_[1])
            && OB_NOT_NULL(project_node->children_[1]->children_[0])) {
          LOG_USER_ERROR(OB_EER_WINDOW_NO_REDEFINE_ORDER_BY,
              (int)strlen("<unnamed window>"), "<unnamed window>",
              (int)(project_node->children_[1]->children_[0]->str_len_),
              project_node->children_[1]->children_[0]->str_value_);
        }
      } else if (OB_ISNULL(sel_expr = select_item.expr_)) {
        ret = OB_NOT_INIT;
        LOG_WARN("select expr is null", K(select_item), K(ret));
      } else if (sel_expr->is_exec_param_expr()) {
        sel_expr = static_cast<ObExecParamRawExpr *>(sel_expr)->get_ref_expr();
        if (OB_ISNULL(sel_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("select expr is null", K(ret));
        }
      }

      if (OB_SUCC(ret) && NULL == alias_node) {
        LOG_DEBUG("select item info", K(select_item));
        if (sel_expr->is_column_ref_expr()) {
          // for t1.c1, extract the exact column name of c1 for searching in resolve_columns
          if (project_node->type_ == T_COLUMN_REF) {
            alias_node = project_node->children_[2];
            select_item.alias_name_.assign_ptr(const_cast<char *>(alias_node->str_value_),
                                               static_cast<int32_t>(alias_node->str_len_));
          } else if (T_OBJ_ACCESS_REF == project_node->type_) {
            while (NULL != project_node->children_[1]) {
              project_node = project_node->children_[1];
            }
            if (T_OBJ_ACCESS_REF != project_node->type_) {
              ret = OB_ERR_UNEXPECTED;
              LOG_WARN("unexpected select item type", K(select_item), K(ret));
            } else {
              alias_node = project_node->children_[0];
              /* bugfix: table has fbi index, select fbi_expr, alias name is empty
              create table t1(c1 number,c2 number);
              create index t1_g_idx on t1(ceil(c1)) global;
              select ceil(c1),ceil(c2) from t1;
              +------+----------+
              |      | CEIL(C2) |   -----》 not display CEIL(C1) COLUM NAME
              +------+----------+
              |    4 |        5 |
              +------+----------+
              */
              if (alias_node->str_len_ > 0) {
                select_item.alias_name_.assign_ptr(const_cast<char *>(alias_node->str_value_),
                                                   static_cast<int32_t>(alias_node->str_len_));
              }
            }
          } else if (T_REF_COLUMN == sel_expr->get_expr_type()) {
            // deal with generated column
            ObColumnRefRawExpr *ref_expr = dynamic_cast<ObColumnRefRawExpr *>(sel_expr);
            if (OB_ISNULL(ref_expr)) {
              ret = OB_ERR_UNEXPECTED;
              LOG_WARN("got an unexpected null", K(ret));
            } else {
              select_item.alias_name_ = ref_expr->get_column_name();
            }
          } else {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("unexpected select item type", K(select_item), K(ret));
          }
        } else if (T_FUN_SYS_SEQ_NEXTVAL == sel_expr->get_expr_type()) {
          // sequence expr, expr is seq_name.nextval or seq_name.currval
          // but column name displayed should be nextval or currval
          do {
            if (T_OP_POS == project_node->type_) {
              project_node = project_node->children_[0];
            } else if (T_EXPR_LIST == project_node->type_) {
              project_node = project_node->children_[0];
            } else {
              break;
            }
          } while (true);
          if (is_oracle_mode()) {
            if (T_OBJ_ACCESS_REF != project_node->type_) {
              ret = OB_ERR_UNEXPECTED;
              LOG_WARN("unexpected select item type", K(select_item), K(project_node->type_), K(ret));
            }
            while (OB_SUCC(ret) && NULL != project_node->children_[1]) {
              project_node = project_node->children_[1];
            }
            if (OB_FAIL(ret)) {
              // do nothing
            } else if (T_OBJ_ACCESS_REF != project_node->type_) {
              ret = OB_ERR_UNEXPECTED;
              LOG_WARN("unexpected select item type", K(select_item), K(project_node->type_), K(ret));
            } else {
              alias_node = project_node->children_[0];
              select_item.alias_name_.assign_ptr(const_cast<char *>(alias_node->str_value_),
                                                 static_cast<int32_t>(alias_node->str_len_));
            }
          } else {
            // mysql mode
            if (T_COLUMN_REF != project_node->type_ || project_node->num_child_ < 3) {
              ret = OB_ERR_UNEXPECTED;
              LOG_WARN("unexpected select item type",
                       K(select_item), K(project_node->type_), K(project_node->num_child_), K(ret));
            } else {
              alias_node = project_node->children_[2];
              select_item.alias_name_.assign_ptr(const_cast<char *>(alias_node->str_value_),
                                                 static_cast<int32_t>(alias_node->str_len_));
            }
          }
        } else if (T_FUN_SYS_CALC_UROWID == sel_expr->get_expr_type()) {
          ObString rowid_name(OB_HIDDEN_LOGICAL_ROWID_COLUMN_NAME);
          if (OB_FAIL(ob_write_string(*allocator_, rowid_name, select_item.alias_name_))) {
            LOG_WARN("failed to ob write string", K(ret));
          }
        }  else if (T_FUN_SYS_NAME_CONST == sel_expr->get_expr_type()) {
          const ParseNode *expr_list_node = project_node->children_[1];
          const ObRawExpr *name_expr = nullptr;
          if (2 != expr_list_node->num_child_) {
            //do nothing
          } else if (OB_ISNULL(name_expr = sel_expr->get_param_expr(0))) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("unexpected null", K(ret), K(name_expr));
          } else if (name_expr->is_const_raw_expr() && T_QUESTIONMARK != name_expr->get_expr_type()) {
            char buf[OB_MAX_ALIAS_NAME_LENGTH + 1];
            int64_t pos = 0;
            const ObObj &value = static_cast<const ObConstRawExpr*>(name_expr)->get_value();
            if (value.is_numeric_type()){
              const ParseNode *alias_node = expr_list_node->children_[0];
              if (OB_ISNULL(alias_node)) {
                ret = OB_ERR_UNEXPECTED;
                LOG_WARN("unexpected null", K(ret));
              } else if (alias_node->str_len_ > 0 && '-' == alias_node->str_value_[0]) {
                ret = OB_INVALID_ARGUMENT;
                LOG_USER_ERROR(OB_INVALID_ARGUMENT, N_NAME_CONST);
                LOG_WARN("the first param of name_const can't be negtive", K(ret));
              } else if (OB_FAIL(value.print_sql_literal(buf, OB_MAX_ALIAS_NAME_LENGTH + 1, pos))) {
                LOG_WARN("fail to print_sql_literal", K(value), K(ret));
              }
            } else if (value.is_string_type()) {
              const ParseNode *alias_node = expr_list_node->children_[0];
              if (OB_ISNULL(alias_node)) {
                ret = OB_ERR_UNEXPECTED;
                LOG_WARN("unexpected null", K(ret));
              } else if ((pos = alias_node->str_len_) > 0) {
                if (pos > OB_MAX_ALIAS_NAME_LENGTH + 1) {
                  pos = OB_MAX_ALIAS_NAME_LENGTH + 1;
                }
                MEMCPY(buf, alias_node->str_value_, pos);
              }
            } else if (value.is_temporal_type()) {
              char time_buf[31];
              if (OB_FAIL(value.print_sql_literal(time_buf, OB_MAX_ALIAS_NAME_LENGTH + 1, pos))) {
                LOG_WARN("fail to print_plain_str_literal", K(value), K(ret));
              } else if (pos < 2 || pos > 31) {
                ret = OB_ERR_UNEXPECTED;
                LOG_WARN("length of time sting is not valid", K(ret));
              } else {
                MEMCPY(buf, time_buf + 1, pos - 2);
                pos = pos - 2;
              }
            } else if (OB_FAIL(value.print_sql_literal(buf, OB_MAX_ALIAS_NAME_LENGTH + 1, pos))) {
              LOG_WARN("fail to print_sql_literal", K(value), K(ret));
            }
            if (OB_SUCC(ret)) {
              ObString name_str(pos, buf);
              if (OB_FAIL(ObSQLUtils::make_field_name(name_str.ptr(),
                                                      static_cast<const int64_t>(name_str.length()),
                                                      CS_TYPE_UTF8MB4_GENERAL_CI,
                                                      allocator_,
                                                      name_str))) {
                LOG_WARN("fail to copy column alias name", K(name_str), K(ret));
              } else if (OB_FAIL(ob_write_string(*allocator_, name_str, select_item.alias_name_))) {
                LOG_WARN("failed to ob write string", K(ret));
              }
            }
          } else if (T_FUN_SYS_VERSION == name_expr->get_expr_type()) {
            ObString version;
            if (OB_FAIL(session_info_->get_sys_variable(share::SYS_VAR_VERSION, version))) {
              LOG_WARN("fail to get version", K(ret));
            } else if (OB_FAIL(ob_write_string(*allocator_, version, select_item.alias_name_))) {
              LOG_WARN("failed to ob write string", K(ret));
            }
          } else if (T_FUN_SYS_OB_VERSION == name_expr->get_expr_type()) {
            if (OB_FAIL(ob_write_string(*allocator_, common::ObString(PACKAGE_VERSION), select_item.alias_name_))) {
              LOG_WARN("failed to ob write string", K(ret));
            }
          } else if (T_FUN_SYS_ICU_VERSION == name_expr->get_expr_type()) {
            if (OB_FAIL(ob_write_string(*allocator_,
                                        common::ObString(ObExprRegexContext::icu_version_string()),
                                        select_item.alias_name_))) {
              LOG_WARN("failed to ob write string", K(ret));
            }
          } else {
            //invalid name, do nothing
          }
        } else if (is_oracle_mode()
                    && T_QUESTIONMARK == sel_expr->get_expr_type()
                    && T_OBJ_ACCESS_REF == project_node->type_) {
          while (OB_SUCC(ret) && NULL != project_node->children_[1]) {
            project_node = project_node->children_[1];
          }
          if (OB_FAIL(ret)) {
          } else if (T_OBJ_ACCESS_REF != project_node->type_) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("unexpected select item type", K(select_item), K(project_node->type_), K(ret));
          } else {
            alias_node = project_node->children_[0];
            select_item.alias_name_.assign_ptr(const_cast<char *>(alias_node->str_value_),
                                                static_cast<int32_t>(alias_node->str_len_));
            if (OB_UNLIKELY(alias_node->str_len_ > OB_MAX_COLUMN_NAME_LENGTH)) {
              ret = OB_ERR_TOO_LONG_IDENT;
              LOG_WARN("alias name too long", K(ret), K(select_item.alias_name_));
            }
          }
        } else {
          if (params_.is_prepare_protocol_
              || !session_info_->get_local_ob_enable_plan_cache()
              || 0 == node.children_[i]->is_val_paramed_item_idx_) {
            // ps 不参数化列; plan cache关闭后不参数化列
            // do nothing
          } else if (OB_ISNULL(params_.select_item_param_infos_) ||
                     node.children_[i]->value_ >= params_.select_item_param_infos_->count()) {
            ret = OB_INVALID_ARGUMENT;
            LOG_WARN("invalid argument", K(params_.select_item_param_infos_));
          } else {
            int64_t idx = node.children_[i]->value_;
            const SelectItemParamInfo &param_info = params_.select_item_param_infos_->at(idx);
            select_item.paramed_alias_name_.assign_ptr(param_info.paramed_field_name_, param_info.name_len_);
            if (OB_FAIL(select_item.questions_pos_.assign(param_info.questions_pos_))) {
              LOG_WARN("failed to assign array", K(ret));
            } else if (OB_FAIL(select_item.params_idx_.assign(param_info.params_idx_))) {
              LOG_WARN("failed to assign array", K(ret));
            } else {
              select_item.esc_str_flag_ = param_info.esc_str_flag_;
              select_item.neg_param_idx_ = param_info.neg_params_idx_;

              LOG_DEBUG("select item param info",
                        K(select_item.alias_name_), K(select_item.params_idx_),
                        K(select_item.paramed_alias_name_),
                        K(select_item.esc_str_flag_), K(select_item.questions_pos_),
                        K(select_item), K(((ObDMLStmt *)stmt_)->get_column_items()));
            }
          }
          is_auto_gen = true;
        }
      }

      if (OB_SUCC(ret) && is_oracle_mode() && sel_expr->has_flag(CNT_SUB_QUERY)) {
        if (OB_FAIL(check_subquery_return_one_column(*sel_expr))) {
          LOG_WARN("failed to check subquery return one column", K(ret));
        }
      }

      // 如果 select field list 表达式中包含了 sequence，则需要判断当前
      // select 语句是否为子查询，或者是否为 set 语句
      // **例外**：insert into select xxxx 的情景下，允许 sequence
      if (OB_SUCC(ret) && sel_expr->has_flag(CNT_SEQ_EXPR)) {
        if (in_set_query_ ||
            (params_.resolver_scope_stmt_type_ == ObItemType::T_INSERT  && current_level_ != 0) ||
            (params_.resolver_scope_stmt_type_ != ObItemType::T_INSERT  && (current_level_ > 1 || is_substmt()))) {
          // 对于 from (select xxxx) a 的场景，a 这个子查询的 current_level_ 和上一级相同，
          // 但设置了 parent namespace，故而还是可以加以区分
          ret = OB_ERR_SEQ_NOT_ALLOWED_HERE;
        }
      }
    }

    // for unqualified column, if current stmt exists joined table with using,
    // it's determined by join type.
    // select c1 from t1 left join t2 using(c1) right join t3 using(c1) => c1 is t3.c1
    // select t2.c1 from t1 left join t2 using(c1) right join t3 using(c1) => c1 is t2.c1
    // select c1 from t1 left join t2 using(c1) right join t3 using(c1),
    //                t3 t left join t4 using(c1) right join t5 using(c1); ==> ambiguious
    if (OB_FAIL(ret)) {
      /*do nothing*/
    } else if (OB_FAIL(set_select_item(select_item, is_auto_gen))) {
      // construct select item from select_expr
      LOG_WARN("set select item failed", K(ret));
    } else if (is_only_full_group_by_on(session_info_->get_sql_mode())) {
      if (OB_FAIL(standard_group_checker_.add_unsettled_expr(select_item.expr_))) {
        LOG_WARN("add unsettled expr to standard group checker failed", K(ret));
      }
    }

    // for oracle mode, check grouping here
    if (OB_FAIL(ret) || !is_oracle_mode()) {
      /*do nothing*/
    } else if (OB_FAIL(recursive_check_grouping_columns(select_stmt, select_item.expr_))) {
      LOG_WARN("failed to recursive check grouping columns", K(ret));
    } else {/*do nothing*/}
    // add for cte:
    if (OB_SUCC(ret) && !is_oracle_mode() && !params_.has_cte_param_list_) {
      if (OB_FAIL(cte_ctx_.cte_col_names_.push_back(select_item.alias_name_))) {
        LOG_WARN("push back column alia name failed", K(ret));
      }
    }
  } // end for

  if (OB_SUCC(ret) && has_nested_aggr_) {
    ObIArray<SelectItem> &select_items = select_stmt->get_select_items();
    for (int64_t i = 0; OB_SUCC(ret) && i < select_items.count(); i++) {
      if (OB_ISNULL(select_items.at(i).expr_)) {
        ret = OB_INVALID_ARGUMENT;
        LOG_WARN("invalid expr in select items.", K(ret));
        //compatible oracle: select 1, sum(max(c1)) from t1 group by c1;
      } else if (select_items.at(i).expr_->is_const_expr()) {
        //do nothing
      } else if (!select_items.at(i).expr_->has_flag(CNT_AGG)) {
        //in oracle it's "not a single-group group function."
        ret = OB_ERR_WRONG_FIELD_WITH_GROUP;
        ObString column_name = select_items.at(i).is_real_alias_ ?
              select_items.at(i).alias_name_ :
              select_items.at(i).expr_name_;
        LOG_USER_ERROR(OB_ERR_WRONG_FIELD_WITH_GROUP,
                       column_name.length(),
                       column_name.ptr());
      } else { /*do nothing.*/ }
    }
    if (OB_SUCC(ret)) {
      if (select_stmt->get_group_expr_size() == 0 &&
          select_stmt->get_rollup_expr_size() == 0 &&
          select_stmt->get_grouping_sets_items_size() == 0 &&
          select_stmt->get_multi_rollup_items_size() == 0) {
        ret = OB_NOT_SUPPORTED;
        LOG_WARN("nested group function without group by", K(ret));
        LOG_USER_ERROR(OB_NOT_SUPPORTED, "nested group function without group by");
      }
    }
  }

  if (OB_SUCC(ret)) {
    // Oracle mode, * can't be used with other expresion
    // like: select 1,* from t1; select *,1 from t1;
    if (is_oracle_mode() && is_bald_star && node.num_child_ > 1) {
      ret = OB_ERR_PARSE_SQL;
      LOG_WARN("star can't be used with other expression", K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::expand_target_list(
  const TableItem &table_item, ObIArray<SelectItem> &target_list)
{
  int ret = OB_SUCCESS;
  ObArray<ColumnItem> column_items;
  if (table_item.is_basic_table() || table_item.is_link_table()) {
    if (OB_FAIL(resolve_all_basic_table_columns(table_item, false, &column_items))) {
      LOG_WARN("resolve all basic table columns failed", K(ret), K(table_item));
    }
  } else if (table_item.is_generated_table() || table_item.is_temp_table()) {
    if (OB_FAIL(resolve_all_generated_table_columns(table_item, &column_items))) {
      LOG_WARN("resolve all generated table columns failed", K(ret));
    }
  } else if (table_item.is_fake_cte_table()) {
    if (OB_FAIL(resolve_all_fake_cte_table_columns(table_item, &column_items))) {
      LOG_WARN("resolve fake cte table failed", K(ret));
    }
  } else if (table_item.is_function_table()) {
    if (OB_FAIL(resolve_all_function_table_columns(table_item, &column_items))) {
      LOG_WARN("resolve function table columns failed", K(ret));
    }
  } else if (table_item.is_json_table()) {
    if (OB_FAIL(resolve_all_json_table_columns(table_item, &column_items))) {
      LOG_WARN("resolve function table columns failed", K(ret));
    }
  } else {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected table type", K_(table_item.type), K(ret));
  }

  const bool is_child_unpivot_select = (NULL != table_item.ref_query_
                                        && table_item.ref_query_->is_unpivot_select());
  LOG_DEBUG("do expand_target_list", K(is_child_unpivot_select), KPC(table_item.ref_query_));
  for (int64_t i = 0; OB_SUCC(ret) && i < column_items.count(); ++i) {
    const ColumnItem &col_item = column_items.at(i);
    SelectItem tmp_select_item;
    if (table_item.is_generated_table() || table_item.is_temp_table()) {
      if (OB_ISNULL(table_item.ref_query_) || i >= table_item.ref_query_->get_select_item_size()) {
        ret = OB_INVALID_ARGUMENT;
        LOG_WARN("invalid argument", K(ret), K(table_item.ref_query_),
                 K(i), K(table_item.ref_query_->get_select_item_size()));
      } else {
        const SelectItem &select_item = table_item.ref_query_->get_select_item(i);
        if (is_child_unpivot_select && select_item.is_unpivot_mocked_column_) {
          LOG_DEBUG("continue", K(select_item));
          continue;
        } else {
          tmp_select_item.questions_pos_ = select_item.questions_pos_;
          tmp_select_item.params_idx_ = select_item.params_idx_;
          tmp_select_item.neg_param_idx_ = select_item.neg_param_idx_;
          tmp_select_item.esc_str_flag_ = select_item.esc_str_flag_;
          tmp_select_item.paramed_alias_name_ = select_item.paramed_alias_name_;
          tmp_select_item.need_check_dup_name_ = select_item.need_check_dup_name_;
          tmp_select_item.is_unpivot_mocked_column_ = select_item.is_unpivot_mocked_column_;
        }
      }
    }
    tmp_select_item.alias_name_ = col_item.column_name_;
    tmp_select_item.expr_name_ = col_item.column_name_;
    tmp_select_item.is_real_alias_ = false;
    tmp_select_item.expr_ = col_item.expr_;
    if (OB_FAIL(target_list.push_back(tmp_select_item))) {
      LOG_WARN("push back target list failed", K(ret));
    }
  }
  return ret;
}

// construct select item from select_expr
int ObSelectResolver::set_select_item(SelectItem &select_item, bool is_auto_gen)
{
  int ret = OB_SUCCESS;
  ObCollationType cs_type = CS_TYPE_INVALID;

  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(select_stmt) || OB_ISNULL(session_info_) || OB_ISNULL(select_item.expr_)) {
    ret = OB_NOT_INIT;
    LOG_WARN("select stmt is null", K_(session_info), K(select_stmt), K_(select_item.expr));
  } else if (OB_FAIL(session_info_->get_collation_connection(cs_type))) {
    LOG_WARN("fail to get collation_connection", K(ret));
  } else if (!select_item.expr_->is_column_ref_expr()) {
    if (NULL != params_.secondary_namespace_ && !select_item.is_real_alias_ && is_auto_gen
        && select_item.alias_name_.length() > static_cast<size_t>(OB_MAX_COLUMN_NAME_LENGTH)) {
      ObString tmp_col_name;
      ObString col_name;
#define AILAS_NAME_LEN 100
      char temp_str_buf[AILAS_NAME_LEN] = { 0 };
      if (snprintf(temp_str_buf, sizeof(temp_str_buf), "Name_exp_%ld", auto_name_id_++) < 0) {
        ret = OB_SIZE_OVERFLOW;
        SQL_RESV_LOG(WARN, "failed to generate buffer for temp_str_buf", K(ret));
      }
#undef AILAS_NAME_LEN
      if (OB_SUCC(ret)) {
        tmp_col_name = ObString::make_string(temp_str_buf);
        if (OB_FAIL(ob_write_string(*allocator_, tmp_col_name, col_name))) {
          SQL_RESV_LOG(WARN, "Can not malloc space for constraint name", K(ret));
        } else {
          select_item.alias_name_.assign_ptr(col_name.ptr(), col_name.length());
        }
      }
      if (OB_SUCC(ret) &&
          OB_FAIL(ObSQLUtils::check_column_name(cs_type, select_item.alias_name_))) {
        LOG_WARN("fail to make field name", K(ret));
      }
    } else if (OB_FAIL(ObSQLUtils::check_and_copy_column_alias_name(cs_type, is_auto_gen,
                                                                    allocator_,
                                                                    select_item.alias_name_))) {
      LOG_WARN("check and copy column alias name failed", K(ret));
    }
  }
  if (OB_SUCC(ret) && OB_FAIL(select_stmt->add_select_item(select_item))) {
    LOG_WARN("add select item to select stmt failed", K(ret));
  } else { /*do nothing.*/ }
  return ret;
}

// find matched table in ijoined table groups, set jointable_idx to the group index if found.
int ObSelectResolver::find_joined_table_group_for_table(
    const uint64_t table_id,
    int64_t &jointable_idx)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();

  jointable_idx = -1;
  ObIArray<JoinedTable*> &joined_tables = select_stmt->get_joined_tables();
  for (int i = 0; i < joined_tables.count(); i++) {
    bool found = false;
    for (int j = 0; j < joined_tables.at(i)->single_table_ids_.count(); j++) {
      if (joined_tables.at(i)->single_table_ids_.at(j) == table_id) {
        found = true;
        break;
      }
    }

    if (found) {
      jointable_idx = i;
      break;
    }
  }

  return ret;
}

// background:
// Tables in table_items of select stmt is added by the executed sequence, either
// based table or generated table. For joined table of each group, join info is
// saved in joined_tables of current select stmt. As for joined table with using,
// columns will be coalesced based on using list and joined table.
//
// idea:
// For each table item in table_items:
//  - based table, add all olumns in table schema
//  - generated table, add all select column items
//  - joined table, find all rest joined tables from one joined_table group, and
//  coalesce columns for based/generated table, which based/generated table columns
//  are producted by the rule above. Skip tables in current joined group for looping.
//
// words:
// table group: seperated by ','
// joined table group: tree of joined table in one table group
// join group: short of joined table group
//
int ObSelectResolver::resolve_star_for_table_groups()
{
  ObSelectStmt *select_stmt = get_select_stmt();
  int ret = OB_SUCCESS;
  int64_t num = 0;
  int64_t jointable_idx = -1;
  if (OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select stmt is null");
  } else {
    num = select_stmt->get_table_size();
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < num; i++) {
    const TableItem *table_item = select_stmt->get_table_item(i);
    if (OB_ISNULL(table_item)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("table item is null");
    } else if (has_oracle_join()) {
      table_item = get_from_items_order(i);
      if (OB_ISNULL(table_item) || table_item->is_joined_table()) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("table_item has wrong type", K(table_item));
      } else {
        ObArray<SelectItem> target_list;
        if (OB_FAIL(expand_target_list(*table_item, target_list))) {
          LOG_WARN("resolve table columns failed", K(ret), K(table_item));
        }
        for (int64_t i = 0; OB_SUCC(ret) && i < target_list.count(); ++i) {
          if (OB_FAIL(select_stmt->add_select_item(target_list.at(i)))) {
            LOG_WARN("add select item to select stmt failed", K(ret));
          } else if (is_only_full_group_by_on(session_info_->get_sql_mode())) {
            //如果是only full group by，所有target list中的列都必须检查是否满足group约束
            if (OB_FAIL(standard_group_checker_.add_unsettled_column(target_list.at(i).expr_))) {
              LOG_WARN("add unsettled column failed", K(ret));
            } else if (OB_FAIL(standard_group_checker_.add_unsettled_expr(target_list.at(i).expr_))) {
              LOG_WARN("add unsettled expr failed", K(ret));
            }
            //同上
          }
        }
      }
    } else {
      if (OB_FAIL(find_joined_table_group_for_table(table_item->table_id_, jointable_idx))) {
        LOG_WARN("find_joined_table_group_for_table failed", K(ret), K(table_item));
      } else if (jointable_idx != -1) {
        // located in joined table with jointable_idx of joined_tables
        ObArray<SelectItem> sorted_select_items;
        if (OB_FAIL(find_select_columns_for_join_group(jointable_idx, &sorted_select_items))) {
          LOG_WARN("find_select_columns_for_join_group failed", K(ret));
        } else {
          // skip next tables in joined group
          i += select_stmt->get_joined_tables().at(jointable_idx)->single_table_ids_.count() - 1;
          // push back select items to select stmt
          for (int j = 0; OB_SUCC(ret) && j < sorted_select_items.count(); j++) {
            SelectItem &item = sorted_select_items.at(j);
            if (OB_FAIL(item.expr_->extract_info())) {
              LOG_WARN("extract info failed", K(ret));
            } else if (OB_FAIL(item.expr_->deduce_type(session_info_))) {
              LOG_WARN("deduce type failed", K(ret));
            } else if (OB_FAIL(select_stmt->add_select_item(item))) {
              LOG_WARN("add_select_item failed", K(ret), K(item));
            } else if (is_only_full_group_by_on(session_info_->get_sql_mode())) {
              //如果是only full group by，所有target list中的列都必须检查是否满足group约束
              if (OB_FAIL(standard_group_checker_.add_unsettled_column(item.expr_))) {
                LOG_WARN("add unsettled column failed", K(ret));
              } else if (standard_group_checker_.add_unsettled_expr(item.expr_)) {
                LOG_WARN("add unsettled expr failed", K(ret));
              }
              //对于select * from t1 group by c1, c2;这样的语句，*展开就是column，所以表达式以及表达式引用到的列都是自己
            }
          }
        }
      } else {
        // based table or alias table or generated table
        ObArray<SelectItem> target_list;
        OZ( expand_target_list(*table_item, target_list), table_item );
        for (int64_t i = 0; OB_SUCC(ret) && i < target_list.count(); ++i) {
          if (OB_FAIL(select_stmt->add_select_item(target_list.at(i)))) {
            LOG_WARN("add select item to select stmt failed", K(ret));
          } else if (is_only_full_group_by_on(session_info_->get_sql_mode())) {
            //如果是only full group by，所有target list中的列都必须检查是否满足group约束
            OZ( standard_group_checker_.add_unsettled_column(target_list.at(i).expr_) );
            OZ( standard_group_checker_.add_unsettled_expr(target_list.at(i).expr_) );
          }
        }
      }
    }
  }

  return ret;
}

int ObSelectResolver::resolve_all_json_table_columns(
  const TableItem &table_item, ObIArray<ColumnItem> *column_items)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(column_items)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("invalid params, null column items", K(ret));
  } else if (OB_FAIL(resolve_json_table_column_all_items(table_item, *column_items))) {
    LOG_WARN("fail to resolve json table column items", K(ret));
  }
  return ret;
}

int ObSelectResolver::resolve_all_function_table_columns(
  const TableItem &table_item, ObIArray<ColumnItem> *column_items)
{
  int ret = OB_SUCCESS;
  CK (OB_NOT_NULL(column_items));
  OZ (resolve_function_table_column_item(table_item, *column_items));
  return ret;
}

int ObSelectResolver::is_need_check_col_dup(const ObRawExpr *expr, bool &need_check)
{
  int ret = OB_SUCCESS;
  need_check = true;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("is null", K(ret));
  } else if (params_.need_check_col_dup_) {
    need_check = true;
  } else if (T_QUESTIONMARK == expr->get_expr_type()) {
    need_check = false;
  } else {
    for (int64_t j = 0; OB_SUCC(ret) && need_check && j < expr->get_children_count(); ++j) {
      const ObRawExpr *child = expr->get_param_expr(j);
      if (OB_ISNULL(child)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("invalid child", K(child));
      } else if (OB_FAIL(SMART_CALL(is_need_check_col_dup(child, need_check)))) {
        LOG_WARN("failed to check if need to check col duplicate", K(ret));
      }
    }
  }
  return ret;
}

int ObSelectResolver::resolve_all_generated_table_columns(
  const TableItem &table_item, ObIArray<ColumnItem> *column_items)
{
  int ret = OB_SUCCESS;
  ColumnItem *col_item = NULL;
  ObSelectStmt *table_ref = table_item.ref_query_;
  bool is_exists = false;
  if (OB_ISNULL(table_ref)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("generate table is null", K(ret), K(table_ref));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < table_ref->get_select_item_size(); ++i) {
    const SelectItem &select_item = table_ref->get_select_item(i);
    const bool is_joined_dup_column = select_item.expr_->is_column_ref_expr()?
        static_cast<ObColumnRefRawExpr *>(select_item.expr_)->is_joined_dup_column():false;
    bool need_check_col_dup = true;
    bool is_skip = is_oracle_mode() && !table_ref->is_view_stmt() && is_joined_dup_column;
    /* 这里进行一次重复列名检测是原因是oracle支持generated table含有重复列名的不引用重复列名的查询，比如：
    *  select 1 from (select c1,c1 from t1)；因此在oracle模式resolve generated table时会跳过检查重复列
    *  但是对于select * from(select c1,c1 from t1)；这样的查询肯定引用了，因此必须在展开*对应的查询时进行一次
    *  检查，如果存在重复列是不允许的；https://work.aone.alibaba-inc.com/issue/29799516
     */
    // if the select item is a duplicable column in generated table, skip the check.
    // else we should set the skip_join_dup parameter to true. 
    if (OB_FAIL(is_need_check_col_dup(select_item.expr_, need_check_col_dup))) {
      LOG_WARN("failed to check if need to check col duplicate", K(ret));
    } else if (FALSE_IT(is_skip = is_skip ? is_skip : !need_check_col_dup)) {
    } else if (!is_skip && OB_FAIL(column_namespace_checker_.check_column_exists(table_item,
                                                              select_item.alias_name_,
                                                              is_exists, // the return value of is_exists is unused.
                                                              !table_ref->is_view_stmt()))) { //if is a view stmt, do not pass the duplicated column.
      LOG_WARN("failed to check column exists", K(ret));
    } else if (OB_FAIL(resolve_generated_table_column_item(table_item,
                                                           select_item.alias_name_,
                                                           col_item,
                                                           NULL,
                                                           OB_INVALID_ID,
                                                           i,
                                                           is_skip))) {
      LOG_WARN("resolve column item failed", K(ret));
    } else if (column_items != NULL) {
      if (OB_FAIL(column_items->push_back(*col_item))) {
        LOG_WARN("push back column item failed", K(ret));
      }
    }
  }
  LOG_DEBUG("finish resolve_all_generated_table_columns", KPC(column_items), K(table_item),
            KPC(table_ref));
  return ret;
}

// rules:
// table name can not same in same level, including alias
// specified columns are ahead of star
// columns are append by table group, seperated by ','.
// each group containers the mixtrue of based/joined/generated table.
int ObSelectResolver::resolve_star(const ParseNode *node)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  const share::schema::ObTableSchema *table_schema = NULL;

  if (OB_ISNULL(node) || OB_ISNULL(session_info_)
      || OB_ISNULL(select_stmt) || OB_ISNULL(params_.expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("invalid status", K(node), K_(session_info), K(select_stmt), K(params_.expr_factory_));
  } else if (node->type_ == T_STAR) {
    int64_t num = select_stmt->get_table_size();
    if (num <= 0) {
      // select *
      // select * from dual
      if (lib::is_mysql_mode()) {
        ObConstRawExpr *c_expr = NULL;
        SelectItem select_item;
        if (!is_in_exists_subquery()) {
          ret = OB_ERR_NO_TABLES_USED;
          LOG_WARN("No tables used");
        } else if (ObRawExprUtils::build_const_int_expr(*params_.expr_factory_,
                                                        ObIntType, 1, c_expr)) {
          LOG_WARN("fail to build const int expr", K(ret));
        } else if (OB_FALSE_IT(select_item.expr_ = c_expr)) {
        } else if (OB_FAIL(select_stmt->add_select_item(select_item))) {
          LOG_WARN("failed to add select item", K(ret));
        } else {/*do nothing*/}
      } else {
        // (select * from dual) is legitimate for oracle ==> output: X
        ObConstRawExpr *c_expr = NULL;
        const char *ptr_value = "X";
        const char *ptr_name = "D";
        ObString string_value(1, ptr_value);
        ObString string_name(1, ptr_name);
        if (select_stmt->has_group_by() || has_group_by_clause()) {
          ret = OB_ERR_WRONG_FIELD_WITH_GROUP;
          LOG_DEBUG("not a GROUP BY expression", K(ret));
        } else if (OB_FAIL(params_.expr_factory_->create_raw_expr(T_VARCHAR, c_expr))) {
          LOG_WARN("fail to create const raw c_expr", K(ret));
        } else {
          ObObj obj;
          obj.set_string(ObVarcharType, string_value);
          obj.set_collation_type(CS_TYPE_UTF8MB4_BIN);
          c_expr->set_value(obj);
          SelectItem select_item;
          select_item.expr_ = c_expr;
          select_item.expr_name_ = string_name;
          select_item.alias_name_ = string_name;
          select_item.is_real_alias_ = true;
          if (OB_FAIL(select_stmt->add_select_item(select_item))) {
            LOG_WARN("failed to add select item", K(ret));
          } else {/*do nothing*/}
        }
      }
    } else if (OB_FAIL(resolve_star_for_table_groups())) {
      LOG_WARN("resolve star for table groups failed", K(ret));
    }
  } else if (node->type_ == T_COLUMN_REF && node->children_[2]->type_ == T_STAR) {
    ObQualifiedName column_ref;
    bool is_json_wildcard_column = false;  // special input : tab_name.column_name.*
    bool is_column_name_equal = false;
    const TableItem* tab_item = NULL;
    ObNameCaseMode case_mode = OB_NAME_CASE_INVALID;
    if (OB_FAIL(session_info_->get_name_case_mode(case_mode))) {
      LOG_WARN("fail to get name case mode", K(ret));
    } else if (OB_FAIL(ObResolverUtils::resolve_column_ref(node, case_mode, column_ref))) {
      LOG_WARN("fail to resolve table name", K(ret));
    } else {
      ObSEArray<const TableItem*, 8> table_items;
      ObArray<SelectItem> target_list;
      if (OB_FAIL(select_stmt->get_all_table_item_by_tname(session_info_, column_ref.database_name_,
                                                           column_ref.tbl_name_, table_items))) {
        LOG_WARN("get all matched table failed", K(ret));
      } else if (table_items.count() <= 0) {
        ret = OB_SUCCESS;
        ObString db_name;
        if (lib::is_oracle_mode() && OB_FAIL(select_stmt->get_all_table_item_by_tname(session_info_, db_name,
                                                                      column_ref.database_name_, table_items))) {
          LOG_WARN("get all matched table failed", K(ret));
        } else if (lib::is_mysql_mode() || table_items.count() <= 0) {
          ret = OB_ERR_BAD_TABLE;
        } else {
          is_json_wildcard_column = true;
        }
        if (ret != 0) {  // according to oracle , need cover error code
          ret = OB_ERR_BAD_TABLE;
          ObString table_name = concat_table_name(column_ref.database_name_, column_ref.tbl_name_);
          LOG_USER_ERROR(OB_ERR_BAD_TABLE, table_name.length(), table_name.ptr());
        }
      }
      for (int64_t i = 0; OB_SUCC(ret) && i < table_items.count(); ++i) {
        target_list.reset();
        tab_item = table_items.at(i);
        if (OB_ISNULL(tab_item)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(tab_item), K(ret));
        } else if (OB_FAIL(expand_target_list(*tab_item, target_list))) {
          LOG_WARN("resolve table columns failed", K(ret), K(tab_item), K(i));
        } else if (is_json_wildcard_column) {
          if (OB_FAIL(schema_checker_->get_table_schema(session_info_->get_effective_tenant_id(), tab_item->ref_id_, table_schema))) {
            ret = OB_TABLE_NOT_EXIST;
            LOG_WARN("get table schema failed", K_(tab_item->table_name), K(tab_item->ref_id_), K(ret));
          } else if (OB_ISNULL(table_schema)) {
            ret = OB_TABLE_NOT_EXIST;
            LOG_WARN("get table schema failed", K_(tab_item->table_name), K(tab_item->ref_id_), K(ret));
          } else if (OB_NOT_NULL(table_schema->get_column_schema(column_ref.tbl_name_))
                      && !table_schema->get_column_schema(column_ref.tbl_name_)->is_json()) {
            ret = OB_ERR_TABLE_NAME_NOT_IN_LIST;
            LOG_WARN("table name not in from list", K(ret), K(column_ref.tbl_name_));
          }
        }
        for (int64_t j = 0; OB_SUCC(ret) && j < target_list.count(); ++j) {
          is_column_name_equal = is_json_wildcard_column & (0 != column_ref.tbl_name_.case_compare(target_list.at(j).alias_name_));
          if (!is_column_name_equal && OB_FAIL(select_stmt->add_select_item(target_list.at(j)))) {
            LOG_WARN("add select item to select stmt failed", K(ret));
          } else if (is_only_full_group_by_on(session_info_->get_sql_mode())) {
            //如果是only full group by，所有target list中的列都必须检查是否满足group约束
            if (is_column_name_equal) {    // target column not equal with current column without judge
            } else if (OB_FAIL(standard_group_checker_.add_unsettled_column(target_list.at(j).expr_))) {
              LOG_WARN("add unsettled column failed", K(ret));
            } else if (OB_FAIL(standard_group_checker_.add_unsettled_expr(target_list.at(j).expr_))) {
              LOG_WARN("add unsettled expr to standard group checker failed", K(ret));
            }
          }
          if (OB_SUCC(ret) && !is_column_name_equal) {
            ret = column_namespace_checker_.check_column_existence_in_using_clause(
                    table_items.at(i)->table_id_, target_list.at(j).expr_name_);
          }
        }
      }
    }
  } else {
    /* won't be here */
  }
  return ret;
}


// coalesce columns from left and right columns for the given joined type,
// with or without using_columns
int ObSelectResolver::coalesce_select_columns_for_joined_table(
  const ObIArray<SelectItem> *left,
  const ObIArray<SelectItem> *right,
  const ObJoinType type,
  const ObIArray<ObString> &using_columns,
  ObIArray<SelectItem> *coalesced_columns)
{
  int ret = OB_SUCCESS;
  ObArray<int64_t> coalesced_column_ids;
  const ObIArray<SelectItem> *items = left;
  if (using_columns.count() > 0 && type == RIGHT_OUTER_JOIN) {
    items = right;
  }
  // 1. pick up matched using columns from select items
  for (int64_t j = 0; OB_SUCC(ret) && j < items->count(); j++) {
    const SelectItem *item = &items->at(j);
    for (int64_t i = 0; OB_SUCC(ret) && i < using_columns.count(); ++i) {
      if (ObCharset::case_insensitive_equal(item->alias_name_, using_columns.at(i))) {
        if (OB_FAIL(coalesced_columns->push_back(*item))) {
          LOG_WARN("coalesced_columns->push_back item failed", K(ret));
        }
        if (OB_FAIL(coalesced_column_ids.push_back(j))) {
          LOG_WARN("coalesced_column_ids.push_back failed", K(ret));
        }
        break;
      }
    }
  }

  // 2. pick up rest columns
  if (using_columns.count() > 0) {
    if (coalesced_column_ids.count() <= 0) {
      ret = OB_ERR_BAD_FIELD_ERROR;
      SQL_RESV_LOG(WARN,"Column not exist", K(ret));
    }
  }
  if (OB_SUCC(ret)) {
    for (int64_t i = 0; OB_SUCC(ret) && i < items->count(); i++) {
      int64_t j = 0;
      for (j = 0; j < coalesced_column_ids.count(); j++) {
        if (coalesced_column_ids.at(j) == i) {
          break;
        }
      }
      if (j == coalesced_column_ids.count()) {
        if (OB_FAIL(coalesced_columns->push_back(items->at(i)))) {
          LOG_WARN("coalesced_columns->push_back failed", K(ret));
        }
      }
    }

    // 3. pick up rest counts in other side
    items = right;
    if (using_columns.count() > 0 && type == RIGHT_OUTER_JOIN) {
      items = left;
    }
    if (coalesced_columns->count() <= 0) {
      ret = OB_ERR_BAD_FIELD_ERROR;
      SQL_RESV_LOG(WARN,"Column not exist", K(ret));
    }
    if (OB_SUCC(ret)) {
      // if we find a duplicated column name (exclude the using column), we need to set the hidden id
      // to distinguish them.
      int64_t left_column_num = coalesced_columns->count();
      for (int64_t i = 0; OB_SUCC(ret) && i < items->count(); i++) {
        const SelectItem *item = &items->at(i);
        bool found = false;
        bool duplicated = false;
        int64_t dup_col_index = 0;
        for (int64_t j = 0; OB_SUCC(ret) && j < using_columns.count(); ++j) {
          if (ObCharset::case_insensitive_equal(item->alias_name_, using_columns.at(j))) {
            found = true;
            break;
          }
        }
        for(dup_col_index = 0; dup_col_index < left_column_num; dup_col_index++ ) {
          if (ObCharset::case_insensitive_equal(item->alias_name_, coalesced_columns->at(dup_col_index).alias_name_)) {
            duplicated=true; 
            break;
          }
        }
        if (!found) {
          if (OB_FAIL(coalesced_columns->push_back(*item))) {
            LOG_WARN("coalesced_columns->push_back failed", K(ret));
          }
          // if found duplicated and the duplicated column is not the using column.
          // set the is_joined_dup_column flag; the i-th column in items (the last column in coalesced_columns) is 
          // duplicated with the left_column_index-th column in coalesced_columns.
          if (OB_SUCC(ret) && duplicated) {
            static_cast<ObColumnRefRawExpr*>(coalesced_columns->at(dup_col_index).expr_)->set_joined_dup_column(true);
            static_cast<ObColumnRefRawExpr*>(coalesced_columns->at(coalesced_columns->count()-1).expr_)->set_joined_dup_column(true);
          }
        }
      }
    }
  }
  return ret;
}

// jointable will be the root node of joined table, if you want to loop the whole tree.
int ObSelectResolver::find_select_columns_for_joined_table_recursive(
  const JoinedTable *jointable,
  ObIArray<SelectItem> *sorted_select_items)
{
  int ret = OB_SUCCESS;
  ObArray<SelectItem> left_select_items;
  ObArray<SelectItem> right_select_items;

  if (jointable->left_table_->type_ == TableItem::JOINED_TABLE) {
    OC( (find_select_columns_for_joined_table_recursive)(
          static_cast<const JoinedTable*>(jointable->left_table_),
          &left_select_items));
  } else {
    OC( (expand_target_list)(*jointable->left_table_, left_select_items) );
  }

  if (OB_SUCC(ret)) {
    if (jointable->right_table_->type_ == TableItem::JOINED_TABLE) {
      OC( (find_select_columns_for_joined_table_recursive)(
            static_cast<const JoinedTable*>(jointable->right_table_),
            &right_select_items));
    } else {
      OC( (expand_target_list)(*jointable->right_table_, right_select_items) );
    }
  }

  ResolverJoinInfo *join_info = NULL;
  if (get_joininfo_by_id(jointable->table_id_, join_info)) {
    OC( (coalesce_select_columns_for_joined_table)(
         &left_select_items,
         &right_select_items,
         jointable->joined_type_,
         join_info->using_columns_,
         sorted_select_items));
  }

  return ret;
}

int ObSelectResolver::find_select_columns_for_join_group(
  const int64_t jointable_idx,
  ObArray<SelectItem> *sorted_select_items)
{
  int ret = OB_SUCCESS;
  const ObSelectStmt *select_stmt = get_select_stmt();
  const JoinedTable *jointable = select_stmt->get_joined_tables().at(jointable_idx);

  if (OB_FAIL(find_select_columns_for_joined_table_recursive(jointable, sorted_select_items))) {
    LOG_WARN("find_select_columns_for_joined_table_recursive failed!", K(*jointable));
  } else {
    const ObIArray<JoinedTable*> &joined_tables = select_stmt->get_joined_tables();
    int64_t n_select_count = sorted_select_items->count();
    for (int64_t i = 0; i < n_select_count; ++i) {
      ObRawExpr *coalesce_expr = NULL;
      for (int j = 0; j < joined_tables.count(); j++) {
        const JoinedTable* joined_table = joined_tables.at(j);
        OZ(recursive_find_coalesce_expr(joined_table,
                                        sorted_select_items->at(i).alias_name_,
                                        coalesce_expr));
        if (coalesce_expr != NULL) {
          sorted_select_items->at(i).expr_ = coalesce_expr;
        }
      }
    }
  }
  return ret;
}

/*               |-------------------------------------r_union_stmt--------------------------------|
 * with cte() as ( left_stmt union all right stmt  ) search by item + pseudo, cycle by item + pseudo
 * r_union_stmt这个stmt的解析过程中，是没有任何一个table item出现在这个层次的stmt的
 * 没有办法按照常规的表达式T_COLUMN_REF产生表达式，并作为column_item加到stmt中
 * 因为加入的时候会检查是否该列的表是否在stmt中。
 * search或者cycle的item在在left_stmt和right_stmt中代表的列不一样，所以无法直接使用左支或者右支的select item
 * 所以只能类似于generate table item中的column item产生的方式来产生
 * */
int ObSelectResolver::generate_fake_column_expr(
  const share::schema::ObColumnSchemaV2 *column_schema,
  ObSelectStmt *left_stmt,
  ObColumnRefRawExpr *&fake_col_expr)
{
  int ret = OB_SUCCESS;
  int64_t projector_offset = column_schema->get_cte_generate_column_projector_offset();
  ObSelectStmt *select_stmt = NULL;
  ObColumnRefRawExpr *col_expr = NULL;
  ColumnItem column_item;
  CK( OB_NOT_NULL(select_stmt = get_select_stmt()),
      OB_NOT_NULL(column_schema),
      OB_NOT_NULL(left_stmt),
      !OB_UNLIKELY(projector_offset >= left_stmt->get_select_item_size()),
      OB_NOT_NULL(left_stmt->get_select_item(projector_offset).expr_),
      !(projector_offset >= cte_ctx_.cte_col_names_.count()));
  OC( (params_.expr_factory_->create_raw_expr)(T_REF_COLUMN, col_expr) );
  OC( (left_stmt->get_select_item(projector_offset).expr_->deduce_type)(session_info_) );
  if (OB_SUCC(ret)) {
    //build a new column ref expr
    col_expr->set_ref_id(
      current_recursive_cte_table_item_->ref_id_,
      column_schema->get_column_id());
    col_expr->set_result_type(left_stmt->get_select_item(projector_offset).expr_->get_result_type());
    col_expr->set_column_attr(current_recursive_cte_table_item_->get_table_name(),
                              cte_ctx_.cte_col_names_.at(projector_offset));
    col_expr->set_database_name(current_recursive_cte_table_item_->database_name_);
    col_expr->set_column_flags(CTE_GENERATED_COLUMN_FLAG);
    if (OB_FAIL(col_expr->extract_info())) {
      LOG_WARN("extract column expr info failed", K(ret));
    } else {
      fake_col_expr = col_expr;
    }
  }
  return ret;
}

int ObSelectResolver::resolve_search_item(const ParseNode *sort_list, ObSelectStmt *r_union_stmt)
{
  int ret = OB_SUCCESS;
  ObSelectStmt* left_stmt = r_union_stmt->get_set_query(0);
  for (int64_t i = 0; OB_SUCC(ret) && i < sort_list->num_child_; ++i) {
    ParseNode *sort_node = sort_list->children_[i];
    OrderItem order_item;
    ObColumnRefRawExpr *fake_col_expr = NULL;
    const share::schema::ObColumnSchemaV2 *column_schema;
    ParseNode *alias_node = sort_node->children_[0];
    ObString column_alia_name;
    if (OB_FAIL(ObResolverUtils::set_direction_by_mode(*sort_node, order_item))) {
      LOG_WARN("failed to set direction by mode", K(ret));
    } else if (OB_ISNULL(alias_node)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("alias node is null", K(ret));
    } else if (T_OBJ_ACCESS_REF != alias_node->type_) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("alias node is not a obj access", K(ret));
    } else if (OB_ISNULL(alias_node->children_[0])) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("alias node is invalid", K(ret));
    } else {
      column_alia_name.assign_ptr(
        (char *) (alias_node->children_[0]->str_value_),
        static_cast<int32_t>(alias_node->children_[0]->str_len_));
    }

    if (OB_SUCC(ret)) {
      if (OB_FAIL(get_column_schema(current_recursive_cte_table_item_->ref_id_,
                                    column_alia_name,
                                    column_schema,
                                    false /*get_hidden*/,
                                    current_recursive_cte_table_item_->is_link_table()))) {
        LOG_WARN("the col item has been resolve, but we do not find it in the search clause resolver", K(ret));
      } else if (OB_FAIL(generate_fake_column_expr(column_schema, left_stmt, fake_col_expr))){
        LOG_WARN("generate the column item", K(ret), K(*column_schema));
      } else {
        order_item.expr_ = fake_col_expr;
        if (OB_FAIL(r_union_stmt->add_search_item(order_item))) {
          // add the search order item
          LOG_WARN("Add order expression error", K(ret));
        }
      }
    }

  } // end of for
  return ret;
}

int ObSelectResolver::resolve_search_pseudo(const ParseNode *search_set_clause,
                                            ObSelectStmt *r_union_stmt,
                                            ObString &search_pseudo_column_name)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(search_set_clause) || OB_ISNULL(r_union_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("search set clause/r_union_stmt is null", K(ret), K(search_set_clause), K(r_union_stmt));
  } else if (OB_FAIL(resolve_and_split_sql_expr(*search_set_clause, r_union_stmt->get_cte_exprs()))) {
    LOG_WARN("resolve and split sql expr failed", K(ret));
  } else {
    int64_t count = r_union_stmt->get_cte_exprs().count() - 1;
    if (count < 0) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("we need at least 1 cte expr!", K(ret));
    } else {
      ObRawExpr* search_pseudo_column_expr = r_union_stmt->get_cte_exprs().at(count);
      if (T_CTE_SEARCH_COLUMN != search_pseudo_column_expr->get_expr_type()) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("expected t_cte_search_column", K(ret));
      } else {
        SelectItem select_item;
        select_item.expr_ = search_pseudo_column_expr;
        select_item.alias_name_.assign_ptr(search_pseudo_column_expr->get_alias_column_name().ptr(),
            search_pseudo_column_expr->get_alias_column_name().length());
        search_pseudo_column_name.assign_ptr(search_pseudo_column_expr->get_alias_column_name().ptr(),
            search_pseudo_column_expr->get_alias_column_name().length());
        select_item.is_real_alias_ = true;
        if (OB_FAIL(r_union_stmt->add_select_item(select_item))) {
          // construct select item from select_expr
          LOG_WARN("set cte search select item failed", K(ret));
        }
      }
    }
  }

  return ret;
}

/**
 * 在search clause中必须严格出现在cte（col alias）定义的列名，不允许出现类似cte.col，指定是定义的名字。
 * 例如：
 *     cte( a, b, c) as (.....) search depth by a, c, b set ordering
 *     只能是单独的一个列的表现形式，已经oracle中测试并确认
 */
int ObSelectResolver::resolve_search_clause(const ParseNode &parse_tree,
                                            const TableItem* cte_table_item,
                                            ObString& search_pseudo_column_name)
{
  int ret = OB_SUCCESS;
  current_scope_ = T_WITH_CLAUSE_SEARCH_SCOPE;
  const ParseNode* sort_list = parse_tree.children_[0];
  const ParseNode* search_set_clause = parse_tree.children_[1];
  ObSelectStmt* r_union_stmt = cte_table_item->ref_query_;
  //获得深度 广度优先选项，查询列选项以及伪列的列名
  if (OB_ISNULL(r_union_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("the recursive union can not be null", K(ret));
  } else if (OB_ISNULL(r_union_stmt->get_set_query(0))
             && OB_ISNULL(r_union_stmt->get_set_query(1))) {
    ret = OB_ERR_CTE_ILLEGAL_SEARCH_CYCLE_CLAUSE;
    LOG_WARN("SEARCH and CYCLE clauses can only be specified for recursive WITH clause elements", K(ret));
  } else if (OB_ISNULL(current_recursive_cte_table_item_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("the recursive cte table item can not be null", K(ret));
  } else if (T_SEARCH_DEPTH_NODE == parse_tree.type_) {
    r_union_stmt->set_breadth_strategy(false);
  } else if (T_SEARCH_BREADTH_NODE == parse_tree.type_) {
    r_union_stmt->set_breadth_strategy(true);
  } else {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected search clause parse tree", K(ret));
  }
  if (OB_SUCC(ret)) {
    if (OB_FAIL(resolve_search_item(sort_list, r_union_stmt))) {
      LOG_WARN("resolve search item failed", K(ret));
    } else if (OB_FAIL(resolve_search_pseudo(search_set_clause, r_union_stmt, search_pseudo_column_name))) {
      LOG_WARN("resolve search pseudo failed", K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::resolve_cycle_item(const ParseNode *alias_list, ObSelectStmt *r_union_stmt)
{
  int ret = OB_SUCCESS;
  ObSelectStmt* left_stmt = r_union_stmt->get_set_query(0);
  ObSEArray<ObString, 8> col_names;
  for (int64_t i = 0; OB_SUCC(ret) && i < alias_list->num_child_; ++i) {
    ParseNode *alias_node = alias_list->children_[i];
    ObString column_alia_name;
    ColumnItem col_item;
    ObColumnRefRawExpr *fake_col_expr = NULL;
    const share::schema::ObColumnSchemaV2 *column_schema;
    column_alia_name.assign_ptr((char *) (alias_node->str_value_),
                                static_cast<int32_t>(alias_node->str_len_));
    if (OB_FAIL(get_column_schema(current_recursive_cte_table_item_->ref_id_,
                                  column_alia_name,
                                  column_schema,
                                  false /*get_hidden*/,
                                  current_recursive_cte_table_item_->is_link_table()))) {
      LOG_WARN("the col item has been resolve, but we do not find it in the cycle clause resolver", K(ret));
    } else if (OB_FAIL(generate_fake_column_expr(column_schema, left_stmt, fake_col_expr))) {
      LOG_WARN("generate the column item", K(ret));
    } else {
      int64_t projector_offset = column_schema->get_cte_generate_column_projector_offset();
      //set col item
      ObResolverUtils::resolve_default_value_and_expr_from_select_item(left_stmt->get_select_item(projector_offset),
                                                                       col_item,
                                                                       left_stmt); 
      col_item.expr_ = fake_col_expr;
      col_item.column_id_ = column_schema->get_column_id();
      col_item.table_id_ = current_recursive_cte_table_item_->ref_id_;
      col_item.column_name_ = column_schema->get_column_name_str();
      if (OB_FAIL(r_union_stmt->add_cycle_item(col_item))) {
        LOG_WARN("add cycle r union stmt col item failed", K(ret));
      }
    }
  } // end of for
  return ret;
}

int ObSelectResolver::resolve_cycle_pseudo(const ParseNode *cycle_set_clause,
                                           ObSelectStmt *r_union_stmt,
                                           const ParseNode *cycle_value,
                                           const ParseNode *cycle_default_value,
                                           ObString &cycle_pseudo_column_name)
{
  int ret = OB_SUCCESS;
  ObRawExpr *expr_v = nullptr;
  ObRawExpr *expr_d_v = nullptr;
  //for pseudo column
  if (OB_ISNULL(cycle_set_clause)) {
    LOG_WARN("cycle clause must have set pseudo column", K(ret));
  } else if (OB_FAIL(resolve_and_split_sql_expr(*cycle_set_clause,
                                                r_union_stmt->get_cte_exprs()))) {
    LOG_WARN("resolve and split sql expr failed", K(ret));
  } else if (cycle_value->type_ == T_QUESTIONMARK
        && cycle_default_value->type_ == T_QUESTIONMARK) {
      ret = OB_INVALID_ARGUMENT;
      LOG_WARN("cycle value can not be '?'",
               K(ret),
               K(cycle_value->text_len_),
               K(cycle_default_value->text_len_));
  } else if (cycle_value->type_ == T_VARCHAR
             && cycle_default_value->type_ == T_VARCHAR) {
    if (cycle_value->str_len_ > 0 && cycle_default_value->str_len_ > 0) {
      if (OB_FAIL(resolve_sql_expr(*cycle_value, expr_v))) {
        LOG_WARN("resolve sql expr failed", K(ret));
      } else if (OB_FAIL(resolve_sql_expr(*cycle_default_value, expr_d_v))) {
        LOG_WARN("resolve sql expr failed", K(ret));
      }
    } else {
      ret = OB_ERR_CTE_ILLEGAL_CYCLE_NON_CYCLE_VALUE;
      LOG_WARN("invalid cycle argument",
               K(ret),
               K(cycle_value->str_len_),
               K(cycle_default_value->str_len_));
    }
  }
  if (OB_SUCC(ret)) {
    int64_t cycle_column_idx = r_union_stmt->get_cte_exprs().count();
    if (OB_UNLIKELY(0 == cycle_column_idx)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("a recursive union stmt without cte expr is unexpected", K(ret));
    } else {
      ObRawExpr *expr = r_union_stmt->get_cte_exprs().at(cycle_column_idx - 1);
      if (OB_UNLIKELY(T_CTE_CYCLE_COLUMN != expr->get_expr_type())) {
        ret = OB_ERR_PARSER_SYNTAX;
        LOG_WARN("must be cycle pseudo column", K(ret));
      } else {
        ObPseudoColumnRawExpr* cycle_expr = static_cast<ObPseudoColumnRawExpr*>(expr);
        cycle_expr->set_cte_cycle_value(expr_v, expr_d_v);
        SelectItem select_item;
        select_item.expr_ = cycle_expr;
        select_item.alias_name_.assign_ptr(cycle_expr->get_alias_column_name().ptr(),
                                           cycle_expr->get_alias_column_name().length());
        cycle_pseudo_column_name.assign_ptr(cycle_expr->get_alias_column_name().ptr(),
                                            cycle_expr->get_alias_column_name().length());
        select_item.is_real_alias_ = true;
        if (OB_FAIL(r_union_stmt->add_select_item(select_item))) {
          // construct select item from select_expr
          LOG_WARN("failed to set cte search select item", K(ret));
        }
      }
    }
  }
  return ret;
}


/**
 * 在cycle clause中必须严格出现在cte（col alias）定义的列名，不允许出现类似cte.col，指定是定义的名字。
 * 例如：
 *     cte( a, b, c) as (.....) search depth by a, c, b set ordering cycle a
 *     只能是单独的一个列的表现形式，已经oracle中测试并确认，不能采用类似cte.a cte.b这样的表现形式
 */
int ObSelectResolver::resolve_cycle_clause(const ParseNode &parse_tree,
                                           const TableItem *cte_table_item,
                                           ObString &cycle_pseudo_column_name)
{
  int ret = OB_SUCCESS;
  current_scope_ = T_WITH_CLAUSE_CYCLE_SCOPE;
  ObSelectStmt *r_union_stmt = cte_table_item->ref_query_;
  const ParseNode *alias_list = parse_tree.children_[0];
  const ParseNode *cycle_set_clause = parse_tree.children_[1];
  const ParseNode *cycle_value = parse_tree.children_[2];
  const ParseNode *cycle_default_value = parse_tree.children_[3];

  CK( OB_NOT_NULL(r_union_stmt),
      OB_NOT_NULL(current_recursive_cte_table_item_));

  if (OB_ISNULL(r_union_stmt->get_set_query(0))
      && OB_ISNULL(r_union_stmt->get_set_query(1))) {
    ret = OB_ERR_CTE_ILLEGAL_SEARCH_CYCLE_CLAUSE;
    LOG_WARN("SEARCH and CYCLE clauses can only be specified for recursive WITH clause elements", K(ret));
  }

  OZ( resolve_cycle_item(alias_list, r_union_stmt) );
  OZ( resolve_cycle_pseudo(cycle_set_clause,
                           r_union_stmt,
                           cycle_value,
                           cycle_default_value,
                           cycle_pseudo_column_name) );
  return ret;
}

int ObSelectResolver::get_current_recursive_cte_table(ObSelectStmt *ref_stmt)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *right_stmt = nullptr;
  if (!ref_stmt->is_recursive_union()) {
    //do nothing
  } else if (OB_ISNULL(ref_stmt)
      || OB_ISNULL(right_stmt = ref_stmt->get_set_query(1))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("invalid argument", K(ret), K(ref_stmt), K(right_stmt));
  } else {
    current_cte_involed_stmt_ = right_stmt;
    int64_t table_count = right_stmt->get_table_size();
    int64_t cte_table_count = 0;
    common::ObIArray<TableItem*>& table_items = right_stmt->get_table_items();
    for (int64_t i = 0; OB_SUCC(ret) && i < table_count; ++i) {
      if (table_items.at(i)->is_fake_cte_table()) {
        current_recursive_cte_table_item_ = table_items.at(i);
        ++cte_table_count;
      }
    }
    if (OB_SUCC(ret) && 1 != cte_table_count) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("the r union stmt's right child stmt must have only one cte table", K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::check_cycle_clause(const ParseNode &cycle_node)
{
  int ret = OB_SUCCESS;
  CK( !OB_UNLIKELY(cycle_node.num_child_ != 4) );
  CK( OB_NOT_NULL(cycle_node.children_[0]) );
  CK( OB_NOT_NULL(cycle_node.children_[1]) );
  CK( OB_NOT_NULL(cycle_node.children_[2]) );
  CK( OB_NOT_NULL(cycle_node.children_[3]) );
  CK( OB_NOT_NULL(cycle_node.children_[1]->children_[1]) );
  const ParseNode *cycle_set_clause = cycle_node.children_[1];
  const ParseNode *alias_list = cycle_node.children_[0];
  if (OB_SUCC(ret)) {
    ObSEArray<ObString, 8> alias;
    for (int64_t i = 0; OB_SUCC(ret) && i < alias_list->num_child_; ++i) {
      ParseNode *alias_node = alias_list->children_[i];
      ObString column_alia_name;
      column_alia_name.assign_ptr((char *) (alias_node->str_value_),
                                  static_cast<int32_t>(alias_node->str_len_));
      for (int64_t j = 0; j < alias.count() && OB_SUCC(ret); ++j) {
        if (ObCharset::case_insensitive_equal(alias.at(j), column_alia_name)) {
          ret = OB_ERR_CTE_DUPLICATE_NAME_IN_CYCLE_CLAUSE;
          LOG_WARN("duplicate name found in cycle column list for CYCLE clause of WITH clause", K(ret));
        }
      }
      OZ( alias.push_back(column_alia_name) );
      if (OB_SUCC(ret)) {
        bool found = false;
        for (int64_t j = 0; OB_SUCC(ret) && j < cte_ctx_.cte_col_names_.count() && !found; ++j) {
          if (ObCharset::case_insensitive_equal(cte_ctx_.cte_col_names_.at(j), column_alia_name)) {
            found = true;
          }
        }
        if (!found) {
          ret = OB_ERR_CTE_ILLEGAL_COLUMN_IN_CYCLE_CLAUSE;
          LOG_WARN("element in cycle column list of CYCLE clause must appear in the column alias list of the WITH clause element", K(ret));
        }
      }
    }
  }
  if (OB_SUCC(ret)) {
    const ParseNode *set_column = cycle_set_clause->children_[1];
    ObString set_column_name;
    set_column_name.assign_ptr((char *) (set_column->str_value_),
                               static_cast<int32_t>(set_column->str_len_));
    bool found = false;
    for (int64_t i = 0; OB_SUCC(ret) && i < cte_ctx_.cte_col_names_.count() && !found; ++i) {
      if (ObCharset::case_insensitive_equal(cte_ctx_.cte_col_names_.at(i), set_column_name)) {
        found = true;
      }
    }
    if (found) {
      ret = OB_ERR_CTE_ILLEGAL_CYCLE_PSEUDO_NAME;
      LOG_WARN("cycle mark column name for CYCLE clause must not be part of the column alias list", K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::check_search_clause(const ParseNode &search_node)
{
  int ret = OB_SUCCESS;
  const ParseNode* sort_list = search_node.children_[0];
  const ParseNode* search_set_clause = search_node.children_[1];
  CK( OB_NOT_NULL(sort_list));
  CK( OB_NOT_NULL(search_set_clause));
  CK( search_set_clause->num_child_ == 2 );
  CK( OB_NOT_NULL(search_set_clause->children_[1]->str_value_) );
  CK( search_set_clause->children_[1]->str_len_ > 0 );
  if (OB_SUCC(ret)) {
    for (int64_t i = 0; OB_SUCC(ret) && i < sort_list->num_child_; ++i) {
      ParseNode *sort_node = sort_list->children_[i];
      ParseNode *alias_node = sort_node->children_[0];
      ObString column_alia_name;
      if (OB_ISNULL(alias_node)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("alias node is null", K(ret));
      } else if (T_OBJ_ACCESS_REF != alias_node->type_) {
        // For oracle error code compatibility
        ret = OB_ERR_CTE_ILLEGAL_COLUMN_IN_SERACH_CALUSE;
        LOG_WARN("alias node is not a obj access", K(ret));
      } else if (OB_ISNULL(alias_node->children_[0])) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("alias node is invalid", K(ret));
      } else {
        column_alia_name.assign_ptr((char *) (alias_node->children_[0]->str_value_),
                                              static_cast<int32_t>(alias_node->children_[0]->str_len_));
        bool found = false;
        for (int64_t j = 0; OB_SUCC(ret) && j < cte_ctx_.cte_col_names_.count() && !found; ++j) {
          if (ObCharset::case_insensitive_equal(cte_ctx_.cte_col_names_.at(j), column_alia_name)) {
            found = true;
          }
        }
        if (!found) {
          ret = OB_ERR_CTE_ILLEGAL_COLUMN_IN_SERACH_CALUSE;
          LOG_WARN("element in sort specification list of SEARCH clause did not appear in the column alias list of the WITH clause element", K(ret));
        }
      }
    }
  }
  if (OB_SUCC(ret)) {
    const ParseNode *set_value = search_set_clause->children_[1];
    ObString set_column_name;
    set_column_name.assign_ptr((char *) (set_value->str_value_),
                               static_cast<int32_t>(set_value->str_len_));
    bool found = false;
    for (int64_t i = 0; OB_SUCC(ret) && i < cte_ctx_.cte_col_names_.count() && !found; ++i) {
      if (ObCharset::case_insensitive_equal(cte_ctx_.cte_col_names_.at(i), set_column_name)) {
        found = true;
      }
    }
    if (found) {
      ret = OB_ERR_CTE_ILLEGAL_SEARCH_PSEUDO_NAME;
      LOG_WARN("sequence column name for SEARCH clause must not be part of the column alias list", K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::check_search_cycle_set_column(const ParseNode &search_node, const ParseNode &cycle_node) {
  int ret = OB_SUCCESS;
  const ParseNode* search_set_clause = search_node.children_[1]->children_[1];
  const ParseNode* cycle_set_clause = cycle_node.children_[1]->children_[1];
  ObString search_set_column_name;
  search_set_column_name.assign_ptr((char *) (search_set_clause->str_value_),
                                    static_cast<int32_t>(search_set_clause->str_len_));
  ObString cycle_set_column_name;
  cycle_set_column_name.assign_ptr((char *) (cycle_set_clause->str_value_),
                                   static_cast<int32_t>(cycle_set_clause->str_len_));

  if (ObCharset::case_insensitive_equal(search_set_column_name, cycle_set_column_name)) {
    ret = OB_ERR_CTE_DUPLICATE_SEQ_NAME_CYCLE_COLUMN;
    LOG_WARN("sequence column for SEARCH clause must be different from the cycle mark column for CYCLE clause", K(ret));
  }
  return ret;
}

int ObSelectResolver::check_cycle_values(const ParseNode &cycle_node) {
  int ret = OB_SUCCESS;
  if (OB_SUCC(ret)) {
    if (cycle_node.children_[2]->str_len_ != 1
        || cycle_node.children_[3]->str_len_ != 1) {
      ret = OB_ERR_CTE_ILLEGAL_CYCLE_NON_CYCLE_VALUE;
      LOG_WARN("cycle mark value and non-cycle mark value must be one byte character string values", K(ret));
    } else {
      const ParseNode* cycle_value_node = cycle_node.children_[2];
      const ParseNode* non_cycle_value_node = cycle_node.children_[3];
      ObString cycle_value;
      ObString non_cycle_value;
      cycle_value.assign_ptr((char *) (cycle_value_node->str_value_),
                            static_cast<int32_t>(cycle_value_node->str_len_));
      non_cycle_value.assign_ptr((char *) (non_cycle_value_node->str_value_),
                                static_cast<int32_t>(non_cycle_value_node->str_len_));
      if (ObCharset::case_insensitive_equal(cycle_value, non_cycle_value)) {
        ret = OB_ERR_CTE_DUPLICATE_CYCLE_NON_CYCLE_VALUE;
        LOG_WARN("cycle value for CYCLE clause must be different from the non-cycle value", K(ret));
      }
    }
  }
  return ret;
}

int ObSelectResolver::check_cte_pseudo(const ParseNode *search_node, const ParseNode *cycle_node) {
  int ret = OB_SUCCESS;
  // For oracle error code compatibility
  if ((OB_NOT_NULL(search_node) || OB_NOT_NULL(cycle_node))
      && cte_ctx_.cte_col_names_.empty()) {
    ret = OB_ERR_CTE_NEED_COLUMN_ALIAS_LIST;
    LOG_WARN("WITH clause element did not have a column alias list", K(ret));
  }

  if (OB_NOT_NULL(search_node)) {
    if (OB_FAIL(check_search_clause(*search_node))) {
      LOG_WARN("Invalid search clause", K(ret));
    }
  }

  if (OB_SUCC(ret) && OB_NOT_NULL(cycle_node)) {
    if (OB_FAIL(check_cycle_clause(*cycle_node))) {
      LOG_WARN("Invalid cycle clause", K(ret));
    }
  }

  if (OB_SUCC(ret) && OB_NOT_NULL(cycle_node) && OB_NOT_NULL(search_node)) {
    if (OB_FAIL(check_search_cycle_set_column(*search_node, *cycle_node))) {
      LOG_WARN("Invalid search/cycle clause", K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::resolve_cte_pseudo_column(const ParseNode *search_node,
                                                const ParseNode *cycle_node,
                                                const TableItem *table_item,
                                                ObString &search_pseudo_column_name,
                                                ObString &cycle_pseudo_column_name)
{
  int ret = OB_SUCCESS;
  if(OB_ISNULL(table_item)) {
    //do nothing

  } else if (OB_ISNULL(table_item->ref_query_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("the recursive union can not be null", K(ret));
  } else {

    if (OB_SUCC(ret) && OB_NOT_NULL(search_node)) {
      OZ( resolve_search_clause(*search_node, table_item, search_pseudo_column_name) );
      OZ( check_pseudo_column_name_legal(search_pseudo_column_name) );
    }

    if (OB_SUCC(ret) && OB_NOT_NULL(cycle_node)) {
      OZ( resolve_cycle_clause(*cycle_node, table_item, cycle_pseudo_column_name) );
      OZ( check_pseudo_column_name_legal(cycle_pseudo_column_name) );
    }
  }

  if (OB_SUCC(ret) && OB_NOT_NULL(cycle_node)) {
    if (OB_FAIL(check_cycle_values(*cycle_node))) {
      LOG_WARN("Invalid cycle/non-cycle values", K(ret));
    }
  }

  if (OB_SUCC(ret)
      && !(table_item->ref_query_->is_recursive_union())
      && (OB_NOT_NULL(cycle_node) || OB_NOT_NULL(search_node))) {
    //oracle 默认非递归的CTE不可以使用search和cycle
    ret = OB_ERR_CTE_ILLEGAL_SEARCH_CYCLE_CLAUSE;
    LOG_WARN("SEARCH and CYCLE clauses can only be specified for recursive WITH clause elements", K(ret));
  }
  return ret;
}

int ObSelectResolver::add_parent_cte_table_item(TableItem *table_item) {
  int ret = OB_SUCCESS;
  if (OB_FAIL(parent_cte_tables_.push_back(table_item))) {
    LOG_WARN("add parent cte table failed", K(ret));
  }
  return ret;
}

int ObSelectResolver::resolve_from_clause(const ParseNode *node)
{
  int ret = OB_SUCCESS;
  if (OB_NOT_NULL(node)) {
    current_scope_ = T_FROM_SCOPE;
    ObSelectStmt *select_stmt = NULL;
    TableItem *table_item = NULL;
    CK( OB_NOT_NULL(select_stmt = get_select_stmt()),
        node->type_ == T_FROM_LIST,
        node->num_child_ >= 1);
    for (int32_t i = 0; OB_SUCC(ret) && i < node->num_child_; i += 1) {
      ParseNode *table_node = node->children_[i];
      CK(OB_NOT_NULL(table_node));
      const bool old_flag = session_info_->is_table_name_hidden();
      bool is_table_hidden = false;
      const ObSessionDDLInfo &ddl_info = session_info_->get_ddl_info();
      // add foreign key will use select xx from t1 minus select xx from t2, here t1 is source table, t2 is dest table
      if (ddl_info.is_ddl()) {
        if (in_set_query_) {
          is_table_hidden = is_left_child_ ? ddl_info.is_source_table_hidden() : ddl_info.is_dest_table_hidden();
        } else {
          is_table_hidden = ddl_info.is_source_table_hidden();
        }
      }
      // TODO@wenqu: wait flags from session info
      session_info_->set_table_name_hidden(is_table_hidden);
      OZ( resolve_table(*table_node, table_item) );
      session_info_->set_table_name_hidden(old_flag);
      OZ( column_namespace_checker_.add_reference_table(table_item), table_item );
      OZ( select_stmt->add_from_item(table_item->table_id_, table_item->is_joined_table()) );
      // oracle outer join will change from items
      OZ( add_from_items_order(table_item), table_item );
      if (OB_SUCC(ret)) {
        select_stmt->set_has_reverse_link(table_item->is_reverse_link_);
      }
    }
    OZ( gen_unpivot_target_column(node->num_child_, *select_stmt, *table_item) );
    OZ( check_recursive_cte_usage(*select_stmt) );
  }
  return ret;
}

int ObSelectResolver::gen_unpivot_target_column(const int64_t table_count,
    ObSelectStmt &select_stmt, TableItem &table_item)
{
  int ret = OB_SUCCESS;
  if (NULL != transpose_item_ && 1 == table_count) {
    select_stmt.set_from_pivot(transpose_item_->is_pivot());
     //mark this stmt is transpose item
    if (transpose_item_->is_unpivot() && transpose_item_->need_use_unpivot_op()) {
      //use unpivot operation
      select_stmt.set_transpose_item(const_cast<TransposeItem *>(transpose_item_));

      const int64_t old_column_count = transpose_item_->old_column_count_;
      const int64_t new_column_count = transpose_item_->unpivot_columns_.count()
                                        + transpose_item_->for_columns_.count();

      ObSelectStmt *child_select_stmt = table_item.ref_query_;
      int64_t select_item_count = 0;
      ObCollationType coll_type = CS_TYPE_INVALID;
      LOG_DEBUG("begin gen_unpivot_target_column", K(table_item), KPC(child_select_stmt));
      if (OB_ISNULL(params_.expr_factory_)
          || OB_ISNULL(session_info_)
          || OB_ISNULL(child_select_stmt)
          || FALSE_IT(select_item_count = child_select_stmt->get_select_item_size())
          || OB_UNLIKELY(new_column_count < 0)
          || OB_UNLIKELY(old_column_count < 0)
          || OB_UNLIKELY(old_column_count >= select_item_count)
          || OB_UNLIKELY((select_item_count - old_column_count) % new_column_count != 0)
          || OB_UNLIKELY((select_item_count - old_column_count) / new_column_count <= 1)
          ) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("params is invalid", K(ret), K(table_item),
                 K(params_.expr_factory_), K(old_column_count), K(new_column_count),
                 K(select_item_count), KPC(child_select_stmt));
      } else if (OB_FAIL(session_info_->get_collation_connection(coll_type))) {
        LOG_WARN("fail to get_collation_connection", K(ret));
      } else {
        const ObLengthSemantics default_ls = session_info_->get_actual_nls_length_semantics();
        ObSEArray<ObExprResType, 16> types;
        ObExprResType res_type;
        ObExprVersion dummy_op(*allocator_);

        for (int64_t colum_idx = 0; OB_SUCC(ret) && colum_idx < new_column_count; colum_idx++) {
          res_type.reset();
          types.reset();

          int64_t item_idx = old_column_count + colum_idx;
          SelectItem &first_select_item = child_select_stmt->get_select_item(item_idx);
          item_idx += new_column_count;
          if (OB_ISNULL(first_select_item.expr_)) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("expr is null", K(ret), K(first_select_item.expr_));
          } else if (types.push_back(first_select_item.expr_->get_result_type())) {
            LOG_WARN("fail to push left_type", K(ret));
          }
          while (OB_SUCC(ret) && item_idx < select_item_count) {
            SelectItem &tmp_select_item = child_select_stmt->get_select_item(item_idx);
            if (OB_ISNULL(tmp_select_item.expr_) ) {
              ret = OB_ERR_UNEXPECTED;
              LOG_WARN("expr is null", K(ret), K(tmp_select_item.expr_));
            } else if (first_select_item.expr_->get_result_type()
                       != tmp_select_item.expr_->get_result_type()) {
              const ObExprResType &first_type = first_select_item.expr_->get_result_type();
              const ObExprResType &tmp_type = tmp_select_item.expr_->get_result_type();
              if (!((first_type.is_null() && !tmp_type.is_lob())
                    || (tmp_type.is_null() && !first_type.is_lob())
                    || (first_type.is_character_type() && tmp_type.is_character_type())
                    || (ob_is_oracle_numeric_type(first_type.get_type())
                        && ob_is_oracle_numeric_type(tmp_type.get_type()))
                    || (ob_is_oracle_temporal_type(first_type.get_type())
                        && (ob_is_oracle_temporal_type(tmp_type.get_type()))))) {
                ret = OB_ERR_EXP_NEED_SAME_DATATYPE;
                LOG_WARN("expression must have same datatype as corresponding expression", K(ret),
                         K(first_type), K(tmp_type));
              } else if (first_type.is_character_type()
                         && tmp_type.is_character_type()
                         && (first_type.is_varchar_or_char() != tmp_type.is_varchar_or_char())) {
                ret = OB_ERR_CHARACTER_SET_MISMATCH;
                LOG_WARN("character set mismatch", K(ret), K(first_type), K(tmp_type));
              } else if (OB_FAIL(types.push_back(tmp_type))) {
                LOG_WARN("fail to push type", K(ret), K(tmp_type));
              }
            }
            item_idx += new_column_count;
          }

          if (OB_SUCC(ret)) {
            if (types.count() == 1) {
              res_type = first_select_item.expr_->get_result_type();
            } else if (OB_FAIL(dummy_op.aggregate_result_type_for_merge(res_type,
                                                                        &types.at(0),
                                                                        types.count(),
                                                                        coll_type,
                                                                        true,
                                                                        default_ls,
                                                                        session_info_))) {
              LOG_WARN("fail to aggregate_result_type_for_merge", K(ret), K(types));
            }
          }

          if (OB_SUCC(ret)) {
            if (OB_UNLIKELY(ObNullType == res_type.get_type() || ObMaxType == res_type.get_type())) {
              ret = OB_ERR_INVALID_TYPE_FOR_OP;
              LOG_WARN("column type incompatible", K(ret), K(res_type));
            } else {
              item_idx = old_column_count + colum_idx;
              while (OB_SUCC(ret) && item_idx < select_item_count) {
                SelectItem &select_item = child_select_stmt->get_select_item(item_idx);
                if (select_item.expr_->get_result_type() != res_type) {
                  ObSysFunRawExpr *new_expr = NULL;
                  if (OB_FAIL(ObRawExprUtils::create_cast_expr(*params_.expr_factory_,
                                                               select_item.expr_,
                                                               res_type,
                                                               new_expr,
                                                               session_info_))) {
                    LOG_WARN("create cast expr for stmt failed", K(ret));
                  } else if (OB_FAIL(new_expr->add_flag(IS_INNER_ADDED_EXPR))) {
                    LOG_WARN("failed to add flag", K(ret));
                  } else {
                    select_item.expr_ = new_expr;
                    LOG_DEBUG("add cast for column", K(select_item), K(res_type));
                  }
                }
                item_idx += new_column_count;
              }
            }
          }
        }//end of for
      }
      LOG_DEBUG("finish gen_unpivot_target_column", K(table_item), KPC(child_select_stmt));
    }
    //reset
    transpose_item_ = NULL;
  }
  return ret;
}

int ObSelectResolver::resolve_group_clause(const ParseNode *node)
{
  int ret = OB_SUCCESS;
  bool has_explicit_dir = false;
  ObSelectStmt *select_stmt = get_select_stmt();
  common::ObIArray<ObRawExpr*>& groupby_exprs = select_stmt->get_group_exprs();
  common::ObIArray<ObRawExpr*>& rollup_exprs = select_stmt->get_rollup_exprs();
  common::ObSEArray<OrderItem, 4> order_items;
  if (OB_ISNULL(node)) {//do nothing for has no groupby clause.
  } else if (OB_FAIL(resolve_group_by_list(node,
                                           groupby_exprs,
                                           rollup_exprs,
                                           order_items,
                                           has_explicit_dir))) {
    LOG_WARN("failed to resolve group rollup list.", K(ret));
  } else if (!has_explicit_dir) {
    /* do nothing. */
  } else if (rollup_exprs.count() > 0) {
    for (int64_t i = 0; OB_SUCC(ret) && i < order_items.count(); i++) {
      if (OB_FAIL(select_stmt->add_rollup_dir(order_items.at(i).order_type_))) {
        LOG_WARN("failed to push back to order items.", K(ret));
      } else {/* do nothing. */}
    }
  } else if (OB_FAIL(append(select_stmt->get_order_items(), order_items))) {
      LOG_WARN("failed to append order itmes by groupby into select stmt.", K(ret));
  } else { /* do nothing. */}

  //for mysql mode, check grouping here
  if (OB_FAIL(ret) || is_oracle_mode()) {
    /*do nothing*/
  } else if (rollup_exprs.count() <= 0 && has_grouping()) {
    ret = OB_ERR_WRONG_FIELD_WITH_GROUP;
    LOG_WARN("the grouping must be with be roll up clause", K(ret));
  } else if (OB_FAIL(check_grouping_columns())) {
    LOG_WARN("failed to check grouping columns", K(ret));
  } // do nothing

  return ret;
}

int ObSelectResolver::check_rollup_clause(const ParseNode *node, bool &has_rollup)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(node) || OB_ISNULL(node->children_) ||
      OB_UNLIKELY(T_GROUPBY_CLAUSE != node->type_)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid resolver arguments", K(ret), K(node));
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; ++i) {
      const ParseNode *child_node = node->children_[i];
      if (OB_ISNULL(child_node)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret), K(child_node));
      } else if (child_node->type_ == T_ROLLUP_LIST ||
                 child_node->type_ == T_CUBE_LIST ||
                 child_node->type_ == T_GROUPING_SETS_LIST ||
                 child_node->type_ == T_WITH_ROLLUP_CLAUSE) {
        has_rollup = true;
      }
    }
  }
  return ret;
}

int ObSelectResolver::resolve_group_by_list(const ParseNode *node,
                                            common::ObIArray<ObRawExpr*> &groupby_exprs,
                                            common::ObIArray<ObRawExpr*> &rollup_exprs,
                                            common::ObIArray<OrderItem> &order_items,
                                            bool &has_explicit_dir)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  current_scope_ = T_GROUP_SCOPE;
  if (OB_ISNULL(node) || OB_ISNULL(node->children_) || OB_ISNULL(select_stmt) ||
      OB_UNLIKELY(T_GROUPBY_CLAUSE != node->type_)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid resolver arguments", K(ret), K(node), K(select_stmt));
  } else {
    bool can_conv_multi_rollup = true;
    for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; ++i) {
      const ParseNode *child_node = node->children_[i];
      if (OB_ISNULL(child_node)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret), K(child_node));
      } else {
        switch (child_node->type_) {
          case T_NULL: {
            /*compatible oracle: select c1 from t1 group by c1, (); do nothing, just skip*/
            break;
          }
          case T_GROUPBY_KEY: {
            if (OB_ISNULL(child_node->children_) || OB_UNLIKELY(child_node->num_child_ != 1)) {
              ret = OB_INVALID_ARGUMENT;
              LOG_WARN("invalid resolver arguments", K(ret), K(child_node));
            } else if (OB_FAIL(resolve_groupby_node(child_node->children_[0],
                                                    child_node,
                                                    groupby_exprs,
                                                    rollup_exprs,
                                                    order_items,
                                                    has_explicit_dir,
                                                    true,
                                                    0))) {// 0 level.
              LOG_WARN("failed to resolve group node.", K(ret));
            } else {/*do nothing*/}
            break;
          }
          case T_ROLLUP_LIST: {
            ObMultiRollupItem rollup_item;
            if (OB_FAIL(resolve_rollup_list(child_node,
                                            rollup_item,
                                            can_conv_multi_rollup))) {
              LOG_WARN("failed to resolve rollup list", K(ret));
            } else if (OB_FAIL(select_stmt->add_rollup_item(rollup_item))) {
              LOG_WARN("failed to add rollup item", K(ret));
            }
            break;
          }
          case T_CUBE_LIST: {
            ret = OB_NOT_SUPPORTED;
            LOG_USER_ERROR(OB_NOT_SUPPORTED, "group by cube");
            LOG_WARN("cube by not supported.", K(ret));//TODO, @jiangxiu.wt
            break;
          }
          case T_GROUPING_SETS_LIST: {
            HEAP_VAR(ObGroupingSetsItem, grouping_sets_item) {
              if (OB_FAIL(resolve_grouping_sets_list(child_node,
                                                     grouping_sets_item))) {
                LOG_WARN("failed to resolve rollup list", K(ret));
              } else if (OB_FAIL(select_stmt->add_grouping_sets_item(grouping_sets_item))) {
                LOG_WARN("failed to add grouping sets item", K(ret));
              } else {/*do nothing*/}
            }
            break;
          }
          case T_WITH_ROLLUP_CLAUSE: {
            if (OB_FAIL(resolve_with_rollup_clause(child_node,
                                                   groupby_exprs,
                                                   rollup_exprs,
                                                   order_items,
                                                   has_explicit_dir))) {
              LOG_WARN("failed to resolve with rollup clause", K(ret));
            } else {/*do nothing*/}
            break;
          }
          default: {
            /* won't be here */
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("unexpected group by type", K(ret), K(get_type_name(child_node->type_)));
            break;
          }
        }
      }
    }
    if (OB_SUCC(ret) && can_conv_multi_rollup && select_stmt->get_multi_rollup_items_size() == 1) {
      const ObIArray<ObGroupbyExpr> &rollup_list_exprs =
                                     select_stmt->get_multi_rollup_items().at(0).rollup_list_exprs_;
      for (int64_t i = 0; OB_SUCC(ret) && i < rollup_list_exprs.count(); ++i) {
        if (OB_UNLIKELY(rollup_list_exprs.at(i).groupby_exprs_.count() != 1)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected error", K(ret), K(rollup_list_exprs.at(i).groupby_exprs_));
        } else if (OB_FAIL(rollup_exprs.push_back(rollup_list_exprs.at(i).groupby_exprs_.at(0)))) {
          LOG_WARN("failed to push back exprs", K(ret));
        }
      }
      if (OB_SUCC(ret)) {
        select_stmt->get_multi_rollup_items().reset();
      }
    }
  }
  return ret;
}

int ObSelectResolver::resolve_rollup_list(const ParseNode *node,
                                          ObMultiRollupItem &rollup_item,
                                          bool &can_conv_multi_rollup)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(node) || OB_UNLIKELY(node->type_ != T_ROLLUP_LIST || !lib::is_oracle_mode())) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("get invalid argument", K(ret), K(node));
  } else {
    ObSEArray<ObRawExpr*, 4> dummy_groupby_exprs;
    ObSEArray<OrderItem, 4> dummy_order_items;
    bool dummy_has_explicit_dir = false;
    for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; ++i) {
      ObGroupbyExpr item;
      const ParseNode *group_key_node = node->children_[i];
      if (OB_ISNULL(group_key_node) ||
          OB_UNLIKELY(group_key_node->type_ != T_GROUPBY_KEY ||
                      group_key_node->num_child_ != 1)) {
        ret = OB_INVALID_ARGUMENT;
        LOG_WARN("invalid resolver arguments", K(ret), K(group_key_node));
      } else if (OB_FAIL(resolve_groupby_node(group_key_node->children_[0],
                                              group_key_node,
                                              dummy_groupby_exprs,
                                              item.groupby_exprs_,
                                              dummy_order_items,
                                              dummy_has_explicit_dir,
                                              false,
                                              0))) {// 0 level.
        LOG_WARN("failed to resolve group node.", K(ret));
      } else if (OB_FAIL(rollup_item.rollup_list_exprs_.push_back(item))) {
        LOG_WARN("failed to push back item", K(ret));
      } else if (item.groupby_exprs_.count() > 1) {//description includes vector rollup
        can_conv_multi_rollup = false;
      }
    }
  }
  return ret;
}

int ObSelectResolver::resolve_grouping_sets_list(const ParseNode *node,
                                                 ObGroupingSetsItem &grouping_sets_item)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(select_stmt) || OB_ISNULL(node) ||
      OB_UNLIKELY(node->type_ != T_GROUPING_SETS_LIST || !lib::is_oracle_mode())) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("get invalid argument", K(ret), K(select_stmt), K(node));
  } else {
    ObSEArray<ObRawExpr*, 4> dummy_rollup_exprs;
    ObSEArray<OrderItem, 4> dummy_order_items;
    bool dummy_has_explicit_dir = false;
    for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; ++i) {
      const ParseNode *child_node = node->children_[i];
      if (OB_ISNULL(child_node)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret), K(child_node));
      } else {
        ObGroupbyExpr item;
        switch (child_node->type_) {
          case T_NULL: {
            //for grouping sets may occur this situation:
            //  select count(c1) from t1 group by grouping sets(c1, ());
            // <==>
            //  select count(c1) from t1 group by c1 union all select count(c1) from t1;
            //we should consider it to compatible oracle better.
            if (OB_FAIL(grouping_sets_item.grouping_sets_exprs_.push_back(item))) {
              LOG_WARN("failed to push back into gs exprs.", K(ret));
            }
            break;
          }
          case T_GROUPBY_KEY: {
            ObGroupbyExpr item;
            if (OB_ISNULL(child_node->children_) || OB_UNLIKELY(child_node->num_child_ != 1)) {
              ret = OB_INVALID_ARGUMENT;
              LOG_WARN("invalid resolver arguments", K(ret), K(child_node));
            } else if (OB_FAIL(resolve_groupby_node(child_node->children_[0],
                                                    child_node,
                                                    item.groupby_exprs_,
                                                    dummy_rollup_exprs,
                                                    dummy_order_items,
                                                    dummy_has_explicit_dir,
                                                    true,
                                                    0))) {// 0 level.
              LOG_WARN("failed to resolve group node.", K(ret));
            } else if (OB_FAIL(grouping_sets_item.grouping_sets_exprs_.push_back(item))) {
              LOG_WARN("failed to push back into gs exprs.", K(ret));
            }
            break;
          }
          case T_ROLLUP_LIST: {
            ObMultiRollupItem rollup_item;
            bool can_conv_multi_rollup = false;
            if (OB_FAIL(resolve_rollup_list(child_node,
                                            rollup_item,
                                            can_conv_multi_rollup))) {
              LOG_WARN("failed to resolve rollup list", K(ret));
            } else if (OB_FAIL(grouping_sets_item.multi_rollup_items_.push_back(rollup_item))) {
              LOG_WARN("failed to add grouping sets item", K(ret));
            }
            break;
          }
          case T_CUBE_LIST: {
            ret = OB_NOT_SUPPORTED;
            LOG_USER_ERROR(OB_NOT_SUPPORTED, "cube in grouping sets");
            LOG_WARN("cube/rollup in groupings sets not supported.", K(ret));//TODO, @jiangxiu.wt
            break;
          }
          default: {
            /* won't be here */
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get unexpected type", K(ret), K(get_type_name(child_node->type_)));
            break;
          }
        }
      }
    }
  }
  return ret;
}


int ObSelectResolver::resolve_with_rollup_clause(const ParseNode *node,
                                                 common::ObIArray<ObRawExpr*> &groupby_exprs,
                                                 common::ObIArray<ObRawExpr*> &rollup_exprs,
                                                 common::ObIArray<OrderItem> &order_items,
                                                 bool &has_explicit_dir)
{
  int ret = OB_SUCCESS;
  const ParseNode *sort_list_node = NULL;
  ObSelectStmt *select_stmt = get_select_stmt();
  // for: select a, sum(b) from t group by a with rollup.
  // with rollup is the children[0] and sort key list is children[1].
  if (OB_ISNULL(node) || OB_ISNULL(select_stmt) || OB_UNLIKELY(!lib::is_mysql_mode()) ||
      OB_UNLIKELY(T_WITH_ROLLUP_CLAUSE != node->type_ || node->num_child_ != 2) ||
      OB_ISNULL(sort_list_node = node->children_[1])) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("get invalid argument", K(ret), K(node), K(sort_list_node), K(select_stmt));
  } else {
    bool has_rollup = false;
    if (node->children_[0] != NULL) {
      if (node->children_[0]->type_ != T_ROLLUP) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get invalid type", K(get_type_name(node->children_[0]->type_)));
      } else {
        has_rollup = true;
      }
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < sort_list_node->num_child_; ++i) {
      const ParseNode *sort_node = sort_list_node->children_[i];
      if (OB_ISNULL(sort_node) || OB_ISNULL(sort_node->children_) ||
          OB_UNLIKELY(T_SORT_KEY != sort_node->type_ || sort_node->num_child_ != 2)) {
        ret = OB_INVALID_ARGUMENT;
        LOG_WARN("invalid resolver arguments", K(ret));
      } else if (OB_FAIL(resolve_groupby_node(sort_node->children_[0],
                                              sort_node,
                                              groupby_exprs,
                                              rollup_exprs,
                                              order_items,
                                              has_explicit_dir,
                                              !(select_stmt->has_rollup() || has_rollup),
                                              0))) {// 0 level.
        LOG_WARN("failed to resolve group node.", K(ret));
      } else  {/*do nothing*/}
    }
  }
  return ret;
}

int ObSelectResolver::resolve_group_by_sql_expr(const ParseNode *group_node,
                                                const ParseNode *group_sort_node,
                                                common::ObIArray<ObRawExpr*> &groupby_exprs,
                                                common::ObIArray<ObRawExpr*> &rollup_exprs,
                                                common::ObIArray<OrderItem> &order_items,
                                                ObSelectStmt *select_stmt,
                                                bool &has_explicit_dir,
                                                bool is_groupby_expr)
{
  int ret = OB_SUCCESS;
  ObRawExpr *expr = NULL;
  bool is_oracle_compatible = is_oracle_mode();
  if (OB_ISNULL(group_node)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid resolver arguments", K(ret));
  } else if (!is_oracle_compatible && group_node->type_ == T_INT) {
    int64_t pos = group_node->value_;
    if (pos <= 0 || pos > select_stmt->get_select_item_size()) {
      ret = OB_ERR_BAD_FIELD_ERROR;
      char buff[OB_MAX_ERROR_MSG_LEN];
      snprintf(buff, OB_MAX_ERROR_MSG_LEN, "%ld", pos);
      ObString scope_name = ObString::make_string(get_scope_name(current_scope_));
      LOG_USER_ERROR(OB_ERR_BAD_FIELD_ERROR, (int)strlen(buff), buff, scope_name.length(), scope_name.ptr());
    }
    if (OB_SUCC(ret)) {
      expr = select_stmt->get_select_item(pos - 1).expr_;
      if (!expr) {
        ret = OB_ERR_ILLEGAL_ID;
        LOG_WARN("Can not find expression", K(expr), K(ret));
      } else if (expr->has_flag(CNT_AGG) || expr->has_flag(CNT_WINDOW_FUNC)) {
        ret = OB_WRONG_GROUP_FIELD;
        const ObString &alias_name = select_stmt->get_select_item(pos-1).alias_name_;
        LOG_USER_ERROR(OB_WRONG_GROUP_FIELD, alias_name.length(), alias_name.ptr());
      } else { /*do nothing*/ }
    }
  } else if (OB_FAIL(resolve_sql_expr(*group_node, expr))) {
    LOG_WARN("resolve sql expr failed", K(ret));
  }

  if (OB_SUCC(ret)) {
    OrderItem order_item;
    order_item.expr_ = expr;
    if (!is_oracle_compatible &&
        group_sort_node->num_child_ == 2 &&
        NULL != group_sort_node->children_[1]) {
      has_explicit_dir = true;
      if (OB_FAIL(ObResolverUtils::set_direction_by_mode(*group_sort_node, order_item))) {
        LOG_WARN("failed to set direction by mode", K(ret));
      } else { /*do nothing.*/ }
    } else {
      order_item.order_type_ = default_asc_direction();
    }
    if (OB_FAIL(ret)) {
    } else if (OB_FAIL(order_items.push_back(order_item))) {
      LOG_WARN("failed to add order element to stmt", K(ret));
    }
  }

  if (OB_SUCC(ret)) {
    if (is_groupby_expr && OB_FAIL(groupby_exprs.push_back(expr))) {
      LOG_WARN("failed to add group by expression to stmt", K(ret));
    } else if(!is_groupby_expr && OB_FAIL(rollup_exprs.push_back(expr))) {
      LOG_WARN("failed to add rollup expression to stmt", K(ret));
    } else if (is_oracle_mode() && expr->has_flag(CNT_SYS_CONNECT_BY_PATH)) {
      // eg: select count*(*) from t1 connect by nocycle prior c1 > c2 group by SYS_CONNECT_BY_PATH('a','/');
      ret = OB_ERR_CBY_CONNECT_BY_PATH_NOT_ALLOWED;
      LOG_WARN("SYS_CONNECT_BY_PATH function is not allowed here", K(ret));
    } else if (is_only_full_group_by_on(session_info_->get_sql_mode())) {
      if (OB_FAIL(standard_group_checker_.add_group_by_expr(expr))) {
        LOG_WARN("add group by expr to standard group checker failed", K(ret));
      }
    }
  }
  return ret;
}

int ObSelectResolver::resolve_groupby_node(const ParseNode *group_node,
                                           const ParseNode *group_sort_node,
                                           common::ObIArray<ObRawExpr*> &groupby_exprs,
                                           common::ObIArray<ObRawExpr*> &rollup_exprs,
                                           common::ObIArray<OrderItem> &order_items,
                                           bool &has_explicit_dir,
                                           bool is_groupby_expr,
                                           int group_expr_level)
{
  int ret = OB_SUCCESS;
  bool is_oracle_compatible = is_oracle_mode();
  ObSelectStmt *select_stmt = get_select_stmt();
  bool is_stack_overflow = false;
  if (OB_ISNULL(group_node)) {
    ret = OB_INVALID_ARGUMENT; /* Won't be here */
    LOG_WARN("error group by node", K(ret));
  } else if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
    LOG_WARN("check stack overflow failed", K(ret), K(is_stack_overflow));
  } else if (is_stack_overflow) {
    ret = OB_SIZE_OVERFLOW;
    LOG_WARN("too deep recursive", K(ret), K(is_stack_overflow));
  } else if (group_node->type_ == T_EXPR_LIST) {
    /****************************************************************************
    suppport row in oracle,such as (by jiangxiu):
    select c1 from t1 group by ((c1)); ==> select c1 from t1 group by c1;
    select c1,c2 from t1 group by (c1, c2); ==> select c1,c2 from t1 group by c1, c2;
    select c1,c2 from t1 group by (c1, c2), c3; ==> select c1,c2 from t1 group by c1, c2, c3;
    select c1,c2 from t1 group by ((c1)), (c2, c3); ==> select c1,c2 from t1 group by c1, c2, c3;
    ****************************************************************************/
    if (!is_oracle_compatible) {
      ret = OB_ERR_PARSER_SYNTAX;
      LOG_WARN("row is illegal in group by", K(ret));
    } else if (++group_expr_level > 1 && group_node->num_child_ > 1) {
      ret = OB_NOT_SUPPORTED;
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "group by nested row");
      LOG_WARN("not valid group by expr.", K(ret));
    } else {
      ParseNode *expr_list_node = NULL;
      for (int64_t i = 0; OB_SUCC(ret) && i < group_node->num_child_; i++) {
        expr_list_node = group_node->children_[i];
        if (OB_ISNULL(expr_list_node)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("expr list node is null", K(ret));
        } else if (OB_FAIL(SMART_CALL(resolve_groupby_node(expr_list_node,
                                                           group_sort_node,
                                                           groupby_exprs,
                                                           rollup_exprs,
                                                           order_items,
                                                           has_explicit_dir,
                                                           is_groupby_expr,
                                                           group_expr_level)))) {
          LOG_WARN("failed to resolve group by node.", K(ret));
        } else {
        } //do nothing.
      }
    }
  } else if (OB_FAIL(resolve_group_by_sql_expr(group_node,
                                               group_sort_node,
                                               groupby_exprs,
                                               rollup_exprs,
                                               order_items,
                                               select_stmt,
                                               has_explicit_dir,
                                               is_groupby_expr))) {
    LOG_WARN("failed to resolve group by sql expr.", K(ret));
  } else {
  } // do nothing.

  return ret;
}

int ObSelectResolver::can_find_group_column(ObRawExpr *&col_expr,
                                            const ObIArray<ObGroupingSetsItem> &grouping_sets_items,
                                            bool &can_find,
                                            ObStmtCompareContext *check_context/*default = NULL*/)
{
  int ret = OB_SUCCESS;
  can_find = false;
  for (int64_t i = 0 ; OB_SUCC(ret) && !can_find && i < grouping_sets_items.count(); ++i) {
    const ObIArray<ObGroupbyExpr> &grouping_sets_exprs =
                                                     grouping_sets_items.at(i).grouping_sets_exprs_;
    if (OB_FAIL(can_find_group_column(col_expr,
                                      grouping_sets_items.at(i).multi_rollup_items_,
                                      can_find,
                                      check_context))) {
      LOG_WARN("failed to failed to find group column.");
    } else {
      for (int64_t j = 0 ; OB_SUCC(ret) && !can_find && j < grouping_sets_exprs.count(); ++j) {
        if (OB_FAIL(can_find_group_column(col_expr,
                                          grouping_sets_exprs.at(j).groupby_exprs_,
                                          can_find,
                                          check_context))) {
          LOG_WARN("failed to find group column.", K(ret));
        } else {
          /*do nothing*/
        }
      }
    }
  }
  return ret;
}

int ObSelectResolver::can_find_group_column(ObRawExpr *&col_expr,
                                            const ObIArray<ObMultiRollupItem> &multi_rollup_items,
                                            bool &can_find,
                                            ObStmtCompareContext *check_context/*default = NULL*/)
{
  int ret = OB_SUCCESS;
  can_find = false;
  for (int64_t i = 0 ; OB_SUCC(ret) && !can_find && i < multi_rollup_items.count(); ++i) {
    const ObIArray<ObGroupbyExpr> &rollup_list_exprs = multi_rollup_items.at(i).rollup_list_exprs_;
    for (int64_t j = 0 ; OB_SUCC(ret) && !can_find && j < rollup_list_exprs.count(); ++j) {
      if (OB_FAIL(can_find_group_column(col_expr,
                                        rollup_list_exprs.at(j).groupby_exprs_,
                                        can_find,
                                        check_context))) {
        LOG_WARN("failed to find group column.", K(ret));
      } else {
        /*do nothing*/
      }
    }
  }
  return ret;
}

int ObSelectResolver::can_find_group_column(ObRawExpr *&col_expr,
                                            const common::ObIArray<ObRawExpr*> &exprs,
                                            bool &can_find,
                                            ObStmtCompareContext *check_context/*default = NULL*/)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(col_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(col_expr));
  } else {
    can_find = false;
    for (int64_t i = 0 ; OB_SUCC(ret) && !can_find && i < exprs.count(); ++i) {
      ObRawExpr *raw_expr = NULL;
      if (OB_ISNULL(raw_expr = exprs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("the expr in groups is null", K(exprs));
      } else if (col_expr->same_as(*raw_expr, check_context)) {
        can_find = true;
        col_expr = raw_expr;
      }
    }
  }
  return ret;
}

int ObSelectResolver::check_grouping_columns()
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(select_stmt)) {
    ret = OB_NOT_INIT;
    LOG_WARN("select_stmt is null", K(select_stmt), K_(session_info));
  } else {
    common::ObIArray<SelectItem> &select_items = select_stmt->get_select_items();
    for (int64_t i = 0; OB_SUCC(ret) && i < select_items.count(); ++i) {
      if (OB_FAIL(recursive_check_grouping_columns(select_stmt, select_items.at(i).expr_))) {
        LOG_WARN("failed to recursive check grouping columns", K(ret));
      }
    }
  }
  return ret;
}

int ObSelectResolver::check_grouping_columns(ObSelectStmt &stmt, ObRawExpr *&expr)
{
  int ret = OB_SUCCESS;
  bool find = false;
  /*
   * bugfix: https://work.aone.alibaba-inc.com/issue/38935701
   * for grouping/grouping_id:
   * select grouping(1+1) from t1 group by rollup(1+1). 
   */
  ObStmtCompareContext questionmark_checker;
  questionmark_checker.reset();
  questionmark_checker.override_const_compare_ = true;
  if (OB_ISNULL(params_.query_ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null pointer.", K(ret));
  } else if (FALSE_IT(questionmark_checker.init(&params_.query_ctx_->calculable_items_))) {
    // skip
  } else if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected expr", K(ret));
  } else if (OB_FAIL(can_find_group_column(expr,
                                           stmt.get_rollup_exprs(),
                                           find,
                                           &questionmark_checker))) {
    LOG_WARN("failed to find group column.", K(ret));
  } else if (!find && is_oracle_mode()
             && OB_FAIL(can_find_group_column(expr,
                                              stmt.get_group_exprs(),
                                              find,
                                              &questionmark_checker))) {
    LOG_WARN("failed to find group column.", K(ret));
  } else if (!find && is_oracle_mode()
             && OB_FAIL(can_find_group_column(expr,
                                              stmt.get_grouping_sets_items(),
                                              find,
                                              &questionmark_checker))) {
    LOG_WARN("failed to find group column.", K(ret));
  } else if (!find && is_oracle_mode()
             && OB_FAIL(can_find_group_column(expr,
                                              stmt.get_multi_rollup_items(),
                                              find,
                                              &questionmark_checker))) {
    LOG_WARN("failed to find group column.", K(ret));
  } else if (!find) {
    ret = OB_ERR_WRONG_FIELD_WITH_GROUP;
    LOG_WARN("the grouping by column must be a group by column", K(ret));
  } else {
    // add constraints.
    for (int64_t i = 0; OB_SUCC(ret) && i < questionmark_checker.equal_param_info_.count(); i++) {
      if (OB_FAIL(params_.query_ctx_->all_equal_param_constraints_.push_back(
                                              questionmark_checker.equal_param_info_.at(i)))) {
        LOG_WARN("fail to push back equal constraints", K(ret));
      }
    }
  }
  return ret;
}

int ObSelectResolver::check_nested_aggr_in_having(ObRawExpr* raw_expr)
{
  int ret = OB_SUCCESS;
  bool is_stack_overflow = false;
  if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {
    LOG_WARN("check stack overflow failed", K(ret));
  } else if (is_stack_overflow) {
    ret = OB_SIZE_OVERFLOW;
    LOG_WARN("stack is overflow", K(ret), K(is_stack_overflow));
  } else if (OB_ISNULL(raw_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("raw expr is NULL ptr", K(ret));
  } else {
    int64_t N = raw_expr->get_param_count();
    for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
      ObRawExpr *child_expr = raw_expr->get_param_expr(i);
      if (OB_ISNULL(child_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("expr is NULL ptr", K(ret));
      } else if (child_expr->is_aggr_expr() &&
        static_cast<ObAggFunRawExpr *>(child_expr)->is_nested_aggr()) {
        ret = OB_ERR_WRONG_FIELD_WITH_GROUP;
        LOG_USER_ERROR(OB_ERR_WRONG_FIELD_WITH_GROUP,
            child_expr->get_expr_name().length(),
          child_expr->get_expr_name().ptr());
      } else if (OB_FAIL(SMART_CALL(check_nested_aggr_in_having(child_expr)))) {
        LOG_WARN("replace reference column failed", K(ret));
      } else { /*do nothing.*/ }
    } // end for
  }
  return ret;
}

int ObSelectResolver::resolve_having_clause(const ParseNode *node)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (node) {
    current_scope_ = T_HAVING_SCOPE;
    if (OB_FAIL(resolve_and_split_sql_expr_with_bool_expr(*node,
                                                  select_stmt->get_having_exprs()))) {
      LOG_WARN("resolve and split sql expr failed", K(ret));
    } else { /*do nothing.*/ }
    for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_having_expr_size(); i++) {
      ObRawExpr* expr = select_stmt->get_having_exprs().at(i);
      if (OB_ISNULL(expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("expr is NULL ptr", K(ret));
      } else if (OB_FAIL(check_nested_aggr_in_having(expr))) {
        LOG_WARN("failed to check nested aggr in having.", K(ret));
      } else if (OB_FAIL(recursive_check_grouping_columns(select_stmt, expr))) {
        LOG_WARN("failed to recursive check grouping columns", K(ret));
      } else if (expr->has_flag(CNT_ROWNUM)
          || expr->has_flag(CNT_LEVEL)
          || expr->has_flag(CNT_CONNECT_BY_ISLEAF)
          || expr->has_flag(CNT_CONNECT_BY_ISCYCLE)
          || expr->has_flag(CNT_CONNECT_BY_ROOT)){
        set_having_has_self_column();
      } else { /*do nothing.*/ }
    }
  }
  return ret;
}

int ObSelectResolver::get_refindex_from_named_windows(const ParseNode *ref_name_node,
                                                      const ParseNode *node,
                                                      int64_t& ref_idx)
{
  int ret = OB_SUCCESS;
  ref_idx = -1;
  if (OB_ISNULL(ref_name_node) || OB_ISNULL(node)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("ref name node or node is NULL ptr", K(ret));
  } else {
    ObString ref_name(static_cast<int32_t>(ref_name_node->str_len_),
                      ref_name_node->str_value_);
    for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; i++) {
      ParseNode *cur_named_win_node = node->children_[i];
      ParseNode *cur_name_node = NULL;
      if (OB_ISNULL(cur_named_win_node)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("cur name win node is NULL ptr", K(ret));
      } else if (OB_ISNULL(cur_name_node = cur_named_win_node->children_[0])) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("cur name node is NULL ptr", K(ret));
      } else {
        ObString cur_ref_name(static_cast<int32_t>(cur_name_node->str_len_),
                              cur_name_node->str_value_);
        if (ObCharset::case_insensitive_equal(ref_name, cur_ref_name)) {
          ref_idx = i;
          break;
        }
      }
    }
  }
  return ret;
}

int ObSelectResolver::check_duplicated_name_window(ObString &name,
                                                   const ObIArray<ObString> &resolved_name_list)
{
  int ret = OB_SUCCESS;
  for (int64_t i = 0; OB_SUCC(ret) && i < resolved_name_list.count(); ++i) {
    const ObString &cur_name = resolved_name_list.at(i);
    if (OB_UNLIKELY(ObCharset::case_insensitive_equal(name, cur_name))) {
      ret =  OB_NOT_SUPPORTED;
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "duplicate window name");
      LOG_WARN("duplicate window name", K(name), K(cur_name), K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::mock_to_named_windows(ObString &name,
                                            ParseNode *win_node)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(select_stmt) || OB_ISNULL(win_node)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select stmt or win node unexpected null.", K(ret));
  } else {
    const ParseNode *mock_node = NULL;
    ObString win_str(win_node->str_len_, win_node->str_value_);
    ObSqlString sql_str;
    ObRawExpr *expr = NULL;
    //bug18840807, 此时frame的常量已经参数化, 重新resolve会导致参数化信息丢失, cg时期望para实际常量;
    //后续若计划重用执行阶段会取错常量值, 这里修改了parse_node的窗口指针使用已参数化的
    if (OB_FAIL(sql_str.append_fmt("COUNT(1) OVER %.*s",
                                   win_str.length(),
                                   win_str.ptr()))) {
      LOG_WARN("fail to concat string", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::parse_expr_node_from_str(sql_str.string(),
                                                                params_.session_info_->get_local_collation_connection(),
                                                                params_.expr_factory_->get_allocator(),
                                                                mock_node))) {
      LOG_WARN("parse expr node from string failed", K(ret));
    } else if (2 != mock_node->num_child_
        || T_WIN_NEW_GENERALIZED_WINDOW != mock_node->children_[1]->type_) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("parse result is not expected", K(ret), K(mock_node->num_child_), K(mock_node->type_));
    } else {
      mock_node->children_[1] = win_node;
    }

    if (OB_FAIL(ret)) {
      //do nothing...
    } else if (OB_FAIL(resolve_sql_expr(*mock_node, expr))) {
      LOG_WARN("failed to resolve sql expr failed", K(ret));
      if (OB_EER_WINDOW_NO_REDEFINE_ORDER_BY == ret && OB_NOT_NULL(win_node->children_[0])) {
        LOG_USER_ERROR(OB_EER_WINDOW_NO_REDEFINE_ORDER_BY, name.length(), name.ptr(),
            (int)(win_node->children_[0]->str_len_), win_node->children_[0]->str_value_);
      }
    } else if (OB_ISNULL(expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null ptr", K(expr), K(ret));
    } else if (!expr->is_win_func_expr()) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected ptr", K(expr->get_expr_type()), K(ret));
    } else {
      ObWinFunRawExpr *win_expr = static_cast<ObWinFunRawExpr *>(expr);
      win_expr->set_win_name(name);
      select_stmt->get_window_func_exprs().pop_back();
      ret = select_stmt->get_window_func_exprs().push_back(win_expr);
    }
  }
  return ret;
}

int ObSelectResolver::resolve_named_windows_clause(const ParseNode *node)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(node)) {// no named windows.
  } else if (OB_UNLIKELY(node->type_ != T_WIN_NAMED_WINDOWS)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected type", K(node->type_), K(ret));
  } else if (OB_UNLIKELY(node->num_child_ > OB_MAX_NAMED_WINDOW_FUNCTION_NUM)) {
    ret = OB_NOT_SUPPORTED;
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "named windows more than 127");
    LOG_WARN("too many windows", K(ret));
  } else {
    current_scope_ = T_NAMED_WINDOWS_SCOPE;
    int64_t ref_list_cnt = 0; // 引用关系链表
    int64_t ref_list[OB_MAX_NAMED_WINDOW_FUNCTION_NUM];
    bool resolved[OB_MAX_NAMED_WINDOW_FUNCTION_NUM] = { false };
    ObSEArray<ObString, 32> resolved_name_list;
    for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; i++) {
      if (resolved[i]) {
        continue;
      }
      // 按依赖关系依次解析，优先解析被引用的window
      ParseNode *name_node = NULL;
      ParseNode *win_node = NULL;
      ParseNode *named_win_node = NULL;
      ref_list[ref_list_cnt++] = i;
      // named_window             ->   named_win_node   ->   window w1 as (w2 partition by c)
      // name_ob                  ->   name_node        ->   w1
      // new_generalized_window   ->   win_node         ->   w2 partition by c
      while (OB_SUCC(ret) && ref_list_cnt > 0) {
        LOG_DEBUG("current window", K(ref_list[ref_list_cnt - 1]), K(ref_list_cnt));
        named_win_node = node->children_[ref_list[ref_list_cnt - 1]];
        if (OB_ISNULL(named_win_node)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("NULL ptr",  K(ret));
        } else if (OB_ISNULL(name_node = named_win_node->children_[0])) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("NULL ptr", K(ret));
        } else if (OB_ISNULL(win_node = named_win_node->children_[1])) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("NULL ptr", K(ret));
        } else {
          // 1. 未引用任何window
          // 2. 引用已经解析好的window
          // 这两种情况会直接解析当前window，否则转而解析被引用的window
          bool resolve_expr = false;
          int64_t ref_idx = -1;
          ParseNode *ref_name_node = win_node->children_[0];
          if (NULL == ref_name_node) {
            resolve_expr = true;
          } else if (OB_FAIL(get_refindex_from_named_windows(ref_name_node,
                                                             node,
                                                             ref_idx))) {
            LOG_WARN("failed to get ref index from named windows.", K(ret));
          } else if (OB_UNLIKELY(-1 == ref_idx)) {
            ret = OB_NOT_SUPPORTED;
            LOG_USER_ERROR(OB_NOT_SUPPORTED, "ref not existed window");
            LOG_WARN("ref window not exist", K(ret));
          } else if ((ref_list + ref_list_cnt) != std::find(ref_list,
                                                            ref_list + ref_list_cnt,
                                                            ref_idx)) {
            ret = OB_NOT_SUPPORTED;
            LOG_USER_ERROR(OB_NOT_SUPPORTED, "circle ref window");
            LOG_WARN("circle ref window not supported", K(ref_list), K(ref_idx), K(ret));
          } else if (resolved[ref_idx]) {
            resolve_expr = true;
          } else {
            resolve_expr = false;
            ref_list[ref_list_cnt++] = ref_idx;
          }
          if (OB_SUCC(ret) && resolve_expr) {
            ObString name(static_cast<int32_t>(name_node->str_len_),
                          name_node->str_value_);
            if (OB_FAIL(check_duplicated_name_window(name, resolved_name_list))) {
              LOG_WARN("has duplicated name widow when check them.", K(ret));
            } else if (OB_FAIL(resolved_name_list.push_back(name))) {
              LOG_WARN("failed to push back win name", K(ret));
            } else if (OB_FAIL(mock_to_named_windows(name,
                                                     win_node))) {
              LOG_WARN("failed to mock to name window", K(ret));
            } else {
              resolved[ref_list[ref_list_cnt - 1]] = true;
              ref_list_cnt--;
            }
          }
        }
      }
    }
    LOG_DEBUG("resolve_named_windows_clause finish", K(ret));
  }
  return ret;
}

int ObSelectResolver::resolve_into_const_node(const ParseNode *node, ObObj &obj)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(node)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("node is null", K(ret));
  } else if (T_CHAR == node->type_ || T_VARCHAR == node->type_) {
    ObCollationType cs_type = params_.session_info_->get_local_collation_connection();
    ObString node_str(node->str_len_, node->str_value_);
    if (lib::is_oracle_mode()) {
      OZ (ObResolverUtils::escape_char_for_oracle_mode(*allocator_, node_str, cs_type));
    }
    if (OB_SUCC(ret)) {
      obj.set_varchar(node_str);
      obj.set_collation_type(cs_type);
    }
  } else if (T_QUESTIONMARK == node->type_) {
    obj.set_unknown(node->value_);
  } else {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("node type must be varchar or ?", K(ret), K(node->type_));
  }
  return ret;
}

int ObSelectResolver::resolve_into_filed_node(
  const ParseNode *list_node,
  ObSelectIntoItem &into_item)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(list_node)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("str node is null", K(ret));
  } else {
    for (int32_t i = 0 ; i < list_node->num_child_ ; ++i) {
      ParseNode *node = list_node->children_[i];
      if (OB_ISNULL(node)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("str node or into_item is null", K(ret));
      } else if (T_FIELD_TERMINATED_STR == node->type_) {
        if (OB_FAIL(resolve_into_const_node(node->children_[0], into_item.filed_str_))) {
          LOG_WARN("resolve into outfile filed str", K(ret));
        }
      } else if (T_OPTIONALLY_CLOSED_STR == node->type_
                 || T_CLOSED_STR == node->type_) {
        if (node->num_child_ != 1) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("child num should be one", K(ret));
        } else if (1 != node->children_[0]->str_len_ || OB_ISNULL(node->children_[0]->str_value_)) {
          ret = OB_WRONG_FIELD_TERMINATORS;
          LOG_WARN("closed str should be a character", K(ret), K(node->children_[0]->str_value_));
        } else {
          into_item.closed_cht_ = node->children_[0]->str_value_[0];
          if (T_OPTIONALLY_CLOSED_STR == node->type_) {
            into_item.is_optional_ = true;
          }
        }
      } else if (T_ESCAPED_STR == node->type_) {
        if (node->num_child_ != 1) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("child num should be one", K(ret));
        } else if (node->children_[0]->str_len_ == 0) {
          into_item.escaped_cht_ = 0;
        } else if (node->children_[0]->str_len_ == 1) {
          into_item.escaped_cht_ = node->children_[0]->str_value_[0];
        } else {
          ret = OB_WRONG_FIELD_TERMINATORS;
          LOG_WARN("escaped str should be a character", K(ret), K(node->children_[0]->str_value_));
        }
      } else {
        // do nothing
      }
    }
  }

  return ret;
}

int ObSelectResolver::resolve_into_line_node(const ParseNode *list_node, ObSelectIntoItem &into_item)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(list_node)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("str node is null", K(ret));
  } else {
    for (int32_t i = 0 ; i < list_node->num_child_ ; ++i) {
      ParseNode *str_node = list_node->children_[i];
      if (OB_ISNULL(str_node)) {
        ret = OB_ERR_UNEXPECTED;
      } else if (T_LINE_TERMINATED_STR == str_node->type_) {
        if (OB_FAIL(resolve_into_const_node(str_node->children_[0], into_item.line_str_))) {
          LOG_WARN("resolve into outfile filed str", K(ret));
        }
      } else {
        // escape
      }
    }
  }
  return ret;
}

int ObSelectResolver::resolve_into_clause(const ParseNode *node)
{
  int ret = OB_SUCCESS;
  if (NULL != node) {
    current_scope_ = T_INTO_SCOPE;
    ObSelectIntoItem *into_item = NULL;
    ObSelectStmt *select_stmt = get_select_stmt();
    if (OB_ISNULL(allocator_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("alloctor is null", K(ret));
    } else if (OB_ISNULL(into_item = static_cast<ObSelectIntoItem *>
                         (allocator_->alloc(sizeof(ObSelectIntoItem))))) {
      ret = OB_ALLOCATE_MEMORY_FAILED;
      LOG_WARN("into item is null", K(ret));
    } else if (OB_ISNULL(select_stmt)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("select stmt is NULL", K(ret));
    } else if (OB_UNLIKELY(get_current_level() != 0)) { //in subquery
      ret = OB_INAPPROPRIATE_INTO;
      LOG_WARN("select into can not in subquery", K(ret));
    } else if (OB_UNLIKELY(is_in_set_query())) {
      ret = OB_INAPPROPRIATE_INTO;
      LOG_WARN("select into can not in set query", K(ret));
    } else {
      new(into_item) ObSelectIntoItem();
      into_item->into_type_ = node->type_;
      if (T_INTO_OUTFILE == node->type_) { // into outfile
        if (OB_FAIL(resolve_into_const_node(node->children_[0], into_item->outfile_name_))) { //name
          LOG_WARN("resolve into outfile name failed", K(ret));
        } else if (NULL != node->children_[1]) { // charset
          ObCharsetType charset_type = CHARSET_INVALID;
          ObString charset(node->children_[1]->str_len_, node->children_[1]->str_value_);
          if (CHARSET_INVALID == (charset_type = ObCharset::charset_type(charset.trim()))) {
            ret = OB_ERR_UNKNOWN_CHARSET;
            LOG_USER_ERROR(OB_ERR_UNKNOWN_CHARSET, charset.length(), charset.ptr());
          } else {
            into_item->cs_type_ = ObCharset::get_default_collation(charset_type);
          }
        }
        if (OB_SUCC(ret) && NULL !=  node->children_[2]) { //field
          if (OB_FAIL(resolve_into_filed_node(node->children_[2], *into_item))) {
            LOG_WARN("reosolve into filed node failed", K(ret));
          }
        }
        if (OB_SUCC(ret) && NULL != node->children_[3]) { // line
          if (OB_FAIL(resolve_into_line_node(node->children_[3], *into_item))) {
            LOG_WARN("reosolve into line node failed", K(ret));
          }
        }
      } else if (T_INTO_DUMPFILE  == node->type_) { // into dumpfile
        if (OB_FAIL(resolve_into_const_node(node->children_[0], into_item->outfile_name_))) {
          LOG_WARN("resolve into outfile name failed", K(ret));
        }
      } else if (T_INTO_VARIABLES == node->type_) { // into @x,@y....
        if (OB_FAIL(resolve_into_variables(node,
                                           into_item->user_vars_,
                                           into_item->pl_vars_,
                                           select_stmt))) {
          LOG_WARN("resolve into variable failed", K(ret));
        }
      } else {
        //do nothing
      }
      if (OB_SUCC(ret)) {
        select_stmt->set_select_into(into_item);
      }
    }
  }
  return ret;
}


int ObSelectResolver::resolve_column_ref_in_all_namespace(
  const ObQualifiedName &q_name,
  ObRawExpr *&real_ref_expr)
{
  int ret = OB_SUCCESS;
  //first, find column in current namespace
  //mysql5.6中alias name不能出现在where子句中，但是可以出现在group by、having、order by子句中
  //如果普通列和alias name重复，那么在group by、having子句中优先使用基础列，并汇报WARNNING
  //order by子句中，优先使用alias name
  if (OB_UNLIKELY(T_ORDER_SCOPE == current_scope_)) {
    if ((lib::is_mysql_mode() && params_.is_column_ref_) || lib::is_oracle_mode()) {
      // should raise an error
      // select id + 1 as data, data from test order by data
      // select id as data, data from test order by data
      if (OB_FAIL(resolve_column_ref_alias_first(q_name, real_ref_expr))) {
        LOG_WARN_IGNORE_COL_NOTFOUND(ret, "resolve column ref alias first failed", K(ret), K(q_name));
      }
    } else {
      // if the item behind order by is an expr in mysql mode, then we should resolve column
      // select id as data, data from test order by data + 1;
      // select id as data, data from test order by sum(data);
      // select id + 1 as data, data from test order by sum(data);
      if (OB_FAIL(resolve_column_ref_table_first(q_name, real_ref_expr, false))) {
        LOG_WARN_IGNORE_COL_NOTFOUND(ret, "resolve column ref table first failed", K(ret), K(q_name));
      }
    }
  } else if (OB_UNLIKELY(T_HAVING_SCOPE == current_scope_)) {
    if (OB_FAIL(resolve_column_ref_for_having(q_name, real_ref_expr))) {
      LOG_WARN_IGNORE_COL_NOTFOUND(ret, "resolve column ref for having failed", K(ret), K(q_name));
    }
  }  else if (T_WITH_CLAUSE_SEARCH_SCOPE == current_scope_) {
    if (OB_FAIL(resolve_column_ref_for_search(q_name, real_ref_expr))) {
      LOG_WARN_IGNORE_COL_NOTFOUND(ret, "resolve column ref for search failed",  K(ret), K(q_name));
    }
  } else {
    //search column in table columns first
    if (OB_FAIL(resolve_column_ref_table_first(q_name, real_ref_expr))) {
      LOG_WARN_IGNORE_COL_NOTFOUND(ret, "resolve column ref table first failed", K(ret), K(q_name));
    }
  }
  ObQueryRefRawExpr *query_ref = NULL;
  for (ObDMLResolver *cur_resolver = get_parent_namespace_resolver();
      OB_ERR_BAD_FIELD_ERROR == ret && cur_resolver != NULL;
      cur_resolver = cur_resolver->get_parent_namespace_resolver()) {
    ObRawExpr *exec_param = NULL;
    //for insert into t1 values((select c1 from dual)) ==> can't check column c1 in t1;
    if (cur_resolver->get_basic_stmt() != NULL &&
        cur_resolver->get_basic_stmt()->is_insert_stmt()) {
      //do nothing
    } else if (OB_FAIL(cur_resolver->resolve_column_ref_for_subquery(q_name, real_ref_expr))) {
      LOG_WARN_IGNORE_COL_NOTFOUND(ret, "resolve column for subquery failed", K(ret), K(q_name));
    } else if (OB_ISNULL(query_ref = cur_resolver->get_subquery())) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("no subquery is found", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::get_exec_param_expr(*params_.expr_factory_,
                                                           query_ref,
                                                           real_ref_expr,
                                                           exec_param))) {
      LOG_WARN("failed to get exec param expr", K(ret));
    } else {
      /// succeed to resolve the correlated column, do the replace here
      real_ref_expr = exec_param;
    }
  }
  return ret;
}

int ObSelectResolver::resolve_column_ref_expr(
  const ObQualifiedName &q_name, ObRawExpr *&real_ref_expr)
{
  int ret = OB_SUCCESS;
  //设置resolve的列是否存在本层的聚集函数中，如果存在聚集函数中，本层的列可以不需要进行only full group by约束
  if (OB_ISNULL(session_info_)) {
    ret = OB_NOT_INIT;
    LOG_WARN("session info is null");
  } else  if (OB_FALSE_IT(const_cast<ObQualifiedName&>(q_name).current_resolve_level_ = current_level_)) {

  } else if (q_name.parents_expr_info_.has_member(IS_AGG)) {
    const_cast<ObQualifiedName&>(q_name).parent_aggr_level_ = current_level_;
  } else {
    const_cast<ObQualifiedName&>(q_name).parent_aggr_level_ = parent_aggr_level_;
  }
  if (OB_SUCC(ret) && OB_FAIL(resolve_column_ref_in_all_namespace(q_name, real_ref_expr))) {
    LOG_WARN_IGNORE_COL_NOTFOUND(ret, "resolve column ref in all namespace failed", K(ret));
  }
  return ret;
}

//resolve table column reference
//select stmt can access joined table column, generated table column or base table column
int ObSelectResolver::resolve_table_column_ref(const ObQualifiedName &q_name, ObRawExpr *&real_ref_expr)
{
  //search order
  //1. joined table column
  //2. basic table column or generated table column
  //3. object (sequence)
  int ret = OB_SUCCESS;
  if (OB_FAIL(resolve_table_column_expr(q_name, real_ref_expr))) {
    LOG_WARN("resolve table column expr failed", K(ret), K(q_name), K(lbt()));
  } else if (column_need_check_group_by(q_name)) {
    //任何一个表达式引用到的本层的列，都必须记录到standard group checker中，并进行only full group by检查
    // In Oracle mode, it will add all referenced columns, but group by checker will check every expression recursively intead of one by one column
    if (OB_FAIL(standard_group_checker_.add_unsettled_column(real_ref_expr))) {
      LOG_WARN("add unsettled column failed", K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::resolve_alias_column_ref(
  const ObQualifiedName &q_name,
  ObRawExpr *&real_ref_expr)
{
  int ret = OB_SUCCESS;
  //resolve column in target list can't reference the alias column
  //such as select 1 as a, (select a) ->error
  //select 1 as a, a; ->error
  ObSelectStmt *select_stmt = get_select_stmt();
  real_ref_expr = NULL;
  if (OB_ISNULL(select_stmt) || OB_ISNULL(q_name.ref_expr_)) {
    ret = OB_NOT_INIT;
    LOG_WARN("select stmt is null", K(select_stmt), K_(q_name.ref_expr));
  } else if ((!lib::is_oracle_mode() && current_level_ < q_name.current_resolve_level_) ||current_scope_ != T_FIELD_LIST_SCOPE) {
    // mysql can use parent filed list, so test current_level_ < q_name.current_resolve_level_
    // such as create table t1(c1 int);create table t2(c1 int);select c1 as id /*(level=0)*/, (/*(level=1)*/select c1 from t1 where c1 = id) from t2;
    const SelectItem *cur_item = NULL;
    if (!q_name.tbl_name_.empty()) {
      //select t1.c1 from t1 having t1.c1 > 0   should check if t1 is correct
      //select t1.c1 from t1 having t2.c1 > 0
      //select c1, c2 as c1 from t1 having t1.c1 > 0 //should choose c1
      //select t1.c1 as cc from t1 having t1.c1 > 0; //should found c1
      //select t1.c1 as cc from t1 having t2.c1 > 0; //should not found c1
      for (int32_t i = 0; OB_SUCC(ret) && i < select_stmt->get_select_item_size(); ++i) {
        bool is_hit = false;
        cur_item = &select_stmt->get_select_item(i);
        if (cur_item->expr_ != NULL) {
          ObColumnRefRawExpr *col_expr = NULL;
          if (cur_item->expr_->is_column_ref_expr()) {
            col_expr = static_cast<ObColumnRefRawExpr *>(cur_item->expr_);
          }
          if (NULL == col_expr) {
            continue;
          }
          if (OB_FAIL(ObResolverUtils::check_column_name(
                        session_info_, q_name, *col_expr, is_hit))) {
            LOG_WARN("check column name failed", K(ret));
          } else if (is_hit) {
            if (NULL == real_ref_expr) {
              ret = column_namespace_checker_.check_column_existence_in_using_clause(
                                    col_expr->get_table_id(), col_expr->get_column_name());
              if (OB_SUCC(ret)) {
                real_ref_expr = col_expr;
              }
            } else if (real_ref_expr != col_expr) {
              ret = OB_NON_UNIQ_ERROR;
            }
          }
        } else {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("cur item expr is null");
        }
      }
      if (OB_SUCC(ret) && NULL == real_ref_expr) {
        ret = OB_ERR_BAD_FIELD_ERROR;
      }
    } else {
      // first loop, find the matched alias column with expr
      for (int32_t i = 0; OB_SUCC(ret) && i < select_stmt->get_select_item_size(); ++i) {
        cur_item = &select_stmt->get_select_item(i);
        if (ObCharset::case_insensitive_equal(q_name.col_name_, cur_item->alias_name_)) {
          /*
           * for oracle mode, column uniqueness is checked among all tables
           * for mysql mode, column uniqueness is only checked among select items
           * for example, create table t1(a int, b int, c int); create table t2(a int, b int, c int);
           * select t1.a, t1.b from t1 left join t2 on t1.a = t2.a order by b
           * for mysql mode, it is ok, and b refer to t1.b
           * for oracle mode, it will get error "column ambiguously defined"
           */
          if (NULL == real_ref_expr) {
            if (lib::is_oracle_mode() && cur_item->expr_->is_column_ref_expr() &&
                !cur_item->is_real_alias_) {
              const TableItem *table_item = NULL;
              ret = column_namespace_checker_.check_table_column_namespace(q_name, table_item);
            }
            if (OB_SUCC(ret)) {
             real_ref_expr = cur_item->expr_;
            }
          } else if (real_ref_expr != cur_item->expr_) {
            ret = OB_NON_UNIQ_ERROR;
          }
        }
      }
      if (OB_SUCC(ret) && NULL == real_ref_expr) {
        // might not found, the caller will check the col_item is NULL or not
        //select c1 as cc from t1 having c1 > 0; //should found c1
        for (int32_t i = 0; i < select_stmt->get_select_item_size(); ++i) {
          cur_item = &select_stmt->get_select_item(i);
          if (cur_item->is_real_alias_ && cur_item->expr_->is_column_ref_expr()) {
            if (ObCharset::case_insensitive_equal(q_name.col_name_, cur_item->expr_name_)) {
              real_ref_expr = cur_item->expr_;
              break;
            }
          }
        }
      }
      if (OB_SUCC(ret) && NULL == real_ref_expr) {
        ret = OB_ERR_BAD_FIELD_ERROR;
      }
    }
  } else {
    ret = OB_ERR_BAD_FIELD_ERROR;
  }
  //group by clause can't use aggregate function alias name
  if (OB_SUCC(ret) && T_GROUP_SCOPE == current_scope_) {
    if (real_ref_expr->has_flag(CNT_AGG)) {
      ret = OB_ILLEGAL_REFERENCE;
      // 为了能给group by报错
      // 兼容mysql报错,
      // select count(c1) as c from t1 group by c和select count(c1)
      // as c from t1 group by (select c)报错不同
    }
  }
  // subquery cannot ref parent aggr/window function alias
  // SELECT SUM(c1) OVER () AS c, (SELECT SUM(c) from t2)  FROM t1;
  // SELECT SUM(c1) AS c, (SELECT SUM(c) from t2)  FROM t1;
  if(OB_SUCC(ret) && current_level_ < q_name.current_resolve_level_ && T_FIELD_LIST_SCOPE == current_scope_) {
    if (real_ref_expr->has_flag(CNT_AGG) ||
        real_ref_expr->has_flag(CNT_WINDOW_FUNC)) {
      ret = OB_ILLEGAL_REFERENCE;
    }
  }

  if (OB_SUCC(ret) && OB_FAIL(wrap_alias_column_ref(q_name, real_ref_expr))) {
    LOG_WARN("wrap alias column ref failed", K(ret), K(q_name));
  }
  return ret;
}

int ObSelectResolver::resolve_column_ref_in_group_by(
  const ObQualifiedName &q_name,
  ObRawExpr *&real_ref_expr)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(select_stmt)) {
    ret = OB_NOT_INIT;
    LOG_WARN("select stmt is null");
  } else if (!is_oracle_mode() && q_name.parent_aggr_level_ < current_level_) {
    //the column don't located in aggregate function in having clause
    // resolve column refs from group by and rollup exprs
    ObSEArray<ObRawExpr*, 16> group_and_rollup_exprs;
    if (OB_FAIL(append(group_and_rollup_exprs, select_stmt->get_group_exprs()))) {
      LOG_WARN("failed to append group exprs", K(ret));
    } else if (OB_FAIL(append(group_and_rollup_exprs, select_stmt->get_rollup_exprs()))) {
      LOG_WARN("failed to append rollup exprs", K(ret));
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < group_and_rollup_exprs.count(); ++i) {
      bool is_hit = false;
      ObRawExpr *expr = NULL;
      ObColumnRefRawExpr *col_ref = NULL;
      if (OB_ISNULL(expr = group_and_rollup_exprs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("expr is null", K(ret));
      } else if (!expr->is_column_ref_expr()) {
        // do nothing
      } else if (OB_FALSE_IT(col_ref = static_cast<ObColumnRefRawExpr*>(expr))) {
      } else if (OB_FAIL(ObResolverUtils::check_column_name(session_info_, q_name, *col_ref, is_hit))) {
        LOG_WARN("check column name failed", K(ret), K(q_name));
      } else if (is_hit) {
        if (OB_ISNULL(real_ref_expr)) {
          real_ref_expr = col_ref;
        } else if (real_ref_expr != col_ref) {
          ret = OB_NON_UNIQ_ERROR;
        }
      }
    }
  } else if (OB_FAIL(resolve_table_column_ref(q_name, real_ref_expr))) {
    LOG_WARN_IGNORE_COL_NOTFOUND(ret, "resolve table column ref failed", K(ret));
  }
  if (OB_SUCC(ret) && NULL == real_ref_expr) {
    ret = OB_ERR_BAD_FIELD_ERROR;
  }
  return ret;
}

int ObSelectResolver::resolve_column_ref_alias_first(
  const ObQualifiedName &q_name,
  ObRawExpr *&real_ref_expr)
{
  int ret = OB_SUCCESS;
  //search column ref in alias list first
  //if alias column exist, use alias column, otherwise, search column ref in table columns
  if (OB_FAIL(resolve_alias_column_ref(q_name, real_ref_expr))) {
    if (OB_ERR_BAD_FIELD_ERROR == ret) {
      if (OB_FAIL(resolve_table_column_ref(q_name, real_ref_expr))) {
        LOG_WARN_IGNORE_COL_NOTFOUND(ret, "resolve table column refs failed", K(ret), K(q_name));
      }
    } else {
      LOG_WARN("resolve alias column ref failed", K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::resolve_column_ref_for_search(
  const ObQualifiedName &q_name,
  ObRawExpr *&real_ref_expr)
{
  int ret = OB_SUCCESS;
  UNUSED(q_name);
  ColumnItem *col_item = NULL;
  if (T_WITH_CLAUSE_SEARCH_SCOPE != current_scope_) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("we only resolve the search clause at the search scope");
  } else if (OB_ISNULL(current_recursive_cte_table_item_) || OB_ISNULL(current_cte_involed_stmt_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("in order to resolve the search clause, the recursive cte table item can not be null");
  } else {
    ObDMLStmt *stmt = current_cte_involed_stmt_;
    TableItem& table_item = *current_recursive_cte_table_item_;
    if (OB_ISNULL(stmt) || OB_ISNULL(schema_checker_) || OB_ISNULL(params_.expr_factory_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("schema checker is null", K(stmt), K_(schema_checker), K_(params_.expr_factory));
    } else if (OB_UNLIKELY(!table_item.is_basic_table() && !table_item.is_fake_cte_table())) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("not base table or alias from base table", K_(table_item.type));
    } else if (NULL != (col_item = stmt->get_column_item(table_item.table_id_, q_name.col_name_))) {
      real_ref_expr = col_item->expr_;
    } else {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("the col item has been resolve, but we do not find it in the search clause resolver");
    }
  }
  return ret;
}

int ObSelectResolver::set_having_self_column(const ObRawExpr *real_ref_expr)
{
  int ret = OB_SUCCESS;
  // set having has columns
  if (OB_ISNULL(real_ref_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select stmt is null or real ref expr is null", K(ret));
  } else if (!real_ref_expr->is_exec_param_expr()) {
    // set having has self column
    set_having_has_self_column();
    LOG_DEBUG("set having self column", K(*real_ref_expr));
  } else {
    LOG_DEBUG("different level", K(*real_ref_expr));
  }
  return ret;
}

/**
 * The SQL standard requires that HAVING must reference only columns in the GROUP BY clause or
 * columns used in aggregate functions. However, MySQL supports an extension to this behavior,
 * and permits HAVING to refer to columns in the SELECT list and columns in outer subqueries as well
 */
int ObSelectResolver::resolve_column_ref_for_having(
  const ObQualifiedName &q_name,
  ObRawExpr *&real_ref_expr)
{
  int ret = OB_SUCCESS;
  ObRawExpr *check_ref = NULL;
  bool is_oracle_compatible = is_oracle_mode();
  if (OB_FAIL(resolve_column_ref_in_group_by(q_name, real_ref_expr))) {
    if (OB_ERR_BAD_FIELD_ERROR == ret) {
      if (OB_FAIL(resolve_alias_column_ref(q_name, real_ref_expr))) {
        LOG_WARN_IGNORE_COL_NOTFOUND(
          ret,
          "resolve alias column reference failed",
          K(ret),
          K(q_name));
      }
    } else {
      LOG_WARN("resolve column ref in group by failed", K(ret), K(q_name));
    }
  } else if (is_oracle_compatible) {
    if (OB_FAIL(set_having_self_column(real_ref_expr))) {
      LOG_WARN("set having self column failed", K(ret), K(q_name));
    }
  } else if (OB_FAIL(resolve_alias_column_ref(q_name, check_ref))) {
    //check column whether exists in alias select list
    if (OB_ERR_BAD_FIELD_ERROR == ret) {
      ret = OB_SUCCESS;
    } else {
      LOG_WARN("resolve alias column ref failed", K(ret), K(q_name));
    }
  } else if (!ObRawExprUtils::is_same_column_ref(real_ref_expr, check_ref)) {
    // if column name exist in both group columns and alias name list,
    // use table column and produce warning msg
    ObString col_name = concat_qualified_name(
      q_name.database_name_, q_name.tbl_name_, q_name.col_name_);
    ObString scope_name = ObString::make_string(get_scope_name(current_scope_));
    LOG_USER_WARN(OB_NON_UNIQ_ERROR,
                  col_name.length(),
                  col_name.ptr(),
                  scope_name.length(),
                  scope_name.ptr());
  }

  return ret;
}

int ObSelectResolver::resolve_column_ref_table_first(
  const ObQualifiedName &q_name,
  ObRawExpr *&real_ref_expr,
  bool need_further_match_alias /* = true */)
{
  int ret = OB_SUCCESS;
  //search column ref in table columns first, follow by alias name
  //if table column exist, check column name whether exist in alias name list
  ObRawExpr *tmp_ref = NULL;
  if (OB_FAIL(resolve_table_column_ref(q_name, real_ref_expr))) {
    if (OB_ERR_BAD_FIELD_ERROR == ret) {
      if (OB_FAIL(resolve_alias_column_ref(q_name, real_ref_expr))) {
        LOG_WARN_IGNORE_COL_NOTFOUND(ret, "resolve alias column ref failed", K(ret), K(q_name));
      }
    } else if (OB_NON_UNIQ_ERROR == ret && lib::is_mysql_mode() &&
               T_GROUP_SCOPE == current_scope_) {
      // in mysql mode, for t1(c1, c2), t2(c1, c2), select t1.c1 from t1, t2 group by c1;
      // the c1 in group by is resolved as t1.c1 in select items.
      if (OB_FAIL(resolve_alias_column_ref(q_name, real_ref_expr))) {
        ret = OB_NON_UNIQ_ERROR;
        LOG_WARN("resolve table column ref failed", K(ret));
      }
    } else {
      LOG_WARN("resolve table column ref failed", K(ret));
    }
  } else if (need_further_match_alias) {
    if (OB_FAIL(resolve_alias_column_ref(q_name, tmp_ref))) {
      if (OB_ERR_BAD_FIELD_ERROR == ret || OB_ILLEGAL_REFERENCE == ret) {
        ret = OB_SUCCESS;
      } else {
        LOG_WARN("try to hit column on target list failed", K(ret));
      }
    } else if (!ObRawExprUtils::is_same_column_ref(real_ref_expr, tmp_ref)) {
      //if column name exist in both table columns and alias name list, use table column and produce warning msg
      ObString col_name = concat_qualified_name(q_name.database_name_, q_name.tbl_name_, q_name.col_name_);
      ObString scope_name = ObString::make_string(get_scope_name(current_scope_));
      LOG_USER_WARN(OB_NON_UNIQ_ERROR, col_name.length(), col_name.ptr(), scope_name.length(), scope_name.ptr());
    }
  }
  return ret;
}

int ObSelectResolver::create_joined_table_item(JoinedTable *&joined_table)
{
  int ret = OB_SUCCESS;
  void *ptr = NULL;
  if (OB_ISNULL(allocator_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("invalid argument", K(ret));
  } else if (NULL == (ptr = allocator_->alloc(sizeof(JoinedTable)))) {
    ret = OB_ALLOCATE_MEMORY_FAILED;
    SQL_RESV_LOG(ERROR, "alloc memory for JoinedTable failed", "size", sizeof(JoinedTable));
  } else {
    joined_table = new (ptr) JoinedTable();
  }
  return ret;
}

int ObSelectResolver::check_special_join_table(const TableItem &join_table, bool is_left_child, ObItemType join_type)
{
  int ret = OB_SUCCESS;
  if (is_left_child) {
    if (join_table.is_fake_cte_table() && cte_ctx_.is_with_resolver()
        && (T_JOIN_RIGHT == join_type || T_JOIN_FULL == join_type)) {
      ret = OB_ERR_ILLEGAL_JOIN_IN_RECURSIVE_CTE;
      LOG_WARN("recursive cte table placed at right join's left is not allowed, and full join is not allowed", K(ret));
    }
  } else {
    if (join_table.is_fake_cte_table() && cte_ctx_.is_with_resolver()
        && (T_JOIN_LEFT == join_type || T_JOIN_FULL == join_type)) {
      ret = OB_ERR_ILLEGAL_JOIN_IN_RECURSIVE_CTE;
      LOG_WARN("recursive cte in left join' right is not allowed, and full join is not allowed", K(ret));
    }
  }
  return ret;
}
//find coalesce_expr in joined table
//@param jointable_idx: the index of joinedtable, use to match correct using_columns/coalesce_expr in
//               jointable_using_columns and jointable_coalesce_exprs_
int ObSelectResolver::recursive_find_coalesce_expr(const JoinedTable *&joined_table,
                                                    const ObString &cname,
                                                    ObRawExpr *&coalesce_expr)
{
  int ret = OB_SUCCESS;
  bool found = false;
  ResolverJoinInfo *join_info = NULL;
  if (get_joininfo_by_id(joined_table->table_id_, join_info) && join_info->coalesce_expr_.count() > 0)
  {
    for (int i = 0; !found && i < join_info->coalesce_expr_.count(); i++) {
      if (ObCharset::case_insensitive_equal(join_info->using_columns_.at(i), cname)) {
        coalesce_expr = join_info->coalesce_expr_.at(i);
        found = true;
      }
    }
  }

  if (!found) {
    if (RIGHT_OUTER_JOIN == joined_table->joined_type_) {
      if (TableItem::JOINED_TABLE == joined_table->right_table_->type_) {
        const JoinedTable *right_table = static_cast<const JoinedTable*>(joined_table->right_table_);
        OZ(SMART_CALL(recursive_find_coalesce_expr(right_table, cname, coalesce_expr)));
      }
    } else if (TableItem::JOINED_TABLE == joined_table->left_table_->type_) {
      const JoinedTable *left_table = static_cast<const JoinedTable*>(joined_table->left_table_);
      OZ(SMART_CALL(recursive_find_coalesce_expr(left_table, cname, coalesce_expr)));
    }
  }
  return ret;
}

int ObSelectResolver::resolve_subquery_info(const ObIArray<ObSubQueryInfo> &subquery_info)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(session_info_)) {
    ret = OB_NOT_INIT;
    LOG_WARN("session info is null");
  } else if (current_level_ + 1 >= OB_MAX_SUBQUERY_LAYER_NUM && subquery_info.count() > 0) {
    ret = OB_NOT_SUPPORTED;
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "too many levels of subqueries");
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < subquery_info.count(); i++) {
    const ObSubQueryInfo &info = subquery_info.at(i);
    ObSelectResolver subquery_resolver(params_);
    subquery_resolver.set_current_level(current_level_ + 1);
    subquery_resolver.set_is_sub_stmt(true);
    subquery_resolver.set_parent_namespace_resolver(this);
    subquery_resolver.set_current_view_level(current_view_level_);
    set_query_ref_expr(info.ref_expr_);
    resolve_alias_for_subquery_ = !(T_FIELD_LIST_SCOPE == current_scope_
                                   && info.parents_expr_info_.has_member(IS_AGG));
    if (OB_FAIL(subquery_resolver.add_parent_gen_col_exprs(gen_col_exprs_))) {
      LOG_WARN("failed to add parent gen col exprs", K(ret));
    }
    OZ( subquery_resolver.set_cte_ctx(cte_ctx_, true, true) );
    OZ( add_cte_table_to_children(subquery_resolver) );
    if (info.parents_expr_info_.has_member(IS_AGG)) {
      subquery_resolver.set_parent_aggr_level(current_level_);
    } else if (is_only_full_group_by_on(session_info_->get_sql_mode())) {
      subquery_resolver.set_parent_aggr_level(parent_aggr_level_);
    }
    OZ ( do_resolve_subquery_info(info, subquery_resolver) );
    set_query_ref_expr(NULL);
  }
  return ret;
}

//can't find column in current namespace, continue to search column in all parent namespace
//compatible with mysql, use of the outer subqueries column follow these rules
//if subquery in having clause, 1. use column in group by, 2. use column in select list
//such as: select c2 as c1 from t1 group by c1 having c2>(select t1.c1 from t) -> use
// t1.c1 in group by
//select c1 from t1 group by c2 having c2>(select t1.c3 from t) -> error, t1.c3 not
// in group by or select list
//if subquery in others clause, 1. use column in table columns, 2. use column in select list
//such as: t1(c1, c2), t2(a), select c1 as c2 from t1 group by (select c2 from t2) -> use t1.c2
//select c1 as c2 from t1 order by (select c2 from t2) -> use t1.c2
//but order by not in subquery will use alias name first, such as: select c1 as c2
// from t1 order by c2 -> use t1.c1
int ObSelectResolver::resolve_column_ref_for_subquery(
  const ObQualifiedName &q_name,
  ObRawExpr *&real_ref_expr)
{
  int ret = OB_SUCCESS;
  if (OB_UNLIKELY(T_HAVING_SCOPE == current_scope_)) {
    if (OB_FAIL(resolve_column_ref_in_group_by(q_name, real_ref_expr))) {
      LOG_WARN_IGNORE_COL_NOTFOUND(ret, "resolve column ref in group by failed", K(ret), K(q_name));
    } else {
      if (is_oracle_mode()) {
        if (OB_FAIL(set_having_self_column(real_ref_expr))) {
          LOG_WARN("set having self column failed", K(ret), K(q_name));
        }
      }
    }
  } else if (OB_FAIL(resolve_table_column_ref(q_name, real_ref_expr))) {
    LOG_WARN_IGNORE_COL_NOTFOUND(ret, "resolve table column failed", K(ret), K(q_name));
  }
  if (OB_ERR_BAD_FIELD_ERROR == ret && resolve_alias_for_subquery_) {
    if (OB_FAIL(resolve_alias_column_ref(q_name, real_ref_expr))) {
      LOG_WARN_IGNORE_COL_NOTFOUND(ret, "resolve alias column ref failed", K(ret), K(q_name));
    }
  }
  return ret;
}

inline bool ObSelectResolver::column_need_check_group_by(const ObQualifiedName &q_name) const
{
  bool bret = true;
  if (OB_ISNULL(session_info_)) {
    bret = false;
  } else if (!is_only_full_group_by_on(session_info_->get_sql_mode())) {
    bret = false;
  } else if (T_FIELD_LIST_SCOPE != current_scope_ && T_ORDER_SCOPE != current_scope_) {
    bret = false;
  } else if (q_name.parent_aggr_level_ >= 0 && current_level_ <= q_name.parent_aggr_level_) {
    //aggr_level不为-1说明该column一定存在aggr function中 current_level_ > aggr_level说明
    //引用的current level低于aggr_level
    //即使aggr没有发生上推，current level的column也不会影响aggr的聚集情况，不受聚集的约束
    //这样能够确保这样的column一定不在aggr中，或者在aggr中，但是不受aggr约束，需要检查group by的合法性
    //因此这里会存在误判的可能，因为aggr function还没有被上推，被需要检查，但是没有检查的列，
    //在上推的分析过程中会再次将其加入到standard group checker中
    //例如:select c1, (select (select count(t2.c1+t1.c1) from t3) from t2) from t1;
    //在这个例子中,count()属于第二层,这里认为t2.c1和t1.c1都不需要check group by,
    //但是在aggre上推分析过程中发现，t2.c1位于count()中，不需要检查,t1.c1需要检查，这里误判了，
    //在聚集上推分析中会加入到standard group checker中
    bret = false;
  }
  return bret;
}

int ObSelectResolver::wrap_alias_column_ref(
  const ObQualifiedName &q_name,
  ObRawExpr *&real_ref_expr)
{
  int ret = OB_SUCCESS;
  //aggr in window function isn't used to wrap column ref, just only expand alias column, and do
  //wrap alias column ref is used to help analyze aggregate pullup for alias column in aggr. the
  //other situation should expand alias column directly.
  //eg: select sum(t1.c1) from t1 order by (select sum(t1.c1) from t2);
  // sum(t1.c1) in subquery is from parent stmt.
  if (!q_name.parents_expr_info_.has_member(IS_WINDOW_FUNC) &&
      q_name.parent_aggr_level_ >= 0 &&
      current_level_ <= q_name.parent_aggr_level_) {
    ObAliasRefRawExpr *alias_expr = NULL;
    if (OB_FAIL(ObRawExprUtils::build_alias_column_expr(
                  *params_.expr_factory_,
                  real_ref_expr,
                  current_level_,
                  alias_expr))) {
      LOG_WARN("build alias column expr failed", K(ret));
    } else {
      real_ref_expr = alias_expr;
    }
  }
  return ret;
}

int ObSelectResolver::mark_nested_aggr_if_required(
    const ObIArray<ObAggFunRawExpr*> &aggr_exprs)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *stmt = static_cast<ObSelectStmt*>(get_stmt());
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret), K(stmt));
  } else if (!has_nested_aggr_) {
    for (int64_t i = 0; OB_SUCC(ret) && i < aggr_exprs.count(); i++) {
      if (OB_ISNULL(aggr_exprs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("aggr item is null", K(ret));
      } else if (OB_FAIL(aggr_exprs.at(i)->extract_info())) {
        LOG_WARN("failed to extract info", K(ret));
      } else if (aggr_exprs.at(i)->contain_nested_aggr()) {
        has_nested_aggr_ = true;
        break;
      }
    }
  }
  if (has_nested_aggr_) {
    ObArray<ObAggFunRawExpr*> param_aggrs;
    ObArray<ObWinFunRawExpr *> param_winfuncs;
    if (OB_UNLIKELY(is_mysql_mode())) {
      ret = OB_ERR_INVALID_GROUP_FUNC_USE;
      LOG_WARN("invalid scope for agg function", K(ret));
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < aggr_exprs.count(); ++i) {
      ObAggFunRawExpr *aggr = NULL;
      if (OB_ISNULL(aggr = aggr_exprs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("aggr item is null", K(ret));
      } else if (OB_FAIL(aggr_exprs.at(i)->extract_info())) {
        LOG_WARN("failed to extract info", K(ret));
      } else if (aggr->has_flag(CNT_AGG) ||
                 aggr->has_flag(CNT_WINDOW_FUNC)) {
        for (int64_t j = 0; OB_SUCC(ret) && j < aggr->get_param_count(); ++j) {
          if (OB_FAIL(ObTransformUtils::extract_aggr_expr(aggr->get_param_expr(j),
                                                          param_aggrs))) {
            LOG_WARN("failed to extract aggr expr", K(ret));
          } else if (OB_FAIL(ObTransformUtils::extract_winfun_expr(aggr->get_param_expr(j),
                                                                   param_winfuncs))) {
            LOG_WARN("failed to extract param win funcs", K(ret));
          }
        }
      }
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < param_winfuncs.count(); ++i) {
      if (OB_ISNULL(param_winfuncs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("param winfunc is null", K(ret));
      } else if (param_winfuncs.at(i)->has_flag(CNT_AGG)) {
        ret = OB_ERR_INVALID_GROUP_FUNC_USE;
        LOG_WARN("aggregated nested in same level", K(ret));
      }
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < param_aggrs.count(); ++i) {
      if (OB_ISNULL(param_aggrs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("normal aggr is null", K(ret));
      } else if (param_aggrs.at(i)->contain_nested_aggr()) {
        ret = OB_ERR_INVALID_GROUP_FUNC_USE;
        LOG_WARN("nested aggr should not contain nested aggr", K(ret));
      } else {
        param_aggrs.at(i)->set_in_nested_aggr(true);
      }
    }
  }
  return ret;
}

int ObSelectResolver::resolve_aggr_exprs(ObRawExpr *&expr, ObIArray<ObAggFunRawExpr*> &aggr_exprs,
    const bool need_analyze/* = true*/)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(params_.expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr factory is null", K(ret));
  } else if (OB_FAIL(mark_nested_aggr_if_required(aggr_exprs))) {
    LOG_WARN("failed check nested aggr.", K(ret));
  } else if (need_analyze) {
    for (int64_t i = 0; OB_SUCC(ret) && i < aggr_exprs.count(); ++i) {
      ObRawExpr *final_aggr = NULL;
      ObAggrExprPushUpAnalyzer aggr_pushup_analyzer(*this);
      if (OB_ISNULL(aggr_exprs.at(i))) {
        ret = OB_INVALID_ARGUMENT;
        LOG_WARN("invalid aggr_expr", K(ret));
      } else if (OB_FAIL(aggr_pushup_analyzer.analyze_and_push_up_aggr_expr(*params_.expr_factory_,
                                                                            aggr_exprs.at(i),
                                                                            final_aggr))) {
        LOG_WARN("resolve aggr expr failed", K(ret));
      } else if (final_aggr != aggr_exprs.at(i)) {
        if (OB_FAIL(ObRawExprUtils::replace_ref_column(expr, aggr_exprs.at(i), final_aggr))) {
          LOG_WARN("replace reference column failed", K(ret));
        } else { /*do nothing.*/ }
      }
    }
  }
  return ret;
}

int ObSelectResolver::resolve_win_func_exprs(ObRawExpr *&expr, common::ObIArray<ObWinFunRawExpr*> &win_exprs)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(expr) || OB_ISNULL(select_stmt)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid arg", K(ret), K(expr), K(select_stmt));
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < win_exprs.count(); ++i) {
      ObWinFunRawExpr *win_expr = static_cast<ObWinFunRawExpr *>(win_exprs.at(i));
      ObAggFunRawExpr *agg_expr = win_expr->get_agg_expr();
      if (OB_ISNULL(win_expr)) {
        ret = OB_INVALID_ARGUMENT;
        LOG_WARN("invalid arg", K(ret), K(win_expr));
      } else if (OB_ISNULL(agg_expr)) {
      } else if (OB_FAIL(agg_expr->formalize(session_info_))) {
        LOG_WARN("formalize agg expr failed", K(ret));
      } else {/*do nothing.*/}
      ObWinFunRawExpr *final_win_expr = NULL;
      const int64_t N = select_stmt->get_window_func_exprs().count();
      if (OB_SUCC(ret)) {
        if (OB_FAIL(check_ntile_compatiable_with_mysql(win_expr))) {
          LOG_WARN("failed to handle compat with mysql ntile.", K(ret));
        } else if (OB_ISNULL(final_win_expr = select_stmt->get_same_win_func_item(win_expr))) {
          ret = select_stmt->add_window_func_expr(win_expr);
        } else if (ObRawExprUtils::replace_ref_column(expr, win_exprs.at(i), final_win_expr)) {
          LOG_WARN("failed to replace ref column.", K(ret), K(*win_exprs.at(i)));
        } else {/*do nothing.*/}
      }
    }
  }
  return ret;
}

int ObSelectResolver::add_aggr_expr(ObAggFunRawExpr *&final_aggr_expr)
{
  int ret = OB_SUCCESS;
  ObAggFunRawExpr *same_aggr_expr = NULL;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(select_stmt) || OB_ISNULL(final_aggr_expr) || OB_ISNULL(session_info_)) {
    ret = OB_NOT_INIT;
    LOG_WARN("select_stmt is null", K(select_stmt), K(final_aggr_expr), K_(session_info));
  } else if (OB_UNLIKELY(select_stmt->is_set_stmt())) {
    ret = OB_ERR_AGGREGATE_ORDER_FOR_UNION;
    LOG_WARN("can't use aggregate function in union stmt");
  } else if (OB_FAIL(select_stmt->check_and_get_same_aggr_item(final_aggr_expr,
                                                               same_aggr_expr))) {
    LOG_WARN("failed to check and get same aggr item.", K(ret));
  } else if (same_aggr_expr != NULL) {
    final_aggr_expr = same_aggr_expr;
  } else if (OB_FAIL(select_stmt->add_agg_item(*final_aggr_expr))) {
    LOG_WARN("add new aggregate function failed", K(ret));
  }
  if (OB_SUCC(ret) && is_only_full_group_by_on(session_info_->get_sql_mode())) {
    standard_group_checker_.set_has_group(true);
  }
  return ret;
}

int ObSelectResolver::add_unsettled_column(ObRawExpr *column_expr)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(session_info_)) {

    ret = OB_NOT_INIT;
    LOG_WARN("session_info is null");
  } else if (is_only_full_group_by_on(session_info_->get_sql_mode())) {
    if (OB_FAIL(standard_group_checker_.add_unsettled_column(column_expr))) {
      LOG_WARN("add unsettled column to standard group checker failed", K(ret));
    }
  }
  if (OB_SUCC(ret) && T_HAVING_SCOPE == current_scope_) {
    if (OB_FAIL(check_column_ref_in_group_by_or_field_list(column_expr))) {
      LOG_WARN_IGNORE_COL_NOTFOUND(ret, "check column ref in group by failed", K(ret));
    }
  }
  return ret;
}

/**
 * create table t1(a int, b int);
 * create table t2(c int);
 * SELECT a FROM t1 GROUP BY a HAVING a IN (SELECT c FROM t2 WHERE MAX(b)>20)
 * 在上面的查询中，b位于max()中，但是此时max()还在子查询中，我们不能确定b是否是上层中合法的列
 * 对于having子句，mysql认为having子句中的列必须出现在group exprs中或者出现在aggregate function
 * 以及field list中，列出现在aggregate function中的列可以来源于当前表中的任何列，不需要出现在group by中
 * 而在解析b的时候还无法判断b是否真正位于聚集函数中，因为聚集函数可能上推，也可能无法上推
 * 在resolve column的时候我们将在聚集函数中的列都视为存在aggregate function中，不需要被group by约束
 * 在聚集上推的过程中，确定了聚集函数最终的层次后，我们再将没有出现在aggregate function中的column推回到
 * 应有的层次上进行group by exprs的检查
 */
int ObSelectResolver::check_column_ref_in_group_by_or_field_list(const ObRawExpr *column_ref) const
{
  int ret = OB_SUCCESS;
  bool found_expr = false;
  const ObSelectStmt *select_stmt = static_cast<const ObSelectStmt*>(stmt_);
  if (OB_ISNULL(select_stmt) || OB_ISNULL(column_ref)) {
    ret = OB_NOT_INIT;
    LOG_WARN("select_stmt is null", K(select_stmt), K(column_ref));
  } else if (column_ref->is_column_ref_expr()) {
    const ObColumnRefRawExpr *column_expr = static_cast<const ObColumnRefRawExpr*>(column_ref);
    for (int64_t i = 0;
         OB_SUCC(ret) && !found_expr && i < select_stmt->get_group_expr_size();
         ++i) {
      if (select_stmt->get_group_exprs().at(i) == column_ref) {
        found_expr = true;
      }
    }
    for (int64_t i = 0;
         OB_SUCC(ret) && !found_expr && i < select_stmt->get_select_item_size();
         ++i) {
      if (select_stmt->get_select_item(i).expr_ == column_ref) {
        found_expr = true;
      }
    }
    if (OB_SUCC(ret) && !found_expr) {
      ret = OB_ERR_BAD_FIELD_ERROR;
      ObString column_name = concat_qualified_name(
        column_expr->get_database_name(),
        column_expr->get_table_name(),
        column_expr->get_column_name());
      ObString scope_name = ObString::make_string(get_scope_name(current_scope_));
      LOG_USER_ERROR(
        OB_ERR_BAD_FIELD_ERROR,
        column_name.length(),
        column_name.ptr(),
        scope_name.length(),
        scope_name.ptr());
    }
  }
  return ret;
}

// use_sys_tenant 标记是否需要以系统租户的身份获取schema
int ObSelectResolver::check_need_use_sys_tenant(bool &use_sys_tenant) const
{
  int ret = OB_SUCCESS;
  if (params_.is_from_show_resolver_) {
    // 若当前已经是系统租户, 则忽略
    if (OB_ISNULL(session_info_)) {
      ret = OB_NOT_INIT;
      LOG_WARN("session info is null");
    } else if (OB_SYS_TENANT_ID == session_info_->get_effective_tenant_id()) {
      use_sys_tenant = false;
    } else {
      use_sys_tenant = true;
    }
  } else {
    use_sys_tenant = false;
  }
  return ret;
}

int ObSelectResolver::check_in_sysview(bool &in_sysview) const
{
  int ret = OB_SUCCESS;
  in_sysview = params_.is_from_show_resolver_;
  return ret;
}

int ObSelectResolver::resolve_start_with_clause(const ParseNode *node)
{
  int ret = OB_SUCCESS;
  if (node != NULL) {//存在start with clause
    current_scope_ = T_START_WITH_SCOPE;
    ObSelectStmt *select_stmt = get_select_stmt();
    if (OB_ISNULL(select_stmt)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("select stmt is NULL", K(ret));
    } else if (OB_FAIL(resolve_and_split_sql_expr(*node, select_stmt->get_start_with_exprs()))) {
      LOG_WARN("resolve and split sql expr failed", K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::check_connect_by_expr_validity(const ObRawExpr *raw_expr)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(raw_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr is null", K(ret));
  } else if (OB_UNLIKELY(raw_expr->is_pseudo_column_expr() &&
                         raw_expr->get_expr_type() != T_LEVEL)) {
    ret = OB_ERR_CBY_PSEUDO_COLUMN_NOT_ALLOWED;
    LOG_WARN("Only Level pseudo allow here", K(ret));
  } else if (OB_UNLIKELY(raw_expr->is_aggr_expr() ||
                          raw_expr->get_expr_class() == ObRawExpr::EXPR_PL_QUERY_REF)) {
    ret = OB_NOT_SUPPORTED;
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "expr in connect by");
    LOG_WARN("expr is not supported here for connect by condition", K(ret));
  } else {
    for (int64_t i = 0; i < raw_expr->get_param_count() && OB_SUCC(ret); i++) {
      if (OB_FAIL(check_connect_by_expr_validity(raw_expr->get_param_expr(i)))) {
        LOG_WARN("check_connect_by_expr_validity failed", K(ret));
      }
    }
  }
  return ret;
}

int ObSelectResolver::resolve_connect_by_clause(const ParseNode *node)
{
  int ret = OB_SUCCESS;
  if (node != NULL) {//存在connect by clause
    current_scope_ = T_CONNECT_BY_SCOPE;
    ObSelectStmt *select_stmt = get_select_stmt();
    const ParseNode *nocycle_node = NULL;
    const ParseNode *connect_by_exprs_node = NULL;
    if (OB_ISNULL(select_stmt)
        || OB_UNLIKELY(node->num_child_ != 2)
        || OB_UNLIKELY(node->type_ != T_CONNECT_BY_CLAUSE)
        || OB_ISNULL(connect_by_exprs_node = node->children_[1])) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("invalid argument", K(select_stmt), K(node->num_child_),
               K(node->type_), K(connect_by_exprs_node), K(ret));
    } else {
      expr_resv_ctx_.set_new_scope();
      nocycle_node = node->children_[0];
      select_stmt->set_nocycle(nocycle_node != NULL);
      OZ( resolve_and_split_sql_expr(
            *connect_by_exprs_node,
            select_stmt->get_connect_by_exprs()) );
      for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_connect_by_exprs().count(); ++i) {
        ObRawExpr *raw_expr = NULL;
        if (OB_ISNULL(raw_expr = select_stmt->get_connect_by_exprs().at(i))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("connect by expr is null", K(ret));
        } else if (raw_expr->has_flag(CNT_CONNECT_BY_ROOT)) {
          ret = OB_ERR_CBY_CONNECT_BY_ROOT_ILLEGAL_USED;
          LOG_WARN("CONNECT BY ROOT operator is not supported in the START WITH or in the CONNECT BY condition", K(ret));
        } else if (raw_expr->has_flag(CNT_SYS_CONNECT_BY_PATH)) {
          ret = OB_ERR_CBY_CONNECT_BY_PATH_NOT_ALLOWED;
          LOG_WARN("CONNECT BY PATH operator is not supported in the START WITH or in the CONNECT BY condition", K(ret));
        } else if (OB_FAIL(check_connect_by_expr_validity(raw_expr))) {
          LOG_WARN("check_connect_by_expr_validity failed", K(ret));
        } else if (raw_expr->has_flag(CNT_PRIOR)) {
          select_stmt->set_has_prior(true);
        }
      }
      expr_resv_ctx_.set_new_scope();
    }
    // window function in select list not supported.
    if (OB_SUCC(ret)) {
      int64_t count = select_stmt->get_select_item_size();
      for (int64_t i = 0; i < count && OB_SUCC(ret); ++i) {
        SelectItem &select_item = select_stmt->get_select_item(i);
        if (OB_ISNULL(select_item.expr_)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("select item is null", K(ret));
        } else if (select_item.expr_->has_flag(CNT_WINDOW_FUNC)) {
          ret = OB_NOT_SUPPORTED;
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "window function in connect by");
          LOG_WARN("window function in connect by not supported", K(ret));
        }
      }
    }
  }
  return ret;
}

int ObSelectResolver::check_pseudo_columns()
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select stmt is null", K(select_stmt), K_(session_info));
  }

  for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_pseudo_column_like_exprs().count(); ++i) {
    ObRawExpr *pseudo_column = select_stmt->get_pseudo_column_like_exprs().at(i);
    if (OB_ISNULL(pseudo_column)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("invalid pseudo column", K(ret));
    } else if (T_CONNECT_BY_ISCYCLE == pseudo_column->get_expr_type()
               && !select_stmt->is_nocycle()) {
      ret = OB_ERR_CBY_NOCYCLE_REQUIRED;
      LOG_WARN("NOCYCLE keyword is required with CONNECT_BY_ISCYCLE pseudo column", K(ret));
    }
  }

  if (OB_FAIL(ret)) {
  } else if (select_stmt->is_order_siblings()) {
    for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_order_item_size(); ++i) {
      const ObRawExpr *sort_expr = select_stmt->get_order_item(i).expr_;
      if (OB_ISNULL(sort_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("sort expr is NULL", K(ret));
      } else if (OB_UNLIKELY(sort_expr->has_flag(CNT_SYS_CONNECT_BY_PATH))) {
        ret = OB_ERR_CBY_CONNECT_BY_PATH_NOT_ALLOWED;
        LOG_WARN("Connect by path not allowed here", K(ret));
      } else if (OB_UNLIKELY(sort_expr->has_flag(CNT_CONNECT_BY_ROOT))) {
        ret = OB_ERR_CBY_CONNECT_BY_ROOT_ILLEGAL_USED;
        LOG_WARN("Connect by root not allowed here", K(ret));
      } else if (OB_UNLIKELY(sort_expr->has_flag(CNT_PSEUDO_COLUMN))
                 || OB_UNLIKELY(sort_expr->has_flag(CNT_PRIOR))) {
        ret = OB_ERR_CBY_PSEUDO_COLUMN_NOT_ALLOWED;
        LOG_WARN("invalid sort expr for order siblings", KPC(sort_expr), K(ret));
      } else if (OB_UNLIKELY(sort_expr->has_flag(CNT_SUB_QUERY))
                 || OB_UNLIKELY(sort_expr->has_flag(CNT_AGG))) {
        ret = OB_NOT_SUPPORTED;
        LOG_USER_ERROR(OB_NOT_SUPPORTED,
                       "Subquery or aggregate function in order siblings by clause is");
      }
    }
  }
  return ret;
}

//同oracle一样, ntile(arg1) (partition by arg2...) 要求arg1 = arg2或者是基于arg2的运算, 如同group by 和 select的有效性检查
int ObSelectResolver::check_win_func_arg_valid(ObSelectStmt *select_stmt,
                                               const ObItemType func_type,
                                               common::ObIArray<ObRawExpr *> &arg_exp_arr,
                                               common::ObIArray<ObRawExpr *> &partition_exp_arr)
{
  int ret = OB_SUCCESS;
  if (T_WIN_FUN_NTILE == func_type || T_FUN_GROUP_CONCAT == func_type) {
    if (OB_ISNULL(select_stmt)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected stmt", K(ret));
    } else {
      // skip add const constraint during prepare stage in PL
      const ParamStore *param_store = (NULL != params_.secondary_namespace_) ? NULL : params_.param_list_;
      if (OB_FAIL(ObGroupByChecker::check_analytic_function(param_store,
                                                            select_stmt,
                                                            arg_exp_arr,
                                                            partition_exp_arr))) {
        LOG_WARN("check_analytic_function failed", K(ret));
      }
    }
  }
  return ret;
}

int ObSelectResolver::check_window_exprs()
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select stmt is null", K(select_stmt));
  }

  for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_window_func_exprs().count(); ++i) {
    ObWinFunRawExpr *win_expr = select_stmt->get_window_func_exprs().at(i);
    if (OB_ISNULL(win_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("NULL ptr", K(win_expr), K(ret));
    } else if (win_expr->get_agg_expr() != NULL &&
               win_expr->get_agg_expr()->has_flag(CNT_WINDOW_FUNC)) {
      ret = OB_ERR_INVALID_WINDOW_FUNC_USE;
      LOG_WARN("agg function's param cannot be window function", K(ret));
    } else {
      const ObIArray<ObRawExpr *> &partition_exprs = win_expr->get_partition_exprs();
      const ObIArray<OrderItem> &order_items = win_expr->get_order_items();
      ObSEArray<ObRawExpr *, 4> exprs;
      ObSEArray<ObRawExpr *, 4> arg_exprs;
      ObRawExpr *bound_expr_arr[2] = {NULL, NULL};
      bool need_check_order_datatype = (lib::is_oracle_mode()
                                       && WINDOW_RANGE == win_expr->get_window_type()
                                       && (BOUND_INTERVAL == win_expr->get_upper().type_
                                           || BOUND_INTERVAL == win_expr->get_lower().type_));
      for (int64_t j = 0; OB_SUCC(ret) && j < partition_exprs.count(); ++j) {
        ret = exprs.push_back(partition_exprs.at(j));
      }
      for (int64_t j = 0; OB_SUCC(ret) && j < order_items.count(); ++j) {
        ret = exprs.push_back(order_items.at(j).expr_);
      }
      if (OB_SUCC(ret) && win_expr->get_upper().interval_expr_ != NULL) {
        ret = exprs.push_back(win_expr->get_upper().interval_expr_);
        bound_expr_arr[0] = win_expr->get_upper().interval_expr_;
      }
      if (OB_SUCC(ret) && win_expr->get_lower().interval_expr_ != NULL) {
        ret = exprs.push_back(win_expr->get_lower().interval_expr_);
        bound_expr_arr[1] = win_expr->get_lower().interval_expr_;
      }
      for (int64_t j = 0; OB_SUCC(ret) && j < exprs.count(); ++j) {
        ObRawExpr *expr = exprs.at(j);
        if (OB_UNLIKELY(expr->has_flag(CNT_WINDOW_FUNC))) {
          ret = OB_ERR_INVALID_WINDOW_FUNC_USE;
          LOG_WARN("partition or sort or interval expr within window function nest window function not supported",
                   K(ret), K(*expr), K(j));
        }
      }
      if (OB_FAIL(ret)) {
        //do nothing...
      } else if (T_FUN_GROUP_CONCAT == win_expr->get_func_type() && NULL != win_expr->get_agg_expr() && is_oracle_mode()) {
        if (win_expr->get_agg_expr()->get_real_param_exprs().count() > 2) {
          ret = OB_INVALID_ARGUMENT_NUM;
          LOG_WARN("incorrect argument number to call listagg", K(win_expr->get_agg_expr()->get_real_param_exprs().count()));
        } else if (win_expr->get_agg_expr()->get_real_param_exprs().count() == 2) {
          if (OB_FAIL(arg_exprs.push_back(win_expr->get_agg_expr()->get_real_param_exprs().at(1)))) {
            LOG_WARN("push seperator expr failed", K(ret));
          }
        }
      } else {
        if (OB_FAIL(arg_exprs.assign(win_expr->get_func_params()))) {
          LOG_WARN("assign func param failed", K(ret));
        }
      }
      //检查分析函数参数 和 partition by是否符合要求
      if (OB_SUCC(ret) && OB_FAIL(check_win_func_arg_valid(select_stmt,
                                                           win_expr->get_func_type(),
                                                           arg_exprs,
                                                           const_cast<ObIArray<ObRawExpr *>&>(partition_exprs)))) {
        LOG_WARN("argument should be a function of expressions in PARTITION BY", K(ret));
      }
      //检查frame是range时数据类型的有效性, 规则同oracle
      if (OB_SUCC(ret) && need_check_order_datatype) {
        if (1 != order_items.count()) {
          ret = OB_ERR_INVALID_WINDOW_FUNC_USE;

          LOG_WARN("invalid window specification", K(ret), K(order_items.count()));
        } else if (OB_ISNULL(order_items.at(0).expr_)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("order by expr should not be null!", K(ret));
        } else {
          for (int64_t i = 0; OB_SUCC(ret) && i < 2; ++ i) {
            const ObObjType &order_res_type = order_items.at(0).expr_->get_data_type();
            if (bound_expr_arr[i] != NULL) {
              if (ob_is_numeric_type(bound_expr_arr[i]->get_data_type())
                  || ob_is_string_tc(bound_expr_arr[i]->get_data_type())) {
                if (!ob_is_numeric_type(order_res_type) && !ob_is_datetime_tc(order_res_type)) {
                  ret = OB_ERR_INVALID_WINDOW_FUNC_USE;
                  LOG_WARN("invalid datatype in order by for range clause", K(ret), K(order_res_type));
                }
              } else {
                //to do: 支持interval后这里要处理interval的情况
                ret = OB_ERR_INVALID_WINDOW_FUNC_USE;
                LOG_WARN("invalid datatype in order by", K(i),
                         K(bound_expr_arr[i]->get_data_type()), K(ret), K(order_res_type));
              }
            }
          }
        }
      }
      // oracle 模式下不允许对 lob 类型进行 order by
      if (OB_SUCC(ret) && lib::is_oracle_mode()) {
        for (int64_t i = 0; OB_SUCC(ret) && i < order_items.count(); ++i) {
          if (ob_is_text_tc(order_items.at(i).expr_->get_data_type())
              || ob_is_lob_tc(order_items.at(i).expr_->get_data_type())
              || ob_is_json_tc(order_items.at(i).expr_->get_data_type())
              || ob_is_geometry_tc(order_items.at(i).expr_->get_data_type())
              || ob_is_extend(order_items.at(i).expr_->get_data_type())) {
            ret = OB_ERR_INVALID_TYPE_FOR_OP;
            LOG_WARN("lob or udt expr can't order", K(ret), K(*order_items.at(i).expr_));
          }
        }
      }
      if (OB_SUCC(ret) && lib::is_oracle_mode()) {
        for (int64_t i = 0; OB_SUCC(ret) && i < partition_exprs.count(); i++) {
          ObRawExpr *param_expr = partition_exprs.at(i);
          if (OB_ISNULL(param_expr)) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("param is null", K(ret));
          } else if (ob_is_lob_locator(param_expr->get_data_type())
                    || ob_is_text_tc(param_expr->get_data_type())
                    || ob_is_extend(param_expr->get_data_type())) {
            ret = OB_ERR_INVALID_TYPE_FOR_OP;
            LOG_WARN("invalid partition by expr", K(ret), K(i), KPC(param_expr));
          }
        }
      }
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_having_exprs().count() +
         select_stmt->get_group_exprs().count(); ++i) {
    ObRawExpr *expr = i < select_stmt->get_having_exprs().count() ?
       select_stmt->get_having_exprs().at(i) :
       select_stmt->get_group_exprs().at(i - select_stmt->get_having_exprs().count());
    if (OB_ISNULL(expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("NULL ptr", K(i), K(expr));
    } else if (OB_UNLIKELY(expr->has_flag(CNT_WINDOW_FUNC))) {
      ret = OB_ERR_INVALID_WINDOW_FUNC_USE;
      LOG_WARN("window function exists in having or group scope not supported",
               K(ret), K(*expr), K(i));
    }
  }

  return ret;
}

int ObSelectResolver::check_pseudo_column_name_legal(const ObString& name)
{
  int ret = OB_SUCCESS;
  for (int64_t i = 0; OB_SUCC(ret) && i < cte_ctx_.cte_col_names_.count(); ++i) {
    if (ObCharset::case_insensitive_equal(cte_ctx_.cte_col_names_.at(i), name)) {
      ret = OB_ERR_CTE_ILLEGAL_SEARCH_PSEUDO_NAME;
      LOG_WARN("the pseudo column can not be same with the defined cte column name", K(ret));
    }
  }
  return ret;
}


/* sequence 有如下禁忌用法：
 *  1. 不能同时与 limit、having、order by、group by 等一起使用
 *  2. 不能出现在 subquery 中的任何地方 (insert into select 除外)
 *  3. 不能出现在 where 表达式里（resolve expr 处检查过了）
 **/
int ObSelectResolver::check_sequence_exprs()
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select stmt is null", K(select_stmt));
  } else if (select_stmt->has_sequence()) {
    if (select_stmt->has_limit() ||
        select_stmt->has_order_by() ||
        select_stmt->has_distinct() ||
        select_stmt->has_having() ||
        select_stmt->has_group_by() ||
        params_.is_from_create_view_) {
      ret = OB_ERR_SEQ_NOT_ALLOWED_HERE;
      LOG_WARN("sequence can not be used with create-view/select-subquery/orderby/limit/groupby/distinct", K(ret));

    }
  }
  return ret;
}

/*
 *  The recursive component of the UNION ALL in a recursive WITH clause
 *  element used an operation that was currently not supported.  The
 *  following should not be used in the recursive branch of the
 *  UNION ALL operation: GROUP BY, DISTINCT, MODEL, grouping sets,
 *  CONNECT BY, window functions, HAVING, aggregate functions.
 **/
int ObSelectResolver::check_unsupported_operation_in_recursive_branch()
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = get_select_stmt();
  if (!cte_ctx_.is_recursive()) {
    // Do nothing
  } else if (cte_ctx_.cte_resolve_level_ >= 2) {
    // Recursive table cann't be quoted in a subquery,
    // Q1:
    // with cte(c1) as (select 1 from dual union all select c1 + 1 from (select * from cte where c1 < 3) where c1 < 5) select * from cte;
    // You will got a error, 32042. 00000 -  "recursive WITH clause must reference itself directly in one of the UNION ALL branches"
    // Q2:
    // with cte(c,d) AS (SELECT c1,c2 from t1 where c1 < 3 union all select c+1, d+1 from cte, t2 where t2.c1 = c and t2.c2 > some (select c1 from t44  t99 group by c1)) select * from cte;
    // No need to check subquery at the rigth union, because recursive table cann't be here.
    // So.do nothing
  } else if (OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select stmt is null", K(select_stmt));
  } else {
    if (select_stmt->has_order_by() ||
        select_stmt->has_distinct() ||
        select_stmt->has_having() ||
        select_stmt->has_group_by() ||
        !select_stmt->get_window_func_exprs().empty() ||
        !select_stmt->get_connect_by_exprs().empty() ||
        !select_stmt->get_aggr_items().empty()) {
      ret = OB_ERR_CTE_ILLEGAL_RECURSIVE_BRANCH;
      LOG_WARN("unsupported operation in recursive branch of recursive WITH clause", K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::resolve_all_fake_cte_table_columns(const TableItem &table_item, common::ObIArray<ColumnItem> *column_items)
{
  return ObDMLResolver::resolve_all_basic_table_columns(table_item, false, column_items);
}

int ObSelectResolver::check_recursive_cte_usage(const ObSelectStmt &select_stmt)
{
  int ret = OB_SUCCESS;
  int64_t fake_cte_table_count = 0;
  for (int64_t i = 0; i < select_stmt.get_table_items().count(); ++i) {
    const TableItem *table_item = select_stmt.get_table_items().at(i);
    if (table_item->is_fake_cte_table()) {
      fake_cte_table_count++;
    }
  }
  if (cte_ctx_.invalid_recursive_union() && fake_cte_table_count >= 1) {
    ret = OB_ERR_NEED_UNION_ALL_IN_RECURSIVE_CTE;
    LOG_WARN("recursive WITH clause must use a UNION ALL operation", K(ret));
  } else if (fake_cte_table_count > 1) {
    ret = OB_ERR_CTE_RECURSIVE_QUERY_NAME_REFERENCED_MORE_THAN_ONCE;
    LOG_WARN("Recursive query name referenced more than once in recursive branch of recursive WITH clause element", K(ret), K(fake_cte_table_count));
  }
  return ret;
}

int ObSelectResolver::check_correlated_column_ref(const ObSelectStmt &select_stmt, ObRawExpr *expr, bool &correalted_query)
{
  int ret = OB_SUCCESS;
  if (expr->is_column_ref_expr()) {
    ObColumnRefRawExpr *col_expr = static_cast<ObColumnRefRawExpr*>(expr);
    uint64_t table_id = col_expr->get_table_id();
    const TableItem *table_item = nullptr;
    if (nullptr == (table_item = select_stmt.get_table_item_by_id(table_id))) {
      correalted_query = true;
      LOG_WARN("Column expr not in this stmt", K(ret));
    } else {
      LOG_DEBUG("Find table item", K(*select_stmt.get_table_item_by_id(table_id)));
    }
  }
  if (!correalted_query) {
    int64_t param_expr_count = expr->get_param_count();
    for (int64_t i = 0; i < param_expr_count && !correalted_query; ++i) {
      ObRawExpr *param_expr = expr->get_param_expr(i);
      if (OB_ISNULL(param_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("Param expr is null", K(ret));
      } else if (OB_FAIL(SMART_CALL(check_correlated_column_ref(select_stmt, param_expr,
                                                                correalted_query)))) {
        LOG_WARN("Failed to check correlated column", K(ret));
      }
    }
  }
  return ret;
}

int ObSelectResolver::check_ntile_compatiable_with_mysql(ObWinFunRawExpr *win_expr)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(win_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("win expr is null.", K(ret));
  } else if (T_WIN_FUN_NTILE == win_expr->get_func_type() && lib::is_mysql_mode()) {
    if (1 != win_expr->get_func_params().count()) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("ntile param count should be 1", K(ret));
    } else {
      ObRawExpr *func_param = win_expr->get_func_params().at(0);
      bool is_valid = true;
      if (OB_ISNULL(func_param)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("param is null", K(ret));
      } else if (OB_FAIL(check_ntile_validity(func_param, is_valid))) {
        LOG_WARN("failed to check ntile validity", K(ret));
      } else if (!is_valid) {
        ret = OB_ERR_NOT_CONST_EXPR;
        LOG_WARN("The argument of the window function should be a constant for a partition", K(ret), K(*func_param));
      }
    }
  }
  return ret;
}

int ObSelectResolver::check_ntile_validity(const ObRawExpr *expr,
                                           bool &is_valid)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr is null", K(ret));
  } else if (expr->is_column_ref_expr() ||
             expr->is_aggr_expr() ||
             expr->is_win_func_expr() ||
             expr->get_expr_type() == T_FUN_SYS_RAND) {
    is_valid = false;
  } else if (expr->is_exec_param_expr()) {
    if (OB_FAIL(SMART_CALL(check_ntile_validity(static_cast<const ObExecParamRawExpr *>(expr)->get_ref_expr(),
                                                is_valid)))) {
      LOG_WARN("failed to check ntile validity", K(ret));
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < expr->get_param_count(); ++i) {
    if (OB_FAIL(SMART_CALL(check_ntile_validity(expr->get_param_expr(i),
                                                is_valid)))) {
      LOG_WARN("failed to check ntile validity", K(ret));
    }
  }
  if (OB_SUCC(ret) && expr->is_query_ref_expr()) {
    if (OB_FAIL(SMART_CALL(check_ntile_validity(static_cast<const ObQueryRefRawExpr *>(expr)->get_ref_stmt(),
                                                is_valid)))) {
      LOG_WARN("failed to check ntile validity", K(ret));
    }
  }
  return ret;
}

int ObSelectResolver::check_ntile_validity(const ObSelectStmt *stmt,
                                           bool &is_valid) {
  int ret = OB_SUCCESS;
  ObArray<ObSelectStmt*> child_stmts;
  ObArray<ObRawExpr *> relation_exprs;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else if (stmt->get_column_size() > 0 ||
             stmt->get_window_func_count() > 0 ||
             stmt->get_aggr_item_size() > 0) {
    is_valid = false;
  } else if (OB_FAIL(stmt->get_child_stmts(child_stmts))) {
    LOG_WARN("failed to get child stmts", K(ret));
  } else if (OB_FAIL(stmt->get_relation_exprs(relation_exprs))) {
    LOG_WARN("failed to get relation exprs", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < relation_exprs.count(); ++i) {
    if (OB_FAIL(check_ntile_validity(relation_exprs.at(i), is_valid))) {
      LOG_WARN("failed to check ntile validity", K(ret));
    }
  }
  for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < child_stmts.count(); ++i) {
    if (OB_FAIL(check_ntile_validity(child_stmts.at(i), is_valid))) {
      LOG_WARN("failed to check ntile validity", K(ret));
    }
  }
  return ret;
}

/**
 * oracle在select item中如果有子查询，当且仅当
 * 子查询为exists、not exists的参数时，
 * 允许子查询返回多列，
 */
int ObSelectResolver::check_subquery_return_one_column(const ObRawExpr &expr, bool is_exists_param)
{
  int ret = OB_SUCCESS;
  if (T_FUN_UDF == expr.get_expr_type()) {
    // select ff(cursor(select * from tbl)) from dual;
    // do nothing
  } else if (expr.has_flag(IS_SUB_QUERY)) {
    const ObQueryRefRawExpr &query_expr = static_cast<const ObQueryRefRawExpr&>(expr);
    if (1 != query_expr.get_output_column() && !is_exists_param) {
      ret = OB_ERR_TOO_MANY_VALUES;
      LOG_WARN("subquery return too many columns", K(query_expr.get_output_column()));
    }
  } else {
    bool is_exists_param = T_OP_EXISTS == expr.get_expr_type() || T_OP_NOT_EXISTS == expr.get_expr_type();
    for (int64_t i = 0; OB_SUCC(ret) && i < expr.get_param_count(); ++i) {
      const ObRawExpr *cur_expr = expr.get_param_expr(i);
      if (OB_ISNULL(cur_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get null expr", K(ret));
      } else if (!cur_expr->has_flag(CNT_SUB_QUERY)) {
        // do nothing
      } else if (OB_FAIL(check_subquery_return_one_column(*cur_expr, is_exists_param))) {
        LOG_WARN("failed to check subquery return one column", K(ret));
      }
    }
  }
  return ret;
}


/*fetch clause:
*[OFFSET offset {ROW | ROWS}] FETCH {NEXT | FIRST} {rowcount| percent PERCENT} {ROW | ROWS} {ONLY | WITH TIES}
 */
int ObSelectResolver::resolve_fetch_clause(const ParseNode *node)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(params_.expr_factory_) || OB_ISNULL(session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(params_.expr_factory_));
  } else if (lib::is_oracle_mode() && NULL != node) {
    current_scope_ = T_LIMIT_SCOPE;
    ObSelectStmt *select_stmt = get_select_stmt();
    select_stmt->set_has_fetch(true);
    ParseNode *limit_node = NULL;
    ParseNode *offset_node = NULL;
    ParseNode *percent_node = NULL;
    if (node->type_ == T_FETCH_CLAUSE) {
      offset_node = node->children_[0];
      limit_node = node->children_[1];
      percent_node = node->children_[2];
    } else if (node->type_ == T_FETCH_TIES_CLAUSE) {
      offset_node = node->children_[0];
      limit_node = node->children_[1];
      percent_node = node->children_[2];
      if (select_stmt->has_order_by()) {
        select_stmt->set_fetch_with_ties(true);
      }
    }
    ObRawExpr* limit_offset = NULL;
    ObRawExpr* case_limit_offset = NULL;
    ObRawExpr* limit_count = NULL;
    ObRawExpr* case_limit_count = NULL;
    ObRawExpr* limit_percent = NULL;
    //1.处理offset node,由于oracle支持为常量的double类型，但是对于行数来说，本质上为整型，同时兼容oracle行为，
    //  向下取整，由于老引擎cast函数转换时无法保证向下取整，所以需要显示分配一个floor函数
    if (offset_node != NULL) {
      ObSysFunRawExpr *floor_offset_expr = NULL;
      if (OB_FAIL(resolve_sql_expr(*offset_node, limit_offset))) {
        LOG_WARN("failed to resolve sql expr", K(ret));
      } else if (OB_ISNULL(limit_offset)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret), K(limit_offset));
      } else if (!limit_offset->is_const_expr()) {
        ret = OB_ERR_INVALID_SQL_ROW_LIMITING;
        LOG_WARN("Invalid SQL ROW LIMITING expression was specified", K(ret));
      } else if (OB_FAIL(params_.expr_factory_->create_raw_expr(T_FUN_SYS_FLOOR,
                                                                floor_offset_expr))) {
        LOG_WARN("failed to create fun sys floor", K(ret));
      } else if (OB_ISNULL(floor_offset_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("floor expr is null", K(ret));
      } else if (OB_FAIL(floor_offset_expr->set_param_expr(limit_offset))) {
        LOG_WARN("failed to set param expr", K(ret));
      //保证offset为非负数,避免在计划生成时转换limit + offset出现负数,需要进行二次处理
      } else if (OB_ISNULL(limit_offset = floor_offset_expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret), K(limit_offset));
      } else {
        floor_offset_expr->set_func_name(ObString::make_string("FLOOR"));
        ObExprResType dst_type;
        dst_type.set_int();
        ObSysFunRawExpr *cast_expr = NULL;
        OZ(ObRawExprUtils::create_cast_expr(
                *params_.expr_factory_, limit_offset, dst_type, cast_expr, session_info_));
        CK(NULL != cast_expr);
        OX(limit_offset = cast_expr);
        OZ(limit_offset->add_flag(IS_INNER_ADDED_EXPR));
      }
    }
    //2.1 处理fetch node ==> limit count同上，可以在resolve阶段提前计算出结果
    if (OB_SUCC(ret)) {
      if (limit_node != NULL) {
        ObSysFunRawExpr *floor_count_expr = NULL;
        if (OB_FAIL(resolve_sql_expr(*limit_node, limit_count))) {
          LOG_WARN("failed to resolve sql expr", K(ret));
        } else if (OB_ISNULL(limit_count)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret), K(limit_count));
        } else if (!limit_count->is_const_expr()) {
          ret = OB_ERR_INVALID_SQL_ROW_LIMITING;
          LOG_WARN("Invalid SQL ROW LIMITING expression was specified", K(ret));
        } else if (OB_FAIL(params_.expr_factory_->create_raw_expr(T_FUN_SYS_FLOOR,
                                                                  floor_count_expr))) {
          LOG_WARN("failed to create fun sys floor", K(ret));
        } else if (OB_ISNULL(floor_count_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("floor expr is null", K(ret));
        } else if (OB_FAIL(floor_count_expr->set_param_expr(limit_count))) {
          LOG_WARN("failed to set param expr", K(ret));
        //保证limit为非负数,避免在计划生成时转换limit + offset出现负数,在preprocess进行二次处理
        } else if (OB_ISNULL(limit_count = floor_count_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret), K(limit_count));
        } else {
          floor_count_expr->set_func_name(ObString::make_string("FLOOR"));
          ObExprResType dst_type;
          dst_type.set_int();
          ObSysFunRawExpr *cast_expr = NULL;
          OZ(ObRawExprUtils::create_cast_expr(
                  *params_.expr_factory_, limit_count, dst_type, cast_expr, session_info_));
          CK(NULL != cast_expr);
          OX(limit_count = cast_expr);
          OZ(limit_count->add_flag(IS_INNER_ADDED_EXPR));
        }
      }
    }
    //2.2 处理fetch node ==> limit percent，由于这里计算的为总行数的百分比,因此不能直接转为int,同时考虑计算的总
    //                                     行时存在小数，因此这里统一设置百分比为double类型
    if (OB_SUCC(ret)) {
      if (percent_node != NULL) {
        if (OB_FAIL(resolve_sql_expr(*percent_node, limit_percent))) {
          LOG_WARN("failed to resolve sql expr", K(ret));
        } else if (OB_ISNULL(limit_percent)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret), K(limit_percent));
        } else if (!limit_percent->is_const_expr()) {
          ret = OB_ERR_INVALID_SQL_ROW_LIMITING;
          LOG_WARN("Invalid SQL ROW LIMITING expression was specified", K(ret));
        } else {
          ObExprResType dst_type;
          dst_type.set_double();
          ObSysFunRawExpr *cast_expr = NULL;
          OZ(ObRawExprUtils::create_cast_expr(
                  *params_.expr_factory_, limit_percent, dst_type, cast_expr, session_info_));
          CK(NULL != cast_expr);
          OX(limit_percent = cast_expr);
          OZ(limit_percent->add_flag(IS_INNER_ADDED_EXPR));
        }
      }
    }
    if (OB_SUCC(ret)) {
      select_stmt->set_fetch_info(limit_offset, limit_count, limit_percent);
    }
  }
  return ret;
}

int ObSelectResolver::resolve_check_option_clause(const ParseNode *node)
{
  int ret = OB_SUCCESS;
  if (NULL != node) {
    const int64_t node_value = node->value_;
    ObSelectStmt *select_stmt = get_select_stmt();
    if (OB_UNLIKELY(node_value < 0 || node_value >= static_cast<int64_t>(VIEW_CHECK_OPTION_MAX))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected check option node value", K(ret), K(node_value));
    } else if (OB_ISNULL(select_stmt)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("select stmt is null", K(ret));
    } else {
      select_stmt->set_check_option(static_cast<ViewCheckOption>(node_value));
    }
  }
  return ret;
}

int ObSelectResolver::check_multi_rollup_items_valid(
                                              const ObIArray<ObMultiRollupItem> &multi_rollup_items)
{
  int ret = OB_SUCCESS;
  for (int64_t i = 0; OB_SUCC(ret) && i < multi_rollup_items.count(); i++) {
    const ObIArray<ObGroupbyExpr> &rollup_list_exprs = multi_rollup_items.at(i).rollup_list_exprs_;
    for (int64_t j = 0; OB_SUCC(ret) && j < rollup_list_exprs.count(); ++j) {
      const ObIArray<ObRawExpr*> &groupby_exprs = rollup_list_exprs.at(j).groupby_exprs_;
      for (int64_t k = 0; OB_SUCC(ret) && k < groupby_exprs.count(); ++k) {
        ObRawExpr *groupby_expr = NULL;
        if (OB_ISNULL(groupby_expr = groupby_exprs.at(k))) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("rollup expr is null", K(ret));
        } else if (ObLongTextType == groupby_expr->get_data_type()
                  || ObLobType == groupby_expr->get_data_type()
                  || ObJsonType == groupby_expr->get_data_type()
                  || ObGeometryType == groupby_expr->get_data_type()
                  || ObExtendType == groupby_expr->get_data_type()) {
          ret = OB_ERR_INVALID_TYPE_FOR_OP;
          LOG_WARN("group by lob or udt expr is not allowed", K(ret));
        }
      }
    }
  }
  return ret;
}

int ObSelectResolver::recursive_check_grouping_columns(ObSelectStmt *stmt, ObRawExpr *expr)
{
  int ret = OB_SUCCESS;
  ObAggFunRawExpr *c_expr = NULL;
  if (OB_ISNULL(stmt) || OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(stmt), K(expr));
  } else if (!expr->has_flag(CNT_AGG)) {
    /*do nothing*/
  } else if (T_FUN_GROUPING == expr->get_expr_type()) {
    if (OB_ISNULL(c_expr = static_cast<ObAggFunRawExpr*>(expr))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unable to convert expr to ObAggFunRawExpr", K(ret));
    } else if (c_expr->is_nested_aggr()) {
      ret = OB_ERR_GROUP_FUNC_NOT_ALLOWED;
      LOG_WARN("grouping shouldn't be nested", K(ret));
    } else if (1 != c_expr->get_real_param_exprs().count() ||
               OB_ISNULL(c_expr->get_real_param_exprs().at(0))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("check grouping has unexpected err", K(ret));      
    } else if (OB_FAIL(check_grouping_columns(*stmt,
                                  c_expr->get_real_param_exprs_for_update().at(0)))) {
      LOG_WARN("failed to check grouping columns", K(ret));
    } else {
      assign_grouping();
    }
  } else if (T_FUN_GROUPING_ID == expr->get_expr_type()) {
    if (OB_ISNULL(c_expr = static_cast<ObAggFunRawExpr*>(expr))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unable to convert expr to ObAggFunRawExpr", K(ret));
    } else if (c_expr->is_nested_aggr()) {
      ret = OB_ERR_GROUP_FUNC_NOT_ALLOWED;
      LOG_WARN("grouping shouldn't be nested", K(ret));
    } else if (c_expr->get_real_param_count() < 1) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("check grouping_id has unexpected err", K(ret));
    } else {
      for (int64_t i = 0; OB_SUCC(ret) && i < c_expr->get_real_param_count(); i++) {
        if (OB_FAIL(check_grouping_columns(*stmt,
                                  c_expr->get_real_param_exprs_for_update().at(i)))) {
          LOG_WARN("fail to check grouping columns", K(ret));
        }
      }
    }
  } else if (T_FUN_GROUP_ID == expr->get_expr_type()) {
    if (OB_ISNULL(c_expr = static_cast<ObAggFunRawExpr*>(expr))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unable to convert expr to ObAggFunRawExpr", K(ret));
    } else if (c_expr->is_nested_aggr()) {
      ret = OB_ERR_GROUP_FUNC_NOT_ALLOWED;
      LOG_WARN("group_id shouldn't be nested", K(ret));
    }
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
      if (OB_FAIL(SMART_CALL(recursive_check_grouping_columns(stmt, expr->get_param_expr(i))))) {
        LOG_WARN("failed to recursive check grouping columns", K(ret));
      } else {/*do nothing*/}
    }
  }
  return ret;
}


int ObSelectResolver::add_name_for_anonymous_view()
{
  int ret = OB_SUCCESS;
  ObSelectStmt *stmt = get_select_stmt();
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null pointer", K(ret));
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_table_size(); i++) {
      TableItem *tmp_table = stmt->get_table_item(i);
      if (OB_ISNULL(tmp_table)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null pointer", K(ret));
      } else if (tmp_table->is_generated_table()
                && tmp_table->alias_name_.empty()
                && tmp_table->table_name_.empty()) {
        // found anonymous view, generate new name.
        if (OB_FAIL(stmt->generate_anonymous_view_name(*params_.allocator_, tmp_table->table_name_))) {
          LOG_WARN("fail to generate view name", K(ret));
        }
      }
    }
  }

  return ret;
}

}  // namespace sql
}  // namespace oceanbase