hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
7887fcce92dce31b03a70f9168db540d02fc0996
oceanbase/src/sql/rewrite/ob_transform_min_max.cpp

593 lines
25 KiB
C++
Raw Blame History

/**
* Copyright (c) 2021 OceanBase
* OceanBase CE is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
*/
#define USING_LOG_PREFIX SQL_REWRITE
#include "ob_transform_min_max.h"
#include "ob_transformer_impl.h"
#include "lib/allocator/ob_allocator.h"
#include "lib/oblog/ob_log_module.h"
#include "common/ob_common_utility.h"
#include "common/ob_smart_call.h"
#include "share/schema/ob_column_schema.h"
#include "share/schema/ob_table_schema.h"
#include "sql/resolver/ob_resolver_utils.h"
#include "sql/resolver/dml/ob_select_stmt.h"
#include "sql/resolver/expr/ob_raw_expr.h"
#include "sql/resolver/expr/ob_raw_expr_util.h"
#include "sql/resolver/expr/ob_raw_expr_resolver_impl.h"
#include "sql/ob_sql_context.h"
#include "sql/rewrite/ob_transform_utils.h"
#include "sql/optimizer/ob_optimizer_util.h"
using namespace oceanbase::common;
using namespace oceanbase::share::schema;
namespace oceanbase
{
namespace sql
{
ObTransformMinMax::ObTransformMinMax(ObTransformerCtx *ctx)
: ObTransformRule(ctx, TransMethod::POST_ORDER, T_FAST_MINMAX)
{
}
ObTransformMinMax::~ObTransformMinMax()
{
}
int ObTransformMinMax::transform_one_stmt(common::ObIArray<ObParentDMLStmt> &parent_stmts,
ObDMLStmt *&stmt,
bool &trans_happened)
{
int ret = OB_SUCCESS;
bool is_valid = false;
trans_happened = false;
UNUSED(parent_stmts);
if (OB_ISNULL(stmt) || OB_ISNULL(ctx_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(stmt), K(ctx_));
} else if (!stmt->is_select_stmt()) {
//do nothing
OPT_TRACE("not select stmt");
} else if (OB_FAIL(check_transform_validity(*ctx_,
static_cast<ObSelectStmt *>(stmt),
is_valid))) {
LOG_WARN("failed to check transform validity", K(ret));
} else if (!is_valid) {
//do nothing
OPT_TRACE("can not do min max transform");
} else if (OB_FAIL(do_transform(static_cast<ObSelectStmt *>(stmt)))) {
LOG_WARN("failed to transform column aggregate", K(ret));
} else if (OB_FAIL(add_transform_hint(*stmt))) {
LOG_WARN("failed to add transform hint", K(ret));
} else {
trans_happened = true;
}
return ret;
}
int ObTransformMinMax::check_transform_validity(ObTransformerCtx &ctx,
ObSelectStmt *select_stmt,
bool &is_valid)
{
int ret = OB_SUCCESS;
is_valid = false;
bool has_rownum = false;
if (OB_ISNULL(select_stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(select_stmt));
} else if (select_stmt->has_recursive_cte() || select_stmt->has_hierarchical_query()) {
OPT_TRACE("stmt has recusive cte or hierarchical query");
} else if (select_stmt->get_from_item_size() != 1 || select_stmt->get_from_item(0).is_joined_
|| select_stmt->get_aggr_item_size() < 1 || !select_stmt->is_scala_group_by()
|| select_stmt->is_contains_assignment()
|| (select_stmt->get_aggr_item_size() > 1 && select_stmt->get_semi_info_size() > 0)) {
OPT_TRACE("not a simple aggr query");
} else if (OB_FAIL(select_stmt->has_rownum(has_rownum))) {
LOG_WARN("failed to check if select stmt has rownum", K(ret));
} else if (has_rownum) {
OPT_TRACE("stmt has rownum");
} else if (OB_FAIL(is_valid_aggr_items(ctx, *select_stmt, is_valid))) {
LOG_WARN("failed to check aggr items", K(ret));
} else if (!is_valid) {
OPT_TRACE("aggr expr is invalid");
} else if (OB_FAIL(is_valid_select_list(*select_stmt, is_valid))) {
LOG_WARN("failed to check is valid select list", K(ret));
} else if (!is_valid) {
OPT_TRACE("select list is not const or aggr_expr");
} else if (OB_FAIL(is_valid_having_list(*select_stmt, is_valid))) {
LOG_WARN("failed to check is valid having", K(ret));
} else if (!is_valid) {
OPT_TRACE("having condition is invalid");
} else if (select_stmt->get_aggr_item_size() > 1 && OB_FAIL(is_valid_order_list(*select_stmt, is_valid))) {
LOG_WARN("failed to check is valid order by", K(ret));
} else if (!is_valid) {
OPT_TRACE("order by is invalid for multi min/max");
} else {
LOG_TRACE("Succeed to check minmax transform validity", K(is_valid));
}
return ret;
}
int ObTransformMinMax::do_transform(ObSelectStmt *select_stmt)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(select_stmt)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("params have null", K(ret), K(select_stmt));
} else if (select_stmt->get_aggr_item_size() == 1) {
if (OB_FAIL(do_single_minmax_transform(select_stmt))) {
LOG_WARN("failed to transform single minmax", K(ret));
}
} else if (select_stmt->get_aggr_item_size() > 1) {
if (OB_FAIL(do_multi_minmax_transform(select_stmt))) {
LOG_WARN("failed to transform multi minmax", K(ret));
}
}
return ret;
}
int ObTransformMinMax::do_single_minmax_transform(ObSelectStmt *select_stmt)
{
int ret = OB_SUCCESS;
ObRawExpr *aggr_param = NULL;
ObRawExpr *new_aggr_param = NULL;
ObSelectStmt *child_stmt = NULL;
ObSEArray<ObRawExpr*, 1> old_exprs;
ObSEArray<ObRawExpr*, 1> new_exprs;
if (OB_ISNULL(select_stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("params have null", K(ret), K(select_stmt), K(ctx_));
} else if (select_stmt->get_aggr_item_size() != 1) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected param", K(ret));
} else {
ObAggFunRawExpr *aggr_expr = select_stmt->get_aggr_item(0);
ObRawExprCopier copier(*ctx_->expr_factory_);
if (OB_ISNULL(aggr_expr) || OB_ISNULL(aggr_param = aggr_expr->get_param_expr(0))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("aggr expr unexpected null", K(ret));
} else if (OB_FAIL(ObTransformUtils::create_simple_view(ctx_, select_stmt, child_stmt))) {
LOG_WARN("failed to create simple view", K(ret));
} else if (OB_FAIL(select_stmt->get_column_exprs(old_exprs))) {
LOG_WARN("failed to get column exprs", K(ret));
} else if (OB_FAIL(child_stmt->get_select_exprs(new_exprs))) {
LOG_WARN("failed to get select exprs", K(ret));
} else if (OB_FAIL(copier.add_replaced_expr(old_exprs, new_exprs))) {
LOG_WARN("failed to add replace pair", K(ret));
} else if (OB_FAIL(copier.copy(aggr_param, new_aggr_param))) {
LOG_WARN("failed to copy expr", K(ret));
} else if (OB_FAIL(set_child_condition(child_stmt, new_aggr_param))) {
LOG_WARN("failed to set child condition", K(ret));
} else if (OB_FAIL(set_child_order_item(child_stmt, new_aggr_param, aggr_expr->get_expr_type()))) {
LOG_WARN("failed to set child order item", K(ret));
} else if (OB_FAIL(ObTransformUtils::set_limit_expr(child_stmt, ctx_))) {
LOG_WARN("failed to set child limit item", K(ret));
} else {
LOG_TRACE("Succeed to do transform min max", K(*select_stmt));
}
}
return ret;
}
int ObTransformMinMax::do_multi_minmax_transform(ObSelectStmt *select_stmt)
{
int ret = OB_SUCCESS;
ObSelectStmt *view_child_stmt = NULL;
ObSelectStmt *child_stmt = NULL;
ObAggFunRawExpr *aggr_expr = NULL;
ObRawExpr *aggr_param = NULL;
ObRawExpr *new_aggr_param = NULL;
ObSEArray<ObRawExpr*, 1> old_exprs;
ObSEArray<ObRawExpr*, 1> new_exprs;
ObArray<ObRawExpr *> aggr_items;
ObArray<ObRawExpr *> query_ref_exprs;
ObQueryRefRawExpr *query_ref_expr = NULL;
ObRawExpr *target_expr = NULL;
if (OB_ISNULL(select_stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("params have null", K(ret), K(select_stmt), K(ctx_));
} else {
ObRawExprCopier copier(*ctx_->expr_factory_);
if (OB_FAIL(ObTransformUtils::create_simple_view(ctx_, select_stmt, view_child_stmt))) {
LOG_WARN("failed to create simple view", K(ret));
} else if (OB_FAIL(select_stmt->get_column_exprs(old_exprs))) {
LOG_WARN("failed to get column exprs", K(ret));
} else if (OB_FAIL(view_child_stmt->get_select_exprs(new_exprs))) {
LOG_WARN("failed to get select exprs", K(ret));
} else if (OB_FAIL(copier.add_replaced_expr(old_exprs, new_exprs))) {
LOG_WARN("failed to add replace pair", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_aggr_item_size(); ++i) {
if (OB_ISNULL(aggr_expr = select_stmt->get_aggr_item(i))
|| OB_ISNULL(aggr_param = aggr_expr->get_param_expr(0))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(copier.copy(aggr_param, new_aggr_param))) {
LOG_WARN("failed to copy expr", K(ret));
} else if (OB_FAIL(deep_copy_subquery_for_aggr(*view_child_stmt,
new_aggr_param,
aggr_expr->get_expr_type(),
child_stmt))) {
LOG_WARN("failed to deep copy subquery for aggr", K(ret));
} else if (OB_FAIL(aggr_items.push_back(aggr_expr))) {
LOG_WARN("failed to push back aggr item", K(ret));
} else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_REF_QUERY, query_ref_expr))) {
LOG_WARN("failed to create query ref expr", K(ret));
} else if (OB_ISNULL(query_ref_expr) || OB_ISNULL(child_stmt)
|| OB_UNLIKELY(child_stmt->get_select_item_size() != 1)
|| OB_ISNULL(target_expr = child_stmt->get_select_item(0).expr_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null expr or select item size of child stmt", K(ret));
} else {
query_ref_expr->set_ref_stmt(child_stmt);
query_ref_expr->set_output_column(1);
if (OB_FAIL(query_ref_expr->add_column_type(target_expr->get_result_type()))) {
LOG_WARN("add column type to subquery ref expr failed", K(ret));
} else if (OB_FAIL(query_ref_expr->formalize(ctx_->session_info_))) {
LOG_WARN("failed to formalize coalesce query expr", K(ret));
} else if (OB_FAIL(query_ref_exprs.push_back(query_ref_expr))) {
LOG_WARN("failed to push back query ref expr", K(ret));
}
}
}
// adjust select_stmt
if (OB_FAIL(ret)) {
} else if (OB_FAIL(select_stmt->replace_relation_exprs(aggr_items, query_ref_exprs))) {
LOG_WARN("failed to replace aggr exprs to query ref exprs", K(ret));
} else if (OB_FAIL(select_stmt->get_condition_exprs().assign(select_stmt->get_having_exprs()))) {
LOG_WARN("failed to assign condition exprs", K(ret));
} else {
select_stmt->get_from_items().reset();
select_stmt->get_table_items().reset();
select_stmt->get_aggr_items().reset();
select_stmt->get_having_exprs().reset();
select_stmt->get_column_items().reset();
if (OB_FAIL(select_stmt->adjust_subquery_list())) {
LOG_WARN("failed to adjust subquery list", K(ret));
} else if (OB_FAIL(select_stmt->formalize_stmt(ctx_->session_info_))) {
LOG_WARN("failed to formalize stmt", K(ret));
} else {
LOG_TRACE("succeed to do transform min max", KPC(select_stmt));
}
}
}
return ret;
}
int ObTransformMinMax::deep_copy_subquery_for_aggr(const ObSelectStmt &copied_stmt,
ObRawExpr *aggr_param,
ObItemType aggr_type,
ObSelectStmt *&child_stmt)
{
int ret = OB_SUCCESS;
ObDMLStmt *dml_stmt = NULL;
ObRawExpr *new_aggr_param = NULL;
ObString qb_name;
TableItem *table = NULL;
ObArray<ObRawExpr *> select_exprs;
ObArray<ObRawExpr *> new_select_exprs;
int64_t new_aggr_param_index = -1;
if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_) || OB_ISNULL(ctx_->stmt_factory_)
|| OB_ISNULL(ctx_->allocator_) || OB_ISNULL(aggr_param)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("params have null", K(ret), K(aggr_param), K(ctx_));
} else if (OB_FAIL(ObTransformUtils::deep_copy_stmt(*ctx_->stmt_factory_,
*ctx_->expr_factory_,
&copied_stmt,
dml_stmt))) {
LOG_WARN("failed to deep copy stmt", K(ret));
} else if (OB_ISNULL(child_stmt = static_cast<ObSelectStmt *>(dml_stmt))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("child stmt is null", K(ret));
} else if (OB_FAIL(child_stmt->adjust_statement_id(ctx_->allocator_,
ctx_->src_qb_name_,
ctx_->src_hash_val_))) {
LOG_WARN("failed to adjust statement id", K(ret));
} else if (OB_FAIL(child_stmt->get_qb_name(qb_name))) {
LOG_WARN("failed to get qb name", K(ret));
} else if (child_stmt->get_table_size() != 1
|| OB_ISNULL(table = child_stmt->get_table_item(0))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected table size or table item is null", K(ret), KPC(child_stmt));
} else if (OB_FALSE_IT(table->qb_name_ = qb_name)) {
} else if (OB_FAIL(child_stmt->update_stmt_table_id(ctx_->allocator_, copied_stmt))) {
LOG_WARN("failed to update stmt table id", K(ret));
} else if (OB_FAIL(copied_stmt.get_select_exprs(select_exprs))) {
LOG_WARN("failed to get select exprs", K(ret));
} else if (!ObOptimizerUtil::find_item(select_exprs, aggr_param, &new_aggr_param_index)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("failed to find new aggr param", K(ret));
} else if (OB_FAIL(child_stmt->get_select_exprs(new_select_exprs))) {
LOG_WARN("failed to get select exprs", K(ret));
} else if (new_aggr_param_index < 0 || new_aggr_param_index >= new_select_exprs.count()
|| OB_ISNULL(new_aggr_param = new_select_exprs.at(new_aggr_param_index))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("failed to find new aggr param", K(ret));
} else {
child_stmt->get_select_items().reset();
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(ObTransformUtils::create_select_item(*ctx_->allocator_,
new_aggr_param,
child_stmt))) {
LOG_WARN("failed to create select item", K(ret));
} else if (OB_FAIL(set_child_condition(child_stmt, new_aggr_param))) {
LOG_WARN("failed to set child condition", K(ret));
} else if (OB_FAIL(set_child_order_item(child_stmt, new_aggr_param, aggr_type))) {
LOG_WARN("failed to set child order item", K(ret));
} else if (OB_FAIL(ObTransformUtils::set_limit_expr(child_stmt, ctx_))) {
LOG_WARN("failed to set child limit item", K(ret));
} else if (OB_FAIL(child_stmt->rebuild_tables_hash())) {
LOG_WARN("failed to rebuild table hash", K(ret));
} else if (OB_FAIL(child_stmt->update_column_item_rel_id())) {
LOG_WARN("failed to update column item by id", K(ret));
} else if (OB_FAIL(child_stmt->formalize_stmt(ctx_->session_info_))) {
LOG_WARN("failed to formalize stmt", K(ret));
}
return ret;
}
int ObTransformMinMax::is_valid_aggr_items(ObTransformerCtx &ctx,
const ObSelectStmt &stmt,
bool &is_valid)
{
int ret = OB_SUCCESS;
const ObAggFunRawExpr *expr = NULL;
bool valid = true;
EqualSets &equal_sets = ctx.equal_sets_;
ObSEArray<ObRawExpr *, 4> const_exprs;
ObSEArray<const ObRawExpr *, 4> valid_col_exprs;
ObArenaAllocator alloc(ObMemAttr(MTL_ID(), "RewriteMinMax"));
if (OB_FAIL(stmt.get_stmt_equal_sets(equal_sets, alloc, true))) {
LOG_WARN("failed to get stmt equal sets", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::compute_const_exprs(stmt.get_condition_exprs(),
const_exprs))) {
LOG_WARN("failed to compute const equivalent exprs", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && valid && i < stmt.get_aggr_item_size(); ++i) {
if (OB_ISNULL(expr = stmt.get_aggr_item(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("params have null", K(ret), KP(expr));
} else if ((T_FUN_MAX != expr->get_expr_type() && T_FUN_MIN != expr->get_expr_type()) ||
expr->get_real_param_count() != 1) {
OPT_TRACE("aggr expr is not min/max expr");
valid = false;
} else if (OB_ISNULL(expr->get_param_expr(0))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null expr", K(ret));
} else if (is_contain(valid_col_exprs, expr->get_param_expr(0))) {
valid = true;
} else if (OB_FAIL(is_valid_index_column(ctx,
&stmt,
expr->get_param_expr(0),
&equal_sets,
&const_exprs,
valid))) {
LOG_WARN("failed to check is valid index column", K(ret));
} else if (!valid) {
OPT_TRACE("aggr expr is not include index column");
} else if (OB_FAIL(valid_col_exprs.push_back(expr->get_param_expr(0)))) {
LOG_WARN("failed to push back valid column", K(ret));
}
}
equal_sets.reuse();
is_valid = valid;
return ret;
}
int ObTransformMinMax::is_valid_select_list(const ObSelectStmt &stmt, bool &is_valid)
{
int ret = OB_SUCCESS;
bool valid = true;
for (int64_t i = 0; OB_SUCC(ret) && valid && i < stmt.get_select_item_size(); ++i) {
if (OB_FAIL(is_valid_select_expr(stmt.get_select_item(i).expr_, valid))) {
LOG_WARN("failed to check expr is valid aggr", K(ret));
}
}
is_valid = valid;
return ret;
}
int ObTransformMinMax::is_valid_select_expr(const ObRawExpr *expr, bool &is_valid)
{
int ret = OB_SUCCESS;
bool is_stack_overflow = false;
bool valid = true;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr should not be NULL", K(ret), KP(expr));
} else if (expr->has_flag(IS_AGG) || expr->is_const_expr()) {
/* do nothing */
} else if (expr->has_flag(CNT_AGG)) {
for (int64_t i = 0; OB_SUCC(ret) && valid && i < expr->get_param_count(); ++i) {
if (OB_FAIL(SMART_CALL(is_valid_select_expr(expr->get_param_expr(i), valid)))) {
LOG_WARN("failed to check is_valid_expr", K(ret));
}
}
} else {
valid = false;
}
is_valid = valid;
return ret;
}
int ObTransformMinMax::is_valid_having_list(const ObSelectStmt &stmt, bool &is_valid)
{
int ret = OB_SUCCESS;
bool valid = true;
for (int64_t i = 0; OB_SUCC(ret) && valid && i < stmt.get_having_expr_size(); ++i) {
if (OB_FAIL(is_valid_having_expr(stmt.get_having_exprs().at(i), valid))) {
LOG_WARN("failed to check having expr", K(ret), K(i));
}
}
is_valid = valid;
return ret;
}
int ObTransformMinMax::is_valid_having_expr(const ObRawExpr *expr, bool &is_valid)
{
int ret = OB_SUCCESS;
bool valid = true;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("current expr is null", K(ret));
} else if (expr->has_flag(IS_AGG)) {
/* do nothing*/
} else if (expr->is_column_ref_expr() || expr->has_flag(CNT_SUB_QUERY)) {
valid = false;
} else if (expr->has_flag(CNT_COLUMN)) {
for (int64_t i = 0; OB_SUCC(ret) && valid && i < expr->get_param_count(); ++i) {
if (OB_FAIL(SMART_CALL(is_valid_having_expr(expr->get_param_expr(i), valid)))) {
LOG_WARN("failed to check having expr", K(ret));
}
}
}
is_valid = valid;
return ret;
}
int ObTransformMinMax::is_valid_order_list(const ObSelectStmt &stmt, bool &is_valid)
{
int ret = OB_SUCCESS;
bool valid = true;
for (int64_t i = 0; OB_SUCC(ret) && valid && i < stmt.get_order_item_size(); ++i) {
if (OB_FAIL(is_valid_order_expr(stmt.get_order_item(i).expr_, valid))) {
LOG_WARN("failed to check having expr", K(ret), K(i));
}
}
is_valid = valid;
return ret;
}
int ObTransformMinMax::is_valid_order_expr(const ObRawExpr *expr, bool &is_valid)
{
int ret = OB_SUCCESS;
bool valid = true;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("current expr is null", K(ret));
} else if (expr->has_flag(IS_AGG)) {
/* do nothing*/
} else if (expr->is_column_ref_expr()) {
valid = false;
} else if (expr->has_flag(CNT_COLUMN)) {
for (int64_t i = 0; OB_SUCC(ret) && valid && i < expr->get_param_count(); ++i) {
if (OB_FAIL(SMART_CALL(is_valid_order_expr(expr->get_param_expr(i), valid)))) {
LOG_WARN("failed to check order expr", K(ret));
}
}
}
is_valid = valid;
return ret;
}
int ObTransformMinMax::is_valid_index_column(ObTransformerCtx &ctx,
const ObSelectStmt *stmt,
const ObRawExpr *expr,
EqualSets *equal_sets,
ObIArray<ObRawExpr*> *const_exprs,
bool &is_valid)
{
int ret = OB_SUCCESS;
const TableItem *table_item = NULL;
const ObColumnRefRawExpr *col_expr = NULL;
bool is_match_index = false;
bool need_check_query_range = false;
is_valid = false;
if (OB_ISNULL(stmt) || OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid argument", K(ret), K(stmt), K(expr));
} else if (!expr->is_column_ref_expr()) {
/* do nothing */
} else if (OB_FALSE_IT(col_expr = static_cast<const ObColumnRefRawExpr *>(expr))) {
} else if (OB_ISNULL(table_item = stmt->get_table_item_by_id(col_expr->get_table_id()))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table item is null", K(ret));
} else if (!table_item->is_basic_table()) {
/* do nothing */
} else {
if (stmt->get_aggr_item_size() > 1 && stmt->get_condition_size() > 0) {
need_check_query_range = true;
}
if (OB_FAIL(ObTransformUtils::is_match_index(ctx.sql_schema_guard_,
stmt,
col_expr,
is_match_index,
equal_sets,
const_exprs,
NULL,
false,
need_check_query_range,
&ctx))) {
LOG_WARN("failed to check whether column matches index", K(ret));
} else if (is_match_index) {
is_valid = true;
}
}
return ret;
}
int ObTransformMinMax::set_child_order_item(ObSelectStmt *stmt,
ObRawExpr *aggr_param,
ObItemType aggr_type)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(stmt) || OB_ISNULL(aggr_param)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("params have null", K(ret), K(stmt), K(aggr_param));
} else {
OrderItem new_order_item;
new_order_item.expr_ = aggr_param;
if (T_FUN_MAX == aggr_type) {
new_order_item.order_type_ = default_desc_direction();
} else if (T_FUN_MIN == aggr_type) {
new_order_item.order_type_ = default_asc_direction();
} else {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("aggregate function type must by max or min", K(ret));
}
if (OB_SUCC(ret)) {
if (OB_FAIL(stmt->add_order_item(new_order_item))) {
LOG_WARN("failed to add order item", K(ret), K(stmt), K(new_order_item));
}
}
}
return ret;
}
int ObTransformMinMax::set_child_condition(ObSelectStmt *stmt, ObRawExpr *aggr_param)
{
int ret = OB_SUCCESS;
ObRawExpr *not_null_expr = NULL;
bool is_not_null = false;
ObArray<ObRawExpr *> constraints;
if (OB_ISNULL(stmt) || OB_ISNULL(aggr_param) || OB_ISNULL(ctx_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("params have null", K(ret), K(stmt), K(aggr_param));
} else if (OB_FAIL(ObTransformUtils::is_expr_not_null(ctx_, stmt, aggr_param, NULLABLE_SCOPE::NS_WHERE,
is_not_null, &constraints))) {
LOG_WARN("failed to check expr not null", K(ret));
} else if (is_not_null) {
if (OB_FAIL(ObTransformUtils::add_param_not_null_constraint(*ctx_, constraints))) {
LOG_WARN("failed to add param not null constraints", K(ret));
}
} else if (OB_FAIL(ObTransformUtils::add_is_not_null(ctx_, aggr_param, not_null_expr))) {
LOG_WARN("failed to add is not null", K(ret));
} else if (OB_FAIL(stmt->add_condition_expr(not_null_expr))) {
LOG_WARN("failed to add condition expr", K(ret));
}
return ret;
}
} // sql
} // oceanbase
Reference in New Issue View Git Blame Copy Permalink