/** * 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 ¶ms) : 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(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 left_child_stmts; ObSEArray 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 &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 left_child_stmts; ObSEArray 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 &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 &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 order_item_exprs; common::ObIArray &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 select_item_exprs; common::ObIArray &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 &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(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 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 &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())) { 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(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 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(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(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(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(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 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(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(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(alias_node->str_value_), static_cast(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(""), "", (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(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(alias_node->str_value_), static_cast(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(alias_node->str_value_), static_cast(alias_node->str_len_)); } } } else if (T_REF_COLUMN == sel_expr->get_expr_type()) { // deal with generated column ObColumnRefRawExpr *ref_expr = dynamic_cast(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(alias_node->str_value_), static_cast(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(alias_node->str_value_), static_cast(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(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(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(alias_node->str_value_), static_cast(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 ¶m_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 &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 &target_list) { int ret = OB_SUCCESS; ObArray 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(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 &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 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 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 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 *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 *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 *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(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 table_items; ObArray 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 *left, const ObIArray *right, const ObJoinType type, const ObIArray &using_columns, ObIArray *coalesced_columns) { int ret = OB_SUCCESS; ObArray coalesced_column_ids; const ObIArray *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(coalesced_columns->at(dup_col_index).expr_)->set_joined_dup_column(true); static_cast(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 *sorted_select_items) { int ret = OB_SUCCESS; ObArray left_select_items; ObArray right_select_items; if (jointable->left_table_->type_ == TableItem::JOINED_TABLE) { OC( (find_select_columns_for_joined_table_recursive)( static_cast(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(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 *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 &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(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 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(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(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& 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 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(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(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(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(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(search_set_clause->str_len_)); ObString cycle_set_column_name; cycle_set_column_name.assign_ptr((char *) (cycle_set_clause->str_value_), static_cast(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(cycle_value_node->str_len_)); non_cycle_value.assign_ptr((char *) (non_cycle_value_node->str_value_), static_cast(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(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 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& groupby_exprs = select_stmt->get_group_exprs(); common::ObIArray& rollup_exprs = select_stmt->get_rollup_exprs(); common::ObSEArray 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 &groupby_exprs, common::ObIArray &rollup_exprs, common::ObIArray &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 &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 dummy_groupby_exprs; ObSEArray 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 dummy_rollup_exprs; ObSEArray 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 &groupby_exprs, common::ObIArray &rollup_exprs, common::ObIArray &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 &groupby_exprs, common::ObIArray &rollup_exprs, common::ObIArray &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 &groupby_exprs, common::ObIArray &rollup_exprs, common::ObIArray &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 &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 &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 &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 &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 &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 &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(¶ms_.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(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(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(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 &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(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 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(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 (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(q_name).current_resolve_level_ = current_level_)) { } else if (q_name.parents_expr_info_.has_member(IS_AGG)) { const_cast(q_name).parent_aggr_level_ = current_level_; } else { const_cast(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(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 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(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(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(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 &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 &aggr_exprs) { int ret = OB_SUCCESS; ObSelectStmt *stmt = static_cast(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 param_aggrs; ObArray 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 &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 &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(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(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(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 &arg_exp_arr, common::ObIArray &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 &partition_exprs = win_expr->get_partition_exprs(); const ObIArray &order_items = win_expr->get_order_items(); ObSEArray exprs; ObSEArray 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&>(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 *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(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(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(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 child_stmts; ObArray 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(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(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(node_value)); } } return ret; } int ObSelectResolver::check_multi_rollup_items_valid( const ObIArray &multi_rollup_items) { int ret = OB_SUCCESS; for (int64_t i = 0; OB_SUCC(ret) && i < multi_rollup_items.count(); i++) { const ObIArray &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 &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(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(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(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