hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
9ebf3e06a58f4c8576ca072663f21f0846968aa8
oceanbase/src/sql/rewrite/ob_transform_const_propagate.cpp

2733 lines
121 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 "sql/resolver/expr/ob_raw_expr.h"
#include "sql/resolver/expr/ob_raw_expr_util.h"
#include "sql/resolver/dml/ob_update_stmt.h"
#include "sql/optimizer/ob_optimizer_util.h"
#include "sql/rewrite/ob_transform_const_propagate.h"
#include "sql/rewrite/ob_transform_utils.h"
#include "sql/rewrite/ob_stmt_comparer.h"
#include "sql/engine/expr/ob_expr_result_type_util.h"
#include "common/ob_smart_call.h"
using namespace oceanbase::common;
namespace oceanbase
{
namespace sql
{
/**
* @brief ObTransformConstPropagate::transform_one_stmt
* collect const info and do propagation for:
* - condition expr
* - semi-condition expr
* - select expr(including subquery)
* - set op expr
* - orderby/groupby expr
* - having expr
* - update assignment expr
* NOTE: folding (pre-calculation) is not included in this rule.
*
* supports pushing down & pull up constant for subquery and generated table.
* supports DML.
*
* following select expr will NOT be replaced:
* 1. all select exprs will NOT be replaced, including:
* a. select expr of null side table item
* 2. col ref select expr will NOT be replaced, including:
* a. col ref select expr of top level select stmt (no benefit)
* b. col ref select expr of updated view (not allowed)
*/
int ObTransformConstPropagate::transform_one_stmt(common::ObIArray<ObParentDMLStmt> &parent_stmts,
ObDMLStmt *&stmt,
bool &trans_happened)
{
int ret = OB_SUCCESS;
trans_happened = false;
ObDMLStmt *parent_stmt = parent_stmts.empty() ? NULL : parent_stmts.at(parent_stmts.count() - 1).stmt_;
bool is_on_null_side = false;
if (OB_ISNULL(stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->session_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (!stmt_map_.created() && OB_FAIL(stmt_map_.create(20, ObModIds::OB_SQL_COMPILE))) {
LOG_WARN("failed to create stmt map", K(ret));
} else if (OB_NOT_NULL(parent_stmt) && stmt->is_select_stmt() &&
OB_FAIL(is_parent_null_side(parent_stmt, stmt, is_on_null_side))) {
LOG_WARN("failed to check null side", K(ret));
} else if (OB_FAIL(do_transform(stmt,
is_on_null_side,
trans_happened))) {
LOG_WARN("failed to do transformation for const propagation", K(ret));
}
if (OB_SUCC(ret) && trans_happened) {
if (OB_FAIL(add_transform_hint(*stmt))) {
LOG_WARN("failed to add transform hint", K(ret));
}
}
return ret;
}
ObTransformConstPropagate::~ObTransformConstPropagate()
{
for (int64_t i = 0; i < stmt_pullup_const_infos_.count(); ++i) {
if (NULL != stmt_pullup_const_infos_.at(i)) {
stmt_pullup_const_infos_.at(i)->~PullupConstInfos();
stmt_pullup_const_infos_.at(i) = NULL;
}
}
}
int ObTransformConstPropagate::ExprConstInfo::merge_complex(ExprConstInfo &other)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(column_expr_ != other.column_expr_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("column expr mismatch when merge cosnt info", K(ret));
} else if (!other.is_complex_const_info_) {
if (OB_FAIL(multi_const_exprs_.push_back(other.const_expr_))) {
LOG_WARN("failed to push back const expr", K(ret));
} else if (OB_FAIL(multi_need_add_constraints_.push_back(other.need_add_constraint_))) {
LOG_WARN("failed to push back pre calc index", K(ret));
}
} else {
if (OB_FAIL(append(multi_const_exprs_, other.multi_const_exprs_))) {
LOG_WARN("failed to append const expr", K(ret));
} else if (OB_FAIL(append(multi_need_add_constraints_, other.multi_need_add_constraints_))) {
LOG_WARN("failed to append pre calc index", K(ret));
}
}
return ret;
}
int ObTransformConstPropagate::ConstInfoContext::add_const_infos(ObIArray<ExprConstInfo> &const_infos)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < const_infos.count(); ++i) {
if (OB_FAIL(add_const_info(const_infos.at(i)))) {
LOG_WARN("failed to add const info", K(ret));
}
}
return ret;
}
int ObTransformConstPropagate::ConstInfoContext::add_const_info(ExprConstInfo &const_info)
{
int ret = OB_SUCCESS;
bool found = false;
for (int64_t i = 0; OB_SUCC(ret) && !found && i < active_const_infos_.count(); ++i) {
ExprConstInfo &cur_info = active_const_infos_.at(i);
if (const_info.column_expr_ == cur_info.const_expr_) {
found = true;
if (const_info.is_used_) {
if (OB_FAIL(expired_const_infos_.push_back(const_info))) {
LOG_WARN("failed to push back", K(ret));
}
}
}
}
if (OB_SUCC(ret) && !found) {
if (OB_FAIL(active_const_infos_.push_back(const_info))) {
LOG_WARN("failed to push back", K(ret));
}
}
return ret;
}
int ObTransformConstPropagate::ConstInfoContext::merge_expired_const_infos(ConstInfoContext &other,
bool can_pull_up)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < other.active_const_infos_.count(); ++i) {
if (can_pull_up) {
if (OB_FAIL(add_const_info(other.active_const_infos_.at(i)))) {
LOG_WARN("failed to push back", K(ret));
}
} else if (other.active_const_infos_.at(i).is_used_) {
if (OB_FAIL(expired_const_infos_.push_back(other.active_const_infos_.at(i)))) {
LOG_WARN("failed to push back", K(ret));
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(append(expired_const_infos_, other.expired_const_infos_))) {
LOG_WARN("failed to append expired const infos", K(ret));
}
}
return ret;
}
int ObTransformConstPropagate::ConstInfoContext::find_exclude_expr(const ObRawExpr *expr,
bool &found)
{
int ret = OB_SUCCESS;
found = false;
for (int64_t i = 0; OB_SUCC(ret) && !found && i < active_const_infos_.count(); ++i) {
if (active_const_infos_.at(i).exclude_expr_ == expr) {
found = true;
}
}
if (OB_SUCC(ret) && !found) {
found = ObOptimizerUtil::find_item(extra_excluded_exprs_, expr);
}
return ret;
}
int ObTransformConstPropagate::ConstInfoContext::expire_const_infos()
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < active_const_infos_.count(); ++i) {
if (!active_const_infos_.at(i).is_used_) {
// do nothing
} else if (OB_FAIL(expired_const_infos_.push_back(active_const_infos_.at(i)))) {
LOG_WARN("failed to push back", K(ret));
}
}
if (OB_SUCC(ret)) {
active_const_infos_.reuse();
extra_excluded_exprs_.reuse();
}
return ret;
}
int ObTransformConstPropagate::check_hint_status(const ObDMLStmt &stmt, bool &need_trans)
{
int ret = OB_SUCCESS;
const ObQueryHint *query_hint = NULL;
const ObHint *trans_hint = NULL;
need_trans = false;
if (OB_ISNULL(ctx_) ||
OB_ISNULL(query_hint = stmt.get_stmt_hint().query_hint_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(ctx_), K(query_hint));
} else if (!query_hint->has_outline_data()) {
need_trans = true;
} else if (NULL != (trans_hint = query_hint->get_outline_trans_hint(ctx_->trans_list_loc_))
&& trans_hint->get_hint_type() == get_hint_type()) {
// next trans hint is REPLACE_CONST, allowed collect equal pair
need_trans = true;
}
return ret;
}
int ObTransformConstPropagate::do_transform(ObDMLStmt *stmt,
bool ignore_all_select_exprs,
bool &trans_happened)
{
int ret = OB_SUCCESS;
ObSharedExprChecker shared_expr_checker;
bool allow_trans = false;
if (OB_ISNULL(stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->session_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (OB_FAIL(check_allow_trans(stmt, allow_trans))) {
LOG_WARN("failed to check trans allowed", K(ret));
} else if (!stmt->is_insert_stmt() && OB_FAIL(shared_expr_checker.init(*stmt))) {
LOG_WARN("failed to init shared expr checker", K(ret));
} else {
ConstInfoContext const_ctx(shared_expr_checker, allow_trans);
bool has_rollup_or_groupingsets = false;
bool is_happened = false;
if (OB_SUCC(ret)) {
if (OB_FAIL(collect_equal_pair_from_condition(stmt,
stmt->get_condition_exprs(),
const_ctx,
is_happened))) {
LOG_WARN("failed to collect const info from where condition", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation while collect from condition", K(is_happened));
}
}
if (OB_SUCC(ret)) {
is_happened = false;
if (OB_FAIL(collect_equal_pair_from_tables(stmt,
const_ctx,
is_happened))) {
LOG_WARN("failed to collect const info from tables", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation while collect from tables", K(is_happened));
}
}
if (OB_SUCC(ret)) {
is_happened = false;
if (OB_FAIL(collect_equal_pair_from_semi_infos(stmt,
const_ctx,
is_happened))) {
LOG_WARN("failed to collect const info from semi info", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation while collect from semi info", K(is_happened));
}
}
if (OB_SUCC(ret)) {
is_happened = false;
if (OB_FAIL(replace_join_conditions(stmt,
const_ctx,
is_happened))) {
LOG_WARN("failed to replace join conditions", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation for join conditions", K(is_happened));
}
}
if (OB_SUCC(ret) && !const_ctx.active_const_infos_.empty()) {
is_happened = false;
if (OB_FAIL(replace_common_exprs(stmt->get_condition_exprs(),
const_ctx,
is_happened))) {
LOG_WARN("failed to replace condition exprs", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation for condition expr", K(is_happened));
}
}
if (OB_SUCC(ret) && !const_ctx.active_const_infos_.empty() &&
(stmt->is_insert_stmt() || stmt->is_merge_stmt())) {
is_happened = false;
ObDelUpdStmt *insert = static_cast<ObDelUpdStmt *>(stmt);
if (OB_FAIL(collect_equal_pair_from_condition(stmt,
insert->get_sharding_conditions(),
const_ctx,
is_happened))) {
LOG_WARN("failed to collect const info from sharding condition", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation while collect from sharding", K(is_happened));
}
}
if (OB_SUCC(ret) && !const_ctx.active_const_infos_.empty() &&
(stmt->is_insert_stmt() || stmt->is_merge_stmt())) {
ObDelUpdStmt *insert = static_cast<ObDelUpdStmt *>(stmt);
is_happened = false;
if (OB_FAIL(replace_common_exprs(insert->get_sharding_conditions(),
const_ctx,
is_happened))) {
LOG_WARN("failed to repalce condition exprs", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation for sharding expr", K(is_happened));
}
}
if (OB_SUCC(ret) && !const_ctx.active_const_infos_.empty()) {
is_happened = false;
if (OB_FAIL(replace_semi_conditions(stmt,
const_ctx,
is_happened))) {
LOG_WARN("failed to replace semi conditions", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation for semi conditions", K(is_happened));
}
}
// replace groupby exprs using common const info
if (OB_SUCC(ret) && stmt->is_select_stmt() && (static_cast<ObSelectStmt*>(stmt)->has_rollup() ||
static_cast<ObSelectStmt*>(stmt)->get_grouping_sets_items_size() != 0)) {
has_rollup_or_groupingsets = true;
}
if (OB_SUCC(ret) && !const_ctx.active_const_infos_.empty() && stmt->is_select_stmt() && !has_rollup_or_groupingsets) {
is_happened = false;
if (OB_FAIL(replace_group_exprs(static_cast<ObSelectStmt*>(stmt),
const_ctx,
ignore_all_select_exprs,
is_happened))) {
LOG_WARN("failed to replace groupby exprs", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation for groupby expr", K(is_happened));
}
}
if (OB_SUCC(ret) && stmt->is_select_stmt() &&
(has_rollup_or_groupingsets || static_cast<ObSelectStmt*>(stmt)->is_scala_group_by())) {
if (OB_FAIL(const_ctx.expire_const_infos())) {
LOG_WARN("failed to expire const infos ", K(ret));
}
}
if (OB_SUCC(ret) && stmt->is_select_stmt()) {
if (!const_ctx.active_const_infos_.empty() && !ignore_all_select_exprs && static_cast<ObSelectStmt*>(stmt)->get_aggr_item_size() > 0) {
is_happened = false;
if (OB_FAIL(replace_select_exprs(static_cast<ObSelectStmt*>(stmt),
const_ctx,
is_happened))) {
LOG_WARN("failed to replace select exprs", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation replace select exprs before get having exprs", K(is_happened));
}
}
}
if (OB_SUCC(ret) && stmt->is_select_stmt()) {
is_happened = false;
if (OB_FAIL(collect_equal_pair_from_condition(stmt,
static_cast<ObSelectStmt*>(stmt)->get_having_exprs(),
const_ctx,
is_happened))) {
LOG_WARN("failed to collect const info from having condition", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation while collect from having", K(is_happened));
}
}
if (OB_SUCC(ret) && stmt->is_select_stmt()) {
is_happened = false;
if (OB_FAIL(replace_common_exprs(static_cast<ObSelectStmt*>(stmt)->get_having_exprs(),
const_ctx,
is_happened))) {
LOG_WARN("failed to replace having exprs", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation for having expr", K(is_happened));
}
}
if (OB_SUCC(ret) && !const_ctx.active_const_infos_.empty()) {
is_happened = false;
if (OB_FAIL(replace_orderby_exprs(stmt->get_order_items(),
const_ctx,
is_happened))) {
LOG_WARN("failed to replace orderby exprs", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation for orderby expr", K(is_happened));
}
}
// replace select exprs using common const info and post-gby const info
if (OB_SUCC(ret) && !const_ctx.active_const_infos_.empty() && stmt->is_select_stmt() && !ignore_all_select_exprs) {
is_happened = false;
if (static_cast<ObSelectStmt*>(stmt)->get_aggr_item_size() > 0) {
if (OB_FAIL(replace_select_exprs_skip_agg(static_cast<ObSelectStmt*>(stmt),
const_ctx,
is_happened))) {
LOG_WARN("failed to replace select exprs", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation for select expr", K(is_happened));
}
} else if (OB_FAIL(replace_select_exprs(static_cast<ObSelectStmt*>(stmt),
const_ctx,
is_happened))) {
LOG_WARN("failed to replace select exprs", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation for select expr", K(is_happened));
}
}
// replace update assignment list
if (OB_SUCC(ret) && !const_ctx.active_const_infos_.empty() && stmt->is_update_stmt()) {
is_happened = false;
ObUpdateStmt *upd_stmt = static_cast<ObUpdateStmt *>(stmt);
for (int64_t i = 0; OB_SUCC(ret) && i < upd_stmt->get_update_table_info().count(); ++i) {
ObUpdateTableInfo* table_info = upd_stmt->get_update_table_info().at(i);
if (OB_ISNULL(table_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get null table info", K(ret));
} else if (OB_FAIL(replace_assignment_exprs(table_info->assignments_,
const_ctx,
is_happened))) {
LOG_WARN("failed to replace assignment exprs", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation for assignment expr", K(is_happened));
}
}
}
// replace condition exprs from check constraint exprs.
if (OB_SUCC(ret) && !const_ctx.active_const_infos_.empty()) {
is_happened = false;
if (OB_FAIL(replace_check_constraint_exprs(stmt,
const_ctx,
is_happened))) {
LOG_WARN("failed to replace condition exprs", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation for check constraint expr", K(is_happened));
}
}
if (OB_SUCC(ret) && trans_happened) {
if (OB_FAIL(collect_equal_param_constraints(const_ctx.active_const_infos_))) {
LOG_WARN("failed to append active equal params constraints", K(ret));
} else if (OB_FAIL(collect_equal_param_constraints(const_ctx.expired_const_infos_))) {
LOG_WARN("failed to append expired equal params constraints", K(ret));
} else if (OB_FAIL(remove_const_exec_param(stmt))) {
LOG_WARN("failed to remove const exec param", K(ret));
} else if (OB_FAIL(stmt->formalize_stmt(ctx_->session_info_))) {
LOG_WARN("failed to formalize stmt info", K(ret));
} else {
LOG_TRACE("succeed to do replacement internal", KPC(stmt));
}
}
if (OB_SUCC(ret) && OB_FAIL(shared_expr_checker.destroy())) {
LOG_WARN("failed to destroy shared expr checker", K(ret));
}
}
return ret;
}
// const info is always collected even if transform is not allowed
int ObTransformConstPropagate::check_allow_trans(ObDMLStmt *stmt, bool &allow_trans)
{
int ret = OB_SUCCESS;
bool hint_allowed_trans = false;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (OB_FAIL(ObTransformRule::check_hint_status(*stmt, hint_allowed_trans))) {
LOG_WARN("failed to check_hint_status", K(ret));
} else {
allow_trans = hint_allowed_trans && !stmt->is_contains_assignment();
}
return ret;
}
int ObTransformConstPropagate::exclude_redundancy_join_cond(ObIArray<ObRawExpr*> &condition_exprs,
ObIArray<ExprConstInfo> &expr_const_infos,
ObIArray<ObRawExpr*> &excluded_exprs)
{
int ret = OB_SUCCESS;
ObRawExpr *l_const_expr = NULL;
ObRawExpr *r_const_expr = NULL;
ObExprEqualCheckContext equal_ctx;
equal_ctx.override_const_compare_ = true;
for (int64_t i = 0; OB_SUCC(ret) && i < condition_exprs.count(); ++i) {
ObRawExpr *expr = condition_exprs.at(i);
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null expr", K(ret));
} else if (!expr->has_flag(IS_JOIN_COND) ||
2 != expr->get_param_count()) {
//do nothing
} else if (!find_const_expr(expr_const_infos, expr->get_param_expr(0), l_const_expr) ||
!find_const_expr(expr_const_infos, expr->get_param_expr(1), r_const_expr)) {
//do nothing
} else if (OB_ISNULL(l_const_expr) || OB_ISNULL(r_const_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null expr", K(ret));
} else if (!l_const_expr->same_as(*r_const_expr, &equal_ctx)) {
//do nothing
} else if (OB_FAIL(excluded_exprs.push_back(expr))) {
LOG_WARN("failed to push back expr", K(ret));
}
}
return ret;
}
bool ObTransformConstPropagate::find_const_expr(ObIArray<ExprConstInfo> &expr_const_infos,
ObRawExpr *expr,
ObRawExpr* &const_expr)
{
const_expr = NULL;
bool found = false;
for (int64_t i = 0; !found && i < expr_const_infos.count(); ++i) {
if (!expr_const_infos.at(i).is_complex_const_info_) {
if (expr == expr_const_infos.at(i).column_expr_) {
const_expr = expr_const_infos.at(i).const_expr_;
found = true;
}
}
}
return found;
}
int ObTransformConstPropagate::collect_equal_pair_from_condition(ObDMLStmt *stmt,
ObIArray<ObRawExpr*> &condition_exprs,
ConstInfoContext &const_ctx,
bool &trans_happened)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < condition_exprs.count(); ++i) {
ObRawExpr *cur_expr = condition_exprs.at(i);
if (OB_ISNULL(cur_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid condition exprs", K(ret));
} else if (OB_FAIL(recursive_collect_equal_pair_from_condition(stmt,
cur_expr,
const_ctx,
trans_happened))) {
LOG_WARN("failed to recursive collect const info from condition", K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(exclude_redundancy_join_cond(condition_exprs,
const_ctx.active_const_infos_,
const_ctx.extra_excluded_exprs_))) {
LOG_WARN("failed to exclude redundancy join cond", K(ret));
}
}
return ret;
}
int ObTransformConstPropagate::collect_equal_pair_from_tables(ObDMLStmt *stmt,
ConstInfoContext &const_ctx,
bool &trans_happened)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_from_item_size(); ++i) {
bool is_happened = false;
FromItem &from_item = stmt->get_from_item(i);
TableItem *table_item = stmt->get_table_item(from_item);
if (OB_ISNULL(table_item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (OB_FAIL(recursive_collect_const_info_from_table(stmt,
table_item,
const_ctx,
false,
is_happened))) {
LOG_WARN("failed to collect const info from table", K(ret));
} else {
trans_happened |= is_happened;
}
}
return ret;
}
int ObTransformConstPropagate::collect_equal_pair_from_semi_infos(ObDMLStmt *stmt,
ConstInfoContext &const_ctx,
bool &trans_happened)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_semi_info_size(); ++i) {
bool is_happened = false;
SemiInfo *semi_info = stmt->get_semi_infos().at(i);
TableItem *right_table = NULL;
if (OB_ISNULL(semi_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid semi info", K(ret));
} else if (OB_ISNULL(right_table = stmt->get_table_item_by_id(semi_info->right_table_id_))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected semi right table", KPC(semi_info), K(ret));
} else if (OB_FAIL(recursive_collect_const_info_from_table(stmt,
right_table,
const_ctx,
true,
is_happened))) {
LOG_WARN("failed to collect const info from table", K(ret));
} else {
trans_happened |= is_happened;
}
}
return ret;
}
/* collect const info from table
* 1. As left-join table(also right-join table
* const infos from not_null_side and on_condition can be pulled up to high level const ctx.
* const infos from null_side can only used on self level join table.
* 2. inner-join table, const infos can be pulled up to high level const ctx.
*/
int ObTransformConstPropagate::recursive_collect_const_info_from_table(ObDMLStmt *stmt,
TableItem *table_item,
ConstInfoContext &const_ctx,
bool is_null_side,
bool &trans_happened)
{
int ret = OB_SUCCESS;
JoinedTable *joined_table = NULL;
if (OB_ISNULL(stmt) || OB_ISNULL(table_item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (table_item->is_generated_table()) {
if (OB_FAIL(collect_equal_pair_from_pullup(stmt, table_item, const_ctx, is_null_side))) {
LOG_WARN("failed to collect const info from pullup", K(ret));
}
} else if (!table_item->is_joined_table()) {
} else if (FALSE_IT(joined_table = static_cast<JoinedTable *>(table_item))) {
} else if (LEFT_OUTER_JOIN == joined_table->joined_type_ ||
RIGHT_OUTER_JOIN == joined_table->joined_type_) {
// FULL_OUT_JOIN is not transformed because may eliminate all equal join conditions
TableItem *left_table = LEFT_OUTER_JOIN == joined_table->joined_type_ ?
joined_table->left_table_ : joined_table->right_table_;
TableItem *right_table = LEFT_OUTER_JOIN == joined_table->joined_type_ ?
joined_table->right_table_ : joined_table->left_table_;
ConstInfoContext tmp_ctx(const_ctx.shared_expr_checker_, const_ctx.allow_trans_);
bool left_happened = false;
bool right_happened = false;
bool condition_happened = false;
bool replace_join_left = false;
bool replace_join_right = false;
if (OB_FAIL(SMART_CALL(recursive_collect_const_info_from_table(stmt, left_table,
tmp_ctx, false,
left_happened)))) {
LOG_WARN("failed to recursive collect const info from table", K(ret));
} else if (OB_FAIL(SMART_CALL(recursive_replace_join_conditions(joined_table, tmp_ctx,
replace_join_left)))) {
LOG_WARN("failed to replace exprs in joined table", K(ret));
} else if (OB_FAIL(const_ctx.merge_expired_const_infos(tmp_ctx, true))) {
LOG_WARN("failed to merge expired const infos", K(ret));
} else if (FALSE_IT(tmp_ctx.reset())) {
} else if (OB_FAIL(SMART_CALL(recursive_collect_const_info_from_table(stmt, right_table,
tmp_ctx, true,
right_happened)))) {
LOG_WARN("failed to recursive collect const info from table", K(ret));
} else if (OB_FAIL(collect_equal_pair_from_condition(stmt, joined_table->get_join_conditions(),
tmp_ctx, condition_happened))) {
LOG_WARN("failed to collect const info from join condition", K(ret));
} else if (OB_FAIL(SMART_CALL(recursive_replace_join_conditions(joined_table, tmp_ctx,
replace_join_right)))) {
LOG_WARN("failed to replace exprs in joined table", K(ret));
} else if (OB_FAIL(const_ctx.merge_expired_const_infos(tmp_ctx, false))) {
LOG_WARN("failed to merge expired const infos", K(ret));
} else {
trans_happened |= left_happened || right_happened || condition_happened ||
replace_join_left || replace_join_right;
LOG_TRACE("collect const info from table", K(trans_happened), K(left_happened),
K(right_happened), K(condition_happened), K(replace_join_left),
K(replace_join_right));
}
} else if (joined_table->is_inner_join()) {
bool left_happened = false;
bool right_happened = false;
bool condition_happened = false;
if (OB_FAIL(SMART_CALL(recursive_collect_const_info_from_table(stmt,
joined_table->left_table_,
const_ctx,
false,
left_happened)))) {
LOG_WARN("failed to recursive collect const info from table", K(ret));
} else if (OB_FAIL(SMART_CALL(recursive_collect_const_info_from_table(stmt,
joined_table->right_table_,
const_ctx,
false,
right_happened)))) {
LOG_WARN("failed to recursive collect const info from table", K(ret));
} else if (OB_FAIL(collect_equal_pair_from_condition(stmt,
joined_table->get_join_conditions(),
const_ctx,
condition_happened))) {
LOG_WARN("failed to collect const info from join condition", K(ret));
} else {
trans_happened |= left_happened || right_happened || condition_happened;
LOG_TRACE("collect const info from table", K(trans_happened), K(left_happened),
K(right_happened), K(condition_happened));
}
}
return ret;
}
int ObTransformConstPropagate::collect_equal_pair_from_pullup(ObDMLStmt *stmt,
TableItem *table,
ConstInfoContext &const_ctx,
bool is_null_side)
{
int ret = OB_SUCCESS;
ObSelectStmt *child_stmt = NULL;
if (OB_ISNULL(stmt) || OB_ISNULL(table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (!table->is_generated_table()) {
// do nothing
} else if (OB_ISNULL(child_stmt = table->ref_query_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid target table ref query", K(ret));
} else {
for (int64_t j = 0; OB_SUCC(ret) && j < child_stmt->get_select_item_size(); ++j) {
ObRawExpr *select_expr = child_stmt->get_select_items().at(j).expr_;
ExprConstInfo equal_info;
equal_info.mem_equal_ = true;
const uint64_t column_id = j + OB_APP_MIN_COLUMN_ID;
if (OB_ISNULL(select_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid selet expr", K(ret));
} else if (OB_ISNULL(equal_info.column_expr_ =
stmt->get_column_expr_by_id(table->table_id_, column_id))) {
// do nothing
} else if (select_expr->is_const_expr()) {
// handle generated_table const pull up.
// case1: select * from (select 1 as a, 2 as b from t1) v, t2 where v.a = t2.c1 and v.b = t2.c2; =>
// select * from (select 1 as a, 2 as b from t1) v, t2 where 1 = t2.c1 and 2 = t2.c2;
equal_info.const_expr_ = select_expr;
} else if (select_expr->is_set_op_expr()) {
// handle const set_op expr pull up.
// NOTE: before replace the set_op const expr, it needs to check the unique equal constraint and record
// it into equal_param_constraints_ in transform context to makes plan cache correct.
// case2: select c1 from (select 1 as c1 from t1 union select 1 as c1 from t2); =>
// select 1 from (select 1 as c1 from t1 union select 1 as c1 from t2);
if (OB_FAIL(check_set_op_expr_const(child_stmt,
static_cast<ObSetOpRawExpr*>(select_expr),
equal_info.const_expr_,
equal_info.equal_infos_))) {
LOG_WARN("failed to check set op expr const", K(ret));
}
} else if (NULL == equal_info.const_expr_) {
// handle const info pull up
// case3: select * from (select c1 as a from t1 where c1 = '1') v, t2 where v.a = t2.c1; =>
// select * from (select c1 as a from t1 where c1 = '1') v, t2 where '1' = t2.c1;
equal_info.mem_equal_ = false;
if (OB_FAIL(collect_from_pullup_const_infos(child_stmt, select_expr, equal_info))) {
LOG_WARN("failed to get expr from pullup const info", K(ret));
}
}
if (OB_SUCC(ret) && equal_info.column_expr_ != NULL && equal_info.const_expr_ != NULL) {
bool is_valid = false;
if (OB_FAIL(check_const_expr_validity(*child_stmt,
equal_info,
is_valid))) {
LOG_WARN("failed to check const expr validity", K(ret));
} else if (!is_valid) {
ObObjType col_type = equal_info.column_expr_->get_result_type().get_type();
if (!(ob_is_text_tc(col_type) || ob_is_lob_tc(col_type) || ob_is_json_tc(col_type)) &&
equal_info.const_expr_->is_static_scalar_const_expr()) {
ObObj result;
bool got_result = false;
if (OB_FAIL(ObSQLUtils::calc_const_or_calculable_expr(ctx_->exec_ctx_,
equal_info.const_expr_,
result,
got_result,
*ctx_->allocator_))) {
LOG_WARN("failed to calc const or caculable expr", K(ret));
} else if (got_result && (result.is_null()
|| (lib::is_oracle_mode() && result.is_null_oracle()))) {
is_valid = true;
if (!equal_info.const_expr_ -> is_const_raw_expr()) {
equal_info.need_add_constraint_ = PRE_CALC_RESULT_NULL;
}
}
}
}
if (OB_SUCC(ret) && is_valid) {
if (OB_FAIL(check_cast_const_expr(equal_info, is_valid))) {
LOG_WARN("failed to check need cast constraint", K(ret));
}
}
if (OB_SUCC(ret) && is_valid) {
if (OB_FAIL(const_ctx.add_const_info(equal_info))) {
LOG_WARN("failed to push back equal info", K(ret));
}
}
}
}
}
return ret;
}
int ObTransformConstPropagate::replace_common_exprs(ObIArray<ObRawExpr *> &exprs,
ConstInfoContext &const_ctx,
bool &trans_happened,
bool used_in_compare)
{
int ret = OB_SUCCESS;
trans_happened = false;
for (int64_t i = 0; OB_SUCC(ret) && i < exprs.count(); ++i) {
ObRawExpr *&cur_expr = exprs.at(i);
bool internal_trans_happened = false;
if (OB_ISNULL(cur_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (OB_FAIL(replace_expr_internal(cur_expr,
const_ctx,
internal_trans_happened,
used_in_compare))) {
LOG_WARN("failed to replace exprs based on equal_pair", K(ret));
} else {
trans_happened |= internal_trans_happened;
}
}
return ret;
}
int ObTransformConstPropagate::replace_group_exprs(ObSelectStmt *stmt,
ConstInfoContext &const_ctx,
bool ignore_all_select_exprs,
bool &trans_happened)
{
int ret = OB_SUCCESS;
trans_happened = false;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_group_expr_size(); ++i) {
ObRawExpr *group_expr = stmt->get_group_exprs().at(i);
bool can_replace = true;
bool internal_trans_happened = false;
if (OB_ISNULL(group_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (OB_FAIL(check_can_replace_in_select(stmt, group_expr, ignore_all_select_exprs,
can_replace))) {
LOG_WARN("failed to check can replace in select", K(ret));
} else if (!can_replace) {
// group expr can not be transfromed when the corresponding select item can not be transfromed
} else if (OB_FAIL(replace_expr_internal(stmt->get_group_exprs().at(i),
const_ctx,
internal_trans_happened,
false))) {
LOG_WARN("failed to replace select exprs based on equal_pair", K(ret));
} else {
trans_happened |= internal_trans_happened;
}
}
return ret;
}
int ObTransformConstPropagate::replace_select_exprs(ObSelectStmt *stmt,
ConstInfoContext &const_ctx,
bool &trans_happened)
{
int ret = OB_SUCCESS;
trans_happened = false;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_select_items().count(); ++i) {
ObRawExpr *&cur_expr = stmt->get_select_items().at(i).expr_;
bool internal_trans_happened = false;
if (OB_ISNULL(cur_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (cur_expr->is_column_ref_expr()) {
if (OB_FAIL(generate_pullup_const_info(stmt, cur_expr, const_ctx))) {
LOG_WARN("failed to generate pullup const info", K(ret));
}
} else if (OB_FAIL(replace_expr_internal(cur_expr,
const_ctx,
internal_trans_happened,
false))) {
LOG_WARN("failed to replace select exprs based on equal_pair", K(ret));
} else {
trans_happened |= internal_trans_happened;
}
}
return ret;
}
int ObTransformConstPropagate::replace_orderby_exprs(ObIArray<OrderItem> &order_items,
ConstInfoContext &const_ctx,
bool &trans_happened)
{
int ret = OB_SUCCESS;
trans_happened = false;
for (int64_t i = 0; OB_SUCC(ret) && i < order_items.count(); ++i) {
ObRawExpr *&cur_expr = order_items.at(i).expr_;
bool internal_trans_happened = false;
if (OB_ISNULL(cur_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (OB_FAIL(replace_expr_internal(cur_expr,
const_ctx,
internal_trans_happened))) {
LOG_WARN("failed to replace order by exprs based on equal_pair", K(ret));
} else {
trans_happened |= internal_trans_happened;
}
}
return ret;
}
int ObTransformConstPropagate::replace_assignment_exprs(ObIArray<ObAssignment> &assignments,
ConstInfoContext &const_ctx,
bool &trans_happened)
{
int ret = OB_SUCCESS;
trans_happened = false;
for (int64_t j = 0; OB_SUCC(ret) && j < assignments.count(); ++j) {
ObAssignment &assign = assignments.at(j);
bool internal_trans_happened = false;
if (OB_ISNULL(assign.expr_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("assgin expr is null", K(ret));
} else if (OB_FAIL(replace_expr_internal(assign.expr_,
const_ctx,
internal_trans_happened,
false))) {
LOG_WARN("failed to replace assignment exprs based on equal_pair", K(ret));
} else {
trans_happened |= internal_trans_happened;
}
}
return ret;
}
int ObTransformConstPropagate::replace_join_conditions(ObDMLStmt *stmt,
ConstInfoContext &const_ctx,
bool &trans_happened)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_table_size(); ++i) {
TableItem *table = stmt->get_table_items().at(i);
bool is_happened = false;
if (OB_ISNULL(table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (OB_FAIL(recursive_replace_join_conditions(table, const_ctx, is_happened))) {
LOG_WARN("failed to replace exprs in joined table", K(ret));
} else {
trans_happened |= is_happened;
}
}
return ret;
}
// replace semi condition exprs using common const info.
// if right only filters in semi info found after replacement, pushing them
// down into right table.
// formalize stmt before pushing down and generate view for right table if needed.
int ObTransformConstPropagate::replace_semi_conditions(ObDMLStmt *stmt,
ConstInfoContext &const_ctx,
bool &trans_happened)
{
int ret = OB_SUCCESS;
trans_happened = false;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_semi_info_size(); ++i) {
SemiInfo *semi_info = stmt->get_semi_infos().at(i);
bool is_happened = false;
if (OB_ISNULL(semi_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid semi info", K(ret));
} else if (OB_FAIL(exclude_redundancy_join_cond(semi_info->semi_conditions_,
const_ctx.active_const_infos_,
const_ctx.extra_excluded_exprs_))) {
LOG_WARN("failed to exclude redundancy join cond", K(ret));
} else if (OB_FAIL(replace_common_exprs(semi_info->semi_conditions_,
const_ctx,
is_happened))) {
LOG_WARN("failed to replace semi condition exprs", K(ret));
} else if (OB_FAIL(stmt->formalize_stmt(ctx_->session_info_))) {
LOG_WARN("formalize child stmt failed", K(ret));
} else {
trans_happened |= is_happened;
LOG_TRACE("succeed to do const propagation for semi condition expr", K(is_happened));
}
}
return ret;
}
int ObTransformConstPropagate::recursive_replace_join_conditions(TableItem *table_item,
ConstInfoContext &const_ctx,
bool &trans_happened)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(table_item)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (!table_item->is_joined_table()) {
// do nothing
} else {
JoinedTable *joined_table = static_cast<JoinedTable *>(table_item);
bool is_happened = false;
if (OB_SUCC(ret) && (joined_table->is_right_join() || joined_table->is_inner_join())) {
if (OB_FAIL(SMART_CALL(recursive_replace_join_conditions(joined_table->left_table_,
const_ctx,
is_happened)))) {
LOG_WARN("failed to replace exprs in joined table", K(ret));
} else {
trans_happened |= is_happened;
}
}
if (OB_SUCC(ret) && (joined_table->is_left_join() || joined_table->is_inner_join())) {
if (OB_FAIL(SMART_CALL(recursive_replace_join_conditions(joined_table->right_table_,
const_ctx,
is_happened)))) {
LOG_WARN("failed to replace exprs in joined table", K(ret));
} else {
trans_happened |= is_happened;
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(SMART_CALL(replace_common_exprs(joined_table->get_join_conditions(),
const_ctx,
is_happened)))) {
LOG_WARN("failed to replace join condition exprs", K(ret));
} else {
trans_happened |= is_happened;
}
}
}
return ret;
}
int ObTransformConstPropagate::replace_expr_internal(ObRawExpr *&cur_expr,
ConstInfoContext &const_ctx,
bool &trans_happened,
bool used_in_compare)
{
int ret = OB_SUCCESS;
if (const_ctx.allow_trans_) {
ObSEArray<ObRawExpr *, 8> parent_exprs;
if (OB_FAIL(recursive_replace_expr(cur_expr,
parent_exprs,
const_ctx,
used_in_compare,
trans_happened))) {
LOG_WARN("failed to recursive");
}
}
return ret;
}
int ObTransformConstPropagate::recursive_replace_expr(ObRawExpr *&cur_expr,
ObIArray<ObRawExpr *> &parent_exprs,
ConstInfoContext &const_ctx,
bool used_in_compare,
bool &trans_happened)
{
int ret = OB_SUCCESS;
bool found = false;
bool is_shared = false;
trans_happened = false;
bool can_replace_child = true;
if (OB_ISNULL(cur_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (OB_FAIL(const_ctx.find_exclude_expr(cur_expr, found))) {
LOG_WARN("failed to find exclude expr", K(ret));
} else if (found || cur_expr->has_flag(IS_ROWID)) {
// do nothing
//because the column expr in rowid will be used to extract query range. So, we can't replace.
//see the issue:
} else if (OB_FAIL(const_ctx.shared_expr_checker_.is_shared_expr(cur_expr, is_shared))) {
LOG_WARN("failed to check is shared expr", K(ret));
} else if (is_shared) {
/* do nothing */
} else if (OB_FAIL(replace_internal(cur_expr,
parent_exprs,
const_ctx.active_const_infos_,
used_in_compare,
trans_happened))) {
LOG_WARN("failed to replace expr internal", K(ret));
} else if (trans_happened || cur_expr->get_param_count() < 1) {
// do nothing
} else if (cur_expr->get_expr_type() == T_OP_ROW &&
OB_FAIL(check_can_replace_child_of_row(const_ctx, cur_expr, can_replace_child))) {
LOG_WARN("failed to check can replace in row", K(ret));
} else if (!can_replace_child) {
// do nothing
} else {
int64_t N = cur_expr->get_param_count();
if (OB_FAIL(parent_exprs.push_back(cur_expr))) {
LOG_WARN("failed to push back", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
bool param_trans_happened = false;
ObRawExpr *&child_expr = cur_expr->get_param_expr(i);
if (OB_FAIL(SMART_CALL(recursive_replace_expr(child_expr,
parent_exprs,
const_ctx,
used_in_compare,
param_trans_happened)))) {
LOG_WARN("replace reference column failed", K(ret));
} else {
trans_happened |= param_trans_happened;
}
}
if (OB_SUCC(ret)) {
parent_exprs.pop_back();
}
}
return ret;
}
int ObTransformConstPropagate::replace_internal(ObRawExpr *&cur_expr,
ObIArray<ObRawExpr *> &parent_exprs,
ObIArray<ExprConstInfo> &expr_const_infos,
bool used_in_compare,
bool &trans_happened)
{
int ret = OB_SUCCESS;
trans_happened = false;
if (OB_ISNULL(cur_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid param", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && !trans_happened && i < expr_const_infos.count(); ++i) {
ObRawExpr *column_expr = expr_const_infos.at(i).column_expr_;
ObRawExpr *const_expr = expr_const_infos.at(i).const_expr_;
bool can_replace = false;
bool need_cast = true;
if (expr_const_infos.at(i).is_complex_const_info_) {
//do nothing
} else if (OB_ISNULL(column_expr) || OB_ISNULL(const_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid expr", K(ret));
} else if (cur_expr != column_expr) {
// do nothing
} else if (expr_const_infos.at(i).mem_equal_) {
can_replace = true;
} else if (OB_FAIL(ObTransformUtils::check_can_replace(cur_expr, parent_exprs,
used_in_compare, can_replace))) {
LOG_WARN("failed to check can replace", K(ret));
}
if (OB_FAIL(ret)) {
} else if (!can_replace) {
// do nothing
} else if (OB_FAIL(check_need_cast_when_replace(cur_expr, const_expr, parent_exprs, need_cast))) {
LOG_WARN("failed to check need cast", K(ret));
} else if (need_cast && OB_FAIL(prepare_new_expr(expr_const_infos.at(i)))) {
LOG_WARN("failed to prepare new expr", K(ret));
} else {
cur_expr = need_cast ? expr_const_infos.at(i).new_expr_ : const_expr;
expr_const_infos.at(i).is_used_ = true;
trans_happened = true;
LOG_TRACE("succeed to replace expr", KPC(column_expr), KPC(cur_expr));
}
}
return ret;
}
int ObTransformConstPropagate::prepare_new_expr(ExprConstInfo &const_info)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(const_info.column_expr_) || OB_ISNULL(const_info.const_expr_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null expr", K(ret));
} else if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_) || OB_ISNULL(ctx_->session_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (NULL == const_info.new_expr_) {
ObRawExpr *cast_expr = const_info.const_expr_;
if (const_info.const_expr_->get_result_type() == const_info.column_expr_->get_result_type()) {
const_info.new_expr_ = const_info.const_expr_;
} else if (OB_FAIL(ObTransformUtils::add_cast_for_replace(*ctx_->expr_factory_,
const_info.column_expr_,
cast_expr,
ctx_->session_info_))) {
LOG_WARN("failed to create cast expr", K(ret));
} else {
const_info.new_expr_ = cast_expr;
}
}
return ret;
}
int ObTransformConstPropagate::remove_const_exec_param(ObDMLStmt *stmt)
{
int ret = OB_SUCCESS;
bool trans_happened = false;
ObArray<ObSelectStmt*> child_stmts;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (OB_FAIL(stmt->do_formalize_query_ref_exprs_pre())) {
LOG_WARN("failed to do formalize query ref exprs", K(ret));
} else if (OB_FAIL(remove_const_exec_param_exprs(stmt,
trans_happened))) {
LOG_WARN("replace reference column failed", K(ret));
} else if (OB_FAIL(stmt->get_child_stmts(child_stmts))) {
LOG_WARN("failed to get child stmts", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < child_stmts.count(); ++i) {
ObSelectStmt *child_stmt = child_stmts.at(i);
if (OB_ISNULL(child_stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid child stmt", K(ret));
} else if (OB_FAIL(SMART_CALL(remove_const_exec_param(child_stmt)))) {
LOG_WARN("replace reference column failed", K(ret));
}
}
}
if (OB_SUCC(ret) && OB_FAIL(stmt->do_formalize_query_ref_exprs_post())) {
LOG_WARN("failed to do formalize query ref exprs post", K(ret));
}
return ret;
}
int ObTransformConstPropagate::remove_const_exec_param_exprs(ObDMLStmt *stmt,
bool &trans_happened)
{
int ret = OB_SUCCESS;
ObSEArray<ObRawExprPointer, 4> exprs;
if (OB_ISNULL(stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->session_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("stmt is null", K(ret), K(stmt));
} else if (OB_FAIL(stmt->get_relation_exprs(exprs))) {
LOG_WARN("failed to get exprs", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < exprs.count(); ++i) {
bool is_happened = false;
ObRawExprPointer &expr_ptr = exprs.at(i);
ObRawExpr *expr = NULL;
ObSEArray<ObRawExpr *, 8> parent_exprs;
if (OB_FAIL(expr_ptr.get(expr))) {
LOG_WARN("failed to get expr", K(ret));
} else if (OB_FAIL(do_remove_const_exec_param(expr, parent_exprs, is_happened))) {
LOG_WARN("failed to remove const exec param", K(ret));
} else if (!is_happened) {
// do nothing
} else if (OB_FAIL(expr->formalize(ctx_->session_info_))) {
LOG_WARN("failed to formalize expr", K(ret));
} else if (OB_FAIL(expr_ptr.set(expr))) {
LOG_WARN("failed to update expr", K(ret));
} else {
trans_happened = true;
}
}
return ret;
}
int ObTransformConstPropagate::do_remove_const_exec_param(ObRawExpr *&expr,
ObIArray<ObRawExpr *> &parent_exprs,
bool &trans_happened)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(expr) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)
|| OB_ISNULL(ctx_->session_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret));
} else if (expr->is_exec_param_expr()) {
ObExecParamRawExpr *exec_param = static_cast<ObExecParamRawExpr *>(expr);
ObRawExpr *ref_expr = exec_param->get_ref_expr();
if (OB_ISNULL(ref_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("ref expr is null", K(ret));
} else if (ref_expr->is_static_const_expr()) {
ObRawExpr *cast_expr = ref_expr;
bool need_cast = false;
trans_happened = true;
if (OB_FAIL(check_need_cast_when_replace(expr, ref_expr, parent_exprs, need_cast))) {
LOG_WARN("failed to check need cast", K(ret));
} else if (!need_cast && parent_exprs.count() != 0) {
expr = ref_expr;
} else if (OB_FAIL(ObTransformUtils::add_cast_for_replace(*ctx_->expr_factory_,
expr,
cast_expr,
ctx_->session_info_))) {
LOG_WARN("failed to create cast expr", K(ret));
} else {
expr = cast_expr;
}
} else if (OB_FAIL(parent_exprs.push_back(exec_param))) {
LOG_WARN("failed to push back", K(ret));
} else if (OB_FAIL(SMART_CALL(do_remove_const_exec_param(ref_expr,
parent_exprs,
trans_happened)))) {
LOG_WARN("failed to do remove const exec param", K(ret));
} else if (OB_FALSE_IT(parent_exprs.pop_back())) {
} else if (ref_expr->is_const_expr() &&
!ref_expr->has_flag(CNT_ONETIME)) {
expr = ref_expr;
trans_happened = true;
} else {
exec_param->set_explicited_reference();
exec_param->set_ref_expr(ref_expr);
}
} else if (expr->has_flag(CNT_DYNAMIC_PARAM)) {
for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
if (OB_FAIL(parent_exprs.push_back(expr))) {
LOG_WARN("failed to push back", K(ret));
} else if (OB_FAIL(do_remove_const_exec_param(expr->get_param_expr(i), parent_exprs,
trans_happened))) {
LOG_WARN("failed to remove const exec param", K(ret));
} else {
parent_exprs.pop_back();
}
}
}
return ret;
}
int ObTransformConstPropagate::check_need_cast_when_replace(ObRawExpr *expr,
ObRawExpr *const_expr,
ObIArray<ObRawExpr *> &parent_exprs,
bool &need_cast)
{
int ret = OB_SUCCESS;
ObRawExpr *parent_expr = NULL;
bool is_in_param = false;
need_cast = true;
if (parent_exprs.empty()) {
need_cast = false;
} else if (OB_ISNULL(parent_expr = parent_exprs.at(parent_exprs.count() - 1)) ||
OB_ISNULL(const_expr) || OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret));
} else if (check_is_in_or_notin_param(parent_exprs, is_in_param)) {
LOG_WARN("failed to check in or notin param", K(ret));
} else if (is_in_param) {
// for static engine, all params in rigth side of in or not in should have same type
need_cast = true;
} else if (const_expr->get_expr_type() == T_NULL &&
ObDatumFuncs::is_null_aware_hash_type(expr->get_result_type().get_type())) {
// To adapt to the behavior of casting NULL values for hash compare
// cast need to be added above NULL for null aware hash type.
need_cast = true;
} else if (parent_expr->is_win_func_expr()) {
ObWinFunRawExpr *win_expr = static_cast<ObWinFunRawExpr*>(parent_expr);
ObAggFunRawExpr *agg_expr = win_expr->get_agg_expr();
ObSEArray<ObRawExpr*,4> agg_params;
if (OB_NOT_NULL(agg_expr) && OB_FAIL(agg_expr->get_param_exprs(agg_params))) {
// Type deduction of some aggr funcs relies on not only real params, e.g. MEDIAN, GROUP_PERCENTILE_CONT
LOG_WARN("failed to get agg params", K(ret));
} else if (OB_NOT_NULL(agg_expr) && ObOptimizerUtil::find_item(agg_params, expr)) {
need_cast = true;
} else if (ObOptimizerUtil::find_item(win_expr->get_func_params(), expr)) {
need_cast = true;
} else {
need_cast = false;
}
} else {
need_cast = !(IS_COMPARISON_OP(parent_expr->get_expr_type()) ||
T_OP_ROW == parent_expr->get_expr_type() ||
parent_expr->is_query_ref_expr());
}
return ret;
}
int ObTransformConstPropagate::check_is_in_or_notin_param(ObIArray<ObRawExpr *> &parent_exprs,
bool &is_right_param)
{
int ret = OB_SUCCESS;
bool found = false;
is_right_param = false;
for (int i = parent_exprs.count() - 1; OB_SUCC(ret) && !found && i >= 0; --i) {
ObRawExpr *cur_expr = parent_exprs.at(i);
if (OB_ISNULL(cur_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret));
} else if (T_OP_ROW == cur_expr->get_expr_type()) {
// check next parent expr
} else if (T_OP_IN == cur_expr->get_expr_type() || T_OP_NOT_IN == cur_expr->get_expr_type()) {
found = true;
if (OB_UNLIKELY(2 != cur_expr->get_param_count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid param count of in expr", KPC(cur_expr), K(ret));
} else if (i < parent_exprs.count() - 1) {
is_right_param = cur_expr->get_param_expr(1) == parent_exprs.at(i + 1);
}
} else {
found = true;
}
}
return ret;
}
int ObTransformConstPropagate::check_const_expr_validity(const ObDMLStmt &stmt,
ExprConstInfo &const_info,
bool &is_valid)
{
int ret = OB_SUCCESS;
if (OB_FAIL(check_const_expr_not_null(stmt, const_info, is_valid))) {
LOG_WARN("failed to check const expr not null", K(ret));
} else if (!is_valid) {
// do nothing
} else if (OB_FAIL(check_cast_const_expr(const_info, is_valid))) {
LOG_WARN("failed to check cast const expr", K(ret));
}
return ret;
}
int ObTransformConstPropagate::check_const_expr_not_null(const ObDMLStmt &stmt,
ExprConstInfo &const_info,
bool &is_valid)
{
int ret = OB_SUCCESS;
is_valid = false;
ObRawExpr *const_expr = const_info.const_expr_;
if (OB_ISNULL(const_expr) ||
OB_UNLIKELY(!const_expr->is_const_expr()) ||
OB_ISNULL(ctx_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("params are invalid", K(ret), K(const_expr), K(ctx_));
} else if (const_expr->has_flag(CNT_DYNAMIC_PARAM)) {
// do nothing
} else {
ObNotNullContext not_null_ctx(*ctx_, &stmt);
ObArray<ObRawExpr *> constraints;
bool is_not_null = false;
if (OB_FAIL(ObTransformUtils::is_expr_not_null(not_null_ctx,
const_expr,
is_not_null,
&constraints))) {
LOG_WARN("failed to check expr not null", K(ret));
} else if (is_not_null) {
is_valid = true;
if (!constraints.empty()) {
const_info.need_add_constraint_ = PRE_CALC_RESULT_NOT_NULL;
}
}
}
return ret;
}
int ObTransformConstPropagate::check_cast_const_expr(ExprConstInfo &const_info,
bool &is_valid)
{
int ret = OB_SUCCESS;
bool need_cast = false;
bool is_scale_adjust_cast = false;
ObObj value;
if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->allocator_) || OB_ISNULL(ctx_->session_info_) ||
OB_ISNULL(const_info.column_expr_) || OB_ISNULL(const_info.const_expr_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (!const_info.const_expr_->is_static_scalar_const_expr()) {
is_valid = false;
} else if (const_info.need_add_constraint_ == PRE_CALC_RESULT_NULL ||
ObTransformUtils::is_const_null(*const_info.const_expr_)) {
// do nothing
} else if (OB_FAIL(ObRawExprUtils::check_need_cast_expr(const_info.const_expr_->get_result_type(),
const_info.column_expr_->get_result_type(),
need_cast,
is_scale_adjust_cast))) {
LOG_WARN("failed to check need cast expr", K(ret));
if (OB_ERR_INVALID_TYPE_FOR_OP == ret) { // rewrite should not happened instead of failed a error
ret = OB_SUCCESS;
is_valid = false;
} else {
LOG_WARN("failed to check need cast expr", K(ret));
}
} else if (!need_cast) {
// do nothing
} else if (OB_FAIL(ObSQLUtils::calc_const_or_calculable_expr(ctx_->exec_ctx_,
const_info.const_expr_,
value,
is_valid,
*ctx_->allocator_))) {
LOG_WARN("failed to calc const or caculable expr", K(ret));
} else if (!is_valid) {
// do nothing
} else {
const ObObj *dest_val = NULL;
const ObExprResType &dst_type = const_info.column_expr_->get_result_type();
ObDataTypeCastParams dtc_params = ctx_->session_info_->get_dtc_params();
ObCastCtx cast_ctx(ctx_->allocator_,
&dtc_params,
CM_WARN_ON_FAIL,
dst_type.get_collation_type());
EXPR_CAST_OBJ_V2(dst_type.get_type(), value, dest_val);
ObObjType cmp_type = ObMaxType;
int64_t eq_cmp = 0;
if (OB_FAIL(ret)) {
if (OB_ERR_INVALID_DATATYPE == ret) { // rewrite should not happened instead of failed a error
ret = OB_SUCCESS;
is_valid = false;
} else {
LOG_WARN("failed to cast obj to dest type", K(ret), K(value), K(dst_type.get_type()));
}
} else if (OB_FAIL(ObExprResultTypeUtil::get_relational_cmp_type(cmp_type,
value.get_type(),
dest_val->get_type()))) {
LOG_WARN("failed to get compare type", K(ret));
} else if (OB_FAIL(ObRelationalExprOperator::compare_nullsafe(eq_cmp,
value,
*dest_val,
cast_ctx,
cmp_type,
dst_type.get_collation_type()))) {
LOG_WARN("failed to compare obj value", K(ret));
} else if (eq_cmp != 0) {
is_valid = false;
} else {
is_valid = true;
// lossless cast constraint contains not null constraint, just overwrite constraint type
const_info.need_add_constraint_ = PRE_CALC_LOSSLESS_CAST;
}
}
return ret;
}
int ObTransformConstPropagate::check_can_replace_in_select(ObSelectStmt *stmt,
ObRawExpr *target_expr,
bool ignore_all_select_exprs,
bool &can_replace)
{
int ret = OB_SUCCESS;
can_replace = true;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && can_replace && i < stmt->get_select_items().count(); ++i) {
ObSEArray<ObRawExpr *, 8> parent_exprs;
ObRawExpr *&cur_expr = stmt->get_select_items().at(i).expr_;
if (OB_ISNULL(cur_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (OB_FAIL(recursive_check_can_replace_in_select(cur_expr,
target_expr,
parent_exprs,
ignore_all_select_exprs,
can_replace))) {
LOG_WARN("failed to replace select exprs based on equal_pair", K(ret));
}
}
return ret;
}
int ObTransformConstPropagate::recursive_check_can_replace_in_select(ObRawExpr *expr,
ObRawExpr *target_expr,
ObIArray<ObRawExpr *> &parent_exprs,
bool ignore_all_select_exprs,
bool &can_replace)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(expr) || OB_ISNULL(target_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid param", K(ret));
} else if (expr == target_expr) {
if (ignore_all_select_exprs || parent_exprs.empty()) {
can_replace = false;
} else if (OB_FAIL(ObTransformUtils::check_can_replace(expr, parent_exprs,
false, can_replace))) {
LOG_WARN("failed to check can replace", K(ret));
}
} else if (can_replace && expr->get_param_count() > 0) {
int64_t N = expr->get_param_count();
if (OB_FAIL(parent_exprs.push_back(expr))) {
LOG_WARN("failed to push back", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && can_replace && i < N; ++i) {
if (OB_FAIL(SMART_CALL(recursive_check_can_replace_in_select(expr->get_param_expr(i),
target_expr,
parent_exprs,
ignore_all_select_exprs,
can_replace)))) {
LOG_WARN("replace reference column failed", K(ret));
}
}
if (OB_SUCC(ret)) {
parent_exprs.pop_back();
}
}
return ret;
}
int ObTransformConstPropagate::check_set_op_expr_const(ObSelectStmt *stmt,
const ObSetOpRawExpr* set_op_expr,
ObRawExpr *&const_expr,
ObIArray<ObPCParamEqualInfo> &equal_infos)
{
int ret = OB_SUCCESS;
int64_t idx = -1;
const_expr = NULL;
bool is_valid = true;
ObStmtCompareContext context;
if (OB_ISNULL(stmt) || OB_ISNULL(stmt->get_query_ctx())
|| OB_ISNULL(set_op_expr) || OB_UNLIKELY(!stmt->is_set_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid set op expr", K(ret));
} else if (OB_FALSE_IT(idx = set_op_expr->get_idx())) {
} else if (idx < 0 || idx >= stmt->get_select_item_size()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("union expr param count is wrong", K(ret), K(idx), K(stmt->get_select_item_size()));
} else {
context.init(&stmt->get_query_ctx()->calculable_items_);
ObIArray<ObSelectStmt*> &child_stmts = stmt->get_set_query();
ObRawExpr* first_expr = NULL;
if (T_OP_UNION == set_op_expr->get_expr_type()) {
// for union, const of children needs to have unique value
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < child_stmts.count(); ++i) {
ObSelectStmt *child = child_stmts.at(i);
if (OB_ISNULL(child)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid child expr", K(ret));
} else if (idx >= child->get_select_item_size()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid param for child stmt ", K(ret), K(idx), K(child->get_select_item_size()));
} else {
ObRawExpr* expr = child->get_select_item(idx).expr_;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid expr", K(ret));
} else if (!expr->is_const_expr()) {
is_valid = false;
} else if (i == 0) {
first_expr = expr;
} else if (OB_NOT_NULL(first_expr) && !expr->same_as(*first_expr, &context)) {
is_valid = false;
} else if (OB_FAIL(append(equal_infos, context.equal_param_info_))) {
LOG_WARN("failed to append equal param map", K(ret));
} else {
context.equal_param_info_.reset();
}
}
}
} else if (T_OP_INTERSECT == set_op_expr->get_expr_type()) {
// for intersect, only need to check any child is const and no need to maintain constriant
for (int64_t i = 0; OB_SUCC(ret) && NULL == first_expr && i < child_stmts.count(); ++i) {
ObSelectStmt *child = child_stmts.at(i);
if (OB_ISNULL(child)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid child expr", K(ret));
} else if (idx >= child->get_select_item_size()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid param for child stmt ", K(ret), K(idx), K(child->get_select_item_size()));
} else {
ObRawExpr* expr = child->get_select_item(idx).expr_;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid expr", K(ret));
} else if (!expr->is_const_expr()) {
// do nothing
} else {
first_expr = expr;
}
}
}
} else if (T_OP_EXCEPT == set_op_expr->get_expr_type()) {
// for except, only need to check the first child is const and no need to maintain constriant
ObSelectStmt *child = child_stmts.at(0);
if (OB_ISNULL(child)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid child expr", K(ret));
} else if (idx >= child->get_select_item_size()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid param for child stmt ", K(ret), K(idx), K(child->get_select_item_size()));
} else {
ObRawExpr* expr = child->get_select_item(idx).expr_;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid expr", K(ret));
} else if (!expr->is_const_expr()) {
// do nothing
} else {
first_expr = expr;
}
}
}
if (OB_SUCC(ret) && is_valid) {
const_expr = first_expr;
}
}
return ret;
}
int ObTransformConstPropagate::is_parent_null_side(ObDMLStmt *&parent_stmt,
ObDMLStmt *&stmt,
bool &is_on_null_side)
{
int ret = OB_SUCCESS;
is_on_null_side = false;
if (OB_ISNULL(parent_stmt) || OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && !is_on_null_side && i < parent_stmt->get_table_size(); ++i) {
TableItem *table_item = NULL;
if (OB_ISNULL(table_item = parent_stmt->get_table_item(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table item is null", K(ret), K(i), K(table_item));
} else if (!table_item->is_generated_table() ||
table_item->ref_query_ != stmt) {
// do nothing
} else if (OB_FAIL(ObOptimizerUtil::is_table_on_null_side(parent_stmt,
table_item->table_id_,
is_on_null_side))) {
LOG_WARN("failed to check null side", K(ret));
}
}
}
return ret;
}
int ObTransformConstPropagate::collect_equal_param_constraints(ObIArray<ExprConstInfo> &expr_const_infos)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(ctx_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid stmt", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < expr_const_infos.count(); ++i) {
if (!expr_const_infos.at(i).is_used_) {
// do nothing
} else if (OB_FAIL(append(ctx_->equal_param_constraints_,
expr_const_infos.at(i).equal_infos_))) {
LOG_WARN("failed to append equal param constraint", K(ret));
} else if (expr_const_infos.at(i).is_complex_const_info_) {
if (OB_UNLIKELY(expr_const_infos.at(i).multi_need_add_constraints_.count() !=
expr_const_infos.at(i).multi_const_exprs_.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(ret), K(expr_const_infos));
}
for (int64_t j = 0; OB_SUCC(ret) && j < expr_const_infos.at(i).multi_const_exprs_.count(); ++j) {
if (OB_FAIL(add_equal_param_constraint(expr_const_infos.at(i).column_expr_,
expr_const_infos.at(i).multi_const_exprs_.at(j),
expr_const_infos.at(i).multi_need_add_constraints_.at(j)))) {
LOG_WARN("failed to add equal param constraint", K(ret));
}
}
} else if (OB_FAIL(add_equal_param_constraint(expr_const_infos.at(i).column_expr_,
expr_const_infos.at(i).const_expr_,
expr_const_infos.at(i).need_add_constraint_))) {
LOG_WARN("failed to add equal param constraint", K(ret));
}
}
return ret;
}
int ObTransformConstPropagate::add_equal_param_constraint(ObRawExpr *column_expr,
ObRawExpr *const_expr,
PreCalcExprExpectResult expect_result)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(column_expr) || OB_ISNULL(const_expr) || OB_ISNULL(ctx_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (PRE_CALC_RESULT_NONE == expect_result) {
// do nothing
} else if (PRE_CALC_RESULT_NULL == expect_result) {
if (OB_FAIL(ObTransformUtils::add_param_null_constraint(*ctx_, const_expr))) {
LOG_WARN(" fail to add param null constraint");
}
} else if (PRE_CALC_RESULT_NOT_NULL == expect_result) {
if (OB_FAIL(ObTransformUtils::add_param_not_null_constraint(*ctx_, const_expr))) {
LOG_WARN("failed to add param not null constraint", K(ret));
}
} else if (PRE_CALC_LOSSLESS_CAST == expect_result) {
if (OB_FAIL(ObTransformUtils::add_param_lossless_cast_constraint(*ctx_,
const_expr,
column_expr))) {
LOG_WARN("failed to add param not null constraint", K(ret));
}
} else {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected expect result type", K(expect_result), K(ret));
}
return ret;
}
int ObTransformConstPropagate::recursive_collect_equal_pair_from_condition(ObDMLStmt *stmt,
ObRawExpr *expr,
ConstInfoContext &const_ctx,
bool &trans_happened)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(stmt) || OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(stmt), K(expr));
} else if (T_OP_EQ == expr->get_expr_type()) {
// todo: support general expr const info instead of column expr
ObRawExpr *param_1 = expr->get_param_expr(0);
ObRawExpr *param_2 = expr->get_param_expr(1);
ObRawExpr *column_expr = NULL;
ObRawExpr *const_expr = NULL;
bool is_valid = true;
if (OB_ISNULL(param_1) || OB_ISNULL(param_2)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid param", K(ret));
} else if (param_1->is_column_ref_expr() &&
param_2->is_const_expr()) {
column_expr = param_1;
const_expr = param_2;
} else if (param_2->is_column_ref_expr() &&
param_1->is_const_expr()) {
column_expr = param_2;
const_expr = param_1;
} else {
is_valid = false;
}
if (OB_SUCC(ret) && is_valid) {
ExprConstInfo new_info;
new_info.column_expr_ = column_expr;
new_info.const_expr_ = const_expr;
if (OB_FAIL(check_const_expr_validity(*stmt, new_info, is_valid))) {
LOG_WARN("failed to check const expr validity", K(ret));
} else if (!is_valid) {
// do nothing
} else {
new_info.exclude_expr_ = expr;
if (OB_FAIL(const_ctx.add_const_info(new_info))) {
LOG_WARN("failed to push back", K(ret));
}
}
}
} else if (T_OP_AND == expr->get_expr_type()) {
for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
bool is_happened = false;
if (OB_FAIL(SMART_CALL(recursive_collect_equal_pair_from_condition(stmt,
expr->get_param_expr(i),
const_ctx,
trans_happened)))) {
LOG_WARN("failed to recursive collect const info from condition", K(ret));
} else {
trans_happened |= is_happened;
}
}
} else if (T_OP_IN == expr->get_expr_type()) {
ObRawExpr *l_expr = NULL;
ObRawExpr *r_expr = NULL;
if (OB_UNLIKELY(2 != expr->get_param_count()) ||
OB_ISNULL(l_expr = expr->get_param_expr(0)) ||
OB_ISNULL(r_expr = expr->get_param_expr(1))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(l_expr), K(r_expr), K(ret));
} else if (l_expr->is_column_ref_expr() && T_OP_ROW == r_expr->get_expr_type()) {
bool is_valid = true;
ExprConstInfo new_info;
new_info.column_expr_ = l_expr;
new_info.is_complex_const_info_ = true;
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < r_expr->get_param_count(); ++i) {
new_info.const_expr_ = r_expr->get_param_expr(i);
if (OB_ISNULL(r_expr->get_param_expr(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(r_expr));
} else if (!r_expr->get_param_expr(i)->is_const_expr()) {
is_valid = false;
} else if (OB_FAIL(check_const_expr_validity(*stmt,
new_info,
is_valid))) {
LOG_WARN("failed to check const expr validity", K(ret));
} else if (!is_valid) {
/*do nothing*/
} else if (OB_FAIL(new_info.multi_const_exprs_.push_back(r_expr->get_param_expr(i)))) {
LOG_WARN("failed to push back", K(ret));
} else if (OB_FAIL(new_info.multi_need_add_constraints_.push_back(new_info.need_add_constraint_))) {
LOG_WARN("failed to push back", K(ret));
}
}
if (OB_SUCC(ret) && is_valid) {
if (OB_FAIL(const_ctx.add_const_info(new_info))) {
LOG_WARN("failed to push back", K(ret));
}
}
}
} else if (T_OP_OR == expr->get_expr_type()) {
ObArray<ExprConstInfo> complex_infos;
for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
ConstInfoContext tmp_ctx(const_ctx.shared_expr_checker_, const_ctx.allow_trans_);
bool child_happened = false;
bool current_happened = false;
if (OB_FAIL(SMART_CALL(recursive_collect_equal_pair_from_condition(stmt,
expr->get_param_expr(i),
tmp_ctx,
child_happened)))) {
LOG_WARN("failed to recursive collect const info from condition", K(ret));
} else if (OB_FAIL(replace_expr_internal(expr->get_param_expr(i),
tmp_ctx,
current_happened))) {
LOG_WARN("failed to replace expr", K(ret));
} else {
trans_happened |= child_happened || current_happened;
}
if (OB_SUCC(ret)) {
if (0 == i) {
if (OB_FAIL(complex_infos.assign(tmp_ctx.active_const_infos_))) {
LOG_WARN("failed to assign complex infos", K(ret));
}
} else if (OB_FAIL(merge_complex_const_infos(complex_infos, tmp_ctx.active_const_infos_))) {
LOG_WARN("failed to merge complex const infos", K(ret));
}
}
if (OB_SUCC(ret) && (child_happened || current_happened)) {
if (OB_FAIL(const_ctx.merge_expired_const_infos(tmp_ctx, false))) {
LOG_WARN("failed to merge expired const infos", K(ret));
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(const_ctx.add_const_infos(complex_infos))) {
LOG_WARN("failed to append complex infos", K(ret));
}
}
} else if (T_OP_IS == expr->get_expr_type()) {
ObRawExpr *param_1 = expr->get_param_expr(0);
ObRawExpr *param_2 = expr->get_param_expr(1);
if (OB_ISNULL(param_1) || OB_ISNULL(param_2)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null ptr", K(param_1), K(param_2), K(ret));
} else if (param_1->is_column_ref_expr() &&
ObNullType == param_2->get_result_type().get_type()) {
ExprConstInfo new_info;
new_info.column_expr_ = param_1;
new_info.const_expr_ = param_2;
new_info.exclude_expr_ = expr;
if (OB_FAIL(const_ctx.add_const_info(new_info))) {
LOG_WARN("failed to push back", K(ret));
}
}
}
return ret;
}
int ObTransformConstPropagate::merge_complex_const_infos(ObIArray<ExprConstInfo> &cur_const_infos,
ObIArray<ExprConstInfo> &new_const_infos)
{
int ret = OB_SUCCESS;
ObSEArray<ExprConstInfo, 4> tmp_const_infos;
for (int64_t i = 0; OB_SUCC(ret) && i < cur_const_infos.count(); ++i) {
bool found = false;
ObRawExpr *param_expr = cur_const_infos.at(i).column_expr_;
if (OB_ISNULL(param_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
}
for (int64_t j = 0; OB_SUCC(ret) && !found && j < new_const_infos.count(); ++j) {
if (param_expr == new_const_infos.at(j).column_expr_) {
found = true;
ExprConstInfo new_info;
if (OB_FAIL(merge_const_info(cur_const_infos.at(i), new_const_infos.at(j), new_info))) {
LOG_WARN("failed to merge const info", K(ret));
} else if (OB_FAIL(tmp_const_infos.push_back(new_info))) {
LOG_WARN("failed to push back", K(ret));
}
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(cur_const_infos.assign(tmp_const_infos))) {
LOG_WARN("failed to assign const infos", K(ret));
}
}
return ret;
}
int ObTransformConstPropagate::merge_const_info(ExprConstInfo &const_info_l,
ExprConstInfo &const_info_r,
ExprConstInfo &new_info)
{
int ret = OB_SUCCESS;
new_info.column_expr_ = const_info_l.column_expr_;
new_info.is_complex_const_info_ = true;
if (OB_FAIL(new_info.merge_complex(const_info_l))) {
LOG_WARN("failed to merge const info left", K(ret));
} else if (OB_FAIL(new_info.merge_complex(const_info_r))) {
LOG_WARN("failed to merge const info right", K(ret));
}
return ret;
}
int ObTransformConstPropagate::replace_check_constraint_exprs(ObDMLStmt *stmt,
ConstInfoContext &const_ctx,
bool &trans_happened)
{
int ret = OB_SUCCESS;
trans_happened = false;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(stmt));
} else if (!const_ctx.allow_trans_) {
/* do nothing */
} else {
LOG_TRACE("begin replace check constraint exprs", K(const_ctx), K(stmt->get_check_constraint_items()));
for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_check_constraint_items().count(); ++i) {
ObDMLStmt::CheckConstraintItem &item = stmt->get_check_constraint_items().at(i);
for (int64_t j = 0; OB_SUCC(ret) && j < item.check_constraint_exprs_.count(); ++j) {
ObRawExpr *check_constraint_expr = item.check_constraint_exprs_.at(j);
bool is_valid = false;
ObSEArray<ObRawExpr*, 16> old_column_exprs;
ObSEArray<ObRawExpr*, 16> new_const_exprs;
ObRawExpr *part_column_expr = NULL;
int64_t complex_cst_info_idx = -1;
if (OB_ISNULL(check_constraint_expr) ||
OB_UNLIKELY(item.check_constraint_exprs_.count() != item.check_flags_.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(item));
} else if (!(item.check_flags_.at(j) & ObDMLStmt::CheckConstraintFlag::IS_VALIDATE_CHECK) &&
!(item.check_flags_.at(j) & ObDMLStmt::CheckConstraintFlag::IS_RELY_CHECK)) {
//do nothing
} else if (OB_FAIL(check_constraint_expr_validity(check_constraint_expr,
stmt->get_part_exprs(),
const_ctx.active_const_infos_,
part_column_expr,
old_column_exprs,
new_const_exprs,
complex_cst_info_idx,
is_valid))) {
LOG_WARN("failed to check constraint expr validity", K(ret));
} else if (!is_valid) {
//do nothing
} else if (OB_FAIL(do_replace_check_constraint_expr(stmt,
check_constraint_expr,
const_ctx.active_const_infos_,
part_column_expr,
old_column_exprs,
new_const_exprs,
complex_cst_info_idx,
trans_happened))) {
LOG_WARN("failed to do replace check constraint expr", K(ret));
}
}
}
}
return ret;
}
int ObTransformConstPropagate::check_constraint_expr_validity(ObRawExpr *check_constraint_expr,
const ObIArray<ObDMLStmt::PartExprItem> &part_items,
ObIArray<ExprConstInfo> &expr_const_infos,
ObRawExpr *&part_column_expr,
ObIArray<ObRawExpr*> &old_column_exprs,
ObIArray<ObRawExpr*> &new_const_exprs,
int64_t &complex_cst_info_idx,
bool &is_valid)
{
int ret = OB_SUCCESS;
is_valid = false;
if (OB_ISNULL(check_constraint_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(check_constraint_expr));
} else if (T_OP_EQ == check_constraint_expr->get_expr_type()) {
ObRawExpr *l_expr = check_constraint_expr->get_param_expr(0);
ObRawExpr *r_expr = check_constraint_expr->get_param_expr(1);
bool is_happened = false;
if (OB_ISNULL(l_expr) || OB_ISNULL(r_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(l_expr), K(r_expr));
} else if (l_expr->is_column_ref_expr() &&
OB_FAIL(do_check_constraint_param_expr_vaildity(l_expr,
r_expr,
part_items,
expr_const_infos,
old_column_exprs,
new_const_exprs,
complex_cst_info_idx,
is_valid))) {
LOG_WARN("failed to do check constraint param expr vaildity", K(ret));
} else if (is_valid) {
part_column_expr = l_expr;
} else if (r_expr->is_column_ref_expr() &&
OB_FAIL(do_check_constraint_param_expr_vaildity(r_expr,
l_expr,
part_items,
expr_const_infos,
old_column_exprs,
new_const_exprs,
complex_cst_info_idx,
is_valid))) {
LOG_WARN("failed to do check constraint param expr vaildity", K(ret));
} else if (is_valid) {
part_column_expr = r_expr;
}
LOG_TRACE("Succeed check constraint expr validity", KPC(check_constraint_expr), K(is_valid));
}
return ret;
}
/*if the check constraint expr is valid:
* 1. equal expr which the column is in left or right param expr and the column is partition column;
* 2. the column which in the non-partition column expr should be can replaced const expr;
* 3. if the non-partition column expr is string sys func, it‘s insensitive to collation.
*/
int ObTransformConstPropagate::do_check_constraint_param_expr_vaildity(
ObRawExpr *column_param_expr,
ObRawExpr *non_column_param_expr,
const ObIArray<ObDMLStmt::PartExprItem> &part_items,
ObIArray<ExprConstInfo> &expr_const_infos,
ObIArray<ObRawExpr*> &old_column_exprs,
ObIArray<ObRawExpr*> &new_const_exprs,
int64_t &complex_cst_info_idx,
bool &is_valid)
{
int ret = OB_SUCCESS;
is_valid = false;
if (OB_ISNULL(column_param_expr) || OB_ISNULL(non_column_param_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(column_param_expr), K(non_column_param_expr), K(ret));
} else {
//check rule 1
for (int64_t i = 0; !is_valid && i < part_items.count(); ++i) {
is_valid = column_param_expr == part_items.at(i).part_expr_ ||
column_param_expr == part_items.at(i).subpart_expr_;
}
if (is_valid) {
bool is_found = false;
for (int64_t i = 0; !is_found && i < expr_const_infos.count(); ++i) {
is_found = (column_param_expr == expr_const_infos.at(i).column_expr_);
}
is_valid = !is_found;
}
//check rule 2
if (is_valid) {
ObSEArray<ObRawExpr *, 8> parent_exprs;
if (OB_FAIL(ObRawExprUtils::extract_column_exprs(non_column_param_expr, old_column_exprs))) {
LOG_WARN("failed to extract column exprs", K(ret));
} else if (OB_FAIL(check_all_const_propagate_column(old_column_exprs,
expr_const_infos,
new_const_exprs,
complex_cst_info_idx,
is_valid))) {
LOG_WARN("failed to check all const propagate column", K(ret));
} else if (!is_valid) {
//do nothing
} else if (complex_cst_info_idx >= 0
&& expr_const_infos.at(complex_cst_info_idx).multi_const_exprs_.count() > 10) {
is_valid = false; //do not deduce big in
//check rule 3
} else if (OB_FAIL(recursive_check_non_column_param_expr_validity(non_column_param_expr,
parent_exprs,
is_valid))) {
LOG_WARN("failed to recursive check non column param expr validity", K(ret));
} else {
LOG_TRACE("succeed to do check constraint param expr vaildity", KPC(column_param_expr),
KPC(non_column_param_expr), K(expr_const_infos), K(part_items), K(old_column_exprs),
K(old_column_exprs), K(new_const_exprs), K(complex_cst_info_idx), K(is_valid));
}
}
}
return ret;
}
int ObTransformConstPropagate::check_constraint_value_validity(ObRawExpr *value_expr, bool &reject)
{
int ret = OB_SUCCESS;
reject = false;
ObObj result;
bool got_result = false;
if (OB_ISNULL(value_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected error", K(ret));
} else if (OB_FAIL(value_expr->extract_info())) {
LOG_WARN("extract info failed", K(ret));
} else if (OB_FAIL(ObSQLUtils::calc_const_or_calculable_expr(ctx_->exec_ctx_,
value_expr,
result,
got_result,
*ctx_->allocator_))) {
LOG_WARN("calc const or calculable expr failed", K(ret));
} else if (!got_result) {
reject = true;
//uncalculable
} else if (result.is_null()) {
reject = true;
//violate null reject, can not add new condition
}
return ret;
}
int ObTransformConstPropagate::check_all_const_propagate_column(ObIArray<ObRawExpr*> &column_exprs,
ObIArray<ExprConstInfo> &expr_const_infos,
ObIArray<ObRawExpr*> &new_const_exprs,
int64_t &const_info_idx,
bool &is_all)
{
int ret = OB_SUCCESS;
const_info_idx = -1;
is_all = !column_exprs.empty();
int64_t remove_id = -1;
for (int64_t i = 0; OB_SUCC(ret) && is_all && i < column_exprs.count(); ++i) {
bool is_found = false;
for (int64_t j = 0; OB_SUCC(ret) && !is_found && j < expr_const_infos.count(); ++j) {
if (column_exprs.at(i) == expr_const_infos.at(j).column_expr_) {
if (expr_const_infos.at(j).is_complex_const_info_) {
if (const_info_idx != -1) {
is_found = (const_info_idx == j);
} else {
is_found = true;
const_info_idx = j;
remove_id = i;
}
} else if (OB_FAIL(prepare_new_expr(expr_const_infos.at(j)))) {
LOG_WARN("failed to create new expr", K(ret));
} else if (OB_FAIL(new_const_exprs.push_back(expr_const_infos.at(j).new_expr_))) {
LOG_WARN("failed to push back", K(ret));
} else {
is_found = true;
}
}
}
is_all = is_found;
}
if (const_info_idx != -1 && remove_id != -1) {
if (OB_FAIL(column_exprs.remove(remove_id))) {
LOG_WARN("failed to remove", K(ret));
}
}
LOG_TRACE("check all const propagate column", K(column_exprs), K(const_info_idx),
K(expr_const_infos), K(new_const_exprs), K(is_all));
return ret;
}
int ObTransformConstPropagate::recursive_check_non_column_param_expr_validity(ObRawExpr *expr,
ObIArray<ObRawExpr *> &parent_exprs,
bool &is_valid)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(expr), K(ret));
} else if (expr->is_column_ref_expr()) {
if (OB_FAIL(ObTransformUtils::check_can_replace(expr, parent_exprs, true, is_valid))) {
LOG_WARN("failed to check can replace", K(ret));
}
} else if (expr->get_param_count() > 0) {
if (OB_FAIL(parent_exprs.push_back(expr))) {
LOG_WARN("failed to push back", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < expr->get_param_count(); ++i) {
if (OB_FAIL(SMART_CALL(recursive_check_non_column_param_expr_validity(expr->get_param_expr(i),
parent_exprs,
is_valid)))) {
LOG_WARN("replace reference column failed", K(ret));
}
}
if (OB_SUCC(ret)) {
parent_exprs.pop_back();
}
}
return ret;
}
int ObTransformConstPropagate::do_replace_check_constraint_expr(ObDMLStmt *stmt,
ObRawExpr *check_constraint_expr,
ObIArray<ExprConstInfo> &expr_const_infos,
ObRawExpr *part_column_expr,
ObIArray<ObRawExpr*> &old_column_exprs,
ObIArray<ObRawExpr*> &new_const_exprs,
int64_t &complex_cst_info_idx,
bool &trans_happened)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(stmt) || OB_ISNULL(check_constraint_expr) || OB_ISNULL(part_column_expr) ||
OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_) ||
OB_UNLIKELY(old_column_exprs.count() != new_const_exprs.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(ret), K(check_constraint_expr), K(stmt), K(part_column_expr),
K(ctx_), K(old_column_exprs), K(new_const_exprs));
} else {
bool reject = false;
ObRawExpr *new_check_cst_expr = NULL;
ObRawExpr *value_expr = NULL;
ObRawExprCopier copier(*ctx_->expr_factory_);
ObSEArray<ObRawExpr *, 4> not_null_values;
if (complex_cst_info_idx >= 0) {//need generate in condition for complex const(or/in expr)
if (OB_UNLIKELY(complex_cst_info_idx > expr_const_infos.count() ||
!expr_const_infos.at(complex_cst_info_idx).is_complex_const_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(ret), K(complex_cst_info_idx), K(expr_const_infos));
} else if (OB_FAIL(build_new_in_condition_expr(check_constraint_expr,
expr_const_infos.at(complex_cst_info_idx),
part_column_expr,
old_column_exprs,
new_const_exprs,
new_check_cst_expr,
not_null_values,
reject))) {
LOG_WARN("failed to build new in condition expr", K(ret));
} else if (reject) {
} else {
expr_const_infos.at(complex_cst_info_idx).is_used_ = true;
}
} else if (OB_FAIL(copier.add_replaced_expr(old_column_exprs, new_const_exprs))) {
LOG_WARN("failed to add replace pair", K(ret));
} else if (OB_FAIL(copier.add_skipped_expr(part_column_expr))) {
LOG_WARN("failed to add skipped expr", K(ret));
} else if (OB_FAIL(copier.copy(check_constraint_expr, new_check_cst_expr))) {
LOG_WARN("failed to copy expr", K(ret));
} else if (OB_ISNULL(new_check_cst_expr) || OB_UNLIKELY(new_check_cst_expr->get_param_count() < 2)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected error", K(ret), KPC(new_check_cst_expr));
} else if (OB_ISNULL(value_expr = (part_column_expr == new_check_cst_expr->get_param_expr(0) ?
new_check_cst_expr->get_param_expr(1) :
new_check_cst_expr->get_param_expr(0)))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("value expr is null", K(ret));
} else if (OB_FAIL(not_null_values.push_back(value_expr))) {
LOG_WARN("push back failed", K(ret));
} else if (OB_FAIL(check_constraint_value_validity(value_expr, reject))) {
LOG_WARN("ensure check cst failed", K(ret));
} else {/*do nothing*/}
if (OB_SUCC(ret) && !reject) {
ObRawExpr *or_expr = NULL;
ObRawExpr *part_col_is_null = NULL;
ObSEArray<ObRawExpr *, 2> or_expr_children;
if (OB_FAIL(ObRawExprUtils::build_is_not_null_expr(*ctx_->expr_factory_, part_column_expr, false, part_col_is_null))) {
LOG_WARN("build is null failed", K(ret));
} else if (OB_FAIL(or_expr_children.push_back(part_col_is_null))) {
LOG_WARN("push back failed", K(ret));
} else if (OB_FAIL(or_expr_children.push_back(new_check_cst_expr))) {
LOG_WARN("push back failed", K(ret));
} else if (OB_FAIL(ObRawExprUtils::build_or_exprs(*ctx_->expr_factory_, or_expr_children, or_expr))) {
LOG_WARN("build or exprs failed", K(ret));
} else {
new_check_cst_expr = or_expr;
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(batch_mark_expr_const_infos_used(old_column_exprs, expr_const_infos))) {
LOG_WARN("failed to batch mark_expr_const_infos_used", K(ret));
} else if (OB_FAIL(stmt->get_condition_exprs().push_back(new_check_cst_expr))) {
LOG_WARN("failed to push back", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < not_null_values.count(); i++) {
if (OB_FAIL(ObTransformUtils::add_param_not_null_constraint(*ctx_, not_null_values.at(i)))) {
LOG_WARN("add not null cst failed", K(ret));
}
}
trans_happened = true;
LOG_TRACE("Succeed to do replace check constraint expr", KPC(new_check_cst_expr));
}
}
}
return ret;
}
int ObTransformConstPropagate::build_new_in_condition_expr(ObRawExpr *check_constraint_expr,
ExprConstInfo &expr_const_info,
ObRawExpr *part_column_expr,
ObIArray<ObRawExpr*> &old_column_exprs,
ObIArray<ObRawExpr*> &new_const_exprs,
ObRawExpr *&new_condititon_expr,
ObIArray<ObRawExpr*> &not_null_values,
bool &reject)
{
int ret = OB_SUCCESS;
new_condititon_expr = NULL;
ObRawExpr *non_part_column_expr = NULL;
if (OB_ISNULL(check_constraint_expr) || OB_ISNULL(part_column_expr) || OB_ISNULL(ctx_) ||
OB_ISNULL(ctx_->expr_factory_) || OB_ISNULL(ctx_->session_info_) ||
OB_UNLIKELY(!expr_const_info.is_complex_const_info_ ||
expr_const_info.multi_const_exprs_.empty() ||
check_constraint_expr->get_param_count() != 2)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(ret), KPC(check_constraint_expr), K(part_column_expr),
K(ctx_), K(expr_const_info));
} else {
ObOpRawExpr *in_expr = NULL;
ObOpRawExpr *row_expr = NULL;
ObRawExpr *non_part_column_expr = NULL;
if (part_column_expr == check_constraint_expr->get_param_expr(0)) {
non_part_column_expr = check_constraint_expr->get_param_expr(1);
} else if (part_column_expr == check_constraint_expr->get_param_expr(1)) {
non_part_column_expr = check_constraint_expr->get_param_expr(0);
}
if (OB_ISNULL(non_part_column_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(ret), K(non_part_column_expr), KPC(check_constraint_expr));
} else if (OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_OP_IN, in_expr)) ||
OB_FAIL(ctx_->expr_factory_->create_raw_expr(T_OP_ROW, row_expr))) {
LOG_WARN("create add expr failed", K(ret), K(in_expr), K(row_expr));
} else if (OB_ISNULL(in_expr) || OB_ISNULL(row_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("add expr is null", K(ret), K(in_expr), K(row_expr));
} else if (OB_FAIL(in_expr->add_param_expr(part_column_expr))) {
LOG_WARN("failed to add param expr", K(ret));
} else if (OB_FAIL(in_expr->add_param_expr(row_expr))) {
LOG_WARN("failed to add param expr", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && !reject && i < expr_const_info.multi_const_exprs_.count(); ++i) {
ObRawExpr *new_param_expr = NULL;
ObRawExprCopier copier(*ctx_->expr_factory_);
if (OB_FAIL(old_column_exprs.push_back(expr_const_info.column_expr_))) {
LOG_WARN("failed to push back", K(ret));
} else if (OB_FAIL(new_const_exprs.push_back(expr_const_info.multi_const_exprs_.at(i)))) {
LOG_WARN("failed to push back", K(ret));
} else if (OB_FAIL(copier.add_replaced_expr(old_column_exprs, new_const_exprs))) {
LOG_WARN("failed to add replace pair", K(ret));
} else if (OB_FAIL(copier.copy(non_part_column_expr, new_param_expr))) {
LOG_WARN("failed to copy expr", K(ret));
} else if (OB_FAIL(row_expr->add_param_expr(new_param_expr))) {
LOG_WARN("failed to add param expr", K(ret));
} else if (OB_FAIL(not_null_values.push_back(new_param_expr))) {
LOG_WARN("failed to add param expr", K(ret));
} else if (OB_FAIL(check_constraint_value_validity(new_param_expr, reject))) {
LOG_WARN("ensure check cst failed", K(ret));
} else {
old_column_exprs.pop_back();
new_const_exprs.pop_back();
}
}
if (OB_SUCC(ret) && !reject) {
if (OB_FAIL(in_expr->formalize(ctx_->session_info_))) {
LOG_WARN("failed to formalize", K(ret));
} else {
new_condititon_expr = in_expr;
LOG_TRACE("Succeed to build new in condition expr", KPC(new_condititon_expr));
}
}
}
}
return ret;
}
int ObTransformConstPropagate::batch_mark_expr_const_infos_used(ObIArray<ObRawExpr*> &column_exprs,
ObIArray<ExprConstInfo> &expr_const_infos)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < column_exprs.count(); ++i) {
bool is_found = false;
for (int64_t j = 0; OB_SUCC(ret) && !is_found && j < expr_const_infos.count(); ++j) {
if (column_exprs.at(i) == expr_const_infos.at(j).column_expr_) {
if (expr_const_infos.at(j).is_complex_const_info_) {
is_found = true;
} else {
expr_const_infos.at(j).is_used_ = true;
is_found = true;
}
}
}
if (OB_UNLIKELY(!is_found)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(ret), K(column_exprs), K(expr_const_infos));
}
}
return ret;
}
int ObTransformConstPropagate::generate_pullup_const_info(ObSelectStmt *stmt,
ObRawExpr *expr,
ConstInfoContext &const_ctx)
{
int ret = OB_SUCCESS;
bool found = false;
if (OB_ISNULL(stmt) || OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && !found && i < const_ctx.active_const_infos_.count(); ++i) {
ExprConstInfo &cur_info = const_ctx.active_const_infos_.at(i);
ObRawExpr *column_expr = cur_info.column_expr_;
ObRawExpr *const_expr = cur_info.const_expr_;
if (cur_info.is_complex_const_info_) {
//do nothing
} else if (OB_ISNULL(column_expr) || OB_ISNULL(const_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid expr", K(ret));
} else if (expr == cur_info.column_expr_) {
found = true;
ObIArray<PullupConstInfo> *pullup_const_infos = NULL;
PullupConstInfo pullup_info;
pullup_info.column_expr_ = cur_info.column_expr_;
pullup_info.const_expr_ = cur_info.const_expr_;
pullup_info.need_add_constraint_ = cur_info.is_used_ ? cur_info.need_add_constraint_ :
PRE_CALC_RESULT_NONE;
if (OB_FAIL(pullup_info.equal_infos_.assign(cur_info.equal_infos_))) {
LOG_WARN("failed to assign equal infos", K(ret));
} else if (OB_FAIL(acquire_pullup_infos(stmt, pullup_const_infos))) {
LOG_WARN("failed to acquire pullup const infos", K(ret));
} else if (OB_ISNULL(pullup_const_infos)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("failed to acquire pullup const infos", K(ret));
} else if (OB_FAIL(pullup_const_infos->push_back(pullup_info))) {
LOG_WARN("failed to push back", K(ret));
}
}
}
return ret;
}
int ObTransformConstPropagate::acquire_pullup_infos(ObDMLStmt *stmt,
ObIArray<PullupConstInfo> *&pullup_infos)
{
int ret = OB_SUCCESS;
int64_t index = -1;
const uint64_t key = reinterpret_cast<const uint64_t>(stmt);
pullup_infos = NULL;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (OB_SUCCESS != (ret = stmt_map_.get_refactored(key, index))) {
if (OB_HASH_NOT_EXIST == ret) {
ret = OB_SUCCESS;
} else {
LOG_WARN("failed to get stmt index", K(ret));
}
} else if (OB_UNLIKELY(index >= stmt_pullup_const_infos_.count() || index < 0)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid index", K(index), K(ret));
} else {
pullup_infos = stmt_pullup_const_infos_.at(index);
}
if (OB_SUCC(ret) && NULL == pullup_infos) {
PullupConstInfos *new_infos = NULL;
index = stmt_pullup_const_infos_.count();
if (OB_ISNULL(new_infos = (PullupConstInfos *) allocator_.alloc(sizeof(PullupConstInfos)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to allocate pullup predicates array", K(ret));
} else {
new_infos = new (new_infos) PullupConstInfos();
if (OB_FAIL(stmt_pullup_const_infos_.push_back(new_infos))) {
LOG_WARN("failed to push back predicates", K(ret));
} else if (OB_FAIL(stmt_map_.set_refactored(key, index))) {
LOG_WARN("failed to add entry info hash map", K(ret));
} else {
pullup_infos = new_infos;
}
}
}
return ret;
}
int ObTransformConstPropagate::collect_from_pullup_const_infos(ObDMLStmt *stmt,
ObRawExpr *expr,
ExprConstInfo &equal_info)
{
int ret = OB_SUCCESS;
int64_t index = -1;
const uint64_t key = reinterpret_cast<const uint64_t>(stmt);
ObIArray<PullupConstInfo> *pullup_infos = NULL;
if (OB_ISNULL(stmt) || OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (OB_SUCCESS != (ret = stmt_map_.get_refactored(key, index))) {
if (OB_HASH_NOT_EXIST == ret) {
ret = OB_SUCCESS;
} else {
LOG_WARN("failed to get stmt index", K(ret));
}
} else if (OB_UNLIKELY(index >= stmt_pullup_const_infos_.count() || index < 0)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid index", K(index), K(ret));
} else {
pullup_infos = stmt_pullup_const_infos_.at(index);
}
if (OB_SUCC(ret) && NULL != pullup_infos) {
bool found = false;
for (int64_t i = 0; OB_SUCC(ret) && !found && i < pullup_infos->count(); ++i) {
PullupConstInfo &pullup_info = pullup_infos->at(i);
if (expr == pullup_info.column_expr_) {
found = true;
equal_info.const_expr_ = pullup_info.const_expr_;
equal_info.need_add_constraint_ = pullup_info.need_add_constraint_;
if (OB_FAIL(equal_info.equal_infos_.assign(pullup_info.equal_infos_))) {
LOG_WARN("failed to assign equal infos", K(ret));
}
}
}
}
return ret;
}
int ObTransformConstPropagate::replace_select_exprs_skip_agg(ObSelectStmt *stmt,
ConstInfoContext &const_ctx,
bool &trans_happened)
{
int ret = OB_SUCCESS;
ObSEArray<ObRawExpr *, 8> parent_exprs;
trans_happened = false;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_select_items().count(); ++i) {
ObRawExpr *&cur_expr = stmt->get_select_items().at(i).expr_;
parent_exprs.reuse();
bool internal_trans_happened = false;
if (OB_ISNULL(cur_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (cur_expr->is_column_ref_expr()) {
//do nothing, const infos have been pulluped befored collect having const infos
} else if (OB_FAIL(replace_select_exprs_skip_agg_internal(cur_expr,
const_ctx,
parent_exprs,
internal_trans_happened,
false))) {
LOG_WARN("failed to replace select exprs based on equal_pair", K(ret));
} else {
trans_happened |= internal_trans_happened;
}
}
return ret;
}
int ObTransformConstPropagate::replace_select_exprs_skip_agg_internal(ObRawExpr *&cur_expr,
ConstInfoContext &const_ctx,
ObIArray<ObRawExpr *> &parent_exprs,
bool &trans_happened,
bool used_in_compare)
{
int ret = OB_SUCCESS;
trans_happened = false;
if (OB_ISNULL(cur_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid parameter", K(ret));
} else if (!cur_expr->has_flag(CNT_AGG)) {
bool is_happened = false;
if (OB_FAIL(recursive_replace_expr(cur_expr,
parent_exprs,
const_ctx,
used_in_compare,
is_happened))) {
LOG_WARN("failed to recursive");
} else {
trans_happened |= is_happened;
}
} else if (cur_expr->is_aggr_expr()) {
// do nothing
} else {
int64_t N = cur_expr->get_param_count();
if (OB_FAIL(parent_exprs.push_back(cur_expr))) {
LOG_WARN("failed to push back", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
bool param_trans_happened = false;
if (OB_FAIL(SMART_CALL(replace_select_exprs_skip_agg_internal(cur_expr->get_param_expr(i),
const_ctx,
parent_exprs,
param_trans_happened,
used_in_compare)))) {
LOG_WARN("fail to replace scalar select exprs internal", K(ret));
} else {
trans_happened |= param_trans_happened;
}
}
if (OB_SUCC(ret)) {
parent_exprs.pop_back();
}
}
return ret;
}
// Check if all non-consts in T_OP_ROW can be replaced to consts.
int ObTransformConstPropagate::check_can_replace_child_of_row(ConstInfoContext &const_ctx,
ObRawExpr *&cur_expr,
bool &can_replace_child)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(cur_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret));
} else if (cur_expr->is_const_expr() || !const_ctx.allow_trans_) {
can_replace_child = false;
} else {
ObSEArray<ObRawExpr*, 4> const_cols;
bool is_const_recursively = false;
for (int64_t i = 0; OB_SUCC(ret) && i < const_ctx.active_const_infos_.count(); i++) {
if (OB_FAIL(const_cols.push_back(const_ctx.active_const_infos_.at(i).column_expr_))) {
LOG_WARN("failed to push back expr", K(ret));
}
}
if (OB_SUCC(ret) && OB_FAIL(ObOptimizerUtil::is_const_expr_recursively(cur_expr,
const_cols,
is_const_recursively))) {
LOG_WARN("failed to check const expr recursively", K(ret));
} else {
can_replace_child &= is_const_recursively;
}
}
return ret;
}
}// namespace sql
} // namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink