/**
 * 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_simplify_groupby.h"
#include "sql/rewrite/ob_transform_utils.h"
#include "sql/optimizer/ob_optimizer_util.h"
#include "common/ob_smart_call.h"

using namespace oceanbase::sql;

int ObTransformSimplifyGroupby::transform_one_stmt(common::ObIArray<ObParentDMLStmt> &parent_stmts,
                                                   ObDMLStmt *&stmt,
                                                   bool &trans_happened)
{
  int ret = OB_SUCCESS;
  bool is_happened = false;
  if (OB_FAIL(convert_count_aggr_contain_const(stmt, is_happened))) {
    LOG_WARN("convert count aggr contain const failed", K(ret));
  } else {
    trans_happened |= is_happened;
    LOG_TRACE("succeed to convert count aggr contain const", K(is_happened));
  }

  if (OB_SUCC(ret)) {
    if (OB_FAIL(remove_stmt_group_by(stmt, is_happened))) {
      LOG_WARN("remove stmt group by failed", K(ret));
    } else {
      trans_happened |= is_happened;
      LOG_TRACE("succeed to stmt remove group by", K(is_happened));
    }
  }
  if (OB_SUCC(ret)) {
    if (OB_FAIL(remove_group_by_duplicates(stmt, is_happened))) {
      LOG_WARN("failed to remove group by duplicates", K(ret));
    } else {
      trans_happened |= is_happened;
      LOG_TRACE("succeed to remove group by duplicates", K(is_happened));
    }
  }
  if (OB_SUCC(ret)) {
    if (OB_FAIL(remove_aggr_distinct(stmt, is_happened))) {
      LOG_WARN("failed to remove aggr distinct", K(ret));
    } else {
      trans_happened |= is_happened;
      LOG_TRACE("succeed to remove aggr distinct", K(is_happened));
    }
  }
  if (OB_SUCC(ret)) {
    if (OB_FAIL(remove_redundant_group_by(stmt, is_happened))) {
      LOG_WARN("failed to remove redundent group by", K(ret));
    } else {
      trans_happened |= is_happened;
      LOG_TRACE("succeed to remove redundent group by", K(is_happened));
    }
  }
  if (OB_SUCC(ret)) {
    if (OB_FAIL(transform_const_minmax_aggr(stmt, is_happened))) {
      LOG_WARN("failed to transform const minmax aggr", K(ret));
    } else {
      trans_happened |= is_happened;
      LOG_TRACE("succeed to transform const minmax aggr", K(is_happened));
    }
  }
  if (OB_SUCC(ret)) {
    if (OB_FAIL(prune_group_by_rollup(parent_stmts, stmt, is_happened))) {
      LOG_WARN("failed to prune rollup", K(ret));
    } else {
      trans_happened |= is_happened;
      LOG_TRACE("succeed to prune group by rollup", K(is_happened));
    }
  }
  if (OB_SUCC(ret) && trans_happened) {
    if (OB_FAIL(add_transform_hint(*stmt))) {
      LOG_WARN("failed to add transform hint", K(ret));
    }
  }
  return ret;
}

//当存在多层group by时尝试对下层group by进行消除:
//select sum(sc2) from (select sum(c2) sc2 from t ... group by c1);
// --> select sum(c2) from (select c2 from t ...);
int ObTransformSimplifyGroupby::remove_redundant_group_by(ObDMLStmt *stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  bool is_valid = false;
  ObArray<ObSelectStmt*> valid_child_stmts;
  ObSelectStmt *select_stmt = NULL;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else if (!stmt->is_select_stmt() || !stmt->is_single_table_stmt()) {
    /*do nothing*/
  } else if (FALSE_IT(select_stmt = static_cast<ObSelectStmt*>(stmt))) {
    /*do nothing*/
  } else if (OB_ISNULL(select_stmt->get_table_item(0))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("table item is null", K(ret));
  } else if (!select_stmt->get_table_item(0)->is_generated_table()) {
    /*do nothing*/
  } else if (OB_FAIL(check_upper_stmt_validity(select_stmt, is_valid))) {
    LOG_WARN("failed to check upper stmt validity", K(ret));
  } else if (!is_valid) {
    /*do nothing*/
  } else if (OB_FAIL(get_valid_child_stmts(select_stmt,
                                           select_stmt->get_table_item(0)->ref_query_,
                                           valid_child_stmts))) {
    LOG_WARN("failed to get valid child stmts", K(ret));
  } else if (valid_child_stmts.empty()) {
    /*do nothing*/
  } else if (OB_FAIL(remove_child_stmts_group_by(valid_child_stmts))) {
    LOG_WARN("failed to remove child stmts group by", K(ret));
  } else {
    trans_happened = true;
  }
  return ret;
}

//upper stmt pre check条件:
//  1.upper stmt 为单表查询, from table 为 generate table
//  2.包含group by
//  3.condition不存在rownum
//  4.仅存在min/max/sum aggr, sum aggr无distinct
//  5.是标准group by,无非聚合输出
int ObTransformSimplifyGroupby::check_upper_stmt_validity(ObSelectStmt *upper_stmt, bool &is_valid)
{
  int ret = OB_SUCCESS;
  is_valid = true;
  if (OB_ISNULL(upper_stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected null", K(ret));
  } else if (!upper_stmt->has_group_by()) {
    is_valid = false;
  } else if (!is_only_full_group_by_on(ctx_->session_info_->get_sql_mode())) {
    is_valid = false;
  }
  //check condition不存在rownum
  for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < upper_stmt->get_condition_size(); ++i) {
    ObRawExpr *cond_expr = NULL;
    if (OB_ISNULL(cond_expr = upper_stmt->get_condition_expr(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null expr", K(ret));
    } else if (cond_expr->has_flag(CNT_ROWNUM)) {
      is_valid = false;
    }
  }
  //cehck aggr仅存在 min/max/sum 且无 distinct
  for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < upper_stmt->get_aggr_item_size(); ++i) {
    ObAggFunRawExpr *aggr_expr = NULL;
    if (OB_ISNULL(aggr_expr = upper_stmt->get_aggr_item(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null aggr", K(ret));
    } else if (T_FUN_MIN != aggr_expr->get_expr_type()
               && T_FUN_MAX != aggr_expr->get_expr_type()
               && T_FUN_SUM != aggr_expr->get_expr_type()) {
      is_valid = false;
    } else if (T_FUN_SUM == aggr_expr->get_expr_type() && aggr_expr->is_param_distinct()) {
      is_valid = false;
    }
  }
  return ret;
}

//获取可消除group by的child stmt, 对union all查找所有分支, 判断条件:
//  1.child stmt 不存在 window function/having/distinct/rownum/limit/rollup
//  2.upper stmt group by 不能包含 child stmt aggr
//  3.upper stmt aggr 与 child aggr 满足消除匹配关系
//  4.upper stmt condition 没有使用 child stmt aggr
int ObTransformSimplifyGroupby::get_valid_child_stmts(ObSelectStmt *upper_stmt,
                                                      ObSelectStmt *stmt,
                                                      ObArray<ObSelectStmt*> &valid_child_stmts)
{
  int ret = OB_SUCCESS;
  bool is_valid = true;
  bool has_rownum = false;
  ObArray<ObRawExpr*> aggr_column_exprs;
  ObArray<ObRawExpr*> no_aggr_column_exprs;
  ObArray<ObRawExpr*> child_aggr_exprs;
  if (OB_ISNULL(upper_stmt) || OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else if (stmt->is_set_stmt()) {
    if (ObSelectStmt::UNION != stmt->get_set_op()
        || stmt->is_set_distinct()
        || stmt->has_limit()) {//判断条件1
      is_valid = false;
    } else {
      ObIArray<ObSelectStmt*> &child_stmts = stmt->get_set_query();
      for (int64_t i = 0; OB_SUCC(ret) && i < child_stmts.count(); ++i) {
        ret = SMART_CALL(get_valid_child_stmts(upper_stmt, child_stmts.at(i), valid_child_stmts));
      }
    }
  } else if (!stmt->has_group_by()
             || stmt->has_rollup()
             || stmt->has_window_function()//判断条件1
             || stmt->has_having()
             || stmt->has_distinct()
             || stmt->has_sequence()
             || stmt->has_limit()) {
    is_valid = false;
  } else if (OB_FAIL(stmt->has_rownum(has_rownum))) {
    LOG_WARN("failed to check has rownum", K(ret));
  } else if (has_rownum) {
    is_valid = false;
  } else if (OB_FAIL(get_upper_column_exprs(*upper_stmt, *stmt,//获取upper stmt column item中的child aggr列与非aggr列
                                            aggr_column_exprs,
                                            no_aggr_column_exprs,
                                            child_aggr_exprs,
                                            is_valid))) {
    LOG_WARN("failed to get upper column exprs", K(ret));
  } else if (!is_valid) {
    /*do nothing*/
  } else if (OB_FAIL(check_upper_group_by(*upper_stmt, no_aggr_column_exprs, is_valid))) {//判断条件2
    LOG_WARN("failed to check upper group by", K(ret));
  } else if (!is_valid) {
    /*do nothing*/
  } else if (OB_FAIL(check_aggrs_matched(upper_stmt->get_aggr_items(),//判断条件3
                                         aggr_column_exprs, no_aggr_column_exprs,
                                         child_aggr_exprs, is_valid))) {
    LOG_WARN("failed to check aggrs matched", K(ret));
  } else if (!is_valid) {
    /*do nothing*/
  } else if (OB_FAIL(check_upper_condition(upper_stmt->get_condition_exprs(),//判断条件4
                                           aggr_column_exprs, is_valid))) {
    LOG_WARN("failed to check upper condition", K(ret));
  } else if (!is_valid) {
    /*do nothing*/
  } else if (OB_FAIL(valid_child_stmts.push_back(stmt))) {
    LOG_WARN("failed to push back child stmt", K(ret));
  } else {
    /*do nothing*/
  }
  return ret;
}

//移除child_stmts中的group by/order by/aggr, 对原select中的aggr进行处理:
//  1. max/min/sum使用aggr参数添加cast后替换aggr,
//  2. count替换为is not, not null时结果为与count结果类型相同的const
int ObTransformSimplifyGroupby::remove_child_stmts_group_by(ObArray<ObSelectStmt*> &child_stmts)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(ctx_) || OB_ISNULL(ctx_->session_info_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid argument", K(ret), K(ctx_));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < child_stmts.count(); ++i) {
    ObSelectStmt *stmt = NULL;
    if (OB_ISNULL(stmt = child_stmts.at(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null", K(ret));
    } else {
      stmt->get_aggr_items().reset();
      stmt->get_group_exprs().reset();
      stmt->get_rollup_exprs().reset();
      stmt->get_rollup_dirs().reset();
      stmt->get_order_items().reset();
      for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_select_item_size(); ++i) {
        ObRawExpr *expr = stmt->get_select_item(i).expr_;
        if (OB_ISNULL(expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("unexpected null", K(ret));
        } else if (!expr->is_aggr_expr()) {
          /*do nothing*/
        } else if (T_FUN_MAX == expr->get_expr_type()
                   || T_FUN_MIN == expr->get_expr_type()
                   || T_FUN_SUM == expr->get_expr_type()) {
          ObRawExpr *cast_expr;
          if (OB_FAIL(ObRawExprUtils::try_add_cast_expr_above(ctx_->expr_factory_,
                                                              ctx_->session_info_,
                                                              *expr->get_param_expr(0),
                                                              expr->get_result_type(),
                                                              cast_expr))) {
            LOG_WARN("try add cast expr above failed", K(ret));
          } else {
            stmt->get_select_item(i).expr_ = cast_expr;
          }
        } else {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("unexpected aggr", K(ret), K(expr->get_expr_type()));
        }
      }
    }
  }
  return ret;
}

//从stmt select中匹配group by/aggr到upper stmt column item
int ObTransformSimplifyGroupby::get_upper_column_exprs(ObSelectStmt &upper_stmt,
                                                       ObSelectStmt &stmt,
                                                       ObIArray<ObRawExpr*> &aggr_column_exprs,
                                                       ObIArray<ObRawExpr*> &no_aggr_column_exprs,
                                                       ObIArray<ObRawExpr*> &child_aggr_exprs,
                                                       bool &is_valid)
{
  int ret = OB_SUCCESS;
  is_valid = true;
  TableItem *table_item = NULL;
  ObSelectStmt *ref_query = NULL;
  if (OB_UNLIKELY(!upper_stmt.is_single_table_stmt())
      || OB_ISNULL(table_item = upper_stmt.get_table_item(0))
      || OB_UNLIKELY(!table_item->is_generated_table())
      || OB_ISNULL(ref_query = table_item->ref_query_)
      || OB_UNLIKELY(stmt.get_select_item_size() != ref_query->get_select_item_size())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected upper stmt", K(ret), K(upper_stmt));
  }
  for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < stmt.get_select_item_size(); ++i) {
    ObRawExpr *stmt_select_expr = NULL;
    ColumnItem *column_item = NULL;
    if (OB_ISNULL(stmt_select_expr = stmt.get_select_item(i).expr_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get unexpected null", K(ret));
    } else if (OB_ISNULL(column_item = upper_stmt.get_column_item_by_id(table_item->table_id_,
                                                                        i + OB_APP_MIN_COLUMN_ID))) {
      // a select expr contains aggr function, it's not used by upper stmt.
      // project pruning will remove it, do not transform here.
      is_valid = !stmt_select_expr->has_flag(CNT_AGG);
    } else if (OB_ISNULL(column_item->expr_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get unexpected null expr", K(ret));
    } else if (stmt_select_expr->is_aggr_expr()) {//is aggr
      int64_t idx = OB_INVALID_INDEX;
      if (!ObOptimizerUtil::find_item(stmt.get_aggr_items(),
                                      static_cast<ObAggFunRawExpr*>(stmt_select_expr),
                                      &idx)) {
        is_valid = false;
        LOG_DEBUG("cannot find aggr in stmt aggr item", K(ret), K(stmt), K(*stmt_select_expr));
      } else if (OB_FAIL(aggr_column_exprs.push_back(column_item->expr_))
                 || OB_FAIL(child_aggr_exprs.push_back(stmt.get_aggr_items().at(idx)))) {
        LOG_WARN("failed to push back aggr", K(ret));
      }
    } else if (ObOptimizerUtil::find_item(stmt.get_group_exprs(), stmt_select_expr)
               || stmt_select_expr->is_const_expr()) {//in group by or is const
      if (OB_FAIL(no_aggr_column_exprs.push_back(column_item->expr_))) {
        LOG_WARN("failed to push back expr", K(ret));
      }
    } else {
      //可能允许转化的场景：
      //  1.select 中为 cast(aggr fun())
      //  2.select 包含 subquery
      is_valid = false;
    }
  }
  return ret;
}

//check upper stmt group by/rollup 不包含 stmt aggr 项
int ObTransformSimplifyGroupby::check_upper_group_by(ObSelectStmt &upper_stmt,
                                                     ObIArray<ObRawExpr*> &no_aggr_column_exprs,
                                                     bool &is_valid)
{
  int ret = OB_SUCCESS;
  is_valid = false;
  if (!ObOptimizerUtil::subset_exprs(upper_stmt.get_rollup_exprs(), no_aggr_column_exprs)) {
    /*do nothing*/
  } else if (!ObOptimizerUtil::subset_exprs(upper_stmt.get_group_exprs(), no_aggr_column_exprs)) {
    /*do nothing*/
  } else {
    is_valid = true;
  }
  return ret;
}

//check upper stmt aggr 与 child aggr 满足消除条件, aggr匹配条件:
//  1.upper aggr min/max/sum 参数为 child min/max/sum 结果, child aggr 为 sum 不能 distinct
//  2.upper aggr min/max 参数为 child stmt 非 aggr 列
int ObTransformSimplifyGroupby::check_aggrs_matched(ObIArray<ObAggFunRawExpr*> &upper_aggrs,
                                                    ObIArray<ObRawExpr*> &aggr_column_exprs,
                                                    ObIArray<ObRawExpr*> &no_aggr_column_exprs,
                                                    ObIArray<ObRawExpr*> &child_aggr_exprs,
                                                    bool &is_valid)
{
  int ret = OB_SUCCESS;
  is_valid = true;
  if (aggr_column_exprs.count() != child_aggr_exprs.count()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected array count", K(ret), K(aggr_column_exprs), K(child_aggr_exprs));
  }
  for (int64_t i = 0; OB_SUCC(ret) && is_valid && i < upper_aggrs.count(); ++i) {
    ObAggFunRawExpr *upper_aggr = NULL;
    ObRawExpr *aggr_param = NULL;
    int64_t idx = OB_INVALID_INDEX;
    if (OB_ISNULL(upper_aggr = upper_aggrs.at(i))
        || OB_ISNULL(aggr_param = upper_aggr->get_param_expr(0))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null", K(ret));
    } else if (ObOptimizerUtil::find_item(aggr_column_exprs, aggr_param, &idx)) {
      const ObAggFunRawExpr *child_aggr = static_cast<ObAggFunRawExpr*>(child_aggr_exprs.at(idx));
      if (upper_aggr->get_expr_type() != child_aggr->get_expr_type()) {//匹配条件1
        is_valid = false;
      } else if (T_FUN_SUM == child_aggr->get_expr_type()
                 && child_aggr->is_param_distinct()) {
        is_valid = false;
      } else {
        /*do nothing*/
      }
    } else if (ObOptimizerUtil::find_item(no_aggr_column_exprs, aggr_param)) {//匹配条件2
      is_valid = T_FUN_MAX == upper_aggr->get_expr_type() ||
          T_FUN_MIN == upper_aggr->get_expr_type();
    } else {
      is_valid = false;
    }
  }
  return ret;
}

//check upper stmt condition 不包含 stmt aggr result
int ObTransformSimplifyGroupby::check_upper_condition(ObIArray<ObRawExpr*> &cond_exprs,
                                                      ObIArray<ObRawExpr*> &aggr_column_exprs,
                                                      bool &is_valid)
{
  int ret = OB_SUCCESS;
  bool find_expr = false;
  int64_t N = cond_exprs.count();
  for (int64_t i = 0; OB_SUCC(ret) && !find_expr && i < N; ++i) {
    ret = exist_exprs_in_expr(cond_exprs.at(i), aggr_column_exprs, find_expr);
  }
  is_valid = !find_expr;
  return ret;
}

int ObTransformSimplifyGroupby::exist_exprs_in_expr(const ObRawExpr *src_expr,
                                                    ObIArray<ObRawExpr*> &dst_exprs,
                                                    bool &is_exist)
{
  int ret = OB_SUCCESS;
  is_exist = false;
  if (OB_ISNULL(src_expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected NULL", K(ret));
  } else if (dst_exprs.empty()) {
    /*do nothing*/
  } else if (ObOptimizerUtil::find_item(dst_exprs, src_expr)) {
    is_exist = true;
  } else {
    int64_t N = src_expr->get_param_count();
    for (int64_t i = 0; OB_SUCC(ret) && !is_exist && i < N; ++i) {
      if (OB_FAIL(SMART_CALL(exist_exprs_in_expr(src_expr->get_param_expr(i),
                                                 dst_exprs,
                                                 is_exist)))) {
        LOG_WARN("failed to smart call", K(ret));
      }
    }
  }
  return ret;
}

/* 当 group by 的表达式唯一的时候，可以做以下改写:
1. 去除 group by
2. 改写可以改写的聚合函数表达式，并删除原来的聚合函数。
*/
int ObTransformSimplifyGroupby::remove_stmt_group_by(ObDMLStmt *&stmt,
                                                     bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  ObSelectStmt *select_stmt = NULL;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else if (!stmt->is_select_stmt()) {
    //do nothing
  } else if (FALSE_IT(select_stmt = static_cast<ObSelectStmt *>(stmt))) {
    /*do nothing*/
  } else if (select_stmt->get_group_expr_size() > 0 && !select_stmt->has_rollup()) {
    //check stmt group by can be removed
    bool can_be = false;
    if (OB_FAIL(check_stmt_group_by_can_be_removed(select_stmt, can_be))) {
      LOG_WARN("check stmt group by can be removed failed", K(ret), K(*select_stmt));
    } else if (!can_be) {
      /*do nothing*/
    } else if (OB_FAIL(inner_remove_stmt_group_by(select_stmt, trans_happened))) {
      LOG_WARN("do transform remove group by failed", K(ret), K(*select_stmt));
    } else {
      /*do nothing*/
    }
  }
  return ret;
}

int ObTransformSimplifyGroupby::check_stmt_group_by_can_be_removed(ObSelectStmt *select_stmt,
                                                                   bool &can_be)
{
  int ret = OB_SUCCESS;
  can_be = false;
  bool has_rownum = false;
  bool is_unique = false;
  if (OB_ISNULL(select_stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->schema_checker_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("NULL pointer error", K(ret), K(ctx_), K(ctx_->schema_checker_));
  } else if (OB_FAIL(select_stmt->has_rownum(has_rownum))) {
    LOG_WARN("check has_rownum error", K(ret));
  } else if (has_rownum && select_stmt->has_having()) {
    /*do nothing */
  } else if (OB_FAIL(ObTransformUtils::check_stmt_unique(select_stmt, ctx_->session_info_,
                                                         ctx_->schema_checker_,
                                                         select_stmt->get_group_exprs(),
                                                         true /* strict */,
                                                         is_unique,
                                                         FLAGS_IGNORE_DISTINCT | FLAGS_IGNORE_GROUP))) {
    LOG_WARN("failed to check stmt unique", K(ret));
  } else if (is_unique) {
    can_be = true;
    for (int64_t i = 0; can_be && i < select_stmt->get_aggr_item_size(); ++i) {
      ObRawExpr *expr = static_cast<ObRawExpr* >(select_stmt->get_aggr_item(i));
      if (OB_ISNULL(expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("NULL pointer error", K(ret));
      } else if (OB_FAIL(check_aggr_win_can_be_removed(select_stmt, expr, can_be))) {
        LOG_WARN("fialed to check aggr can be removed", K(ret), K(*expr));
      }
    }
  } else {
    //do nothing
  }
  return ret;
}

int ObTransformSimplifyGroupby::inner_remove_stmt_group_by(ObSelectStmt *select_stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(select_stmt) || OB_ISNULL(ctx_) ||
      OB_ISNULL(ctx_->expr_factory_) || OB_ISNULL(ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("NULL pointer error", K(ret), K(select_stmt), K(ctx_),
             K(ctx_->expr_factory_), K(ctx_->session_info_));
  } else {
    ObArray<ObRawExpr*> new_exprs;
    ObArray<ObRawExpr*> old_exprs;
    for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_aggr_item_size(); ++i) {
      ObRawExpr *new_expr = NULL;
      ObRawExpr *expr = static_cast<ObRawExpr* >(select_stmt->get_aggr_item(i));
      if (OB_ISNULL(expr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("NULL pointer error", K(ret));
      } else if (OB_FAIL(old_exprs.push_back(expr))) {
        LOG_WARN("old exprs push back failed", K(ret));
      } else if (OB_FAIL(transform_aggr_win_to_common_expr(select_stmt, expr, new_expr))) {
        LOG_WARN("transform aggr to common expr failed", K(ret), K(expr));
      }
      if (OB_SUCC(ret)) {
        if (OB_ISNULL(new_expr)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("get unexpected null", K(ret), K(new_expr));
        } else if (OB_FAIL(new_exprs.push_back(new_expr))) {
          LOG_WARN("new exprs push back failed", K(ret));
        }
      }
    }
    if (OB_SUCC(ret)) {
      if (OB_FAIL(select_stmt->replace_inner_stmt_expr(old_exprs, new_exprs))) {
        LOG_WARN("select_stmt replace inner stmt expr failed", K(ret), K(select_stmt));
      } else if (OB_FAIL(append(select_stmt->get_condition_exprs(), select_stmt->get_having_exprs()))) {
        LOG_WARN("failed append having exprs to condition exprs", K(ret));
      } else {
        select_stmt->get_having_exprs().reset();
        select_stmt->get_aggr_items().reset();
        select_stmt->get_group_exprs().reset();
        trans_happened = true;
      }
    }
  }
  return ret;
}

//移除group by重复列
//select * from t1 group by c1,c1,c1
//==>
//select * from t1 group by c1
int ObTransformSimplifyGroupby::remove_group_by_duplicates(ObDMLStmt *&stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = NULL;
  trans_happened = false;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null pointer", K(ret));
  } else if (!stmt->is_select_stmt()) {
    //do nothing
  } else if (FALSE_IT(select_stmt = static_cast<ObSelectStmt *>(stmt))) {
    /* do nothing */
  } else if (select_stmt->get_group_expr_size() > 0 && !select_stmt->has_rollup()) {
    ObArray<ObRawExpr*> new_group_exprs;
    ObIArray<ObRawExpr*> &group_exprs = select_stmt->get_group_exprs();
    for (int64_t i = 0; OB_SUCC(ret) && i < group_exprs.count(); ++i) {
      if (ObOptimizerUtil::find_equal_expr(new_group_exprs, group_exprs.at(i))) {
        /*do nothing*/
      } else if (OB_FAIL(new_group_exprs.push_back(group_exprs.at(i)))) {
        LOG_WARN("new group exprs push back failed", K(ret), K(group_exprs.at(i)));
      } else {
        /*do nothing*/
      }
    }
    if (OB_SUCC(ret)) {
      select_stmt->get_group_exprs().reset();
      if (OB_FAIL(select_stmt->get_group_exprs().assign(new_group_exprs))) {
        LOG_WARN("failed to assign a new group exprs", K(ret));
      }
    }
  }
  return ret;
}

// try to remove distinct in aggr(distinct) and window_function(distinct)
int ObTransformSimplifyGroupby::remove_aggr_distinct(ObDMLStmt *stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  ObAggFunRawExpr *aggr_expr = NULL;
  ObWinFunRawExpr *win_expr = NULL;
  if (OB_ISNULL(stmt) || OB_ISNULL(ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(stmt), K(ctx_));
  } else if (stmt->is_select_stmt()) {
    ObSelectStmt *select_stmt = static_cast<ObSelectStmt *>(stmt);
    // remove distinct in aggr
    for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_aggr_item_size(); ++i) {
      if (OB_ISNULL(aggr_expr = select_stmt->get_aggr_item(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get null aggr expr", K(ret));
      } else if (!aggr_expr->is_param_distinct()) {
        // do nothing
      } else if (T_FUN_MAX == aggr_expr->get_expr_type() ||
                 T_FUN_MIN == aggr_expr->get_expr_type()) {
        // max/min(distinct) 可以直接消掉distinct
        aggr_expr->set_param_distinct(false);
        trans_happened = true;
      } else if (T_FUN_SUM == aggr_expr->get_expr_type() ||
                 T_FUN_COUNT == aggr_expr->get_expr_type() ||
                 T_FUN_GROUP_CONCAT == aggr_expr->get_expr_type()) {
        // sum/count/group_concat(distinct) 要求param在做group by之前是非严格unique的
        ObSEArray<ObRawExpr *, 4> aggr_param_exprs;
        bool is_unique = false;
        if (OB_FAIL(aggr_param_exprs.assign(aggr_expr->get_real_param_exprs()))) {
          LOG_WARN("failed to push back aggr param expr", K(ret));
        } else if (OB_FAIL(append(aggr_param_exprs, select_stmt->get_group_exprs()))) {
          LOG_WARN("failed to append group by expr", K(ret));
        } else if (OB_FAIL(ObTransformUtils::check_stmt_unique(select_stmt, ctx_->session_info_,
                                                               ctx_->schema_checker_,
                                                               aggr_param_exprs,
                                                               false,
                                                               is_unique,
                                                               FLAGS_IGNORE_DISTINCT|FLAGS_IGNORE_GROUP))) {
          LOG_WARN("failed to check stmt unique", K(ret));
        } else if (is_unique) {
          aggr_expr->set_param_distinct(false);
          trans_happened = true;
        }
      } else {
        // do nothing
      }
    }
    // 整合消除distinct之后重复出现的aggr item:select min(distinct c), min(c) from t1;
    if (OB_SUCC(ret) && trans_happened) {
      if (OB_FAIL(remove_aggr_duplicates(select_stmt))) {
        LOG_WARN("failed to remove aggr item duplicates", K(ret));
      } else {/*do nothing*/}
    }
    // remove distinct in window function
    bool win_happened = false;
    for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_window_func_count(); ++i) {
      if (OB_ISNULL(win_expr = select_stmt->get_window_func_expr(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get null window function expr", K(ret));
      } else if (NULL == (aggr_expr = win_expr->get_agg_expr()) ||
                 !aggr_expr->is_param_distinct()) {
        // do nothing if window function not has aggr expr(such as rownum)
        // or aggr expr not contain distinct
      } else if (T_FUN_MAX == aggr_expr->get_expr_type() ||
                 T_FUN_MIN == aggr_expr->get_expr_type()) {
        // max/min(distinct) 可以直接消掉distinct
        aggr_expr->set_param_distinct(false);
        trans_happened = true;
        win_happened = true;
      } else if (T_FUN_SUM == aggr_expr->get_expr_type() ||
                 T_FUN_COUNT == aggr_expr->get_expr_type()) {
        // sum/count(distinct) 要求param在做group by之后是非严格unique的
        ObSEArray<ObRawExpr *, 4> aggr_param_exprs;
        bool is_unique = false;
        if (OB_FAIL(aggr_param_exprs.assign(aggr_expr->get_real_param_exprs()))) {
          LOG_WARN("failed to push back aggr param expr", K(ret));
        } else if (OB_FAIL(ObTransformUtils::check_stmt_unique(select_stmt, ctx_->session_info_,
                                                               ctx_->schema_checker_,
                                                               aggr_param_exprs,
                                                               false,
                                                               is_unique,
                                                               FLAGS_IGNORE_DISTINCT))) {
          LOG_WARN("failed to check stmt unique", K(ret));
        } else if (is_unique) {
          aggr_expr->set_param_distinct(false);
          trans_happened = true;
          win_happened = true;
        }
      } else {
        // do nothing
      }
    }
    if (OB_SUCC(ret) && win_happened) {
      if (OB_FAIL(remove_win_func_duplicates(select_stmt))) {
        LOG_WARN("failed to remove win func duplicates", K(ret));
      } else {/*do nothing*/}
    }

  }
  return ret;
}

int ObTransformSimplifyGroupby::remove_aggr_duplicates(ObSelectStmt *select_stmt)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(select_stmt));
  } else {
    ObSEArray<ObRawExpr *, 4> old_aggr_exprs;
    ObSEArray<ObRawExpr *, 4> new_aggr_exprs;
    ObSEArray<ObAggFunRawExpr *, 4> new_aggr_items;
    ObAggFunRawExpr *old_aggr_expr = NULL;
    ObAggFunRawExpr *new_aggr_expr = NULL;
    ObSqlBitSet<> removed_items;
    for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_aggr_item_size(); ++i) {
      if (OB_ISNULL(new_aggr_expr = select_stmt->get_aggr_item(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get null aggr expr", K(ret));
      } else if (removed_items.has_member(i)) {
        /*do nothing */
      } else if (OB_FAIL(new_aggr_items.push_back(new_aggr_expr))) {
        LOG_WARN("failed to push back expr", K(ret));
      } else {
        for (int64_t j = i + 1; OB_SUCC(ret) && j < select_stmt->get_aggr_item_size(); ++j) {
          if (OB_ISNULL(old_aggr_expr = select_stmt->get_aggr_item(j))) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get null aggr expr", K(ret));
          } else if (new_aggr_expr->same_as(*old_aggr_expr)) {
            if (OB_FAIL(removed_items.add_member(j))) {
              LOG_WARN("failed to add member", K(ret));
            } else if (OB_FAIL(new_aggr_exprs.push_back(new_aggr_expr))) {
              LOG_WARN("failed to push back expr", K(ret));
            } else if (OB_FAIL(old_aggr_exprs.push_back(old_aggr_expr))) {
              LOG_WARN("failed to push back expr", K(ret));
            } else {/*do nothing*/}
          } else {/*do nothing*/}
        }
      }
    }
    if (OB_SUCC(ret)) {
      if (!old_aggr_exprs.empty()) {
        if (OB_UNLIKELY(old_aggr_exprs.count() != new_aggr_exprs.count())) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("replace expr item size not equal", K(ret), K(old_aggr_exprs.count()),
                   K(new_aggr_exprs.count()));
        } else if (OB_FAIL(select_stmt->replace_inner_stmt_expr(old_aggr_exprs,
                                                                new_aggr_exprs))) {
          LOG_WARN("failed to replace inner stmt expr", K(ret));
        } else if (OB_FAIL(select_stmt->get_aggr_items().assign(new_aggr_items))) {
          LOG_WARN("failed to assign aggr items failed", K(ret));
        }
      } else { /*do nothing */}
    }
  }
  return ret;
}

int ObTransformSimplifyGroupby::remove_win_func_duplicates(ObSelectStmt *select_stmt)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(select_stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret), K(select_stmt));
  } else {
    ObSEArray<ObRawExpr *, 4> old_win_func_exprs;
    ObSEArray<ObRawExpr *, 4> new_win_func_exprs;
    ObSEArray<ObWinFunRawExpr *, 4> new_win_func_items;
    ObWinFunRawExpr *old_win_func_expr = NULL;
    ObWinFunRawExpr *new_win_func_expr = NULL;
    ObSqlBitSet<> removed_items;
    for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_window_func_count(); ++i) {
      if (OB_ISNULL(new_win_func_expr = select_stmt->get_window_func_expr(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get null win func expr", K(ret));
      } else if (removed_items.has_member(i)) {
        /*do nothing */
      } else if (OB_FAIL(new_win_func_items.push_back(new_win_func_expr))) {
        LOG_WARN("failed to push back expr", K(ret));
      } else {
        for (int64_t j = i + 1; OB_SUCC(ret) && j < select_stmt->get_window_func_count(); ++j) {
          if (OB_ISNULL(old_win_func_expr = select_stmt->get_window_func_expr(j))) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get null aggr expr", K(ret));
          } else if (new_win_func_expr->same_as(*old_win_func_expr)) {
            if (OB_FAIL(removed_items.add_member(j))) {
              LOG_WARN("failed to add member", K(ret));
            } else if (OB_FAIL(new_win_func_exprs.push_back(new_win_func_expr))) {
              LOG_WARN("failed to push back expr", K(ret));
            } else if (OB_FAIL(old_win_func_exprs.push_back(old_win_func_expr))) {
              LOG_WARN("failed to push back expr", K(ret));
            } else {/*do nothing*/}
          } else {/*do nothing*/}
        }
      }
    }
    if (OB_SUCC(ret)) {
      if (!old_win_func_exprs.empty()) {
        if (OB_UNLIKELY(old_win_func_exprs.count() != new_win_func_exprs.count())) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("replace expr item size not equal", K(ret), K(old_win_func_exprs.count()),
                   K(new_win_func_exprs.count()));
        } else if (OB_FAIL(select_stmt->replace_inner_stmt_expr(old_win_func_exprs,
                                                                new_win_func_exprs))) {
          LOG_WARN("failed to replace inner stmt expr", K(ret));
        } else if (OB_FAIL(select_stmt->get_window_func_exprs().assign(new_win_func_items))) {
          LOG_WARN("failed to assign win func items failed", K(ret));
        }
      } else { /*do nothing */}
    }
  }
  return ret;
}



// convert count(1) --> count(*)
// convert count([distinct] null) --> 0
// if is scaler group by and count is the only aggr, do not transform
int ObTransformSimplifyGroupby::convert_count_aggr_contain_const(ObDMLStmt *stmt,
                                                                 bool &trans_happened)
{
  int ret = OB_SUCCESS;
  trans_happened = false;
  ObSelectStmt *select_stmt = NULL;
  ObSEArray<ObAggFunRawExpr*, 2> count_const;
  ObSEArray<ObAggFunRawExpr*, 2> count_null;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else if (!stmt->is_select_stmt() ||
             FALSE_IT(select_stmt = static_cast<ObSelectStmt *>(stmt))) {
    /*do nothing*/
  } else if (select_stmt->has_rollup()) {
    /*do nothing*/
  } else if (OB_FAIL(get_valid_count_aggr(select_stmt, count_null, count_const))) {
    LOG_WARN("failed to get calid count exprs", K(ret));
  } else if (count_null.empty() && count_const.empty()) {
    /*do nothing*/
  } else if (select_stmt->is_scala_group_by() &&
             count_null.count() == select_stmt->get_aggr_items().count()) {
    /* scaler group by and count is the only aggr, do not transform */
  } else if (OB_FAIL(convert_valid_count_aggr(select_stmt, count_null, count_const))) {
    LOG_WARN("failed to convert valid count aggr", K(ret));
  } else {
    trans_happened = true;
  }
  return ret;
}

int ObTransformSimplifyGroupby::convert_valid_count_aggr(ObSelectStmt *select_stmt,
                                                         ObIArray<ObAggFunRawExpr*> &count_null,
                                                         ObIArray<ObAggFunRawExpr*> &count_const)
{
  int ret = OB_SUCCESS;
  ObAggFunRawExpr *aggr = NULL;
  ObSEArray<ObRawExpr*, 2> count_null_exprs;
  ObSEArray<ObRawExpr*, 2> const_zeros;
  ObConstRawExpr *const_zero = NULL;
  if (OB_ISNULL(select_stmt) || OB_ISNULL(ctx_) || OB_ISNULL(ctx_->expr_factory_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null", K(ret), K(select_stmt), K(ctx_));
  } else {
    for (int64_t i = 0; OB_SUCC(ret) && i < count_null.count(); ++i) {
      if (OB_ISNULL(aggr = count_null.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null", K(ret), K(aggr));
      } else if (OB_FAIL(ObTransformUtils::add_const_param_constraints(aggr->get_param_expr(0),
                                                                       ctx_))) {
        LOG_WARN("failed to add const param constraints", K(ret));
      } else if (OB_FAIL(count_null_exprs.push_back(aggr))) {
        LOG_WARN("failed to push back exprs", K(ret));
      } else if (OB_FAIL(ObTransformUtils::build_const_expr_for_count(*ctx_->expr_factory_, 0,
                                                                      const_zero))) {
        LOG_WARN("failed to build const expr for count", K(ret));
      } else if (OB_FAIL(const_zeros.push_back(const_zero))) {
        LOG_WARN("failed to push back exprs", K(ret));
      }
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < count_const.count(); ++i) {
      if (OB_ISNULL(aggr = count_const.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null", K(ret), K(aggr));
      } else if (OB_FAIL(ObTransformUtils::add_const_param_constraints(aggr->get_param_expr(0),
                                                                       ctx_))) {
        LOG_WARN("failed to add const param constraints", K(ret));
      } else {
        aggr->get_real_param_exprs_for_update().reuse();
      }
    }
    if (OB_FAIL(ret)) {
    } else if (OB_FAIL(ObOptimizerUtil::remove_item(select_stmt->get_aggr_items(), count_null))) {
      LOG_WARN("failed to remove items", K(ret));
    } else if (OB_FAIL(select_stmt->replace_inner_stmt_expr(count_null_exprs, const_zeros))) {
      LOG_WARN("failed to replace inner stmt exprs", K(ret));
    }
  }
  return ret;
}

int ObTransformSimplifyGroupby::get_valid_count_aggr(ObSelectStmt *select_stmt,
                                                     ObIArray<ObAggFunRawExpr*> &count_null,
                                                     ObIArray<ObAggFunRawExpr*> &count_const)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(select_stmt) || OB_ISNULL(ctx_) ||
      OB_ISNULL(ctx_->allocator_) || OB_ISNULL(ctx_->exec_ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null", K(ret), K(select_stmt), K(ctx_));
  } else {
    ObAggFunRawExpr *aggr = NULL;
    ObRawExpr *param = NULL;
    ObObj obj_value;
    bool got_result = false;
    ObIArray<ObAggFunRawExpr*> &aggrs = select_stmt->get_aggr_items();
    for (int64_t i = 0; OB_SUCC(ret) && i < aggrs.count(); ++i) {
      if (OB_ISNULL(aggr = aggrs.at(i))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null", K(ret), K(aggr));
      } else if (T_FUN_COUNT != aggr->get_expr_type() || 1 != aggr->get_real_param_exprs().count()) {
        /* do nothing */
        /* count(distinct 1, null) can not convert, count(1, null) do not convert now */
      } else if (OB_ISNULL(param = aggr->get_param_expr(0))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unexpect null", K(ret), K(param));
      } else if (!param->is_static_scalar_const_expr()) {
        /* do nothing */
      } else if (OB_FAIL(ObSQLUtils::calc_const_or_calculable_expr(ctx_->exec_ctx_,
                                                                   param, obj_value,
                                                                   got_result,
                                                                   *ctx_->allocator_))) {
        LOG_WARN("failed to calc const or calculable expr", K(ret));
      } else if (!got_result) {
        /* do nonthing */
      } else if (obj_value.is_null()) {
        ret = count_null.push_back(aggr);
      } else if (aggr->is_param_distinct()) {
        /* do nothing */
      } else {
        ret = count_const.push_back(aggr);
      }
    }
  }
  return ret;
}

int ObTransformSimplifyGroupby::check_aggr_win_can_be_removed(const ObDMLStmt *stmt,
                                                              ObRawExpr *expr,
                                                              bool &can_remove)
{
  can_remove = false;
  int ret = OB_SUCCESS;
  ObItemType func_type = T_INVALID;
  ObAggFunRawExpr *aggr = NULL;
  ObWinFunRawExpr *win_func = NULL;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret));
  } else if (expr->is_aggr_expr()) {
    aggr = static_cast<ObAggFunRawExpr*>(expr);
    func_type = aggr->get_expr_type();
  } else if (expr->is_win_func_expr()) {
    win_func = static_cast<ObWinFunRawExpr*>(expr);
    func_type = win_func->get_func_type();
    aggr = win_func->get_agg_expr();
    func_type = NULL == aggr ? win_func->get_func_type() : aggr->get_expr_type();
  } else {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected expr", K(ret), K(expr));
  }
  if (OB_SUCC(ret)) {
    switch (func_type) {
    // aggr func
    case T_FUN_COUNT: //case when 1 or 0
    case T_FUN_MAX: //return expr
    case T_FUN_MIN:
      //case T_FUN_APPROX_COUNT_DISTINCT_SYNOPSIS_MERGE: //不进行改写
    case T_FUN_AVG: //return expr
    case T_FUN_COUNT_SUM:
    case T_FUN_SUM:
      //case T_FUN_APPROX_COUNT_DISTINCT: // return 1 or 0 //不进行改写
      //case T_FUN_APPROX_COUNT_DISTINCT_SYNOPSIS://不进行改写
    case T_FUN_GROUP_CONCAT:// return expr
      // case T_FUN_GROUP_RANK:// return 1 or 2    需要考虑order desc、nulls first、多列条件，暂不改写
      // case T_FUN_GROUP_DENSE_RANK:
      // case T_FUN_GROUP_PERCENT_RANK:// return 1 or 0
      // case T_FUN_GROUP_CUME_DIST:// return 1 or 0.5
    case T_FUN_MEDIAN: // return expr
    case T_FUN_GROUP_PERCENTILE_CONT:
    case T_FUN_GROUP_PERCENTILE_DISC:
    case T_FUN_KEEP_MAX:
    case T_FUN_KEEP_MIN:
    case T_FUN_KEEP_COUNT: // return 1 or 0
    case T_FUN_KEEP_SUM: // return expr
      // 部分数学分析函数会在改写阶段进行展开:
      // ObExpandAggregateUtils::expand_aggr_expr
      // ObExpandAggregateUtils::expand_window_aggr_expr

      // window func
    case T_WIN_FUN_ROW_NUMBER: // return 1
    case T_WIN_FUN_RANK: // return 1
    case T_WIN_FUN_DENSE_RANK: // return 1
    case T_WIN_FUN_PERCENT_RANK: { // return 0
      can_remove = true;
      break;
    }
    case T_WIN_FUN_NTILE: {//return 1
      //need check invalid param: ntile(-1)
      can_remove = false;
      ObRawExpr *expr = NULL;
      int64_t bucket_num = 0;
      bool is_valid = false;
      if (OB_ISNULL(win_func) || OB_UNLIKELY(win_func->get_func_params().empty())
          || OB_ISNULL(expr = win_func->get_func_params().at(0))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected func", K(ret));
      } else if (OB_FAIL(get_param_value(stmt, expr, is_valid, bucket_num))) {
        LOG_WARN("failed to get param value", K(ret));
      } else if (!is_valid) {
        can_remove = false;
      } else if (OB_UNLIKELY(bucket_num <= 0)) {
        if (is_oracle_mode()) {
          ret = OB_DATA_OUT_OF_RANGE;
          LOG_WARN("bucket_num out of range", K(ret), K(bucket_num));
        } else {
          ret = OB_INVALID_ARGUMENT;
          LOG_WARN("bucket_num is invalid", K(ret), K(bucket_num));
        }
      } else {
        can_remove = true;
      }
      break;
    }
    case T_WIN_FUN_NTH_VALUE: { // nth_value(expr,1) return expr, else return null
      //need check invalid param: nth_value(expr, -1)
      can_remove = false;
      ObRawExpr *nth_expr = NULL;
      int64_t value = 0;
      bool is_valid = false;
      if (OB_ISNULL(win_func) || OB_UNLIKELY(2 > win_func->get_func_params().count())
          || OB_ISNULL(nth_expr = win_func->get_func_params().at(1))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected func", K(ret));
      } else if (OB_FAIL(get_param_value(stmt, nth_expr, is_valid, value))) {
        LOG_WARN("failed to get param value", K(ret));
      } else if (!is_valid) {
        can_remove = false;
      } else if (OB_UNLIKELY(value <= 0)) {
        ret = OB_DATA_OUT_OF_RANGE;
        LOG_WARN("invalid argument", K(ret), K(value));
      } else {
        can_remove = true;
      }
      break;
    }
    case T_WIN_FUN_FIRST_VALUE: // return expr (respect or ignore nulls)
    case T_WIN_FUN_LAST_VALUE: { // return expr (respect or ignore nulls)
      // first_value && last_value has been converted to nth_value when resolving
      can_remove = false;
      break;
    }
    case T_WIN_FUN_CUME_DIST: { // return 1
      can_remove = true;
      break;
    }
    case T_WIN_FUN_LEAD: // return null or default value
    case T_WIN_FUN_LAG: { // return null or default value
      can_remove = false;
      ObRawExpr *expr = NULL;
      int64_t value = 0;
      bool is_valid = false;
      if (OB_ISNULL(win_func)|| OB_UNLIKELY(win_func->get_func_params().empty())) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected func", K(ret));
      } else if (1 == win_func->get_func_params().count()) {
        can_remove = true;
      } else if (OB_ISNULL(expr = win_func->get_func_params().at(1))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected NULL", K(ret));
      } else if (OB_FAIL(get_param_value(stmt, expr, is_valid, value))) {
        LOG_WARN("failed to get param value", K(ret));
      } else if (!is_valid) {
        can_remove = false;
      } else if (OB_UNLIKELY(value < 0)) {
        ret = OB_ERR_ARGUMENT_OUT_OF_RANGE;
        LOG_USER_ERROR(OB_ERR_ARGUMENT_OUT_OF_RANGE, value);
        LOG_WARN("lead/lag argument is out of range", K(ret), K(value));
      } else {
        can_remove = true;
      }
      break;
    }
    case T_WIN_FUN_RATIO_TO_REPORT: { //resolver 阶段被转化为 expr/sum（expr）
      can_remove = true;
      break;
    }
    case T_WIN_FUN_SUM: //无效
    case T_WIN_FUN_MAX: //无效
    case T_WIN_FUN_AVG: //无效
    default: {
      can_remove = false;
      break;
    }
    }
  }
  return ret;
}

int ObTransformSimplifyGroupby::transform_aggr_win_to_common_expr(ObSelectStmt *select_stmt,
                                                                  ObRawExpr *expr,
                                                                  ObRawExpr *&new_expr)
{
  int ret = OB_SUCCESS;
  new_expr = NULL;
  ObRawExpr *param_expr = NULL;
  ObItemType func_type = T_INVALID;
  ObAggFunRawExpr *aggr = NULL;
  ObWinFunRawExpr *win_func = NULL;
  if (OB_ISNULL(select_stmt) || OB_ISNULL(expr) || OB_ISNULL(ctx_)
      || OB_ISNULL(ctx_->expr_factory_) || OB_ISNULL(ctx_->session_info_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret));
  } else if (expr->is_aggr_expr()) {
    aggr = static_cast<ObAggFunRawExpr*>(expr);
    func_type = aggr->get_expr_type();
  } else if (expr->is_win_func_expr()) {
    win_func = static_cast<ObWinFunRawExpr*>(expr);
    func_type = win_func->get_func_type();
    aggr = win_func->get_agg_expr();
    // to fix bug: win magic 可能导致 func type 与 aggr 不一致
    func_type = NULL == aggr ? win_func->get_func_type() : aggr->get_expr_type();
  } else {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected expr", K(ret), K(expr));
  }
  if (OB_SUCC(ret)) {
    switch (func_type) {
    // aggr
    case T_FUN_MAX:// return expr
    case T_FUN_MIN:
    case T_FUN_AVG:
    case T_FUN_SUM:
    case T_FUN_GROUP_CONCAT:
    case T_FUN_MEDIAN:
    case T_FUN_KEEP_MAX:
    case T_FUN_KEEP_MIN:
    case T_FUN_KEEP_SUM:
    case T_FUN_COUNT_SUM: {
      if (OB_ISNULL(aggr) || OB_ISNULL(param_expr = aggr->get_param_expr(0))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret));
      }
      break;
    }
    case T_FUN_GROUP_PERCENTILE_CONT:// return expr
    case T_FUN_GROUP_PERCENTILE_DISC: {
      if (OB_ISNULL(aggr) || OB_UNLIKELY(aggr->get_order_items().empty())
          || OB_ISNULL(param_expr = aggr->get_order_items().at(0).expr_)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected func", K(ret));
      }
      break;
    }
    case T_FUN_COUNT:
    case T_FUN_KEEP_COUNT: { // return 1 or 0
      ObConstRawExpr *const_one = NULL;
      ObConstRawExpr *const_zero = NULL;
      if (OB_ISNULL(aggr)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected null", K(ret));
      } else if (OB_FAIL(ObTransformUtils::build_const_expr_for_count(*ctx_->expr_factory_, 1,
                                                                      const_one))) {
        LOG_WARN("failed to build const expr for count", K(ret));
      } else if (0 == aggr->get_real_param_count()) { // count(*) --> 1
        param_expr = const_one;
      } else if (OB_FAIL(ObTransformUtils::build_const_expr_for_count(*ctx_->expr_factory_, 0,
                                                                      const_zero))) {
        LOG_WARN("failed to build const expr for count", K(ret));
        // count(c1) --> case when
      } else if (OB_FAIL(ObTransformUtils::build_case_when_expr(*select_stmt,
                                                                expr->get_param_expr(0),
                                                                const_one, const_zero,
                                                                param_expr, ctx_))) {
        LOG_WARN("failed to build case when expr", K(ret));
      }
      break;
    }
    case T_WIN_FUN_ROW_NUMBER: // return int 1
    case T_WIN_FUN_RANK:
    case T_WIN_FUN_DENSE_RANK: {
      ObConstRawExpr *const_one = NULL;
      if (OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_, ObIntType,
                                                       1, const_one))) {
        LOG_WARN("failed to build const int expr", K(ret));
      } else {
        param_expr = const_one;
      }
      break;
    }
    case T_WIN_FUN_NTILE: { // return int 1 and add constraint
      ObConstRawExpr *const_one = NULL;
      if (OB_ISNULL(win_func) || OB_UNLIKELY(win_func->get_func_params().empty())) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected func", K(ret), K(win_func));
      } else if (OB_FAIL(ObRawExprUtils::build_const_int_expr(*ctx_->expr_factory_, ObIntType,
                                                              1, const_one))) {
        LOG_WARN("failed to build const int expr", K(ret));
      } else if (OB_FAIL(ObTransformUtils::add_const_param_constraints(
                           win_func->get_func_params().at(0),
                           ctx_))) {
        LOG_WARN("failed to add const param constraints", K(ret));
      } else {
        param_expr = const_one;
      }
      break;
    }
    case T_WIN_FUN_CUME_DIST: { // return number 1
      ObConstRawExpr *const_one = NULL;
      if (OB_FAIL(ObRawExprUtils::build_const_number_expr(*ctx_->expr_factory_, ObNumberType,
                                                          number::ObNumber::get_positive_one(),
                                                          const_one))) {
        LOG_WARN("failed to build const number expr", K(ret));
      } else {
        param_expr = const_one;
      }
      break;
    }
    case T_WIN_FUN_PERCENT_RANK: { // return number 0
      ObConstRawExpr *const_zero = NULL;
      if (OB_FAIL(ObRawExprUtils::build_const_number_expr(*ctx_->expr_factory_, ObNumberType,
                                                          number::ObNumber::get_zero(),
                                                          const_zero))) {
        LOG_WARN("failed to build const number expr", K(ret));
      } else {
        param_expr = const_zero;
      }
      break;
    }
    case T_WIN_FUN_NTH_VALUE: { // nth_value(expr,1) return expr, else return null
      // need add constraint for nth_expr
      ObRawExpr *nth_expr = NULL;
      int64_t value = 0;
      bool is_valid = false;
      if (OB_ISNULL(win_func) || OB_UNLIKELY(2 > win_func->get_func_params().count())
          || OB_ISNULL(nth_expr = win_func->get_func_params().at(1))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected func", K(ret));
      } else if (OB_FAIL(get_param_value(select_stmt, nth_expr, is_valid, value))) {
        LOG_WARN("failed to get param value", K(ret));
      } else if (OB_UNLIKELY(!is_valid || value <= 0)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected func", K(ret), K(*win_func));
      } else if (OB_FAIL(ObTransformUtils::add_const_param_constraints(nth_expr, ctx_))) {
        LOG_WARN("failed to add const param constraints", K(ret));
      } else if (1 == value) { // return expr
        param_expr = win_func->get_func_params().at(0);
      } else { //return null
        ret = ObRawExprUtils::build_null_expr(*ctx_->expr_factory_, param_expr);
      }
      break;
    }
    case T_WIN_FUN_LEAD: // return null or default value
    case T_WIN_FUN_LAG: {
      ObRawExpr *expr = NULL;
      int64_t value = 1;
      bool is_valid = false;
      if (OB_ISNULL(win_func)|| OB_UNLIKELY(win_func->get_func_params().empty())) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected func", K(ret));
      } else if (1 == win_func->get_func_params().count()) {
        value = 1;
      } else if (OB_ISNULL(expr = win_func->get_func_params().at(1))) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected NULL", K(ret));
      } else if (OB_FAIL(get_param_value(select_stmt, expr, is_valid, value))) {
        LOG_WARN("failed to get param value", K(ret));
      } else if (OB_UNLIKELY(!is_valid || value < 0)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("get unexpected func", K(ret), K(*win_func));
      } else if (OB_FAIL(ObTransformUtils::add_const_param_constraints(expr, ctx_))) {
        LOG_WARN("failed to add const param constraints", K(ret));
      }

      if (OB_FAIL(ret)) {
      } else if (0 == value) { // return current value
        param_expr = win_func->get_func_params().at(0);
      } else if (2 < win_func->get_func_params().count()) { // return default value
        param_expr = win_func->get_func_params().at(2);
      } else if (OB_FAIL(ObRawExprUtils::build_null_expr(*ctx_->expr_factory_, param_expr))) {
        LOG_WARN("failed to build null expr", K(ret));
      }
      break;
    }
    default: {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get unexpected func", K(ret), K(*expr));
      break;
    }
    }

    //尝试添加类型转化
    if (OB_FAIL(ret)) {
      /*do nothing*/
    } else if (OB_ISNULL(param_expr)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get unexpected null", K(ret));
    } else if (OB_FAIL(ObRawExprUtils::try_add_cast_expr_above(ctx_->expr_factory_,
                                                               ctx_->session_info_,
                                                               *param_expr,
                                                               expr->get_result_type(),
                                                               new_expr))) {
      LOG_WARN("try add cast expr above failed", K(ret));
    }
  }
  return ret;
}

int ObTransformSimplifyGroupby::get_param_value(const ObDMLStmt *stmt,
                                                ObRawExpr *param,
                                                bool &is_valid,
                                                int64_t &value)
{
  int ret = OB_SUCCESS;
  is_valid = true;
  ObObj obj_value;
  bool got_result = false;
  if (OB_ISNULL(stmt) || OB_ISNULL(param) || OB_ISNULL(ctx_) ||
      OB_ISNULL(ctx_->allocator_) || OB_ISNULL(ctx_->exec_ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpect null", K(ret), K(stmt), K(param), K(ctx_));
  } else if (param->is_static_scalar_const_expr() &&
             (param->get_result_type().is_integer_type() ||
              param->get_result_type().is_number())) {
    if (OB_FAIL(ObSQLUtils::calc_const_or_calculable_expr(ctx_->exec_ctx_,
                                                          param, obj_value,
                                                          got_result,
                                                          *ctx_->allocator_))) {
      LOG_WARN("Failed to calc const or calculable expr", K(ret));
    } else if (!got_result) {
      is_valid = false;
    }
  } else {
    is_valid = false;
  }
  if (OB_SUCC(ret) && is_valid) {
    number::ObNumber number;
    if (obj_value.is_null()) {
      is_valid = false;
    } else if (obj_value.is_integer_type()) {
      value = obj_value.get_int();
    } else if (!obj_value.is_number()) {
      is_valid = false;
    } else if (OB_FAIL(obj_value.get_number(number))) {
      LOG_WARN("unexpected value type", K(ret), K(obj_value));
    } else if (OB_UNLIKELY(!number.is_valid_int64(value))) {
      is_valid = false;
    }
  }
  return ret;
}

// 1. With group by
//    select max(1) from t1 group by c1; -> select 1 from t1 group by c1;
// 2. Without group by && not from dual
//    select max(1) from t1; -> select max(t.a) from (select 1 as a from t1 limit 1) t;
int ObTransformSimplifyGroupby::transform_const_minmax_aggr(ObDMLStmt *stmt, bool &trans_happened)
{
  int ret = OB_SUCCESS;
  bool is_valid = false;
  ObRawExpr *expr = NULL;
  TableItem *table = NULL;
  trans_happened = false;
  ObSelectStmt *select_stmt = NULL;
  ObSelectStmt *view_stmt = NULL;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is NULL", K(ret), K(stmt));
  } else if (!stmt->is_select_stmt() ||
             FALSE_IT(select_stmt = static_cast<ObSelectStmt *>(stmt))) {
    //do nothing
  } else if (OB_FAIL(is_valid_const_aggregate(select_stmt, is_valid))) {
    LOG_WARN("failed to check is valid const aggregate", K(ret));
  } else if (!is_valid) {
    // do nothing
  } else if (OB_UNLIKELY(1 != select_stmt->get_select_item_size())
             || OB_ISNULL(expr = select_stmt->get_select_item(0).expr_)
             || OB_UNLIKELY(!expr->is_aggr_expr())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("select item is invalid", K(ret));
  } else if (select_stmt->get_group_expr_size() > 0) {
    // with group by
    select_stmt->get_select_item(0).expr_ = expr->get_param_expr(0);
    select_stmt->get_aggr_items().reset();
    select_stmt->get_order_items().reset();
    trans_happened = true;
  } else if (0 == select_stmt->get_from_items().count()) {
    //from dual
  } else if (select_stmt->is_single_table_stmt()
             && OB_NOT_NULL(table = select_stmt->get_table_item(0))
             && table->is_generated_table()) {
    ObSelectStmt *ref_query = NULL;
    if (OB_ISNULL(ref_query = table->ref_query_)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected null", K(ret));
    } else if (ref_query->has_limit() ||
               ref_query->is_scala_group_by() ||
               ref_query->get_table_size() == 0) {
      /*do nothing*/
    } else if (OB_FAIL(ObTransformUtils::set_limit_expr(ref_query, ctx_))) {
      LOG_WARN("fail to set child limit item", K(ret));
    } else {
      trans_happened = true;
    }
  } else if (OB_FAIL(ObTransformUtils::create_simple_view(ctx_, select_stmt, view_stmt))) {
    LOG_WARN("failed to create simple view", K(ret));
  } else if (OB_FAIL(ObTransformUtils::set_limit_expr(view_stmt, ctx_))) {
    LOG_WARN("failed to set limit expr", K(ret));
  } else {
    trans_happened = true;
  }
  return ret;
}

int ObTransformSimplifyGroupby::is_valid_const_aggregate(ObSelectStmt *stmt, bool &is_valid)
{
  int ret = OB_SUCCESS;
  is_valid = false;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is NULL", K(ret));
  } else if (1 == stmt->get_select_item_size() &&
             !stmt->has_having() &&
             1 == stmt->get_aggr_item_size()) {
    SelectItem &select_item = stmt->get_select_item(0);
    if (OB_FAIL(is_min_max_const(stmt, select_item.expr_, is_valid))) {
      LOG_WARN("is_min_max_const() fails", K(ret), K(is_valid));
    }
  }
  return ret;
}

int ObTransformSimplifyGroupby::is_min_max_const(ObSelectStmt *stmt,
                                                 ObRawExpr *expr,
                                                 bool &is_const)
{
  int ret = OB_SUCCESS;
  is_const = false;
  if (OB_ISNULL(expr)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr from select_item is NULL", K(ret), K(expr));
  } else if (T_FUN_MAX == expr->get_expr_type() ||
             T_FUN_MIN == expr->get_expr_type()) {
    if (OB_UNLIKELY(expr->get_param_count() != 1) ||
        OB_ISNULL(expr->get_param_expr(0))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get unexpected error", K(ret), KPC(expr));
    } else {
      is_const = expr->get_param_expr(0)->is_const_expr();
    }
  } else { /* Do nothing */ }
  return ret;
}

int ObTransformSimplifyGroupby::prune_group_by_rollup(ObIArray<ObParentDMLStmt> &parent_stmts,
                                                      ObDMLStmt *stmt,
                                                      bool &trans_happened)
{
  int ret = OB_SUCCESS;
  ObSelectStmt *select_stmt = NULL;
  int64_t pruned_expr_idx = -1;
  trans_happened = false;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else if (!stmt->is_select_stmt()) {
    // do nothing
  } else if (FALSE_IT(select_stmt = static_cast<ObSelectStmt *>(stmt))) {
    // do nothing
  } else if (!select_stmt->has_rollup()) {
    // do nothing
  } else if (OB_FAIL(check_can_prune_rollup(parent_stmts, select_stmt, pruned_expr_idx))) {
    LOG_WARN("failed to check rollup expr", K(ret));
  } else if (-1 == pruned_expr_idx) {
    // do nothing
  } else if (OB_FAIL(do_prune_rollup(select_stmt, pruned_expr_idx))) {
    LOG_WARN("failed to do prune rollup", K(ret));
  } else {
    trans_happened = true;
  }
  return ret;
}

int ObTransformSimplifyGroupby::check_can_prune_rollup(ObIArray<ObParentDMLStmt> &parent_stmts,
                                                       ObSelectStmt *stmt,
                                                       int64_t &pruned_expr_idx)
{
  int ret = OB_SUCCESS;
  int64_t pruned_by_self_idx = -1;
  int64_t pruned_by_parent_idx = -1;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else if (OB_FAIL(check_rollup_pruned_by_self(stmt, pruned_by_self_idx))) {
    LOG_WARN("failed to check rollup expr by self", K(ret));
  } else if (OB_FAIL(check_rollup_pruned_by_parent(parent_stmts, stmt, pruned_by_parent_idx))) {
    LOG_WARN("failed to check rollup expr by parent", K(ret));
  } else {
    pruned_expr_idx = MAX(pruned_by_self_idx, pruned_by_parent_idx);
  }
  return ret;
}

int ObTransformSimplifyGroupby::check_rollup_pruned_by_self(ObSelectStmt *stmt,
                                                            int64_t &pruned_expr_idx)
{
  int ret = OB_SUCCESS;
  bool is_found = false;
  ObSEArray<ObRawExpr*, 4> valid_having_exprs;
  pruned_expr_idx = -1;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else if (OB_FAIL(get_valid_having_exprs_contain_aggr(stmt->get_having_exprs(),
                                                         valid_having_exprs))) {
    LOG_WARN("failed to check contain aggr", K(ret));
  } else if (valid_having_exprs.empty()) {
    //do nothing
  } else {
    for (int64_t i = stmt->get_rollup_exprs().count() - 1; OB_SUCC(ret) && !is_found && i >= 0; --i) {
      bool has_null_reject = false;
      bool is_first = false;
      if (OB_FAIL(ObTransformUtils::has_null_reject_condition(valid_having_exprs,
                                                              stmt->get_rollup_exprs().at(i),
                                                              has_null_reject))) {
        LOG_WARN("failed to check has null reject condition", K(ret));
      } else if (!has_null_reject) {
        //do nothing
      } else if (OB_FAIL(is_first_rollup_with_duplicates(stmt, i, is_first))) {
        LOG_WARN("failed to check is first rollup", K(ret));
      } else if (!is_first) {
        // do nothing
      } else {
        is_found = true;
        pruned_expr_idx = i;
      }
    }
  }
  return ret;
}

int ObTransformSimplifyGroupby::check_rollup_pruned_by_parent(ObIArray<ObParentDMLStmt> &parent_stmts,
                                                              ObSelectStmt *stmt,
                                                              int64_t &pruned_expr_idx)
{
  int ret = OB_SUCCESS;
  pruned_expr_idx = -1;
  ObDMLStmt *parent_stmt = NULL;
  TableItem *table_item = NULL;
  if (parent_stmts.empty()) {
    // do nothing
  } else if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret));
  } else if (OB_ISNULL(parent_stmt = parent_stmts.at(parent_stmts.count() - 1).stmt_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("get unexpected null", K(ret));
  } else if (OB_FAIL(ObTransformUtils::get_generated_table_item(*parent_stmt, stmt, table_item))) {
    LOG_WARN("failed to get table_item", K(ret));
  } else if (OB_NOT_NULL(table_item)) {
    bool found = false;
    ObSEArray<ObRawExpr *, 16> conditions;
    if (OB_FAIL(ObTransformUtils::get_table_related_condition(*parent_stmt,
                                                              table_item,
                                                              conditions))) {
      LOG_WARN("failed to get table related condition", K(ret));
    }
    for (int64_t i = stmt->get_rollup_exprs().count() - 1; OB_SUCC(ret) && !found && i >= 0; --i) {
      bool has_null_reject = false;
      bool is_first = false;
      ObSEArray<ObRawExpr *, 2> select_exprs;
      ObSEArray<ObRawExpr *, 2> targets;
      if (OB_FAIL(find_null_propagate_select_exprs(stmt,
                                                    stmt->get_rollup_exprs().at(i),
                                                    select_exprs))) {
        LOG_WARN("failed to find null propagate select expr", K(ret));
      } else if (OB_FAIL(ObTransformUtils::convert_select_expr_to_column_expr(select_exprs,
                                                                              *stmt,
                                                                              *parent_stmt,
                                                                              table_item->table_id_,
                                                                              targets))) {
        LOG_WARN("failed to convert expr to column epxr", K(ret));
      } else if (OB_FAIL(ObTransformUtils::has_null_reject_condition(conditions,
                                                                      targets,
                                                                      has_null_reject))) {
        LOG_WARN("failed to check has null reject condition", K(ret));
      } else if (!has_null_reject) {
        //do nothing
      } else if (OB_FAIL(is_first_rollup_with_duplicates(stmt, i, is_first))) {
        LOG_WARN("failed to check is first rollup", K(ret));
      } else if (!is_first) {
        // do nothing
      } else {
        found = true;
        pruned_expr_idx = i;
      }
    }
  }
  return ret;
}

int ObTransformSimplifyGroupby::find_null_propagate_select_exprs(ObSelectStmt *stmt,
                                                                 const ObRawExpr *expr,
                                                                 ObIArray<ObRawExpr *> &select_exprs)
{
  int ret = OB_SUCCESS;
  ObSEArray<const ObRawExpr *, 1> dummy_exprs;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else if (OB_FAIL(dummy_exprs.push_back(expr))) {
    LOG_WARN("failed to push back expr", K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_select_item_size(); ++i) {
    bool is_null_propagate = false;
    ObRawExpr *select_expr = stmt->get_select_item(i).expr_;
    if (OB_FAIL(ObTransformUtils::is_null_propagate_expr(select_expr,
                                                         dummy_exprs,
                                                         is_null_propagate))) {
      LOG_WARN("failed to check null propagate expr", K(ret));                                                    
    } else if (!is_null_propagate) {
      // do nothing
    } else if (OB_FAIL(select_exprs.push_back(select_expr))) {
      LOG_WARN("failed to push back expr", K(ret));
    }
  }
  return ret;
}

int ObTransformSimplifyGroupby::is_first_rollup_with_duplicates(ObSelectStmt *stmt,
                                                                const int64_t rollup_expr_idx,
                                                                bool &is_first)
{
  int ret = OB_SUCCESS;
  int64_t idx = OB_INVALID_INDEX;
  is_first = false;
  ObRawExpr *rollup_expr = NULL;
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else if (OB_UNLIKELY(rollup_expr_idx < 0)
             || OB_UNLIKELY(rollup_expr_idx >= stmt->get_rollup_exprs().count())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("invalid rollup expr idx", K(rollup_expr_idx), K(ret));
  } else if (FALSE_IT(rollup_expr = stmt->get_rollup_exprs().at(rollup_expr_idx))) {
    // do nothing
  } else if (ObOptimizerUtil::find_equal_expr(stmt->get_group_exprs(), rollup_expr)) {
    is_first = false;
  } else if (OB_UNLIKELY(!ObOptimizerUtil::find_equal_expr(stmt->get_rollup_exprs(),
                                                           rollup_expr,
                                                           idx))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("failed to find rollup expr in rollup exprs", K(ret));
  } else {
    is_first = idx == rollup_expr_idx;
  }
  return ret;
}

int ObTransformSimplifyGroupby::do_prune_rollup(ObSelectStmt *stmt, const int64_t pruned_expr_idx)
{
  int ret = OB_SUCCESS;
  bool found = false;
  ObArray<ObRawExpr *> new_rollup_exprs;
  ObArray<ObOrderDirection> new_rollup_dirs;
  bool has_rollup_dir = stmt->has_rollup_dir();
  if (OB_ISNULL(stmt)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("stmt is null", K(ret));
  } else if (OB_UNLIKELY(has_rollup_dir
                         && (stmt->get_rollup_dir_size() != stmt->get_rollup_exprs().count()))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("failed to check rollup exprs and directions count", K (ret));
  } else if (OB_UNLIKELY(pruned_expr_idx < 0)
             || OB_UNLIKELY(pruned_expr_idx >= stmt->get_rollup_exprs().count())) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("invalid pruned expr idx", K(pruned_expr_idx), K(ret));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_rollup_exprs().count(); ++i) {
    ObRawExpr *rollup_expr = stmt->get_rollup_exprs().at(i);
    if (i <= pruned_expr_idx) {
      if (OB_FAIL(stmt->add_group_expr(rollup_expr))) {
        LOG_WARN("failed to push back rollup expr", K(ret));
      }
    } else {
      if (OB_FAIL(new_rollup_exprs.push_back(rollup_expr))) {
        LOG_WARN("failed to push back rollup expr", K(ret));
      } else if (has_rollup_dir &&
                 OB_FAIL(new_rollup_dirs.push_back(stmt->get_rollup_dirs().at(i)))) {
        LOG_WARN("failed to push back rollup expr", K(ret));
      }
    }
  }
  if (OB_SUCC(ret)) {
    stmt->get_rollup_exprs().reset();
    stmt->get_rollup_dirs().reset();
    if (OB_FAIL(stmt->get_rollup_exprs().assign(new_rollup_exprs))) {
      LOG_WARN("failed to assign new rollup exprs", K(ret));
    } else if (OB_FAIL(stmt->get_rollup_dirs().assign(new_rollup_dirs))) {
      LOG_WARN("failed to assign new rollup dirs", K(ret));
    }
  }
  return ret;
}

//bug:https://work.aone.alibaba-inc.com/issue/43889458
// create table t1(c1 int, c2 int);
// select sum(c1) from t1 group by c1,c2 with rollup having sum(c1) > 1 ==> can't prune
int ObTransformSimplifyGroupby::get_valid_having_exprs_contain_aggr(
    const ObIArray<ObRawExpr *> &having_exprs,
    ObIArray<ObRawExpr *> &vaild_having_exprs)
{
  int ret = OB_SUCCESS;
  for (int64_t i = 0; OB_SUCC(ret) && i < having_exprs.count(); ++i) {
    if (OB_ISNULL(having_exprs.at(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("get unexpected null", K(ret), K(having_exprs.at(i)));
    } else if (having_exprs.at(i)->has_flag(CNT_AGG)) {
      //do nothing
    } else if (OB_FAIL(vaild_having_exprs.push_back(having_exprs.at(i)))) {
      LOG_WARN("faield to push back", K(ret));
    } else {/*do nothing*/}
  }
  return ret;
}