hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
2f8121bad83ca5f17ed352ba0d53ad3b6d2bc7f0
oceanbase/src/sql/optimizer/ob_log_group_by.cpp
obdev fea19bc54e [CP] reorder the order of complex filters
2024-02-21 09:19:05 +00:00

905 lines
34 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_OPT
#include "ob_log_group_by.h"
#include "lib/allocator/page_arena.h"
#include "sql/resolver/expr/ob_raw_expr_replacer.h"
#include "ob_log_operator_factory.h"
#include "ob_log_exchange.h"
#include "ob_log_sort.h"
#include "ob_log_topk.h"
#include "ob_log_material.h"
#include "ob_log_table_scan.h"
#include "ob_optimizer_context.h"
#include "ob_optimizer_util.h"
#include "ob_opt_est_cost.h"
#include "ob_select_log_plan.h"
#include "common/ob_smart_call.h"
#include "ob_opt_selectivity.h"
#include "ob_log_operator_factory.h"
#include "sql/optimizer/ob_join_order.h"
#include "sql/rewrite/ob_transform_utils.h"
using namespace oceanbase;
using namespace sql;
using namespace oceanbase::common;
int ObThreeStageAggrInfo::assign(const ObThreeStageAggrInfo &info)
{
int ret = OB_SUCCESS;
aggr_stage_ = info.aggr_stage_;
distinct_aggr_count_ = info.distinct_aggr_count_;
aggr_code_idx_ = info.aggr_code_idx_;
aggr_code_expr_ = info.aggr_code_expr_;
aggr_code_ndv_ = info.aggr_code_ndv_;
if (OB_FAIL(distinct_exprs_.assign(info.distinct_exprs_))) {
LOG_WARN("failed to assign distinct exprs", K(ret));
} else if (OB_FAIL(distinct_aggr_batch_.assign(info.distinct_aggr_batch_))) {
LOG_WARN("failed to assign distinct col idx", K(ret));
}
return ret;
}
int ObRollupAdaptiveInfo::assign(const ObRollupAdaptiveInfo &info)
{
int ret = OB_SUCCESS;
rollup_id_expr_ = info.rollup_id_expr_;
rollup_status_ = info.rollup_status_;
enable_encode_sort_ = info.enable_encode_sort_;
sort_keys_.reset();
ecd_sort_keys_.reset();
if (OB_FAIL(append(sort_keys_, info.sort_keys_))) {
LOG_WARN("failed to assign distinct col idx", K(ret));
} else if (OB_FAIL(append(ecd_sort_keys_, info.ecd_sort_keys_))) {
LOG_WARN("failed to append sort keys", K(ret));
}
return ret;
}
int ObLogGroupBy::get_explain_name_internal(char *buf,
const int64_t buf_len,
int64_t &pos)
{
int ret = OB_SUCCESS;
if (SCALAR_AGGREGATE == algo_) {
ret = BUF_PRINTF("SCALAR ");
} else if (HASH_AGGREGATE == algo_) {
ret = BUF_PRINTF("HASH ");
} else {
if (ObRollupStatus::ROLLUP_DISTRIBUTOR != rollup_adaptive_info_.rollup_status_) {
ret = BUF_PRINTF("MERGE ");
} else {
// inner sort in groupby
ret = BUF_PRINTF("SORT ");
}
}
if (OB_SUCC(ret)) {
ret = BUF_PRINTF("%s", get_name());
}
if (OB_FAIL(ret)) {
} else if (ObRollupStatus::ROLLUP_DISTRIBUTOR == rollup_adaptive_info_.rollup_status_) {
ret = BUF_PRINTF(" ROLLUP DISTRIBUTOR");
} else if (ObRollupStatus::ROLLUP_COLLECTOR == rollup_adaptive_info_.rollup_status_) {
ret = BUF_PRINTF(" ROLLUP COLLECTOR");
}
if (OB_SUCC(ret) && from_pivot_) {
ret = BUF_PRINTF(" PIVOT");
}
if (OB_FAIL(ret)) {
LOG_WARN("BUF_PRINTF fails", K(ret));
}
return ret;
}
int ObLogGroupBy::set_group_by_exprs(const common::ObIArray<ObRawExpr *> &group_by_exprs)
{
return group_exprs_.assign(group_by_exprs);
}
int ObLogGroupBy::set_rollup_exprs(const common::ObIArray<ObRawExpr *> &rollup_exprs)
{
return rollup_exprs_.assign(rollup_exprs);
}
int ObLogGroupBy::set_aggr_exprs(const common::ObIArray<ObAggFunRawExpr *> &aggr_exprs)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < aggr_exprs.count(); i++) {
ObAggFunRawExpr *aggr_expr = aggr_exprs.at(i);
if (OB_ISNULL(aggr_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("aggr_expr is null", K(ret));
} else {
ret = aggr_exprs_.push_back(aggr_expr);
}
}
return ret;
}
int ObLogGroupBy::get_group_rollup_exprs(common::ObIArray<ObRawExpr *> &group_rollup_exprs) const
{
int ret = OB_SUCCESS;
if (OB_FAIL(append(group_rollup_exprs, group_exprs_))) {
LOG_WARN("failed to append group exprs into group rollup exprs.", K(ret));
} else if (OB_FAIL(append(group_rollup_exprs, rollup_exprs_))) {
LOG_WARN("failed to append rollup exprs into group rollup exprs.", K(ret));
} else { /*do nothing*/ }
return ret;
}
int ObLogGroupBy::get_op_exprs(ObIArray<ObRawExpr*> &all_exprs)
{
int ret = OB_SUCCESS;
if (OB_FAIL(append(all_exprs, group_exprs_))) {
LOG_WARN("failed to add exprs to ctx", K(ret));
} else if (OB_FAIL(append_array_no_dup(all_exprs, rollup_exprs_))) {
LOG_WARN("failed to add exprs to ctx", K(ret));
} else if (OB_FAIL(append(all_exprs, aggr_exprs_))) {
LOG_WARN("failed to append exprs", K(ret));
} else if (is_three_stage_aggr() && all_exprs.push_back(three_stage_info_.aggr_code_expr_)) {
LOG_WARN("failed to push back exprs", K(ret));
} else if (NULL != rollup_adaptive_info_.rollup_id_expr_ &&
OB_FAIL(all_exprs.push_back(rollup_adaptive_info_.rollup_id_expr_))) {
LOG_WARN("failed to add rollup id expr", K(ret));
} else if (OB_FAIL(ObLogicalOperator::get_op_exprs(all_exprs))) {
LOG_WARN("failed to get op exprs", K(ret));
} else { /*do nothing*/ }
if (OB_SUCC(ret) && is_first_stage()) {
for (int64_t i = 0; i < three_stage_info_.distinct_aggr_batch_.count() && OB_SUCC(ret); ++i) {
const ObDistinctAggrBatch &distinct_batch = three_stage_info_.distinct_aggr_batch_.at(i);
for (int64_t j = 0; j < distinct_batch.mocked_params_.count() && OB_SUCC(ret); ++j) {
if (OB_FAIL(all_exprs.push_back(distinct_batch.mocked_params_.at(j).first))) {
LOG_WARN("failed to push back distinct expr", K(ret));
}
}
}
}
if (OB_SUCC(ret) && rollup_adaptive_info_.enable_encode_sort_) {
for (int64_t i = 0; i < rollup_adaptive_info_.sort_keys_.count() && OB_SUCC(ret); ++i) {
if (OB_FAIL(all_exprs.push_back(rollup_adaptive_info_.sort_keys_.at(i).expr_))) {
LOG_WARN("failed to push back distinct expr", K(ret));
}
}
for (int64_t i = 0; i < rollup_adaptive_info_.ecd_sort_keys_.count() && OB_SUCC(ret); ++i) {
if (OB_FAIL(all_exprs.push_back(rollup_adaptive_info_.ecd_sort_keys_.at(i).expr_))) {
LOG_WARN("failed to push back distinct expr", K(ret));
}
}
}
return ret;
}
uint64_t ObLogGroupBy::hash(uint64_t seed) const
{
uint64_t hash_value = seed;
hash_value = do_hash(algo_, hash_value);
hash_value = ObLogicalOperator::hash(hash_value);
return hash_value;
}
int ObLogGroupBy::get_plan_item_info(PlanText &plan_text,
ObSqlPlanItem &plan_item)
{
int ret = OB_SUCCESS;
if (OB_FAIL(ObLogicalOperator::get_plan_item_info(plan_text, plan_item))) {
LOG_WARN("failed to get plan item info", K(ret));
} else {
BEGIN_BUF_PRINT;
if (OB_FAIL(get_explain_name_internal(buf, buf_len, pos))) {
LOG_WARN("failed to get explain name", K(ret));
}
END_BUF_PRINT(plan_item.operation_, plan_item.operation_len_);
}
if (OB_SUCC(ret)) {
BEGIN_BUF_PRINT;
const ObIArray<ObRawExpr *> &group = get_group_by_exprs();
EXPLAIN_PRINT_EXPRS(group, type);
const ObIArray<ObRawExpr *> &rollup = get_rollup_exprs();
if (OB_FAIL(ret) || (rollup.count() <= 0)) {
} else if(OB_FAIL(BUF_PRINTF(", "))) {
LOG_WARN("BUF_PRINTF fails", K(ret));
} else {
EXPLAIN_PRINT_EXPRS(rollup, type);
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(BUF_PRINTF(", "))) {
LOG_WARN("BUF_PRINTF fails", K(ret));
} else {
const ObIArray<ObRawExpr *> &agg_func = get_aggr_funcs();
EXPLAIN_PRINT_EXPRS(agg_func, type);
}
END_BUF_PRINT(plan_item.special_predicates_,
plan_item.special_predicates_len_);
}
return ret;
}
int ObLogGroupBy::est_cost()
{
int ret = OB_SUCCESS;
double child_card = 0.0;
double child_ndv = 0.0;
double selectivity = 1.0;
double group_cost = 0.0;
ObLogicalOperator *child = get_child(ObLogicalOperator::first_child);
if (OB_ISNULL(child)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(child));
} else if (OB_FAIL(get_child_est_info(get_parallel(), child_card, child_ndv, selectivity))) {
LOG_WARN("failed to get chidl est info", K(ret));
} else if (OB_FAIL(inner_est_cost(get_parallel(),
child_card,
child_ndv,
distinct_per_dop_,
group_cost))) {
LOG_WARN("failed to est group by cost", K(ret));
} else {
distinct_card_ = child_ndv;
set_card(distinct_card_ * selectivity);
set_cost(child->get_cost() + group_cost);
set_op_cost(group_cost);
}
return ret;
}
int ObLogGroupBy::do_re_est_cost(EstimateCostInfo &param, double &card, double &op_cost, double &cost)
{
int ret = OB_SUCCESS;
double child_card = 0.0;
double child_ndv = 0.0;
double selectivity = 1.0;
ObLogicalOperator *child = get_child(ObLogicalOperator::first_child);
const int64_t parallel = param.need_parallel_;
double number_of_copies = get_number_of_copies();
if (OB_ISNULL(child) || OB_UNLIKELY(number_of_copies < 1)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(child), K(number_of_copies));
} else if (OB_FAIL(get_child_est_info(parallel, child_card, child_ndv, selectivity))) {
LOG_WARN("failed to get chidl est info", K(ret));
} else {
double child_cost = child->get_cost();
double need_ndv = child_ndv;
double origin_child_card = child_card;
bool need_scale_ndv = false;
if (param.need_row_count_ >= 0 &&
child->get_card() > 0 &&
child_ndv > 0 &&
param.need_row_count_ < child_ndv) {
need_ndv = param.need_row_count_;
if (selectivity > OB_DOUBLE_EPSINON) {
need_ndv /= selectivity;
}
if (child_card > 0) {
param.need_row_count_ = child_card * (1 - std::pow((1 - need_ndv / child_ndv), child_ndv / child_card));
param.need_row_count_ /= number_of_copies;
} else {
param.need_row_count_ = 0;
}
} else {
param.need_row_count_ = -1;
need_scale_ndv = true;
}
if (is_block_op()) {
param.need_row_count_ = -1; //reset need row count
}
if (OB_FAIL(SMART_CALL(child->re_est_cost(param, child_card, child_cost)))) {
LOG_WARN("failed to re est child cost", K(ret));
} else {
// At the first stage, child output will be replicated
child_card = child_card * number_of_copies;
if (need_scale_ndv) {
need_ndv = std::min(child_ndv, ObOptSelectivity::scale_distinct(child_card, origin_child_card, child_ndv));
}
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(inner_est_cost(parallel,
child_card,
need_ndv,
distinct_per_dop_,
op_cost))) {
LOG_WARN("failed to est distinct cost", K(ret));
} else {
cost = child_cost + op_cost;
card = need_ndv * selectivity;
if (param.override_) {
set_total_ndv(need_ndv);
}
}
}
return ret;
}
int ObLogGroupBy::inner_est_cost(const int64_t parallel, double child_card, double &child_ndv, double &per_dop_ndv, double &op_cost)
{
int ret = OB_SUCCESS;
double per_dop_card = 0.0;
per_dop_ndv = 0.0;
common::ObSEArray<ObRawExpr *, 8> group_rollup_exprs;
ObLogicalOperator *child = get_child(ObLogicalOperator::first_child);
if (OB_ISNULL(get_plan()) ||
OB_ISNULL(child)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(child));
} else if (OB_UNLIKELY(parallel < 1)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(child));
} else if (OB_FAIL(get_group_rollup_exprs(group_rollup_exprs))) {
LOG_WARN("failed to get group rollup exprs", K(ret));
} else {
per_dop_card = child_card / parallel;
if ((get_group_by_exprs().empty() && get_rollup_exprs().empty()) || SCALAR_AGGREGATE == algo_) {
per_dop_ndv = 1.0;
} else if (parallel > 1) {
if (is_push_down()) {
per_dop_ndv = ObOptSelectivity::scale_distinct(per_dop_card, child_card, child_ndv);
} else {
per_dop_ndv = child_ndv / parallel;
}
} else {
per_dop_ndv = child_ndv;
}
}
if (OB_SUCC(ret)) {
ObOptimizerContext &opt_ctx = get_plan()->get_optimizer_context();
if (SCALAR_AGGREGATE == algo_) {
op_cost = ObOptEstCost::cost_scalar_group(per_dop_card,
get_aggr_funcs().count(),
opt_ctx);
} else if (MERGE_AGGREGATE == algo_) {
op_cost = ObOptEstCost::cost_merge_group(per_dop_card,
per_dop_ndv,
child->get_width(),
group_rollup_exprs,
get_aggr_funcs().count(),
opt_ctx);
} else {
op_cost = ObOptEstCost::cost_hash_group(per_dop_card,
per_dop_ndv,
child->get_width(),
group_exprs_,
get_aggr_funcs().count(),
opt_ctx);
}
child_ndv = std::min(child_card, per_dop_ndv * parallel);
if (SCALAR_AGGREGATE == algo_) {
child_ndv = std::max(1.0, child_ndv);
}
}
return ret;
}
int ObLogGroupBy::get_child_est_info(const int64_t parallel, double &child_card, double &child_ndv, double &selectivity)
{
int ret = OB_SUCCESS;
ObLogicalOperator *child = get_child(ObLogicalOperator::first_child);
if (OB_ISNULL(child) || OB_ISNULL(get_plan())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(child));
} else if (OB_UNLIKELY(parallel < 1)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(child));
} else if ((get_group_by_exprs().empty() && get_rollup_exprs().empty())
|| SCALAR_AGGREGATE == algo_) {
child_card = child->get_card();
child_ndv = parallel;
} else {
child_card = child->get_card();
child_ndv = get_total_ndv();
}
//having filter selectivity
if (OB_SUCC(ret)) {
// At the first stage, child output will be replicated
child_card = child_card * get_number_of_copies();
get_plan()->get_selectivity_ctx().init_row_count(get_origin_child_card(), child_ndv);
if (OB_FAIL(ObOptSelectivity::calculate_selectivity(get_plan()->get_update_table_metas(),
get_plan()->get_selectivity_ctx(),
get_filter_exprs(),
selectivity,
get_plan()->get_predicate_selectivities()))) {
LOG_WARN("failed to calculate selectivity", K(ret));
}
}
return ret;
}
int ObLogGroupBy::est_width()
{
int ret = OB_SUCCESS;
double width = 0.0;
ObSEArray<ObRawExpr*, 16> output_exprs;
if (OB_ISNULL(get_plan())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid plan", K(ret));
} else if (OB_FAIL(get_gby_output_exprs(output_exprs))) {
LOG_WARN("failed to compute gby output column exprs", K(ret));
} else if (OB_FAIL(ObOptEstCost::estimate_width_for_exprs(get_plan()->get_basic_table_metas(),
get_plan()->get_selectivity_ctx(),
output_exprs,
width))) {
LOG_WARN("failed to estimate width for output gby column exprs", K(ret));
} else {
set_width(width);
LOG_TRACE("est width for gby", K(output_exprs), K(width));
}
return ret;
}
int ObLogGroupBy::get_gby_output_exprs(ObIArray<ObRawExpr *> &output_exprs)
{
int ret = OB_SUCCESS;
ObLogPlan *plan = NULL;
ObSEArray<ObRawExpr*, 16> candi_exprs;
ObSEArray<ObRawExpr*, 16> extracted_col_or_aggr_exprs;
if (OB_ISNULL(plan = get_plan())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid input", K(ret));
} else if (OB_FAIL(append_array_no_dup(candi_exprs, plan->get_winfunc_exprs_for_width_est()))) {
LOG_WARN("failed to add into output exprs", K(ret));
} else if (OB_FAIL(append_array_no_dup(candi_exprs, plan->get_select_item_exprs_for_width_est()))) {
LOG_WARN("failed to add into output exprs", K(ret));
} else if (OB_FAIL(append_array_no_dup(candi_exprs, plan->get_orderby_exprs_for_width_est()))) {
LOG_WARN("failed to add into output exprs", K(ret));
} else if (OB_FAIL(ObRawExprUtils::extract_col_aggr_exprs(candi_exprs,
extracted_col_or_aggr_exprs))) {
LOG_WARN("failed to extract exprs", K(ret));
} else if (OB_FAIL(append_array_no_dup(output_exprs, extracted_col_or_aggr_exprs))) {
LOG_WARN("failed to add into output exprs", K(ret));
} else {/*do nothing*/}
return ret;
}
int ObLogGroupBy::inner_replace_op_exprs(ObRawExprReplacer &replacer)
{
int ret = OB_SUCCESS;
if (OB_FAIL(replace_exprs_action(replacer, get_group_by_exprs()))) {
LOG_WARN("failed to extract subplan params in log group by exprs", K(ret));
} else if (OB_FAIL(replace_exprs_action(replacer, get_rollup_exprs()))) {
LOG_WARN("failed to extract subplan params in log rollup exprs", K(ret));
} else if (OB_FAIL(replace_exprs_action(replacer, get_aggr_funcs()))) {
LOG_WARN("failed to extract subplan params in log agg funcs", K(ret));
} else {
for(int64_t i = 0; OB_SUCC(ret) && i < rollup_adaptive_info_.sort_keys_.count(); ++i) {
OrderItem &cur_order_item = rollup_adaptive_info_.sort_keys_.at(i);
if (OB_FAIL(replace_expr_action(replacer, cur_order_item.expr_))) {
LOG_WARN("failed to resolve ref params in sort key ", K(cur_order_item), K(ret));
} else { /* Do nothing */ }
}
for(int64_t i = 0; OB_SUCC(ret) && i < rollup_adaptive_info_.ecd_sort_keys_.count(); ++i) {
OrderItem &cur_order_item = rollup_adaptive_info_.ecd_sort_keys_.at(i);
if (OB_FAIL(replace_expr_action(replacer, cur_order_item.expr_))) {
LOG_WARN("failed to resolve ref params in sort key ", K(cur_order_item), K(ret));
} else { /* Do nothing */ }
}
}
if (OB_SUCC(ret) && is_three_stage_aggr()) {
if (OB_FAIL(replace_exprs_action(replacer, three_stage_info_.distinct_exprs_))) {
LOG_WARN("failed to replace three stage info distinct exprs", K(ret));
} else {
for(int64_t i = 0; OB_SUCC(ret) && i < three_stage_info_.distinct_aggr_batch_.count(); ++i) {
ObDistinctAggrBatch &distinct_batch = three_stage_info_.distinct_aggr_batch_.at(i);
for (int64_t j = 0; OB_SUCC(ret) && j < distinct_batch.mocked_params_.count(); ++j) {
if (OB_FAIL(replace_expr_action(replacer, distinct_batch.mocked_params_.at(j).first))) {
LOG_WARN("failed to replace distinct expr", K(ret));
}
}
}
}
}
return ret;
}
int ObLogGroupBy::print_outline_data(PlanText &plan_text)
{
int ret = OB_SUCCESS;
const ObDMLStmt *stmt = NULL;
ObString qb_name;
if (is_push_down()) {
/* print outline in top group by */
} else if (OB_ISNULL(get_plan()) || OB_ISNULL(stmt = get_plan()->get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL", K(ret), K(get_plan()), K(stmt));
} else if (OB_FAIL(stmt->get_qb_name(qb_name))) {
LOG_WARN("fail to get qb_name", K(ret), K(stmt->get_stmt_id()));
} else {
if (OB_SUCC(ret) && has_push_down_) {
ObOptHint hint(T_GBY_PUSHDOWN);
hint.set_qb_name(qb_name);
if (OB_FAIL(hint.print_hint(plan_text))) {
LOG_WARN("failed to print hint", K(ret), K(hint));
}
}
if (OB_SUCC(ret) && (use_hash_aggr_ || use_part_sort_)) {
ObAggHint hint(use_hash_aggr_ ? T_USE_HASH_AGGREGATE : T_NO_USE_HASH_AGGREGATE);
hint.set_qb_name(qb_name);
hint.set_use_partition_sort(use_part_sort_);
if (OB_FAIL(hint.print_hint(plan_text))) {
LOG_WARN("failed to print hint", K(ret), K(hint));
}
}
}
return ret;
}
int ObLogGroupBy::print_used_hint(PlanText &plan_text)
{
int ret = OB_SUCCESS;
const ObHint *hint = NULL;
if (is_push_down()) {
/* print outline in top group by */
} else if (OB_ISNULL(get_plan())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL", K(ret), K(get_plan()));
} else if (NULL != (hint = get_plan()->get_log_plan_hint().get_normal_hint(T_GBY_PUSHDOWN))
&& hint->is_enable_hint() == has_push_down_
&& OB_FAIL(hint->print_hint(plan_text))) {
LOG_WARN("failed to print used hint for group by", K(ret), K(*hint));
} else if (NULL != (hint = get_plan()->get_log_plan_hint().get_normal_hint(T_USE_HASH_AGGREGATE))
&& hint->is_enable_hint() == use_hash_aggr_
&& static_cast<const ObAggHint*>(hint)->force_partition_sort() == use_part_sort_
&& OB_FAIL(hint->print_hint(plan_text))) {
LOG_WARN("failed to print used hint for group by", K(ret), K(*hint));
}
return ret;
}
int ObLogGroupBy::compute_const_exprs()
{
int ret = OB_SUCCESS;
ObLogicalOperator *child = NULL;
if (OB_ISNULL(my_plan_) || OB_UNLIKELY(get_num_of_child() < 0)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("operator is invalid", K(ret), K(get_num_of_child()), K(my_plan_));
} else if (OB_ISNULL(child = get_child(0))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("child is null", K(ret), K(child));
} else if (!has_rollup() &&
OB_FAIL(append(get_output_const_exprs(), child->get_output_const_exprs()))) {
LOG_WARN("failed to append exprs", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::compute_const_exprs(get_filter_exprs(), get_output_const_exprs()))) {
LOG_WARN("failed to compute const conditionexprs", K(ret));
} else {/*do nothing*/}
return ret;
}
int ObLogGroupBy::compute_equal_set()
{
int ret = OB_SUCCESS;
EqualSets *ordering_esets = NULL;
if (OB_ISNULL(my_plan_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("operator is invalid", K(ret), K(my_plan_));
} else if (!has_rollup()) {
if (OB_FAIL(ObLogicalOperator::compute_equal_set())) {
LOG_WARN("failed to compute equal set", K(ret));
}
} else if (filter_exprs_.empty()) {
set_output_equal_sets(&empty_expr_sets_);
} else if (OB_ISNULL(ordering_esets = get_plan()->create_equal_sets())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to create equal sets", K(ret));
} else if (OB_FAIL(ObEqualAnalysis::compute_equal_set(
&my_plan_->get_allocator(),
filter_exprs_,
*ordering_esets))) {
LOG_WARN("failed to compute ordering output equal set", K(ret));
} else {
set_output_equal_sets(ordering_esets);
}
return ret;
}
int ObLogGroupBy::compute_fd_item_set()
{
int ret = OB_SUCCESS;
const ObLogicalOperator *child = NULL;
ObFdItemSet *fd_item_set = NULL;
ObTableFdItem *fd_item = NULL;
if (OB_ISNULL(child = get_child(ObLogicalOperator::first_child)) || OB_ISNULL(my_plan_) ||
OB_ISNULL(get_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpect null", K(ret), K(child), K(my_plan_), K(get_stmt()));
} else if (has_rollup()) {
// do nothing
} else if (OB_FAIL(my_plan_->get_fd_item_factory().create_fd_item_set(fd_item_set))) {
LOG_WARN("failed to create fd item set", K(ret));
} else if (OB_FAIL(fd_item_set->assign(child->get_fd_item_set()))) {
LOG_WARN("failed to assign fd item set", K(ret));
} else if (group_exprs_.empty()) {
// scalar group by
if (get_stmt()->is_select_stmt() && OB_FAIL(create_fd_item_from_select_list(fd_item_set))) {
LOG_WARN("failed to create fd item from select list", K(ret));
}
} else if (!ObTransformUtils::need_compute_fd_item_set(group_exprs_)) {
//do nothing
} else if (OB_FAIL(my_plan_->get_fd_item_factory().create_table_fd_item(
fd_item,
true,
group_exprs_,
get_table_set()))) {
LOG_WARN("failed to create fd item", K(ret));
} else if (OB_FAIL(fd_item_set->push_back(fd_item))) {
LOG_WARN("failed to push back fd item", K(ret));
}
if (OB_FAIL(ret)) {
/*do nothing*/
} else if (OB_NOT_NULL(fd_item_set) && // rollup 时 fd_item_set is null
OB_FAIL(deduce_const_exprs_and_ft_item_set(*fd_item_set))) {
LOG_WARN("falied to deduce fd item set", K(ret));
} else {
set_fd_item_set(fd_item_set);
}
return ret;
}
int ObLogGroupBy::create_fd_item_from_select_list(ObFdItemSet *fd_item_set)
{
int ret = OB_SUCCESS;
ObSEArray<ObRawExpr*, 8> select_exprs;
ObTableFdItem *fd_item = NULL;
if (OB_ISNULL(fd_item_set) || OB_ISNULL(my_plan_) || OB_ISNULL(get_stmt()) ||
OB_UNLIKELY(!get_stmt()->is_select_stmt())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpect parameter", K(ret), K(fd_item_set), K(my_plan_), K(get_stmt()));
} else if (OB_FAIL(static_cast<const ObSelectStmt *>(get_stmt())->get_select_exprs(select_exprs))) {
LOG_WARN("failed to get select exprs", K(ret));
} else if (ObTransformUtils::need_compute_fd_item_set(select_exprs)) {
for (int64_t i = 0; OB_SUCC(ret) && i < select_exprs.count(); ++i) {
ObSEArray<ObRawExpr *, 1> value_exprs;
if (OB_FAIL(value_exprs.push_back(select_exprs.at(i)))) {
LOG_WARN("failed to push back expr", K(ret));
} else if (OB_FAIL(my_plan_->get_fd_item_factory().create_table_fd_item(fd_item,
true,
value_exprs,
get_table_set()))) {
LOG_WARN("failed to create fd item", K(ret));
} else if (OB_FAIL(fd_item_set->push_back(fd_item))) {
LOG_WARN("failed to push back fd item", K(ret));
}
}
}
return ret;
}
int ObLogGroupBy::compute_op_ordering()
{
int ret = OB_SUCCESS;
ObLogicalOperator *child = NULL;
if (HASH_AGGREGATE == algo_) {
// do nothing
reset_op_ordering();
} else if (OB_ISNULL(child = get_child(ObLogicalOperator::first_child))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("child is null", K(ret));
} else if (has_rollup()) {
ObSEArray<OrderItem, 4> ordering;
// for rollup distributor, sort key is inner
if (ObRollupStatus::ROLLUP_DISTRIBUTOR != rollup_adaptive_info_.rollup_status_) {
for (int64_t i = 0; OB_SUCC(ret) && i < group_exprs_.count(); i++) {
if (i < child->get_op_ordering().count() &&
child->get_op_ordering().at(i).expr_ == group_exprs_.at(i) &&
OB_FAIL(ordering.push_back(child->get_op_ordering().at(i)))) {
LOG_WARN("failed to push back into ordering.", K(ret));
} else {}
}
}
if (OB_SUCC(ret) && OB_FAIL(set_op_ordering(ordering))) {
LOG_WARN("failed to set op ordering.", K(ret));
} else {
is_range_order_ = child->get_is_range_order();
is_local_order_ = is_fully_partition_wise() && !get_op_ordering().empty();
}
} else if (OB_FAIL(set_op_ordering(child->get_op_ordering()))) {
LOG_WARN("failed to set op ordering", K(ret));
} else {
is_range_order_ = child->get_is_range_order();
is_local_order_ = is_fully_partition_wise() && !get_op_ordering().empty();
}
return ret;
}
int ObLogGroupBy::allocate_granule_pre(AllocGIContext &ctx)
{
int ret = OB_SUCCESS;
if (OB_FAIL(pw_allocate_granule_pre(ctx))) {
LOG_WARN("failed to allocate partition wise granule", K(ret));
} else { /*do nothing*/ }
return ret;
}
int ObLogGroupBy::allocate_granule_post(AllocGIContext &ctx)
{
return pw_allocate_granule_post(ctx);
}
int ObLogGroupBy::compute_one_row_info()
{
int ret = OB_SUCCESS;
if (group_exprs_.empty() && rollup_exprs_.empty()) {
set_is_at_most_one_row(true);
} else if (has_rollup()) {
set_is_at_most_one_row(false);
} else if (OB_FAIL(ObLogicalOperator::compute_one_row_info())) {
LOG_WARN("failed to compute one row info", K(ret));
} else { /*do nothing*/ }
return ret;
}
int ObLogGroupBy::allocate_startup_expr_post()
{
int ret = OB_SUCCESS;
if (SCALAR_AGGREGATE == algo_) {
//do nothing
} else if (OB_FAIL(ObLogicalOperator::allocate_startup_expr_post())) {
LOG_WARN("failed to allocate startup exprs post", K(ret));
}
return ret;
}
int ObLogGroupBy::set_rollup_info(
const ObRollupStatus rollup_status,
ObRawExpr *rollup_id_expr)
{
int ret = OB_SUCCESS;
rollup_adaptive_info_.rollup_id_expr_ = rollup_id_expr;
rollup_adaptive_info_.rollup_status_ = rollup_status;
return ret;
}
int ObLogGroupBy::set_rollup_info(
const ObRollupStatus rollup_status,
ObRawExpr *rollup_id_expr,
ObIArray<OrderItem> &sort_keys,
ObIArray<OrderItem> &ecd_sort_keys,
bool enable_encode_sort)
{
int ret = OB_SUCCESS;
rollup_adaptive_info_.rollup_id_expr_ = rollup_id_expr;
rollup_adaptive_info_.rollup_status_ = rollup_status;
rollup_adaptive_info_.enable_encode_sort_ = enable_encode_sort;
rollup_adaptive_info_.sort_keys_.reset();
rollup_adaptive_info_.ecd_sort_keys_.reset();
if (OB_FAIL(append(rollup_adaptive_info_.sort_keys_, sort_keys))) {
LOG_WARN("failed to append sort keys", K(ret));
} else if (OB_FAIL(append(rollup_adaptive_info_.ecd_sort_keys_, ecd_sort_keys))) {
LOG_WARN("failed to append sort keys", K(ret));
}
return ret;
}
int ObThreeStageAggrInfo::set_first_stage_info(ObRawExpr *aggr_code_expr,
ObIArray<ObDistinctAggrBatch> &batch,
double aggr_code_ndv)
{
int ret = OB_SUCCESS;
reuse();
aggr_stage_ = ObThreeStageAggrStage::FIRST_STAGE;
aggr_code_expr_ = aggr_code_expr;
distinct_aggr_count_ = 0;
aggr_code_ndv_ = aggr_code_ndv;
if (OB_FAIL(distinct_aggr_batch_.assign(batch))) {
LOG_WARN("failed to assign batch", K(ret));
} else {
for (int64_t i = 0; i < batch.count(); ++i) {
distinct_aggr_count_ += batch.at(i).mocked_aggrs_.count();
}
}
return ret;
}
int ObThreeStageAggrInfo::set_second_stage_info(ObRawExpr *aggr_code_expr,
ObIArray<ObDistinctAggrBatch> &batch,
ObIArray<ObRawExpr *> &distinct_exprs)
{
int ret = OB_SUCCESS;
reuse();
aggr_stage_ = ObThreeStageAggrStage::SECOND_STAGE;
aggr_code_expr_ = aggr_code_expr;
distinct_aggr_count_ = 0;
if (OB_FAIL(distinct_aggr_batch_.assign(batch))) {
LOG_WARN("failed to assign batch", K(ret));
} else if (OB_FAIL(distinct_exprs_.assign(distinct_exprs))) {
LOG_WARN("failed to assign distinct", K(ret));
} else {
for (int64_t i = 0; i < batch.count(); ++i) {
distinct_aggr_count_ += batch.at(i).mocked_aggrs_.count();
}
}
return ret;
}
int ObThreeStageAggrInfo::set_third_stage_info(ObRawExpr *aggr_code_expr,
ObIArray<ObDistinctAggrBatch> &batch)
{
int ret = OB_SUCCESS;
reuse();
aggr_stage_ = ObThreeStageAggrStage::THIRD_STAGE;
aggr_code_expr_ = aggr_code_expr;
distinct_aggr_count_ = 0;
if (OB_FAIL(distinct_aggr_batch_.assign(batch))) {
LOG_WARN("failed to assign batch", K(ret));
} else {
for (int64_t i = 0; i < batch.count(); ++i) {
distinct_aggr_count_ += batch.at(i).mocked_aggrs_.count();
}
}
return ret;
}
int ObLogGroupBy::set_three_stage_info(const ObThreeStageAggrInfo &info)
{
int ret = OB_SUCCESS;
if (OB_FAIL(three_stage_info_.assign(info))) {
LOG_WARN("failed to assgin", K(ret));
} else if (is_third_stage()) {
// do nothing
} else if (!ObOptimizerUtil::find_item(group_exprs_,
three_stage_info_.aggr_code_expr_,
&three_stage_info_.aggr_code_idx_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("aggr code expr is not found", K(ret));
}
return ret;
}
int ObLogGroupBy::is_my_fixed_expr(const ObRawExpr *expr, bool &is_fixed)
{
int ret = OB_SUCCESS;
is_fixed = false;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret));
} else {
is_fixed = ObOptimizerUtil::find_item(aggr_exprs_, expr) ||
(T_FUN_SYS_REMOVE_CONST == expr->get_expr_type() && ObOptimizerUtil::find_item(rollup_exprs_, expr));
}
return ret;
}
int ObLogGroupBy::compute_sharding_info()
{
int ret = OB_SUCCESS;
if (ObRollupStatus::ROLLUP_COLLECTOR == rollup_adaptive_info_.rollup_status_) {
ObLogicalOperator *child = NULL;
if (get_num_of_child() == 0) {
/*do nothing*/
} else if (OB_ISNULL(child = get_child(ObLogicalOperator::first_child))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (child->get_strong_sharding() != NULL &&
OB_FAIL(weak_sharding_.push_back(child->get_strong_sharding()))) {
LOG_WARN("failed to push back weak sharding");
} else if (OB_FAIL(append(weak_sharding_, child->get_weak_sharding()))) {
LOG_WARN("failed to assign sharding info", K(ret));
} else {
inherit_sharding_index_ = ObLogicalOperator::first_child;
strong_sharding_ = NULL;
}
} else if (OB_FAIL(ObLogicalOperator::compute_sharding_info())) {
LOG_WARN("failed to compute sharding info", K(ret));
}
return ret;
}
int ObLogGroupBy::get_card_without_filter(double &card)
{
int ret = OB_SUCCESS;
card = get_distinct_card();
return ret;
}
Reference in New Issue View Git Blame Copy Permalink