hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity
Files
b9cce76b3d11a984413ee430f031a9ae30308fb4
oceanbase/src/sql/rewrite/ob_transform_win_magic.cpp
jingtaoye35 55248cfd56 add IS_EXPR_DETERMINISTIC flag
2024-09-24 03:16:23 +00:00

2028 lines
90 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_win_magic.h"
#include "ob_transform_utils.h"
#include "sql/resolver/expr/ob_raw_expr_util.h"
#include "share/schema/ob_table_schema.h"
#include "sql/optimizer/ob_optimizer_util.h"
#include "sql/ob_sql_context.h"
#include "sql/rewrite/ob_stmt_comparer.h"
#include "common/ob_smart_call.h"
#include "sql/rewrite/ob_equal_analysis.h"
using namespace oceanbase::sql;
using namespace oceanbase::common;
using namespace oceanbase::share::schema;
/**
* The origin win magic implements the paper <WinMagic: Subquery Elimination Using Window Aggregation>
* And the subquery is in where condition in the paper.
* Now we try realizing it in another way. The subquery is not in where condition, while the from item is view.
* Thus we can merge some rewrite rules, and make the rewrite path more clear.
* @brief ObTransformWinMagic::transform_one_stmt
* @return
*/
int ObTransformWinMagic::transform_one_stmt(common::ObIArray<ObParentDMLStmt> &parent_stmts,
ObDMLStmt *&stmt,
bool &trans_happened)
{
int ret = OB_SUCCESS;
int64_t drill_down_idx = -1;
int64_t roll_up_idx = -2; // -1 means main stmt
ObSEArray<TableItem *, 4> trans_tables;
SMART_VARS_2((ObStmtCompareContext, context), (ObStmtMapInfo, map_info)) {
if (OB_ISNULL(stmt) || OB_ISNULL(stmt->get_query_ctx())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("stmt is null", K(ret), K(stmt));
} else if (OB_FAIL(get_view_to_trans(stmt, drill_down_idx, roll_up_idx, context, map_info, trans_tables))) {
LOG_WARN("get view to trans failed", K(ret));
} else if (drill_down_idx == -1 || roll_up_idx == -2) {
// no valid item to do trans
} else if (OB_FAIL(do_transform(
parent_stmts, stmt, drill_down_idx, roll_up_idx, map_info, context, trans_happened, trans_tables))) {
LOG_WARN("do win magic transform for from failed", K(ret));
}
} // end smart vars
return ret;
}
int ObTransformWinMagic::check_hint_valid(ObDMLStmt &stmt, TableItem &table, bool &is_valid)
{
int ret = OB_SUCCESS;
const ObQueryHint *query_hint = NULL;
const ObWinMagicHint *hint = static_cast<const ObWinMagicHint*>(get_hint(stmt.get_stmt_hint()));
if (NULL == hint) {
is_valid = true;
LOG_TRACE("check win magic hint is null", K(is_valid), K(table), K(stmt.get_stmt_hint()));
} else if (OB_ISNULL(query_hint = stmt.get_stmt_hint().query_hint_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(query_hint));
} else {
is_valid = hint->enable_win_magic(query_hint->cs_type_, table);
LOG_TRACE("succeed to check win magic hint valid", K(is_valid), K(table), K(*hint));
}
return ret;
}
int ObTransformWinMagic::construct_transform_hint(ObDMLStmt &stmt, void *trans_params)
{
int ret = OB_SUCCESS;
typedef ObSEArray<TableItem *, 4> single_or_joined_table;
ObIArray<single_or_joined_table> *win_magic_tables = NULL;
ObWinMagicHint *hint = NULL;
if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->allocator_) || OB_ISNULL(trans_params) ||
OB_ISNULL(win_magic_tables = static_cast<ObIArray<single_or_joined_table>*>(trans_params)) ||
OB_UNLIKELY(win_magic_tables->count() < 2)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(ctx_), K(win_magic_tables));
} else if (OB_FAIL(ObQueryHint::create_hint(ctx_->allocator_, T_WIN_MAGIC, hint))) {
LOG_WARN("failed to create hint", K(ret));
} else if (OB_FAIL(ctx_->outline_trans_hints_.push_back(hint))) {
LOG_WARN("failed to push back hint", K(ret));
} else if (OB_FAIL(ctx_->add_used_trans_hint(get_hint(stmt.get_stmt_hint())))) {
LOG_WARN("failed to add used trans hint", K(ret));
} else {
hint->set_qb_name(ctx_->src_qb_name_);
for (int64_t i = 0; OB_SUCC(ret) && i < win_magic_tables->count(); ++i) {
for (int64_t j = 0; OB_SUCC(ret) && j < win_magic_tables->at(i).count(); ++j) {
ObTableInHint *hint_table = NULL;
TableItem *table = win_magic_tables->at(i).at(j);
if (OB_ISNULL(table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(hint->get_tb_name_list().push_back(ObTableInHint(*table)))) {
LOG_WARN("failed to push back hint table", K(ret));
}
}
}
}
return ret;
}
int ObTransformWinMagic::construct_trans_table(const ObDMLStmt *stmt,
const TableItem *table,
ObIArray<ObSEArray<TableItem *, 4>> &trans_basic_tables)
{
int ret = OB_SUCCESS;
ObSEArray<TableItem *, 4> trans_table;
if (OB_ISNULL(stmt) || OB_ISNULL(table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (table->is_joined_table()) {
const JoinedTable *joined_table = static_cast<const JoinedTable *>(table);
for (int64_t i = 0; OB_SUCC(ret) && i < joined_table->single_table_ids_.count(); ++i) {
TableItem *table = stmt->get_table_item_by_id(joined_table->single_table_ids_.at(i));
if (OB_ISNULL(table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(trans_table.push_back(table))) {
LOG_WARN("failed to push back trans table", K(ret));
}
}
} else if (OB_FAIL(trans_table.push_back(const_cast<TableItem *>(table)))) {
LOG_WARN("failed to push back table", K(ret));
}
if (OB_SUCC(ret) && OB_FAIL(trans_basic_tables.push_back(trans_table))) {
LOG_WARN("failed to push back trans tables", K(ret));
}
return ret;
}
int ObTransformWinMagic::construct_trans_tables(const ObDMLStmt *stmt,
const ObDMLStmt *trans_stmt,
ObIArray<ObSEArray<TableItem *, 4>> &trans_basic_tables,
ObIArray<TableItem *> &trans_tables)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < trans_tables.count(); ++i) {
int64_t idx;
const TableItem *table_item = NULL;
if (OB_ISNULL(trans_tables.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(stmt->get_table_item_idx(trans_tables.at(i), idx))) {
LOG_WARN("get table item idx failed", K(ret));
} else if (OB_LIKELY(idx >= 0 && idx < trans_stmt->get_table_size()) &&
OB_ISNULL(table_item = trans_stmt->get_table_item(idx))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table item is null", K(ret));
} else if (OB_FAIL(construct_trans_table(stmt,
table_item,
trans_basic_tables))) {
LOG_WARN("failed to construct eliminated table", K(ret));
}
}
}
return ret;
}
/*
After aggr first join aggregation, we may get a sql like:
SELECT *
FROM TICKETS P,
(SELECT film, max(price) as agg FROM TICKETS T GROUP BY film) V
WHERE P.film = V.film AND P.price < V.agg;
The join can be eliminated by the window functions.
SELECT *
FROM (SELECT film, max(price) over (partition by film), ...
from TICKETS T where ...) V
WHERE V.price < V.agg;
This is a more intuitive transformation for win magic.
*/
int ObTransformWinMagic::do_transform(common::ObIArray<ObParentDMLStmt> &parent_stmts,
ObDMLStmt *&stmt,
int64_t drill_down_idx,
int64_t roll_up_idx,
ObStmtMapInfo &map_info,
ObStmtCompareContext &context,
bool &trans_happened,
ObIArray<TableItem *> &trans_tables)
{
int ret = OB_SUCCESS;
UNUSED(parent_stmts);
ObDMLStmt *trans_stmt = NULL;
bool accepted = false;
ObSEArray<ObSEArray<TableItem *, 4>, 4> trans_basic_tables;
ObTryTransHelper try_trans_helper;
const ObWinMagicHint *myhint = static_cast<const ObWinMagicHint*>(stmt->get_stmt_hint().get_normal_hint(T_WIN_MAGIC));
if (OB_ISNULL(stmt) || OB_ISNULL(stmt->get_query_ctx()) || OB_ISNULL(ctx_) ||
OB_ISNULL(ctx_->stmt_factory_) || OB_ISNULL(ctx_->expr_factory_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("stmt or stmt ctx is null", K(ret));
} else if (NULL != myhint && myhint->is_disable_hint()) {
LOG_TRACE("hint is diabled", K(*myhint));
} else if (OB_FAIL(try_trans_helper.fill_helper(stmt->get_query_ctx()))) {
LOG_WARN("failed to fill try trans helper", K(ret));
} else if (OB_FAIL(ObTransformUtils::deep_copy_stmt(*ctx_->stmt_factory_,
*ctx_->expr_factory_,
stmt,
trans_stmt))) {
LOG_WARN("deep copy stmt failed", K(ret));
} else if (OB_FAIL(construct_trans_tables(stmt, trans_stmt, trans_basic_tables, trans_tables))) {
LOG_WARN("construct tans tables faield", K(ret));
} else if (OB_FAIL(do_transform_from_type(trans_stmt, drill_down_idx, roll_up_idx,
context, map_info))) {
LOG_WARN("win magic do transform from type failed", K(ret));
} else if (OB_FAIL(try_to_push_down_join(trans_stmt))) {
LOG_WARN("try to push down join failed.", K(*trans_stmt));
} else if (OB_FAIL(accept_transform(parent_stmts,
stmt,
trans_stmt,
NULL != myhint && myhint->is_enable_hint(),
false,
accepted))) {
LOG_WARN("accept transform failed", K(ret));
} else if (!accepted) {
LOG_TRACE("win magic transform not accpeted", K(ret));
if (OB_FAIL(try_trans_helper.recover(stmt->get_query_ctx()))) {
LOG_WARN("failed to recover params", K(ret));
}
} else if (OB_FAIL(add_transform_hint(*stmt, &trans_basic_tables))) {
LOG_WARN("failed to add transform hint", K(ret));
} else if (OB_FAIL(append(stmt->get_query_ctx()->all_equal_param_constraints_,
map_info.equal_param_map_))) {
LOG_WARN("failed to append equal params constraints", K(ret));
} else {
add_trans_type(ctx_->happened_cost_based_trans_, WIN_MAGIC);
trans_happened = true;
LOG_TRACE("equal param constraints", K(map_info.equal_param_map_));
}
return ret;
}
/*
select ...
from T, (select agg(c1) aggr, c2
from T
group by c2
) v
where T.c2 = v.c2
and ...;
=>
select ...
from (select agg(c1) over(partition by c2) as aggr, c2, ... //partition by's expr is same as group by's
from T //if has numerous tables,then they should be lossless join
where c2 is not null) v //the c2 is not null is referred by the T.c2 = V.c2;
where ...
*/
int ObTransformWinMagic::do_transform_from_type(ObDMLStmt *&stmt,
const int64_t drill_down_idx,
const int64_t roll_up_idx,
ObStmtCompareContext &context,
ObStmtMapInfo &map_info)
{
int ret = OB_SUCCESS;
ObDMLStmt *main_stmt = stmt;
TableItem *drill_down_table = NULL;
TableItem *roll_up_table = NULL;
ObSelectStmt *drill_down_stmt = NULL;
ObDMLStmt *roll_up_stmt = NULL;
bool match_main =false;
if (OB_ISNULL(stmt) ||
OB_ISNULL(drill_down_table = main_stmt->get_table_item(main_stmt->get_from_item(drill_down_idx))) ||
OB_ISNULL(drill_down_stmt = drill_down_table->ref_query_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("stmt is null", K(ret), K(stmt), K(drill_down_table), K(drill_down_stmt));
} else if (roll_up_idx == -1) {
roll_up_stmt = main_stmt;
match_main = true;
} else if (OB_ISNULL(roll_up_table = main_stmt->get_table_item(main_stmt->get_from_item(roll_up_idx))) ||
OB_ISNULL(roll_up_stmt = roll_up_table->ref_query_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("rollup table is invalid", K(roll_up_table), K(roll_up_stmt));
}
if (OB_FAIL(ret)) {
//do nothing
} else if (match_main) {
if (OB_FAIL(adjust_column_and_table(main_stmt, drill_down_table, map_info))) {
LOG_WARN("adjust column and table failed");
} else if (OB_FAIL(adjust_agg_to_win(drill_down_stmt))) {
LOG_WARN("adjust agg to win faield", K(ret));
}
} else {
TableItem *transed_view_table = NULL;
ObSEArray<ObRawExpr *, 4> transed_output;
if (OB_FAIL(adjust_view_for_trans(main_stmt, drill_down_table, roll_up_table,
transed_view_table, transed_output, context, map_info))) {
LOG_WARN("adjust view for trans failed", K(ret));
} else if (OB_FAIL(adjust_win_after_group_by(main_stmt, drill_down_table, roll_up_table,
transed_view_table, transed_output, context, map_info))) {
LOG_WARN("create view and win failed", K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(remove_dup_condition(main_stmt))) {
LOG_WARN("remove dup condition failed", K(ret));
} else if (OB_FAIL(stmt->rebuild_tables_hash())) {
LOG_WARN("failed to rebuild table hash", K(ret));
} else if (OB_FAIL(stmt->update_column_item_rel_id())) {
LOG_WARN("failed to update column item relation id", K(ret));
} else if (OB_FAIL(drill_down_stmt->rebuild_tables_hash())) {
LOG_WARN("failed to rebuild table hash", K(ret));
} else if (OB_FAIL(drill_down_stmt->update_column_item_rel_id())) {
LOG_WARN("failed to update column item relation id", K(ret));
} else if (OB_FAIL(stmt->formalize_stmt(ctx_->session_info_))) {
LOG_WARN("failed to formalize stmt info", K(ret));
}
}
return ret;
}
int ObTransformWinMagic::adjust_transform_types(uint64_t &transform_types)
{
int ret = OB_SUCCESS;
if (cost_based_trans_tried_) {
transform_types &= (~(1 << transformer_type_));
}
return ret;
}
int ObTransformWinMagic::check_aggr_expr_validity(ObSelectStmt &subquery, bool &is_valid)
{
int ret = OB_SUCCESS;
is_valid = true;
if (subquery.get_select_item_size() != 1) {
is_valid = false;
} else if (OB_ISNULL(subquery.get_select_item(0).expr_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("select expr is null", K(ret));
} else {
is_valid = subquery.get_select_item(0).expr_->has_flag(CNT_AGG);
}
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < subquery.get_aggr_item_size(); ++i) {
if (OB_ISNULL(subquery.get_aggr_item(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("aggregation expr is null", K(ret));
} else if (subquery.get_aggr_item(i)->is_param_distinct()) {
is_valid = false;
} else if (subquery.get_aggr_item(i)->get_expr_type() != T_FUN_MIN &&
subquery.get_aggr_item(i)->get_expr_type() != T_FUN_MAX &&
subquery.get_aggr_item(i)->get_expr_type() != T_FUN_SUM &&
subquery.get_aggr_item(i)->get_expr_type() != T_FUN_COUNT) {
is_valid = false;
}
}
return ret;
}
// TODO (link.zt)
int ObTransformWinMagic::check_lossess_join(ObSelectStmt &subquery,
ObIArray<FromItem> &from_items,
ObIArray<ObRawExpr *> &conditions,
bool &is_valid)
{
int ret = OB_SUCCESS;
UNUSED(subquery);
is_valid = from_items.empty() && conditions.empty();
return ret;
}
int ObTransformWinMagic::create_window_function(ObAggFunRawExpr *agg_expr,
ObIArray<ObRawExpr *> &partition_exprs,
ObWinFunRawExpr *&win_expr)
{
int ret = OB_SUCCESS;
ObRawExprFactory *expr_factory = NULL;
if (OB_ISNULL(ctx_) || OB_ISNULL(expr_factory = ctx_->expr_factory_) ||
OB_ISNULL(ctx_->session_info_) || OB_ISNULL(agg_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid argument", K(ret), K(ctx_), K(expr_factory), K(agg_expr));
} else if (OB_FAIL(expr_factory->create_raw_expr(T_WINDOW_FUNCTION,
win_expr))) {
LOG_WARN("create window function expr failed", K(ret));
} else if (OB_ISNULL(win_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid argument", K(ret), K(win_expr));
} else if (OB_FAIL(win_expr->set_partition_exprs(partition_exprs))) {
LOG_WARN("fail to set partition exprs", K(ret));
} else {
ObItemType func_type = agg_expr->get_expr_type();
Bound upper;
Bound lower;
upper.type_ = BOUND_UNBOUNDED;
lower.type_ = BOUND_UNBOUNDED;
upper.is_preceding_ = true;
lower.is_preceding_ = false;
win_expr->set_func_type(func_type);
win_expr->set_window_type(WINDOW_RANGE);
win_expr->set_is_between(true);
win_expr->set_upper(upper);
win_expr->set_lower(lower);
win_expr->set_agg_expr(agg_expr);
}
if (OB_SUCC(ret)) {
if (OB_FAIL(win_expr->formalize(ctx_->session_info_))) {
LOG_WARN("failed to formalize windown function", K(ret));
} else if (OB_FAIL(win_expr->pull_relation_id())) {
LOG_WARN("failed to pull relation id and levels", K(ret));
}
}
return ret;
}
/*-from type-*/
int ObTransformWinMagic::check_view_table_basic(ObSelectStmt *stmt, bool &is_valid)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("stmt is null", K(ret));
//roll up stmt should have coarser granularity.
} else if (stmt->has_limit()
|| stmt->has_having()
|| stmt->is_hierarchical_query()
|| stmt->is_set_stmt()
|| stmt->has_window_function()
|| stmt->has_rollup()
|| stmt->get_table_size() < 1
|| stmt->get_user_var_size() > 0) {
is_valid = false;
} else if (OB_FAIL(stmt->is_query_deterministic(is_valid))) {
LOG_WARN("has rand failed", K(ret));
} else if (!is_valid) {
/* do nothing */
} else if (OB_FAIL(check_select_expr_validity(*stmt, is_valid))) {
LOG_WARN("check view select expr validity failed");
}
return ret;
}
int ObTransformWinMagic::check_view_valid_to_trans(ObSelectStmt *view, ObStmtMapInfo &map_info, bool &is_valid)
{
int ret = OB_SUCCESS;
ObSEArray<FromItem, 4> lossless_froms;
ObSEArray<ObRawExpr *, 4> lossless_conditions;
if (OB_ISNULL(view)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret));
}
// for select * from t1 a, t1 b, (select * from t1 c) v where ...
// table c should match which table? a or b ?
for (int64_t i = 0; is_valid && i < view->get_from_item_size(); ++i) {
// the from item in view has no match, have to check lossless
if (OB_INVALID_ID == map_info.from_map_.at(i)) {
if (OB_FAIL(lossless_froms.push_back(view->get_from_item(i)))) {
LOG_WARN("failed to push from item into lossless froms array", K(ret));
}
}
}
if (OB_FAIL(ret)) {
// no table is matched
} else if (lossless_froms.count() == view->get_from_item_size()) {
is_valid = false;
}
// check if the condition is in main stmt.
for (int64_t i = 0; is_valid && i < view->get_condition_size(); ++i) {
if (OB_INVALID_ID == map_info.cond_map_.at(i)) {
if (OB_FAIL(lossless_conditions.push_back(view->get_condition_expr(i)))) {
LOG_WARN("failed to push from item into lossless froms array", K(ret));
}
}
}
if (OB_SUCC(ret) && is_valid) {
if (OB_FAIL(check_lossess_join(*view, lossless_froms, lossless_conditions, is_valid))) {
LOG_WARN("failed check is lossess join", K(ret));
} else if (!is_valid) {
LOG_TRACE("has extra conditions or from items", K(ret));
OPT_TRACE("view has extra conditions or from items");
}
}
return ret;
}
int ObTransformWinMagic::sanity_check_and_init(ObDMLStmt *stmt,
ObDMLStmt *view,
ObStmtMapInfo &map_info,
ObStmtCompareContext &context)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(stmt) || OB_ISNULL(view)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret));
} else if (view->get_from_item_size() != map_info.from_map_.count()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("from item size does not match to from map count", K(ret));
} else if (view->get_condition_size() != map_info.cond_map_.count()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("condtition size does not match to cond map count", K(ret));
} else if (view->get_table_size() != map_info.table_map_.count()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table size does not match to table map count", K(ret));
} else if (OB_FAIL(context.init(view, stmt, map_info, nullptr))) {
LOG_WARN("failed to init", K(ret));
}
return ret;
}
/* if a view can match main stmt ,and also another view.
* we do the transform with the main stmt first.
*/
int ObTransformWinMagic::get_view_to_trans(ObDMLStmt *&stmt,
int64_t &drill_down_idx,
int64_t &roll_up_idx,
ObStmtCompareContext &context,
ObStmtMapInfo &map_info,
ObIArray<TableItem *> &trans_tables)
{
int ret = OB_SUCCESS;
drill_down_idx = -1;
roll_up_idx = -2; //-1 means main stmt
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret));
}
// compare generated_table with stmt
for (int64_t i = 0; OB_SUCC(ret) && drill_down_idx == -1 && i < stmt->get_from_item_size(); i++) {
bool is_valid = true;
TableItem *rewrite_table = NULL;
ObSelectStmt *rewrite_view = NULL;
if (stmt->get_from_item(i).is_joined_) {
//do nothing
} else if (OB_ISNULL(rewrite_table = stmt->get_table_item_by_id(stmt->get_from_item(i).table_id_))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("view stmt is null", K(ret));
} else if (rewrite_table->is_generated_table()) {
rewrite_view = rewrite_table->ref_query_;
OPT_TRACE("try to transform view:", rewrite_table);
if (OB_ISNULL(rewrite_view)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("view stmt is null", K(ret));
} else if (OB_FAIL(check_view_table_basic(rewrite_view, is_valid))) {
LOG_WARN("check view table basic failed", K(ret));
} else if (!is_valid) {
//do nothing
OPT_TRACE("not a valid stmt");
} else if (OB_FAIL(ObStmtComparer::compute_stmt_overlap(rewrite_view,
stmt,
map_info))) {
LOG_WARN("compute stmt overlap failed", K(ret));
} else if (OB_FAIL(sanity_check_and_init(stmt, rewrite_view, map_info, context))) {
LOG_WARN("sanity check and init failed", K(ret));
} else if (OB_FAIL(check_view_valid_to_trans(rewrite_view, map_info, is_valid))) {
LOG_WARN("check view valid to trans failed", K(ret));
} else if (OB_FAIL(check_stmt_and_view(stmt, rewrite_table, map_info, is_valid, trans_tables))) {
LOG_WARN("check stmt and view failed", K(ret));
} else if (is_valid) {
drill_down_idx = i; //rewrite_view idx
roll_up_idx = -1;
} else {
OPT_TRACE("can not transform");
}
}
}
//compare generated_table with generated table
for (int64_t i = 0; OB_SUCC(ret) && drill_down_idx == -1 && i < stmt->get_from_item_size(); i++) {
ObSelectStmt *drill_down_view = NULL;
TableItem *drill_down_table = NULL;
if (OB_ISNULL(drill_down_table = stmt->get_table_item(stmt->get_from_item(i)))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("view stmt is null", K(ret));
} else if (drill_down_table->is_generated_table()) {
drill_down_view = drill_down_table->ref_query_;
bool is_valid = true;
if (OB_ISNULL(drill_down_view)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("view stmt is null", K(ret));
} else if (OB_FAIL(check_view_table_basic(drill_down_view, is_valid))) {
LOG_WARN("check table basic failed", K(ret));
} else if (is_valid) {
for (int64_t j = 0; OB_SUCC(ret) && drill_down_idx == -1 && j < stmt->get_from_item_size(); j++) {
bool is_valid = true;
TableItem *roll_up_table = NULL;
ObSelectStmt *roll_up_view = NULL;
if (i == j) {
//do nothing
} else if (OB_ISNULL(roll_up_table = stmt->get_table_item(stmt->get_from_item(j)))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("view stmt is null", K(ret));
} else if (roll_up_table->is_generated_table()) {
roll_up_view = roll_up_table->ref_query_;
if (OB_ISNULL(roll_up_view)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("view stmt is null", K(ret));
} else if (OB_FAIL(check_view_table_basic(roll_up_view, is_valid))) {
LOG_WARN("check view table basic failed", K(ret));
} else if (!is_valid) {
//do nothing
} else if (drill_down_view->get_from_item_size() != roll_up_view->get_from_item_size()
|| drill_down_view->get_table_size() != roll_up_view->get_table_size()) {
is_valid = false;
} else if (OB_FAIL(ObStmtComparer::compute_stmt_overlap(drill_down_view,
roll_up_view,
map_info))) {
LOG_WARN("compute stmt overlap failed", K(ret));
} else if (OB_FAIL(sanity_check_and_init(roll_up_view, drill_down_view, map_info, context))) {
LOG_WARN("sanity check and init failed", K(ret));
} else if (OB_FAIL(check_view_valid_to_trans(drill_down_view, map_info, is_valid))) {
LOG_WARN("sanity view valid to trans failed", K(ret));
} else if (OB_FAIL(check_view_and_view(stmt, drill_down_table, roll_up_table,
map_info, is_valid, trans_tables))) {
LOG_WARN("check view and view failed", K(ret));
} else if (!is_valid) {
//do nothing
//T_FUN_COUNT_SUM window function not implemented.
} else if (OB_FAIL(check_mode_and_agg_type(roll_up_view, is_valid))) {
LOG_WARN("check mode and agg type failed", K(ret));
} else if (is_valid) {
drill_down_idx = i;
roll_up_idx = j;
}
}
}
}
}
}
// avoid empty table name produce internal error. should be removed after bugfix.
for (int64_t i = 0; OB_SUCC(ret) && i < trans_tables.count(); i++) {
if (trans_tables.at(i)->get_object_name().empty()) {
drill_down_idx = -1;
roll_up_idx = -2;
break;
}
}
LOG_DEBUG("drill_down_idx roll_up_idx", K(drill_down_idx), K(roll_up_idx));
return ret;
}
int ObTransformWinMagic::check_mode_and_agg_type(ObSelectStmt *stmt, bool &is_valid)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret));
} else if (!lib::is_oracle_mode()) {
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < stmt->get_aggr_item_size(); ++i) {
if (OB_ISNULL(stmt->get_aggr_item(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("aggregation expr is null", K(ret));
} else if (stmt->get_aggr_item(i)->get_expr_type() == T_FUN_COUNT) {
is_valid = false;
LOG_DEBUG("T_FUN_COUNT_SUM in mysql mode not implemented");
}
}
}
return ret;
}
int ObTransformWinMagic::get_reverse_map(ObIArray<int64_t> &map, ObIArray<int64_t> &reverse_map, int64_t size)
{
int ret = OB_SUCCESS;
if (OB_FAIL(reverse_map.prepare_allocate(size))) {
LOG_WARN("pre allocate failed", K(ret));
} else {
for (int64_t i = 0; i < reverse_map.count(); i++) {
reverse_map.at(i) = OB_INVALID_ID;
}
for (int64_t i = 0; OB_SUCC(ret) && i < map.count(); i++) {
if (map.at(i) == OB_INVALID_ID) {
//do nothing
} else if (OB_UNLIKELY(map.at(i) >= size || map.at(i) < 0)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("out of range", K(ret));
} else {
reverse_map.at(map.at(i)) = i;
}
}
}
return ret;
}
int ObTransformWinMagic::check_stmt_and_view(ObDMLStmt *stmt,
TableItem *rewrite_table,
ObStmtMapInfo &map_info,
bool &is_valid,
ObIArray<TableItem *> &trans_tables)
{
int ret = OB_SUCCESS;
ObSEArray<TableItem *, 4> tables;
ObSqlBitSet<> tables_id;
ObSEArray<ObRawExpr *, 4> column_exprs;
ObSEArray<ObRawExpr *, 4> view_group_exprs;
ObSEArray<int64_t, 4> expr_map;
EqualSets dummy_set;
ObSelectStmt *rewrite_view = NULL;
int64_t match_count = 0;
QueryRelation relation;
if (OB_ISNULL(stmt) || OB_ISNULL(rewrite_table) || OB_ISNULL(rewrite_view = rewrite_table->ref_query_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret));
} else if (!is_valid) {
} else if (OB_FAIL(check_hint_valid(*stmt, *rewrite_table, is_valid))) {
LOG_WARN("check hint valid", K(ret));
} else if (!is_valid) {
OPT_TRACE("hint reject transform");
}
for (int64_t k = 0; OB_SUCC(ret) && is_valid && k < map_info.table_map_.count(); k++) {
TableItem *table = NULL;
if (map_info.table_map_.at(k) == OB_INVALID_ID) {
//do nothing
} else if (OB_ISNULL(table = stmt->get_table_item(map_info.table_map_.at(k)))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table item is null", K(ret));
} else if (OB_FAIL(tables.push_back(table))) {
LOG_WARN("push back table item failed", K(ret));
} else if (OB_FAIL(tables_id.add_member(map_info.table_map_.at(k) + 1))) {
LOG_WARN("push back item failed", K(ret));
} else if (OB_FAIL(check_hint_valid(*stmt, *table, is_valid))) {
LOG_WARN("check table valid faield", K(ret));
}
}
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < stmt->get_condition_exprs().count(); i++) {
ObRawExpr *expr = stmt->get_condition_exprs().at(i);
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr is null", K(ret));
} else if (expr->get_expr_type() == T_OP_EQ) {
if (expr->get_param_count() < 0) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("param count not expected", K(ret));
} else if (OB_ISNULL(expr->get_param_expr(0)) || OB_ISNULL(expr->get_param_expr(1))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr is null", K(ret));
} else if (expr->get_param_expr(0)->get_relation_ids().is_subset(tables_id) &&
OB_FAIL(column_exprs.push_back(expr->get_param_expr(0)))) {
LOG_WARN("push back item failed", K(ret));
} else if (expr->get_param_expr(1)->get_relation_ids().is_subset(tables_id) &&
OB_FAIL(column_exprs.push_back(expr->get_param_expr(1)))) {
LOG_WARN("push back item failed", K(ret));
}
}
}
if (OB_FAIL(ret) || !is_valid) {
//do nothing
} else if (OB_FAIL(ObStmtComparer::compute_semi_infos_map(rewrite_view, stmt,
true, map_info, match_count))) {
LOG_WARN("failed to compute semi info map", K(ret));
} else if (match_count != rewrite_view->get_semi_info_size() ||
match_count != stmt->get_semi_info_size()) {
is_valid = false;
OPT_TRACE("semi info not match");
} else if (OB_FAIL(stmt->get_column_exprs(tables, column_exprs))) {
LOG_WARN("get column exprs failed", K(ret));
} else if (OB_FAIL(ObStmtComparer::compute_conditions_map(rewrite_view,
stmt, rewrite_view->get_group_exprs(),
column_exprs, map_info, expr_map, relation))) {
LOG_WARN("compute expr map failed", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::get_parent_stmt_exprs(dummy_set, rewrite_table->table_id_,
*stmt, *rewrite_view,
rewrite_view->get_group_exprs(),
view_group_exprs))) {
LOG_WARN("get parent stmt exprs failed", K(ret));
} else if (OB_FAIL(check_outer_stmt_conditions(stmt, view_group_exprs, column_exprs,
expr_map, is_valid))) {
LOG_WARN("check outer stmt condition failed", K(ret));
} else if (!is_valid) {
OPT_TRACE("group expr not match");
}
if (OB_SUCC(ret) && is_valid) {
if (OB_FAIL(trans_tables.push_back(rewrite_table))) {
LOG_WARN("push back", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < tables.count(); i++) {
if (OB_FAIL(trans_tables.push_back(tables.at(i)))) {
LOG_WARN("push back", K(ret));
}
}
}
}
return ret;
}
int ObTransformWinMagic::check_view_and_view(ObDMLStmt *main_stmt,
TableItem *drill_down_table,
TableItem *roll_up_table,
ObStmtMapInfo &map_info,
bool &is_valid,
ObIArray<TableItem *> &trans_tables)
{
int ret = OB_SUCCESS;
ObSelectStmt *drill_down_view = NULL;
ObSelectStmt *roll_up_view = NULL;
ObSEArray<ObRawExpr *, 4> drill_group_exprs;
ObSEArray<ObRawExpr *, 4> roll_group_exprs;
ObSEArray<int64_t, 4> reverse_map;
ObSqlBitSet<> matched_cond;
int64_t match_count = 0;
QueryRelation relation;
EqualSets dummy_set;
if (OB_ISNULL(main_stmt) || OB_ISNULL(drill_down_table) || OB_ISNULL(roll_up_table)
|| OB_ISNULL(drill_down_view = drill_down_table->ref_query_)
|| OB_ISNULL(roll_up_view = roll_up_table->ref_query_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret));
// drill map roll => roll map drill
} else if (!is_valid) {
//do nothing
} else if (OB_FAIL(check_hint_valid(*main_stmt, *drill_down_table, is_valid))) {
LOG_WARN("check table valid faield", K(ret));
} else if (!is_valid) {
//do nothing
} else if (OB_FAIL(check_hint_valid(*main_stmt, *roll_up_table, is_valid))) {
LOG_WARN("check table valid faield", K(ret));
} else if (!is_valid) {
//do nothing
} else if (OB_FAIL(ObStmtComparer::compute_semi_infos_map(drill_down_view, roll_up_view,
true, map_info, match_count))) {
LOG_WARN("failed to compute semi info map", K(ret));
} else if (match_count != drill_down_view->get_semi_info_size() ||
match_count != roll_up_view->get_semi_info_size()) {
is_valid = false;
} else if (OB_FAIL(ObStmtComparer::compute_conditions_map(drill_down_view,
roll_up_view, drill_down_view->get_group_exprs(),
roll_up_view->get_group_exprs(), map_info,
map_info.group_map_, relation))) {
LOG_WARN("compute expr map failed", K(ret));
} else if (OB_FAIL(get_reverse_map(map_info.group_map_, reverse_map, roll_up_view->get_group_exprs().count()))) {
LOG_WARN("get reverse map failed", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::get_parent_stmt_exprs(dummy_set, drill_down_table->table_id_,
*main_stmt, *drill_down_view,
drill_down_view->get_group_exprs(),
drill_group_exprs))) {
LOG_WARN("get parent stmt exprs failed", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::get_parent_stmt_exprs(dummy_set, roll_up_table->table_id_,
*main_stmt, *roll_up_view,
roll_up_view->get_group_exprs(),
roll_group_exprs))) {
LOG_WARN("get parent stmt exprs failed", K(ret));
} else if (OB_FAIL(check_outer_stmt_conditions(main_stmt, roll_group_exprs, drill_group_exprs,
reverse_map, is_valid))) {
LOG_WARN("check outer stmt condition failed", K(ret));
}
if (OB_SUCC(ret) && map_info.from_map_.count() != roll_up_view->get_from_item_size()) {
is_valid = false;
}
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < map_info.from_map_.count(); i++) {
if (map_info.from_map_.at(i) == OB_INVALID_ID) {
is_valid = false;
}
}
//check if cnt agg
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < roll_up_view->get_select_item_size(); i++) {
ObRawExpr *expr = roll_up_view->get_select_item(i).expr_;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr is null", K(ret));
} else if (!expr->has_flag(CNT_AGG) && !expr->has_flag(CNT_COLUMN)) { // T_FUN_AVG is ok
is_valid = false;
}
}
// simple check: conditions should one to one match.
// begin check
if (OB_FAIL(ret) || !is_valid) {
//do nothing
} else if (roll_up_view->get_condition_size() != drill_down_view->get_condition_size()) {
is_valid = false;
}
//the condition should be one to one match.
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < roll_up_view->get_condition_size(); i++) {
if (map_info.cond_map_.at(i) == OB_INVALID_ID) {
is_valid = false;
} else if (OB_FAIL(matched_cond.add_member(map_info.cond_map_.at(i)))) {
LOG_WARN("bitset add member failed", K(ret));
}
}
if (OB_FAIL(ret) || !is_valid) {
//do nothing
//the condition num should be same
} else if (matched_cond.num_members() != roll_up_view->get_condition_size()) {
is_valid = false;
//record agg map in select item map
}
if (OB_SUCC(ret) && is_valid) {
if (OB_FAIL(trans_tables.push_back(drill_down_table)) ||
OB_FAIL(trans_tables.push_back(roll_up_table))) {
LOG_WARN("push back failed", K(ret));
}
}
return ret;
}
int ObTransformWinMagic::remove_dup_condition(ObDMLStmt *stmt) {
int ret = OB_SUCCESS;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret));
}
ObSEArray<ObRawExpr *, 4> new_conditions;
for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_condition_size(); i++) {
ObRawExpr *expr = stmt->get_condition_expr(i);
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr is null", K(ret));
} else if (expr->get_expr_type() == T_OP_EQ) {
if (expr->get_param_count() < 2) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("equal op expr's child less than 2", K(ret));
} else if (!expr->get_param_expr(0)->same_as(*expr->get_param_expr(1))) {
if (OB_FAIL(new_conditions.push_back(expr))) {
LOG_WARN("push back failed", K(ret));
}
} else {
ObRawExpr *is_not_null = NULL;
if (OB_FAIL(ObTransformUtils::add_is_not_null(ctx_, expr->get_param_expr(0), is_not_null))) {
LOG_WARN("failed to add is not null expr", K(ret));
} else if (OB_FAIL(new_conditions.push_back(is_not_null))) {
LOG_WARN("failed to append is not null exprs to where conditions", K(ret));
}
}
} else if (OB_FAIL(new_conditions.push_back(expr))) {
LOG_WARN("push back failed", K(ret));
}
}
if (OB_SUCC(ret) && OB_FAIL(stmt->get_condition_exprs().assign(new_conditions))) {
LOG_WARN("assign exprs failed", K(ret));
}
return ret;
}
// the group by column must be the join condition.
// for group by c1,c2
// the outer stmt must have where v.c1=T.c1 and v.c2=T.c2 and ...
// roll group exprs is subset of drill group exprs
int ObTransformWinMagic::check_outer_stmt_conditions(ObDMLStmt *stmt,
ObIArray<ObRawExpr *> &roll_group_exprs,
ObIArray<ObRawExpr *> &drill_group_exprs,
ObIArray<int64_t> &map,
bool &is_valid)
{
int ret = OB_SUCCESS;
EqualSets equal_sets;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret));
} else if (roll_group_exprs.count() > drill_group_exprs.count() ||
map.count() != roll_group_exprs.count()) {
is_valid = false;
} else if (OB_FAIL(ObEqualAnalysis::compute_equal_set(ctx_->allocator_, stmt->get_condition_exprs(), equal_sets))) {
LOG_WARN("compute equal set failed", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < map.count(); i++) {
if (map.at(i) == OB_INVALID_ID) {
is_valid = false;
} else {
ObRawExpr *roll_expr = roll_group_exprs.at(i);
ObRawExpr *drill_expr = drill_group_exprs.at(map.at(i));
if (roll_expr == NULL || drill_expr == NULL) {
is_valid = false;
} else if (!ObOptimizerUtil::is_expr_equivalent(roll_expr, drill_expr, equal_sets)) {
is_valid = false;
}
}
}
}
return ret;
}
// simple check only full group by
int ObTransformWinMagic::check_expr_in_group(ObRawExpr *expr,
ObIArray<ObRawExpr *> &group_exprs,
bool &is_valid) {
int ret = OB_SUCCESS;
bool found_match = false;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr is null", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && !found_match && i < group_exprs.count(); ++i) {
if (expr == group_exprs.at(i) || expr->same_as(*group_exprs.at(i))) {
found_match = true;
}
}
if (OB_FAIL(ret)) {
//do nothing
} else if (!found_match) {
if (expr->is_column_ref_expr()) {
is_valid = false;
} else if (IS_AGGR_FUN(expr->get_expr_type()) ||
expr->get_expr_type() == T_FUN_MIN ||
expr->get_expr_type() == T_FUN_MAX ||
expr->get_expr_type() == T_FUN_COUNT ||
expr->get_expr_type() == T_FUN_SUM ||
!expr->has_flag(CNT_COLUMN)) {
// do nothing
} else {
// simple check only full group by
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < expr->get_param_count(); ++i) {
if (OB_ISNULL(expr->get_param_expr(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr child is null", K(ret));
} else if (OB_FAIL(SMART_CALL(check_expr_in_group(expr->get_param_expr(i),
group_exprs, is_valid)))) {
LOG_WARN("failed to recursive check", K(ret));
}
}
}
}
return ret;
}
int ObTransformWinMagic::simple_check_group_by(ObIArray<ObRawExpr *> &exprs,
ObIArray<ObRawExpr *> &group_exprs,
bool &is_valid) {
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < exprs.count(); i++) {
if (OB_FAIL(SMART_CALL(check_expr_in_group(exprs.at(i), group_exprs, is_valid)))) {
LOG_WARN("failed to recursive check", K(ret));
}
}
return ret;
}
// subquery select item shold contain aggr function
int ObTransformWinMagic::check_select_expr_validity(ObSelectStmt &subquery, bool &is_valid)
{
int ret = OB_SUCCESS;
bool found_agg = false;
ObSEArray<ObRawExpr *, 4> check_exprs;
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < subquery.get_select_item_size(); ++i) {
if (OB_ISNULL(subquery.get_select_item(i).expr_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("select expr is null", K(ret));
} else if (subquery.get_select_item(i).expr_->has_flag(CNT_AGG)) {
found_agg = true;
}
}
if (OB_FAIL(ret)) {
//do nothing
} else if (FALSE_IT(is_valid = found_agg)) {
//never reach
} else if (!is_valid) {
//do nothing
} else if (lib::is_oracle_mode()) {
//do nothing
} else if (OB_FAIL(subquery.get_select_exprs(check_exprs))) {
LOG_WARN("subquery get select exprs failed", K(ret));
} else if (OB_FAIL(subquery.get_order_exprs(check_exprs))) {
LOG_WARN("append failed", K(ret));
} else if (OB_FAIL(append(check_exprs, subquery.get_having_exprs()))) {
LOG_WARN("append failed", K(ret));
} else if (OB_FAIL(simple_check_group_by(check_exprs, subquery.get_group_exprs(), is_valid))) {
LOG_WARN("simple check group by failed", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < subquery.get_aggr_item_size(); ++i) {
if (OB_ISNULL(subquery.get_aggr_item(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("aggregation expr is null", K(ret));
} else if (subquery.get_aggr_item(i)->is_param_distinct()) {
is_valid = false;
} else if (subquery.get_aggr_item(i)->get_expr_type() != T_FUN_MIN &&
subquery.get_aggr_item(i)->get_expr_type() != T_FUN_MAX &&
subquery.get_aggr_item(i)->get_expr_type() != T_FUN_SUM &&
subquery.get_aggr_item(i)->get_expr_type() != T_FUN_COUNT) {
is_valid = false;
}
}
return ret;
}
int ObTransformWinMagic::adjust_column_and_table(ObDMLStmt *main_stmt,
TableItem *view,
ObStmtMapInfo &map_info)
{
int ret = OB_SUCCESS;
ObSelectStmt *view_stmt = NULL;
ObSEArray<TableItem *, 4> main_tables;
ObSEArray<TableItem *, 4> view_tables;
ObSEArray<uint64_t, 4> main_table_ids;
ObSEArray<FromItem, 4> rm_from_items;
ObSEArray<ObRawExpr *, 4> merged_column_expr;
ObSEArray<ObRawExpr *, 4> pushed_column_exprs;
ObSEArray<ObRawExpr *, 4> merged_pseudo_column_exprs;
ObSEArray<ObRawExpr *, 4> pushed_pseudo_column_exprs;
ObArray<SemiInfo *> rm_semi_infos;
if (OB_ISNULL(main_stmt) || OB_ISNULL(view) ||
OB_ISNULL(view_stmt = view->ref_query_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret), K(main_stmt), K(view), K(view_stmt));
}
//init viriables and push down table
for (int64_t i = 0; OB_SUCC(ret) && i < map_info.table_map_.count(); ++i) {
int64_t idx = map_info.table_map_.at(i);
TableItem *table = NULL;
if (idx == OB_INVALID_ID) {
// do nothing
} else if (OB_UNLIKELY(idx < 0 || idx >= main_stmt->get_table_size()) ||
OB_ISNULL(table = main_stmt->get_table_item(idx))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("index is invalid", K(ret), K(idx), K(table));
} else if (OB_FAIL(main_tables.push_back(table))) {
LOG_WARN("failed to push back table item", K(ret));
} else if (OB_FAIL(view_tables.push_back(view_stmt->get_table_item(i)))) {
LOG_WARN("failed to push back view table item", K(ret));
} else if (OB_FAIL(main_table_ids.push_back(table->table_id_))) {
LOG_WARN("failed to push back table id", K(ret));
} else if (OB_FAIL(main_stmt->remove_part_expr_items(table->table_id_))) {
LOG_WARN("failed to remove part exprs", K(ret));
} else if (OB_FAIL(ObTransformUtils::add_table_item(view_stmt, table))) {
LOG_WARN("failed to add table item", K(ret));
}
}
// push down column
ObArray<ColumnItem> column_items;
if (OB_FAIL(ret)) {
} else if (OB_FAIL(main_stmt->get_column_items(main_table_ids, column_items))) {
LOG_WARN("get column items failed", K(ret));
} else if (OB_FAIL(view_stmt->add_column_item(column_items))) {
LOG_WARN("add column item failed", K(ret));
}
// push down pseudo column
ObArray<ObRawExpr *> pseudo_columns;
if (OB_FAIL(ret)) {
} else if (OB_FAIL(main_stmt->get_table_pseudo_column_like_exprs(main_table_ids, pseudo_columns))) {
LOG_WARN("get table pseudo column like exprs failed", K(ret));
} else if (OB_FAIL(append(view_stmt->get_pseudo_column_like_exprs(), pseudo_columns))) {
LOG_WARN("append failed", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < map_info.semi_info_map_.count(); ++i) {
int64_t idx = map_info.semi_info_map_.at(i);
SemiInfo *semi = NULL;
if (idx == OB_INVALID_ID) {
// do nothing
} else if (OB_UNLIKELY(idx < 0 || idx >= main_stmt->get_semi_info_size()) ||
OB_ISNULL(semi = main_stmt->get_semi_infos().at(idx))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("semi info is null", K(ret), K(idx), K(semi));
} else if (OB_FAIL(rm_semi_infos.push_back(semi))) {
LOG_WARN("failed to push back semi info", K(ret));
}
}
if (OB_SUCC(ret) && ObOptimizerUtil::remove_item(main_stmt->get_semi_infos(),
rm_semi_infos)) {
LOG_WARN("failed to remove semi infos", K(ret));
}
//merge table
for (int64_t i = 0; OB_SUCC(ret) && i < main_tables.count(); ++i) {
TableItem *main_table = main_tables.at(i);
TableItem *view_table = view_tables.at(i);
if (OB_ISNULL(main_table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table item is null", K(ret));
} else if (OB_FAIL(ObTransformUtils::merge_table_items(view_stmt,
view_table,
main_table,
NULL,
&pushed_column_exprs,
&merged_column_expr,
&pushed_pseudo_column_exprs,
&merged_pseudo_column_exprs))) {
LOG_WARN("failed to merge table items", K(ret));
} else if (OB_FAIL(ObTransformUtils::replace_table_in_semi_infos(main_stmt, view_table,
main_table))) {
LOG_WARN("failed to replace table info in semi infos", K(ret));
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < map_info.from_map_.count(); i++) {
int64_t from_idx = map_info.from_map_.at(i);
if (from_idx != OB_INVALID_ID &&
OB_FAIL(rm_from_items.push_back(main_stmt->get_from_item(from_idx)))) {
LOG_WARN("failed to push back from item", K(ret));
}
}
//remove joined table
for (int64_t i = 0; OB_SUCC(ret) && i < rm_from_items.count(); i++) {
if (OB_FAIL(main_stmt->remove_from_item(rm_from_items.at(i).table_id_))) {
LOG_WARN("failed to remove from item", K(ret));
} else if (!rm_from_items.at(i).is_joined_) {
// do nothing
} else if (OB_FAIL(main_stmt->remove_joined_table_item(
main_stmt->get_joined_table(rm_from_items.at(i).table_id_)))) {
LOG_WARN("remove joined table item failed", K(ret));
}
}
if (OB_SUCC(ret) && (main_stmt->is_update_stmt() || main_stmt->is_delete_stmt())) {
ObDelUpdStmt *del_upd_stmt = static_cast<ObDelUpdStmt *>(main_stmt);
ObArray<ObDmlTableInfo *> table_infos;
if (OB_FAIL(del_upd_stmt->get_dml_table_infos(table_infos))) {
LOG_WARN("failed to get dml table info", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < table_infos.count(); ++i) {
int64_t idx = -1;
if (OB_ISNULL(table_infos.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table info is null", K(ret));
} else if (!ObOptimizerUtil::find_item(main_table_ids,
table_infos.at(i)->table_id_,
&idx)) {
// do nothing
} else {
table_infos.at(i)->table_id_ = view->table_id_;
table_infos.at(i)->loc_table_id_ = view_tables.at(idx)->table_id_;
}
}
}
ObSEArray<ObRawExpr *, 4> new_col_for_pseudo_cols;
if (OB_FAIL(ret)) {
} else if (OB_FAIL(ObOptimizerUtil::remove_item(main_stmt->get_pseudo_column_like_exprs(),
pushed_pseudo_column_exprs))) {
LOG_WARN("remove item failed", K(ret));
} else if (OB_FAIL(ObTransformUtils::create_columns_for_view(ctx_,
*view,
main_stmt,
merged_pseudo_column_exprs,
new_col_for_pseudo_cols))) {
LOG_WARN("create columns for view failed", K(ret));
} else if (OB_FAIL(main_stmt->replace_relation_exprs(pushed_pseudo_column_exprs, new_col_for_pseudo_cols))) {
LOG_WARN("replace inner stmt expr failed", K(ret));
}
ObSEArray<ObRawExpr *, 4> new_col_in_main;
//create select item for view
if (OB_FAIL(ret)) {
//do nothing.
} else if (OB_FAIL(ObTransformUtils::create_columns_for_view(ctx_,
*view,
main_stmt,
merged_column_expr,
new_col_in_main))) {
LOG_WARN("create columns for view failed", K(ret));
} else if (OB_FAIL(main_stmt->remove_table_item(main_tables))) {
LOG_WARN("failed to remove table item", K(ret));
} else if (OB_FAIL(view_stmt->remove_table_item(main_tables))) {
LOG_WARN("failed to remove table item", K(ret));
} else if (OB_FAIL(main_stmt->remove_column_item(main_table_ids))) {
LOG_WARN("remove column item failed", K(ret));
} else if (OB_FAIL(main_stmt->replace_relation_exprs(pushed_column_exprs, new_col_in_main))) {
LOG_WARN("replace inner stmt expr failed", K(ret));
}
//add is not null expr
for (int64_t i = 0; OB_SUCC(ret) && i < view_stmt->get_group_expr_size(); i++) {
ObRawExpr *expr = view_stmt->get_group_exprs().at(i);
ObSEArray<ObRawExpr *, 1> is_not_null_exprs;
ObRawExpr *is_not_null = NULL;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("gourp by expr is null", K(ret));
} else if (OB_FAIL(ObTransformUtils::add_is_not_null(ctx_, expr, is_not_null))) {
LOG_WARN("failed to add is not null expr", K(ret));
} else if (OB_FAIL(is_not_null_exprs.push_back(is_not_null))) {
LOG_WARN("failed to push is not null expr into array", K(ret));
} else if (OB_FAIL(append(view_stmt->get_condition_exprs(), is_not_null_exprs))) {
LOG_WARN("failed to append is not null exprs to where conditions", K(ret));
}
}
if (OB_SUCC(ret) && (main_stmt->is_update_stmt() || main_stmt->is_delete_stmt())) {
ObDelUpdStmt *del_upd_stmt = static_cast<ObDelUpdStmt *>(main_stmt);
if (OB_FAIL(ObTransformUtils::adjust_updatable_view(
*ctx_->expr_factory_,
del_upd_stmt,
*view))) {
LOG_WARN("failed to adjust updatable view", K(ret));
}
}
return ret;
}
int ObTransformWinMagic::adjust_agg_to_win(ObSelectStmt *view_stmt)
{
int ret = OB_SUCCESS;
ObSEArray<ObRawExpr *, 4> aggr_exprs;
ObSEArray<ObRawExpr *, 4> win_exprs;
ObSEArray<ObRawExpr *, 4> partition_exprs;
if (OB_FAIL(partition_exprs.assign(view_stmt->get_group_exprs()))) {
LOG_WARN("failed to assign group exprs", K(ret));
} else if (OB_FAIL(append(aggr_exprs, view_stmt->get_aggr_items()))) {
LOG_WARN("failed to append aggr exprs", K(ret));
} else {
view_stmt->get_group_exprs().reset();
view_stmt->clear_aggr_item();
}
for (int64_t i = 0; OB_SUCC(ret) && i < aggr_exprs.count(); ++i) {
ObWinFunRawExpr *win_expr = NULL;
if (OB_FAIL(create_window_function(static_cast<ObAggFunRawExpr *>(aggr_exprs.at(i)),
partition_exprs,
win_expr))) {
LOG_WARN("failed to create window function", K(ret));
} else if (OB_FAIL(view_stmt->add_window_func_expr(win_expr))) {
LOG_WARN("failed to add window func expr", K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(append(aggr_exprs, view_stmt->get_aggr_items()))) {
LOG_WARN("failed to convert aggregation exprs", K(ret));
} else if (OB_UNLIKELY(aggr_exprs.count() != view_stmt->get_window_func_exprs().count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected aggr and winfun count", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < view_stmt->get_window_func_exprs().count(); i ++) {
ObRawExpr *expr = view_stmt->get_window_func_exprs().at(i);
if (OB_FAIL(ObTransformUtils::add_cast_for_replace_if_need(
*ctx_->expr_factory_, aggr_exprs.at(i), expr, ctx_->session_info_))) {
LOG_WARN("failed to add cast", K(ret));
} else if (OB_FAIL(win_exprs.push_back(expr))) {
LOG_WARN("failed to push back expr", K(ret));
}
}
if (OB_SUCC(ret) && OB_FAIL(view_stmt->replace_relation_exprs(aggr_exprs, win_exprs))) {
LOG_WARN("failed to replace relation expr", K(ret));
}
}
return ret;
}
int ObTransformWinMagic::adjust_view_for_trans(ObDMLStmt *main_stmt,
TableItem *&drill_down_table,
TableItem *roll_up_table,
TableItem *&transed_view_table,
ObIArray<ObRawExpr *> &new_transed_output,
ObStmtCompareContext &context,
ObStmtMapInfo &map_info)
{
int ret = OB_SUCCESS;
ObSelectStmt *drill_down_stmt = NULL;
ObSelectStmt *roll_up_stmt = NULL;
ObSEArray<ObRawExpr *, 4> new_drill_down_view_column_exprs;
ObSEArray<ObRawExpr *, 4> pushed_column_exprs;
ObSEArray<ObRawExpr *, 4> new_select_exprs_for_drill;
ObSEArray<ObRawExpr *, 4> new_drill_down_view_output_columns;
ObSEArray<ObRawExpr *, 4> new_select_exprs_for_trans;
ObSEArray<ObRawExpr *, 4> old_roll_up_view_output_columns;
ObSEArray<ObRawExpr *, 4> new_transed_view_output_columns;
if (OB_ISNULL(main_stmt) || OB_ISNULL(drill_down_table) || OB_ISNULL(roll_up_table) ||
OB_ISNULL(drill_down_stmt = drill_down_table->ref_query_) ||
OB_ISNULL(roll_up_stmt = roll_up_table->ref_query_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret));
} else if (OB_FAIL(ObTransformUtils::replace_with_empty_view(ctx_,
main_stmt,
transed_view_table,
drill_down_table))) {
LOG_WARN("failed to create empty view table", K(ret));
} else if (OB_FAIL(ObTransformUtils::create_inline_view(ctx_,
main_stmt,
transed_view_table,
drill_down_table))) {
LOG_WARN("failed to create inline view", K(ret));
} else if (OB_ISNULL(transed_view_table) ||
OB_ISNULL(transed_view_table->ref_query_) ||
OB_UNLIKELY(transed_view_table->ref_query_->get_table_size() != 1)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("transed view table is null", K(ret), K(transed_view_table));
} else {
drill_down_table = transed_view_table->ref_query_->get_table_item(0);
}
// push down table
for (int64_t i = 0; OB_SUCC(ret) && i < roll_up_stmt->get_table_size(); i++) {
TableItem *table = NULL;
ObSEArray<ObDMLStmt::PartExprItem, 4> part_exprs;
if (OB_ISNULL(table = roll_up_stmt->get_table_item(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table item is null", K(ret));
} else if (OB_FAIL(ObTransformUtils::add_table_item(drill_down_stmt, table))) {
LOG_WARN("add table item failed", K(ret));
} else if (OB_FAIL(main_stmt->get_part_expr_items(table->table_id_, part_exprs))) {
LOG_WARN("failed to get part expr items", K(ret));
} else if (!part_exprs.empty() && OB_FAIL(drill_down_stmt->set_part_expr_items(part_exprs))) {
LOG_WARN("failed to set part expr item", K(ret));
} else if (OB_FAIL(main_stmt->remove_part_expr_items(table->table_id_))) {
LOG_WARN("failed to remove part epxr", K(ret));
}
}
// push down column
for (int64_t i = 0; OB_SUCC(ret) && i < roll_up_stmt->get_column_size(); i++) {
if (OB_ISNULL(roll_up_stmt->get_column_item(i)) ||
OB_ISNULL(roll_up_stmt->get_column_item(i)->get_expr())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("column or column expr is null", K(ret));
} else if (OB_FAIL(drill_down_stmt->add_column_item(roll_up_stmt->get_column_items().at(i)))) {
LOG_WARN("add column item failed", K(ret));
}
}
ObSEArray<ObRawExpr *, 4> agg_in_roll;
ObSEArray<ObRawExpr *, 4> agg_in_drill;
// push aggr item
for (int64_t i = 0; OB_SUCC(ret) && i < roll_up_stmt->get_aggr_item_size(); i++) {
if (OB_ISNULL(roll_up_stmt->get_aggr_item(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("agg expr is null", K(ret));
} else {
bool found = false;
for(int64_t j = 0; OB_SUCC(ret) && !found && j < drill_down_stmt->get_aggr_item_size(); j++) {
if (drill_down_stmt->get_aggr_item(j)->same_as(*roll_up_stmt->get_aggr_item(i), &context)) {
found = true;
if (OB_FAIL(agg_in_roll.push_back(roll_up_stmt->get_aggr_item(i))) ||
OB_FAIL(agg_in_drill.push_back(drill_down_stmt->get_aggr_item(j)))) {
LOG_WARN("push back expr into array failed", K(ret));
} else if (OB_FAIL(append(map_info.equal_param_map_, context.equal_param_info_))) {
LOG_WARN("failed to append equal param map", K(ret));
} else {
context.equal_param_info_.reset();
}
}
}
if (OB_FAIL(ret) || found) {
//do nothing
} else if (OB_FAIL(drill_down_stmt->add_agg_item(*roll_up_stmt->get_aggr_item(i)))) {
LOG_WARN("add agg item failed", K(ret));
}
}
}
//push
//merge table
for (int64_t i = 0; OB_SUCC(ret) && i < map_info.table_map_.count(); i++) {
TableItem *table_in_roll_up = NULL;
TableItem *table_in_drill_down = NULL;
if (map_info.table_map_.at(i) == OB_INVALID_ID) {
//do nothing
} else if (OB_ISNULL(table_in_roll_up = roll_up_stmt->get_table_item(map_info.table_map_.at(i))) ||
OB_ISNULL(table_in_drill_down = drill_down_stmt->get_table_item(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("table item is null", K(ret));
} else if (OB_FAIL(ObTransformUtils::merge_table_items(drill_down_stmt,
table_in_drill_down,
table_in_roll_up,
NULL,
&pushed_column_exprs,
&new_drill_down_view_column_exprs))) {
LOG_WARN("failed to merge table items", K(ret));
} else if (OB_FAIL(drill_down_stmt->remove_table_item(table_in_roll_up))) {
LOG_WARN("remove table item failed", K(ret));
} else if (OB_FAIL(ObTransformUtils::replace_table_in_semi_infos(main_stmt, transed_view_table,
table_in_drill_down))) {
LOG_WARN("failed to replace table info in semi infos", K(ret));
} else if (OB_FAIL(ObTransformUtils::replace_table_in_semi_infos(main_stmt, transed_view_table,
table_in_roll_up))) {
LOG_WARN("failed to replace table info in semi infos", K(ret));
}
}
if (OB_FAIL(ret)) {
//do nothing
//create new select for drill down table begin
} else if (OB_FAIL(append(new_select_exprs_for_drill, roll_up_stmt->get_group_exprs()) ||
OB_FAIL(append(new_select_exprs_for_drill, roll_up_stmt->get_aggr_items())))) {
LOG_WARN("append exprs after array failed", K(ret));
//make the exprs in roll up stmt become exprs in drill down stmt
} else if (OB_FAIL(ObTransformUtils::replace_exprs(pushed_column_exprs,
new_drill_down_view_column_exprs,
new_select_exprs_for_drill))) {
LOG_WARN("replace exprs failed", K(ret));
} else if (OB_FAIL(ObTransformUtils::replace_exprs(agg_in_roll, agg_in_drill,
new_select_exprs_for_drill))) {
LOG_WARN("replace exprs failed", K(ret));
//create select item for drill_down_stmt
} else if (OB_FAIL(ObTransformUtils::create_columns_for_view(ctx_, *drill_down_table,
transed_view_table->ref_query_,
new_select_exprs_for_drill,
new_drill_down_view_output_columns))) {
LOG_WARN("create column for view failed", K(ret));
//create new select for drill down table end
//create new select for transed table begin
} else if (OB_FAIL(main_stmt->get_view_output(*roll_up_table, new_select_exprs_for_trans,
old_roll_up_view_output_columns))) {
LOG_WARN("get view output failed", K(ret));
//make the exprs in roll up stmt become exprs in drill down stmt
} else if (OB_FAIL(ObTransformUtils::replace_exprs(pushed_column_exprs,
new_drill_down_view_column_exprs,
new_select_exprs_for_trans))) {
LOG_WARN("replace exprs failed", K(ret));
} else if (OB_FAIL(ObTransformUtils::replace_exprs(agg_in_roll, agg_in_drill,
new_select_exprs_for_trans))) {
LOG_WARN("replace exprs failed", K(ret));
//map the select exprs in drill to column exprs in transed
} else if (OB_FAIL(ObTransformUtils::replace_exprs(new_select_exprs_for_drill,
new_drill_down_view_output_columns,
new_select_exprs_for_trans))) {
LOG_WARN("replace exprs failed", K(ret));
} else if (OB_FAIL(ObTransformUtils::create_columns_for_view(ctx_, *transed_view_table,
main_stmt,
new_select_exprs_for_trans,
new_transed_view_output_columns,
true, true))) {
LOG_WARN("create columns for view failed", K(ret));
//create new select for transed table end
} else if (OB_FAIL(main_stmt->remove_column_item(roll_up_table->table_id_))) {
LOG_WARN("remove column item failed", K(ret));
} else if (OB_FAIL(main_stmt->replace_relation_exprs(old_roll_up_view_output_columns,
new_transed_view_output_columns))) {
LOG_WARN("replace inner stmt expr failed", K(ret));
} else if (OB_FAIL(new_transed_output.assign(new_transed_view_output_columns))) {
LOG_WARN("assign array failed", K(ret));
}
return ret;
}
int ObTransformWinMagic::change_agg_to_win_func(ObDMLStmt *main_stmt,
ObSelectStmt *roll_up_stmt,
ObSelectStmt *drill_down_stmt,
TableItem *transed_view_table,
ObStmtMapInfo &map_info,
ObStmtCompareContext &context,
ObIArray<ObRawExpr *> &old_col,
ObIArray<ObRawExpr *> &new_win)
{
int ret = OB_SUCCESS;
UNUSED(main_stmt);
ObSEArray<ObRawExpr *, 4> partition_exprs;
ObRawExpr *col_expr = NULL;
ObItemType type;
ObSelectStmt *transed_stmt = NULL;
ObAggFunRawExpr *new_agg_expr = NULL;
ObWinFunRawExpr *win_expr = NULL;
ObRawExpr *cast_win_expr = NULL;
ObSEArray<ObRawExpr *, 4> drill_select_exprs;
if (OB_ISNULL(main_stmt) || OB_ISNULL(roll_up_stmt) || OB_ISNULL(drill_down_stmt)
|| OB_ISNULL(transed_view_table) || OB_ISNULL(transed_stmt = transed_view_table->ref_query_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret));
} else if (OB_FAIL(drill_down_stmt->get_select_exprs(drill_select_exprs))) {
LOG_WARN("get select exprs failed", K(ret));
}
//get partition exprs
for(int64_t i = 0; OB_SUCC(ret) && i < roll_up_stmt->get_group_exprs().count(); i++) {
bool found = false;
ObRawExpr *group_expr_in_roll = NULL;
ObRawExpr *group_expr_in_drill = NULL;
for(int64_t j = 0; OB_SUCC(ret) && !found && j < drill_down_stmt->get_group_exprs().count(); j++) {
if (OB_ISNULL(group_expr_in_roll = roll_up_stmt->get_group_exprs().at(i)) ||
OB_ISNULL(group_expr_in_drill = drill_down_stmt->get_group_exprs().at(j))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("group expr is null", K(ret));
} else if (group_expr_in_drill->same_as(*group_expr_in_roll, &context)) {
found = true;
int64_t idx = -1;
if (OB_FAIL(ObTransformUtils::get_expr_idx(drill_select_exprs, group_expr_in_drill, idx))) {
LOG_WARN("get expr idx faield", K(ret));
} else if (idx == -1) {
// do nothing
} else if (OB_FAIL(partition_exprs.push_back(transed_stmt->get_column_expr_by_id(
transed_stmt->get_table_item(0)->table_id_, idx + OB_APP_MIN_COLUMN_ID)))) {
LOG_WARN("push back expr failed", K(ret));
}
}
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < partition_exprs.count(); i++) {
ObRawExpr *expr = partition_exprs.at(i);
ObSEArray<ObRawExpr *, 1> is_not_null_exprs;
ObRawExpr *is_not_null = NULL;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("gourp by expr is null", K(ret));
} else if (OB_FAIL(ObTransformUtils::add_is_not_null(ctx_, expr, is_not_null))) {
LOG_WARN("failed to add is not null expr", K(ret));
} else if (OB_FAIL(is_not_null_exprs.push_back(is_not_null))) {
LOG_WARN("failed to push is not null expr into array", K(ret));
} else if (OB_FAIL(append(transed_stmt->get_condition_exprs(), is_not_null_exprs))) {
LOG_WARN("failed to append is not null exprs to where conditions", K(ret));
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < roll_up_stmt->get_aggr_item_size(); i++) {
ObRawExpr *agg_expr = roll_up_stmt->get_aggr_item(i);
int64_t sel_idx = -1;
if (OB_ISNULL(agg_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr is null", K(ret));
}
for (int64_t j = 0; OB_SUCC(ret) && sel_idx == -1 && j < drill_down_stmt->get_select_item_size(); j++) {
if (drill_down_stmt->get_select_item(j).expr_->same_as(*agg_expr, &context)) {
sel_idx = j;
if (OB_FAIL(append(map_info.equal_param_map_, context.equal_param_info_))) {
LOG_WARN("failed to append equal param map", K(ret));
} else {
context.equal_param_info_.reset();
}
}
}
ColumnItem *col_in_transed = NULL;
if (sel_idx == -1) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("select item idx is out of range", K(ret));
} else if (OB_ISNULL(col_in_transed = transed_stmt->get_column_item_by_id(
transed_stmt->get_table_item(0)->table_id_,
sel_idx + OB_APP_MIN_COLUMN_ID))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("can not find the corresponding select item", K(ret), K(sel_idx));
} else if (OB_ISNULL(col_expr = col_in_transed->get_expr())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("col expr is null", K(ret));
} else if (FALSE_IT(type = (lib::is_oracle_mode() ?
(agg_expr->get_expr_type() == T_FUN_COUNT ?
T_FUN_SUM : agg_expr->get_expr_type()) :
(agg_expr->get_expr_type() == T_FUN_COUNT ?
T_FUN_COUNT_SUM : agg_expr->get_expr_type())))) {
//never reach
} else if (OB_FAIL(ObTransformUtils::create_aggr_expr(ctx_, type, new_agg_expr, col_expr))) {
LOG_WARN("creat aggr expr failed", K(ret));
} else if (OB_ISNULL(new_agg_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("new agg expr is null", K(ret));
} else if (OB_FAIL(create_window_function(new_agg_expr, partition_exprs, win_expr))) {
LOG_WARN("create window function failed", K(ret));
} else if (OB_ISNULL(win_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("win function expr is null", K(ret));
} else if (OB_FAIL(transed_stmt->add_window_func_expr(win_expr))) {
LOG_WARN("add windon func expr failed", K(ret));
} else if (FALSE_IT(cast_win_expr = win_expr)) {
} else if (OB_FAIL(ObTransformUtils::add_cast_for_replace_if_need(
*ctx_->expr_factory_, col_expr, cast_win_expr, ctx_->session_info_))) {
LOG_WARN("failed to add cast", K(ret));
} else if (OB_FAIL(old_col.push_back(col_expr))) {
LOG_WARN("failed to push expr into array", K(ret));
} else if (OB_FAIL(new_win.push_back(cast_win_expr))) {
LOG_WARN("failed to push expr into array", K(ret));
} else {
}
}
return ret;
}
int ObTransformWinMagic::adjust_win_after_group_by(ObDMLStmt *main_stmt,
TableItem *drill_down_table,
TableItem *roll_up_table,
TableItem *transed_view_table,
ObIArray<ObRawExpr *> &new_transed_view_output_columns,
ObStmtCompareContext &context,
ObStmtMapInfo &map_info)
{
int ret = OB_SUCCESS;
ObSelectStmt *drill_down_stmt = NULL;
ObSelectStmt *roll_up_stmt = NULL;
ObSelectStmt *transed_stmt = NULL;
ObSEArray<ObRawExpr *, 4> old_agg;
ObSEArray<ObRawExpr *, 4> new_win;
if (OB_ISNULL(main_stmt) || OB_ISNULL(drill_down_table) || OB_ISNULL(transed_view_table)
|| OB_ISNULL(roll_up_table) || OB_ISNULL(drill_down_stmt = drill_down_table->ref_query_)
|| OB_ISNULL(roll_up_stmt = roll_up_table->ref_query_)
|| OB_ISNULL(transed_stmt = transed_view_table->ref_query_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret));
} else if (OB_FAIL(change_agg_to_win_func(main_stmt, roll_up_stmt, drill_down_stmt, transed_view_table,
map_info, context,
old_agg, new_win))) {
LOG_WARN("change agg to window function failed", K(ret));
}
for (int64_t i = 0 ;OB_SUCC(ret) && i < new_transed_view_output_columns.count(); i++) {
ObRawExpr *&expr = transed_stmt->get_select_item(
static_cast<ObColumnRefRawExpr *>(new_transed_view_output_columns.at(i))->get_column_id() -
OB_APP_MIN_COLUMN_ID).expr_;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr is null", K(ret));
} else if (OB_FAIL(ObTransformUtils::replace_expr(old_agg, new_win, expr))) {
LOG_WARN("replace exprs failed", K(ret));
}
ObSEArray<ObRawExpr *, 4> col_exprs;
ObSEArray<ObRawExpr *, 4> sel_exprs;
transed_stmt->get_column_exprs(drill_down_table->table_id_, col_exprs);
transed_stmt->get_select_exprs(sel_exprs);
}
if (OB_FAIL(ret)) {
//do nothing
} else if (OB_FAIL(main_stmt->remove_column_item(roll_up_table->table_id_))) {
LOG_WARN("remove column item failed", K(ret));
} else if (OB_FAIL(main_stmt->remove_table_item(roll_up_table))) {
LOG_WARN("remove table item failed", K(ret));
} else if (OB_FAIL(main_stmt->remove_from_item(roll_up_table->table_id_))) {
LOG_WARN("remove from item failed", K(ret));
}
return ret;
}
int ObTransformWinMagic::check_join_push_down(ObDMLStmt *main_stmt,
TableItem *view_table,
TableItem *push_down_table,
ObIArray<ObRawExpr *> &cond_to_push_down,
bool &is_valid)
{
int ret = OB_SUCCESS;
int64_t view_table_idx = -1;
int64_t push_down_table_idx = -1;
EqualSets dummy_set;
if (OB_ISNULL(main_stmt) || OB_ISNULL(view_table) || OB_ISNULL(view_table->ref_query_) ||
OB_ISNULL(push_down_table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("view table ref query is null", K(ret));
} else if (view_table->ref_query_->has_group_by() ||
view_table->ref_query_->has_limit() ||
view_table->ref_query_->is_hierarchical_query() ||
view_table->ref_query_->has_rollup() ||
view_table->ref_query_->is_set_stmt() ||
view_table->ref_query_->has_sequence() ||
!view_table->ref_query_->has_window_function()) {
is_valid = false;
} else {
// to calculate the parition exprs intersection among win functions.
ObSEArray<ObSEArray<ObRawExpr *, 4>, 2> partition_expr_sets;
ObSEArray<ObRawExpr *, 4> intersection;
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < view_table->ref_query_->get_window_func_exprs().count(); i++) {
ObSEArray<ObRawExpr *, 4> parition_exprs;
if (OB_FAIL(append(parition_exprs, view_table->ref_query_->get_window_func_expr(i)->get_partition_exprs()))) {
LOG_WARN("append partition exprs failed", K(ret));
} else if (OB_FAIL(partition_expr_sets.push_back(parition_exprs))) {
LOG_WARN("failed to push back exprs into array", K(ret));
}
}
if (OB_FAIL(ret)) {
//do nothing
} else if (OB_FAIL(ObOptimizerUtil::intersect(partition_expr_sets, intersection))) {
LOG_WARN("failed to calculate the intersection of sets", K(ret));
} else if (intersection.count() == 0) {
is_valid = false;
}
ObSEArray<ObRawExpr *, 4> intersection_in_parent;
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < intersection.count(); i++) {
ObRawExpr *parent_stmt_expr = NULL;
if (OB_FAIL(ObOptimizerUtil::get_parent_stmt_expr(dummy_set, view_table->table_id_, *main_stmt,
*view_table->ref_query_, intersection.at(i),
parent_stmt_expr))) {
LOG_WARN("get parent stmt expr failed", K(ret));
} else if (parent_stmt_expr == NULL) {
//do nothing
} else if (OB_FAIL(intersection_in_parent.push_back(parent_stmt_expr))) {
LOG_WARN("failed to push back intersection in parent", K(ret));
}
}
//select * from T2, (select ..., agg(..) over(parition by c1,c2) from T1) v where T2.c1 = v.c1
//to push down T2
//1. the join condition should be equal condition
//2. the join column c from v should be in the partition exprs intersection. It can be function f(c).
//3. the set of join column from T2 should be unique. It can't be f(c), like abs(c) may break the unique property.
ObSEArray<ObRawExpr *, 4> exprs_unqiue_check;
bool is_unique = false;
if (OB_FAIL(ret) || !is_valid) {
//do nothing
} else if (intersection_in_parent.count() <= 0) {
is_valid = false;
} else if (OB_FAIL(main_stmt->get_table_item_idx(view_table->table_id_, view_table_idx))) {
LOG_WARN("get table item idx failed", K(ret));
} else if (OB_FAIL(main_stmt->get_table_item_idx(push_down_table->table_id_, push_down_table_idx))) {
LOG_WARN("get table item idx failed", K(ret));
} else {
view_table_idx++;
push_down_table_idx++;
}
for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < main_stmt->get_condition_size(); i++) {
ObRawExpr *expr = main_stmt->get_condition_expr(i);
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
//if has condition like T1.c1 op v.c1 op T3.c2 T2 could not be push down.
} else if (expr->get_relation_ids().num_members() > 2 &&
expr->get_relation_ids().has_member(view_table_idx) &&
expr->get_relation_ids().has_member(push_down_table_idx)) {
is_valid = false;
//for condition like T2.c1 = const, it could be push down.
} else if (expr->get_relation_ids().num_members() == 1 &&
expr->get_relation_ids().has_member(push_down_table_idx)) {
if (OB_FAIL(cond_to_push_down.push_back(expr))) {
LOG_WARN("failed to push expr into array",K(ret));
}
// for condition like v.c1 op T2.c1,
//we now only support f(v.c1)=T2.c1 for simple, v.c1+T2.c1+1=0 won't be recognized.
} else if (expr->get_relation_ids().num_members() == 2 &&
expr->get_relation_ids().has_member(view_table_idx) &&
expr->get_relation_ids().has_member(push_down_table_idx)) {
ObSEArray<ObRawExpr *, 4> column_exprs;
if (!expr->is_op_expr() || expr->get_param_count() < 2) {
//do nothing
} else if (OB_ISNULL(expr->get_param_expr(0)) ||
OB_ISNULL(expr->get_param_expr(1))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr's param is null", K(ret));
} else if (OB_FAIL(ObRawExprUtils::extract_column_exprs(expr, column_exprs))) {
LOG_WARN("extract column exprs failed", K(ret));
} else {
bool found = true;
for (int64_t j = 0; OB_SUCC(ret) && found && j < column_exprs.count(); j++) {
int64_t idx =-1;
if (static_cast<ObColumnRefRawExpr *>(column_exprs.at(j))->get_table_id() != view_table->table_id_) {
//do nothing
} else if (OB_FAIL(ObTransformUtils::get_expr_idx(intersection_in_parent,
column_exprs.at(j), idx))) {
LOG_WARN("get expr idx failed", K(ret));
} else if (idx == -1) {
found = false;
}
}
if (OB_FAIL(ret) || !found) {
//do nothing
} else if (OB_FAIL(cond_to_push_down.push_back(expr))) {
LOG_WARN("failed to push expr into array",K(ret));
} else if (T_OP_EQ == expr->get_expr_type() &&
expr->get_param_expr(0)->get_relation_ids().num_members() == 1 &&
expr->get_param_expr(1)->get_relation_ids().num_members() == 1) {
if (expr->get_param_expr(0)->get_relation_ids().has_member(push_down_table_idx)) {
// expr0 is from view , expr1 is from push down table.
std::swap(expr->get_param_expr(0), expr->get_param_expr(1));
}
if (OB_FAIL(exprs_unqiue_check.push_back(expr->get_param_expr(1)))) {
LOG_WARN("failed to push back expr into array", K(ret));
}
}
}
}
}
if (OB_FAIL(ret) || !is_valid) {
//do nothing
} else if (OB_FAIL(ObTransformUtils::check_exprs_unique(*main_stmt, push_down_table, exprs_unqiue_check,
ctx_->session_info_, ctx_->schema_checker_, is_valid))) {
LOG_WARN("check exprs unique failed", K(ret));
}
}
return ret;
}
//cost based trans, treat as rule trans here
int ObTransformWinMagic::try_to_push_down_join(ObDMLStmt *&main_stmt)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(main_stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < main_stmt->get_from_item_size(); i++) {
FromItem view_from = main_stmt->get_from_item(i);
TableItem *view_table = NULL;
if (view_from.is_joined_) {
//do nothing
} else if (OB_ISNULL(view_table = main_stmt->get_table_item_by_id(view_from.table_id_))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get table item by id failed", K(ret), K(view_from), K(i));
} else if (!view_table->is_generated_table()) {
//do nothing
} else {
for (int64_t j = 0; OB_SUCC(ret) && j < main_stmt->get_from_item_size(); j++) {
bool is_valid = true;
TableItem *push_down_table = NULL;
FromItem push_down_from = main_stmt->get_from_item(j);
ObSEArray<ObRawExpr *, 8> cond_to_push_down;
if (i == j) {
//do nothing
} else if (push_down_from.is_joined_) {
//do nothing
} else if (OB_ISNULL(push_down_table = main_stmt->get_table_item_by_id(push_down_from.table_id_))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get table item by id failed", K(ret), K(i), K(j));
//do nothing
} else if (OB_FAIL(check_join_push_down(main_stmt, view_table,
push_down_table, cond_to_push_down, is_valid))) {
LOG_WARN("check join push down failed", K(ret));
} else if (!is_valid) {
// do nothing
} else if (OB_FAIL(push_down_join(main_stmt, view_table, push_down_table, cond_to_push_down))) {
LOG_WARN("push down join failed", K(ret));
} else {
//do nothing
}
}
}
}
return ret;
}
int ObTransformWinMagic::push_down_join(ObDMLStmt *main_stmt,
TableItem *view_table,
TableItem *push_down_table,
ObIArray<ObRawExpr *> &cond_to_push_down)
{
int ret = OB_SUCCESS;
ObSelectStmt *view_stmt = NULL;
ObSEArray<ObRawExpr *, 4> renamed_cond;
ObSEArray<ObDMLStmt::PartExprItem,4> part_exprs;
ObSEArray<ObRawExpr *, 4> view_select_list;
ObSEArray<ObRawExpr *, 4> view_column_list;
ObSEArray<ObQueryRefRawExpr *, 4> query_refs;
ObSEArray<ObRawExpr *, 4> old_column;
ObSEArray<ObRawExpr *, 4> new_column;
if (OB_ISNULL(main_stmt) || OB_ISNULL(view_table) || OB_ISNULL(push_down_table) ||
OB_ISNULL(view_stmt = view_table->ref_query_) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pointer is null", K(ret));
} else if (OB_FAIL(ObTransformUtils::extract_query_ref_expr(cond_to_push_down, query_refs))) {
LOG_WARN("failed to extract subquery", K(ret));
} else if (OB_FAIL(main_stmt->get_view_output(*view_table, view_select_list, view_column_list))) {
LOG_WARN("get view output failed", K(ret));
} else {
ObRawExprCopier copier(*ctx_->expr_factory_);
if (OB_FAIL(copier.add_replaced_expr(view_column_list, view_select_list))) {
LOG_WARN("failed to add exprs", K(ret));
} else if (OB_FAIL(copier.add_skipped_expr(query_refs, false))) {
LOG_WARN("failed to add skipped expr", K(ret));
} else if (OB_FAIL(copier.copy_on_replace(cond_to_push_down, renamed_cond))) {
LOG_WARN("failed to copy on replace filters", K(ret));
}
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(ObTransformUtils::add_table_item(view_stmt, push_down_table))) {
LOG_WARN("add table item failed", K(ret));
} else if (OB_FAIL(append(view_stmt->get_condition_exprs(), renamed_cond))) {
LOG_WARN("append cond to push down after condition exprs failed", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::remove_item(main_stmt->get_condition_exprs(), cond_to_push_down))) {
LOG_WARN("remove item failed", K(ret));
} else if (OB_FAIL(main_stmt->remove_table_item(push_down_table))) {
LOG_WARN("remove tbale item failed", K(ret));
} else if (OB_FAIL(main_stmt->remove_from_item(push_down_table->table_id_))) {
LOG_WARN("remove from item faield", K(ret));
} else if (OB_FAIL(view_stmt->add_from_item(push_down_table->table_id_))) {
LOG_WARN("add from item failed", K(ret));
} else if (OB_FAIL(main_stmt->get_part_expr_items(push_down_table->table_id_, part_exprs))) {
LOG_WARN("failed to get part expr items", K(ret));
} else if (!part_exprs.empty() && OB_FAIL(view_stmt->set_part_expr_items(part_exprs))) {
LOG_WARN("failed to set part expr item", K(ret));
} else if (OB_FAIL(main_stmt->remove_part_expr_items(push_down_table->table_id_))) {
LOG_WARN("failed to remove part epxr", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < main_stmt->get_column_size(); i++) {
if (OB_ISNULL(main_stmt->get_column_item(i)) || OB_ISNULL(main_stmt->get_column_item(i)->expr_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("column is null", K(ret));
} else if (main_stmt->get_column_item(i)->expr_->get_table_id() == push_down_table->table_id_) {
if (OB_FAIL(view_stmt->add_column_item(*main_stmt->get_column_item(i)))) {
LOG_WARN("add column item failed", K(ret));
} else if (OB_FAIL(old_column.push_back(main_stmt->get_column_item(i)->expr_))) {
LOG_WARN("push back expr into array failed", K(ret));
}
}
}
if (OB_FAIL(ret)) {
//do nothing
} else if (OB_FAIL(main_stmt->remove_column_item(push_down_table->table_id_))) {
LOG_WARN("remove column item failed", K(ret));
} else if (OB_FAIL(ObTransformUtils::create_columns_for_view(
ctx_, *view_table, main_stmt, old_column, new_column))) {
LOG_WARN("create columns for view failed", K(ret));
} else if (OB_FAIL(main_stmt->replace_relation_exprs(old_column, new_column))) {
LOG_WARN("replace inner stmt expr failed", K(ret));
} else if (OB_FAIL(main_stmt->rebuild_tables_hash())) {
LOG_WARN("failed to rebuild table hash", K(ret));
} else if (OB_FAIL(main_stmt->update_column_item_rel_id())) {
LOG_WARN("failed to update column item relation id", K(ret));
} else if (OB_FAIL(view_stmt->rebuild_tables_hash())) {
LOG_WARN("failed to rebuild table hash", K(ret));
} else if (OB_FAIL(view_stmt->update_column_item_rel_id())) {
LOG_WARN("failed to update column item relation id", K(ret));
} else if (OB_FAIL(main_stmt->formalize_stmt(ctx_->session_info_))) {
LOG_WARN("failed to formalize stmt info", K(ret));
} else {
LOG_DEBUG("push down join", K(*main_stmt));
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink