/** * 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. */ #ifndef OCEANBASE_SQL_OPTIMIZER_OB_OPT_EST_COST_MODEL_ #define OCEANBASE_SQL_OPTIMIZER_OB_OPT_EST_COST_MODEL_ #include "lib/container/ob_array.h" #include "common/object/ob_object.h" #include "share/ob_simple_batch.h" #include "share/ob_rpc_struct.h" #include "sql/rewrite/ob_query_range_provider.h" #include "sql/optimizer/ob_opt_default_stat.h" #include "sql/resolver/dml/ob_dml_stmt.h" #include "share/stat/ob_opt_ds_stat.h" namespace oceanbase { namespace sql { struct OrderItem; struct ObExprSelPair; struct JoinFilterInfo; class OptTableMetas; class OptSelectivityCtx; class ObOptCostModelParameter; class OptSystemStat; enum RowCountEstMethod { INVALID_METHOD = 0 }; // deprecated enum ObBaseTableEstBasicMethod { EST_INVALID = 0, EST_DEFAULT = 1 << 0, EST_STAT = 1 << 1, EST_STORAGE = 1 << 2, EST_DS_BASIC = 1 << 3, EST_DS_FULL = 1 << 4, }; typedef uint64_t ObBaseTableEstMethod; // all the table meta info need to compute cost struct ObTableMetaInfo { ObTableMetaInfo(uint64_t ref_table_id) : ref_table_id_(ref_table_id), schema_version_(share::OB_INVALID_SCHEMA_VERSION), part_count_(0), micro_block_size_(0), table_column_count_(0), table_rowkey_count_(0), table_row_count_(0), part_size_(0), average_row_size_(0), row_count_(0), has_opt_stat_(false), micro_block_count_(-1), table_type_(share::schema::MAX_TABLE_TYPE) { } virtual ~ObTableMetaInfo() { } void assign(const ObTableMetaInfo &table_meta_info); double get_micro_block_numbers() const; TO_STRING_KV(K_(ref_table_id), K_(part_count), K_(micro_block_size), K_(part_size), K_(average_row_size), K_(table_column_count), K_(table_rowkey_count), K_(table_row_count), K_(row_count), K_(micro_block_count), K_(table_type)); /// the following fields come from schema info uint64_t ref_table_id_; //ref table id int64_t schema_version_; // schema version int64_t part_count_; //partition count int64_t micro_block_size_; //main table micro block size int64_t table_column_count_; // table column count int64_t table_rowkey_count_; // table rowkey count, used in index_back cost calc.index_back时候会从索引表获取主键 /// the following fields come from access path estimation int64_t table_row_count_; // table row count in stat. double part_size_; //main table best partition data size double average_row_size_; //main table best partition average row size double row_count_; // row count after filters, estimated by stat manager bool has_opt_stat_; int64_t micro_block_count_; // main table micro block count share::schema::ObTableType table_type_; private: DISALLOW_COPY_AND_ASSIGN(ObTableMetaInfo); }; // all the index meta info need to compute cost struct ObIndexMetaInfo { ObIndexMetaInfo(uint64_t ref_table_id, uint64_t index_id) : ref_table_id_(ref_table_id), index_id_(index_id), index_micro_block_size_(0), index_part_count_(1), index_part_size_(0), index_column_count_(0), is_index_back_(false), is_unique_index_(false), is_global_index_(false), is_geo_index_(false), index_micro_block_count_(-1) { } virtual ~ObIndexMetaInfo() { } void assign(const ObIndexMetaInfo &index_meta_info); double get_micro_block_numbers() const; TO_STRING_KV(K_(ref_table_id), K_(index_id), K_(index_micro_block_size), K_(index_part_count), K_(index_part_size), K_(index_column_count), K_(is_index_back), K_(is_unique_index), K_(index_micro_block_count)); uint64_t ref_table_id_; // ref table id uint64_t index_id_; // index id int64_t index_micro_block_size_; //index micro block size, same as main table when path is primary uint64_t index_part_count_; double index_part_size_; //index table partition(0) data size, same as main table when path is primary int64_t index_column_count_; //index column count bool is_index_back_; // is index back bool is_unique_index_; // is unique index bool is_global_index_; // whether is global index bool is_geo_index_; // whether is spatial index int64_t index_micro_block_count_; // micro block count from table static info private: DISALLOW_COPY_AND_ASSIGN(ObIndexMetaInfo); }; struct ObBasicCostInfo { ObBasicCostInfo() : rows_(0), cost_(0), width_(0), exchange_allocated_(false) {} ObBasicCostInfo(double rows, double cost, double width, bool exchange_allocated = false) : rows_(rows), cost_(cost), width_(width), exchange_allocated_(exchange_allocated) {} TO_STRING_KV(K_(rows), K_(cost), K_(width), K_(exchange_allocated)); double rows_; double cost_; double width_; bool exchange_allocated_; }; struct ObTwoNodeCostInfo { ObTwoNodeCostInfo(double left_rows, double left_width, double right_rows, double right_width, OptTableMetas *table_metas, OptSelectivityCtx *sel_ctx) : left_rows_(left_rows), left_width_(left_width), right_rows_(right_rows), right_width_(right_width), table_metas_(table_metas), sel_ctx_(sel_ctx) { } const double left_rows_; const double left_width_; const double right_rows_; const double right_width_; OptTableMetas *table_metas_; OptSelectivityCtx *sel_ctx_; }; struct ObCostColumnGroupInfo { ObCostColumnGroupInfo() :micro_block_count_(0.0), filter_sel_(1.0), skip_rate_(1.0), skip_filter_sel_(1.0) { } int assign(const ObCostColumnGroupInfo& info); TO_STRING_KV( K_(filters), K_(access_column_items), K_(column_id), K_(micro_block_count), K_(filter_sel), K_(skip_rate), K_(skip_filter_sel) ); common::ObSEArray filters_; common::ObSEArray access_column_items_; uint64_t column_id_; int64_t micro_block_count_; double filter_sel_; double skip_rate_; double skip_filter_sel_; }; /* * store all the info needed to cost table scan */ struct ObCostTableScanInfo { ObCostTableScanInfo(uint64_t table_id, uint64_t ref_table_id, uint64_t index_id) : table_id_(table_id), ref_table_id_(ref_table_id), index_id_(index_id), table_meta_info_(NULL), index_meta_info_(ref_table_id, index_id), is_virtual_table_(is_virtual_table(ref_table_id)), is_unique_(false), is_inner_path_(false), can_use_batch_nlj_(false), ranges_(), ss_ranges_(), range_columns_(), prefix_filters_(), pushdown_prefix_filters_(), ss_postfix_range_filters_(), postfix_filters_(), table_filters_(), table_metas_(NULL), sel_ctx_(NULL), est_method_(EST_INVALID), prefix_filter_sel_(1.0), pushdown_prefix_filter_sel_(1.0), postfix_filter_sel_(1.0), table_filter_sel_(1.0), join_filter_sel_(1.0), ss_prefix_ndv_(1.0), ss_postfix_range_filters_sel_(1.0), logical_query_range_row_count_(0.0), phy_query_range_row_count_(0.0), index_back_row_count_(0.0), output_row_count_(0.0), batch_type_(common::ObSimpleBatch::ObBatchType::T_NONE), use_column_store_(false), at_most_one_range_(false), index_back_with_column_store_(false) { } virtual ~ObCostTableScanInfo() { } int assign(const ObCostTableScanInfo &other_est_cost_info); TO_STRING_KV(K_(table_id), K_(ref_table_id), K_(index_id), K_(table_meta_info), K_(index_meta_info), K_(access_column_items), K_(is_virtual_table), K_(is_unique), K_(is_inner_path), K_(can_use_batch_nlj), K_(est_method), K_(prefix_filter_sel), K_(pushdown_prefix_filter_sel), K_(postfix_filter_sel), K_(table_filter_sel), K_(ss_prefix_ndv), K_(ss_postfix_range_filters_sel), K_(use_column_store), K_(index_back_with_column_store), K_(index_scan_column_group_infos), K_(index_back_column_group_infos)); // the following information need to be set before estimating cost uint64_t table_id_; // table id uint64_t ref_table_id_; // ref table id uint64_t index_id_; // index_id ObTableMetaInfo *table_meta_info_; // table related meta info ObIndexMetaInfo index_meta_info_; // index related meta info bool is_virtual_table_; // is virtual table bool is_unique_; // whether query range is unique bool is_inner_path_; bool can_use_batch_nlj_; ObRangesArray ranges_; // all the ranges ObRangesArray ss_ranges_; // skip scan ranges common::ObSEArray range_columns_; // all the range columns common::ObSEArray access_column_items_; // all the access columns common::ObSEArray index_access_column_items_; // all the access columns //这几个filter的分类参考OptimizerUtil::classify_filters() common::ObSEArray prefix_filters_; // filters match index prefix common::ObSEArray pushdown_prefix_filters_; // filters match index prefix along pushed down filter common::ObSEArray ss_postfix_range_filters_; // range conditions extract postfix range for skip scan common::ObSEArray postfix_filters_; // filters evaluated before index back, but not index prefix common::ObSEArray table_filters_; // filters evaluated after index back common::ObSEArray access_columns_; OptTableMetas *table_metas_; OptSelectivityCtx *sel_ctx_; // the following information are useful when estimating cost ObBaseTableEstMethod est_method_; double prefix_filter_sel_; double pushdown_prefix_filter_sel_; double postfix_filter_sel_; double table_filter_sel_; double join_filter_sel_; double ss_prefix_ndv_; // skip scan prefix columns NDV double ss_postfix_range_filters_sel_; double logical_query_range_row_count_;// 估计出的抽出的query range中所包含的行数(logical) double phy_query_range_row_count_;// 估计出的抽出的query range中所包含的行数(physical) double index_back_row_count_;// 估计出的需要回表的行数 double output_row_count_; common::ObSimpleBatch::ObBatchType batch_type_; SampleInfo sample_info_; bool use_column_store_; bool at_most_one_range_; bool index_back_with_column_store_; common::ObSEArray index_scan_column_group_infos_; common::ObSEArray index_back_column_group_infos_; private: DISALLOW_COPY_AND_ASSIGN(ObCostTableScanInfo); }; struct ObCostBaseJoinInfo : public ObTwoNodeCostInfo { ObCostBaseJoinInfo(double left_rows, double left_width, double right_rows, double right_width, ObRelIds left_ids, ObRelIds right_ids, ObJoinType join_type, const common::ObIArray &equal_join_conditions, const common::ObIArray &other_join_conditions, const common::ObIArray &filters, OptTableMetas *table_metas, OptSelectivityCtx *sel_ctx) : ObTwoNodeCostInfo(left_rows, left_width, right_rows, right_width, table_metas, sel_ctx), left_ids_(left_ids), right_ids_(right_ids), join_type_(join_type), equal_join_conditions_(equal_join_conditions), other_join_conditions_(other_join_conditions), filters_(filters) { } virtual ~ObCostBaseJoinInfo() { }; TO_STRING_KV(K_(left_rows), K_(right_rows), K_(left_width), K_(right_width), K_(left_ids), K_(right_ids), K(join_type_), K_(equal_join_conditions), K_(other_join_conditions)); ObRelIds left_ids_; ObRelIds right_ids_; ObJoinType join_type_; const common::ObIArray &equal_join_conditions_; const common::ObIArray &other_join_conditions_; // for outer join, denote where condition const common::ObIArray &filters_; private: DISALLOW_COPY_AND_ASSIGN(ObCostBaseJoinInfo); }; struct ObCostNLJoinInfo : public ObCostBaseJoinInfo { ObCostNLJoinInfo(double left_rows, double left_cost, double left_width, double right_rows, double right_cost, double right_width, ObRelIds left_ids, ObRelIds right_ids, ObJoinType join_type, double anti_or_semi_match_sel, bool with_nl_param, bool need_mat, bool right_has_px_rescan, int64_t parallel, const common::ObIArray &equal_join_conditions, const common::ObIArray &other_join_conditions, const common::ObIArray &filters, OptTableMetas *table_metas, OptSelectivityCtx *sel_ctx) : ObCostBaseJoinInfo(left_rows, left_width, right_rows, right_width, left_ids, right_ids, join_type, equal_join_conditions, other_join_conditions, filters, table_metas, sel_ctx), left_cost_(left_cost), right_cost_(right_cost), anti_or_semi_match_sel_(anti_or_semi_match_sel), parallel_(parallel), with_nl_param_(with_nl_param), need_mat_(need_mat), right_has_px_rescan_(right_has_px_rescan) { } virtual ~ObCostNLJoinInfo() { } TO_STRING_KV(K_(left_rows), K_(left_cost), K_(right_rows), K_(right_cost), K_(left_width), K_(right_width), K_(left_ids), K_(right_ids), K_(join_type), K_(with_nl_param), K_(need_mat), K_(right_has_px_rescan), K_(equal_join_conditions), K_(other_join_conditions), K_(filters)); double left_cost_; double right_cost_; double anti_or_semi_match_sel_; int64_t parallel_; bool with_nl_param_; bool need_mat_; bool right_has_px_rescan_; private: DISALLOW_COPY_AND_ASSIGN(ObCostNLJoinInfo); }; /** * so far hash join info only contain variables from base class, * in future, we will change cost model and may need additional information */ struct ObCostMergeJoinInfo : public ObCostBaseJoinInfo { ObCostMergeJoinInfo(double left_rows, double left_width, double right_rows, double right_width, ObRelIds left_ids, ObRelIds right_ids, ObJoinType join_type, const common::ObIArray &equal_join_conditions, const common::ObIArray &other_join_conditions, const common::ObIArray &filters, double equal_cond_sel, double other_cond_sel, OptTableMetas *table_metas, OptSelectivityCtx *sel_ctx) : ObCostBaseJoinInfo(left_rows, left_width, right_rows, right_width, left_ids, right_ids, join_type, equal_join_conditions, other_join_conditions, filters, table_metas, sel_ctx), equal_cond_sel_(equal_cond_sel), other_cond_sel_(other_cond_sel) { } virtual ~ObCostMergeJoinInfo() { }; TO_STRING_KV(K_(left_rows), K_(right_rows), K_(left_width), K_(right_width), K_(left_ids), K_(right_ids), K_(join_type), K_(equal_join_conditions), K_(other_join_conditions), K_(filters)); double equal_cond_sel_; double other_cond_sel_; private: DISALLOW_COPY_AND_ASSIGN(ObCostMergeJoinInfo); }; /** * so far hash join info only contain variables from base class, * in future, we will change cost model and may need additional information */ struct ObCostHashJoinInfo : public ObCostBaseJoinInfo { ObCostHashJoinInfo(double left_rows, double left_width, double right_rows, double right_width, ObRelIds left_ids, ObRelIds right_ids, ObJoinType join_type, const common::ObIArray &equal_join_conditions, const common::ObIArray &other_join_conditions, const common::ObIArray &filters, const ObIArray &join_filter_infos, double equal_cond_sel, double other_cond_sel, OptTableMetas *table_metas, OptSelectivityCtx *sel_ctx) : ObCostBaseJoinInfo(left_rows, left_width, right_rows, right_width, left_ids, right_ids, join_type, equal_join_conditions, other_join_conditions, filters, table_metas, sel_ctx), join_filter_infos_(join_filter_infos), equal_cond_sel_(equal_cond_sel), other_cond_sel_(other_cond_sel) { }; TO_STRING_KV(K_(left_rows), K_(right_rows), K_(left_width), K_(right_width), K_(left_ids), K_(right_ids), K_(join_type), K_(equal_join_conditions), K_(other_join_conditions), K_(filters)); virtual ~ObCostHashJoinInfo() { }; const ObIArray &join_filter_infos_; double equal_cond_sel_; double other_cond_sel_; private: DISALLOW_COPY_AND_ASSIGN(ObCostHashJoinInfo); }; struct ObSubplanFilterCostInfo { ObSubplanFilterCostInfo(const ObIArray &children, const ObBitSet<> &onetime_idxs, const ObBitSet<> &initplan_idxs) : children_(children), onetime_idxs_(onetime_idxs), initplan_idxs_(initplan_idxs) { } TO_STRING_KV(K_(children), K_(onetime_idxs), K_(initplan_idxs)); const ObIArray &children_; const ObBitSet<> &onetime_idxs_; const ObBitSet<> &initplan_idxs_; }; struct ObCostMergeSetInfo { ObCostMergeSetInfo(const ObIArray &children, int64_t op, int64_t num_select_items) : children_(children), op_(op), num_select_items_(num_select_items){} const ObIArray &children_; int64_t op_; int64_t num_select_items_; }; struct ObCostHashSetInfo : public ObTwoNodeCostInfo { ObCostHashSetInfo(double left_rows, double left_width, double right_rows, double right_width, int64_t op, const ObIArray &hash_columns, OptTableMetas *table_metas, OptSelectivityCtx *sel_ctx) : ObTwoNodeCostInfo( left_rows, left_width, right_rows, right_width, table_metas, sel_ctx), op_(op), hash_columns_(hash_columns) {} int64_t op_; const ObIArray &hash_columns_; }; struct ObSortCostInfo { ObSortCostInfo(double rows, double width, int64_t prefix_pos, const ObIArray &order_items, const bool is_local_order, OptTableMetas *table_metas = NULL, OptSelectivityCtx *sel_ctx = NULL, double topn = -1, int64_t part_cnt = 0) : rows_(rows), width_(width), prefix_pos_(prefix_pos), order_items_(order_items), is_local_merge_sort_(is_local_order), table_metas_(table_metas), sel_ctx_(sel_ctx), topn_(topn), part_cnt_(part_cnt) {} TO_STRING_KV(K_(rows), K_(width), K_(prefix_pos), K_(order_items), K_(is_local_merge_sort), K_(topn), K_(part_cnt)); double rows_; double width_; // not prefix sort if prefix_pos_ <= 0 int64_t prefix_pos_; const ObIArray &order_items_; bool is_local_merge_sort_; // used to calculate ndv in prefix sort OptTableMetas *table_metas_; OptSelectivityCtx *sel_ctx_; // not top-n sort if topn_ < 0 double topn_; // not hash_based sort if part_cnt <= 0 int64_t part_cnt_; }; struct ObDelUpCostInfo { ObDelUpCostInfo(double affect_rows, double index_count, double constraint_count) :affect_rows_(affect_rows), index_count_(index_count), constraint_count_(constraint_count) {} TO_STRING_KV( K_(affect_rows), K_(index_count), K_(constraint_count) ); double affect_rows_; double index_count_; double constraint_count_; }; struct ObExchCostInfo { ObExchCostInfo(double rows, double width, ObPQDistributeMethod::Type dist_method, int64_t out_parallel, int64_t in_parallel, bool is_local_order, const ObIArray &sort_keys, int64_t in_server_cnt) : sort_keys_(sort_keys), rows_(rows), width_(width), dist_method_(dist_method), out_parallel_(out_parallel), in_parallel_(in_parallel), is_local_order_(is_local_order), in_server_cnt_(in_server_cnt) { } const ObIArray &sort_keys_; double rows_; double width_; ObPQDistributeMethod::Type dist_method_; int64_t out_parallel_; int64_t in_parallel_; bool is_local_order_; int64_t in_server_cnt_; }; struct ObExchInCostInfo { ObExchInCostInfo(double rows, double width, ObPQDistributeMethod::Type dist_method, int64_t parallel, int64_t server_cnt, bool is_local_order, const ObIArray &sort_keys) : sort_keys_(sort_keys), rows_(rows), width_(width), dist_method_(dist_method), parallel_(parallel), server_cnt_(server_cnt), is_local_order_(is_local_order) {} const ObIArray &sort_keys_; double rows_; double width_; ObPQDistributeMethod::Type dist_method_; int64_t parallel_; int64_t server_cnt_; bool is_local_order_; }; struct ObExchOutCostInfo { ObExchOutCostInfo(double rows, double width, ObPQDistributeMethod::Type dist_method, int64_t parallel, int64_t server_cnt) : rows_(rows), width_(width), dist_method_(dist_method), parallel_(parallel), server_cnt_(server_cnt) {} double rows_; double width_; ObPQDistributeMethod::Type dist_method_; int64_t parallel_; int64_t server_cnt_; }; class ObOptEstCostModel { public: const static int64_t DEFAULT_LOCAL_ORDER_DEGREE; const static int64_t DEFAULT_MAX_STRING_WIDTH; const static int64_t DEFAULT_FIXED_OBJ_WIDTH; ObOptEstCostModel(const ObOptCostModelParameter &cost_params, const OptSystemStat &stat) :cost_params_(cost_params), sys_stat_(stat) {} virtual ~ObOptEstCostModel()=default; int cost_nestloop(const ObCostNLJoinInfo &est_cost_info, double &cost, double &filter_selectivity, common::ObIArray &all_predicate_sel); int cost_mergejoin(const ObCostMergeJoinInfo &est_cost_info, double &cost); int cost_hashjoin(const ObCostHashJoinInfo &est_cost_info, double &cost); int cost_sort_and_exchange(OptTableMetas *table_metas, OptSelectivityCtx *sel_ctx, const ObPQDistributeMethod::Type dist_method, const bool is_distributed, const bool input_local_order, const double input_card, const double input_width, const double input_cost, const int64_t out_parallel, const int64_t in_server_cnt, const int64_t in_parallel, const ObIArray &expected_ordering, const bool need_sort, const int64_t prefix_pos, double &cost); // 对外提供两个估算排序算子代价的接口，一个使用ObRawExpr表示sort key，另一个使用 // OrderItem。 // 其它的参数信息通过cost_info传入，内部基于参数信息应该采用哪种排序 // 算法（目前包括普通排序、top-n 排序、前缀排序），对外暂不暴露实际排序算法的估算接口 int cost_sort(const ObSortCostInfo &cost_info, double &cost); int cost_exchange(const ObExchCostInfo &cost_info, double &ex_cost); int cost_exchange_in(const ObExchInCostInfo &cost_info, double &cost); int cost_exchange_out(const ObExchOutCostInfo &cost_info, double &cost); double cost_merge_group(double rows, double res_rows, double width, const ObIArray &group_columns, int64_t agg_col_count); double cost_hash_group(double rows, double res_rows, double width, const ObIArray &group_columns, int64_t agg_col_count); double cost_scalar_group(double rows, int64_t agg_col_count); double cost_merge_distinct(double rows, double res_rows, double width, const ObIArray &distinct_columns); double cost_hash_distinct(double rows, double res_rows, double width, const ObIArray &disinct_columns); double cost_get_rows(double rows); double cost_sequence(double rows, double uniq_sequence_cnt); double cost_material(const double rows, const double average_row_size); double cost_read_materialized(const double rows); double cost_filter_rows(double rows, ObIArray &filters); int cost_subplan_filter(const ObSubplanFilterCostInfo &info, double &cost); int cost_union_all(const ObCostMergeSetInfo &info, double &cost); int cost_merge_set(const ObCostMergeSetInfo &info, double &cost); int cost_hash_set(const ObCostHashSetInfo &info, double &cost); int cost_project(double rows, const ObIArray &columns, bool is_get, bool use_column_store, double &cost); int cost_project(double rows, const ObIArray &columns, bool is_get, bool use_column_store, double &cost); int cost_full_table_scan_project(double rows, const ObCostTableScanInfo &est_cost_info, bool is_get, double &cost); double cost_quals(double rows, const ObIArray &quals, bool need_scale = true); double cost_hash(double rows, const ObIArray &hash_exprs); double cost_late_materialization_table_get(int64_t column_cnt); void cost_late_materialization_table_join(double left_card, double left_cost, double right_card, double right_cost, double &op_cost, double &cost); void cost_late_materialization(double left_card, double left_cost, int64_t column_count, double &cost); int get_sort_cmp_cost(const common::ObIArray &types, double &cost); int cost_window_function(double rows, double width, double win_func_cnt, double &cost); int cost_insert(ObDelUpCostInfo& cost_info, double &cost); int cost_update(ObDelUpCostInfo& cost_info, double &cost); int cost_delete(ObDelUpCostInfo& cost_info, double &cost); /* * entry point for estimating table access cost */ int cost_table(const ObCostTableScanInfo &est_cost_info, int64_t parallel, double &cost); int cost_table_for_parallel(const ObCostTableScanInfo &est_cost_info, const int64_t parallel, const double part_cnt_per_dop, double &px_cost, double &cost); int cost_px(int64_t parallel, double &px_cost); int calc_range_cost(const ObTableMetaInfo& table_meta_info, const ObIArray &filters, int64_t index_column_count, int64_t range_count, double range_sel, double &cost); int calc_pred_cost_per_row(const ObRawExpr *expr, double card, double &cost); protected: int cost_sort(const ObSortCostInfo &cost_info, const common::ObIArray &order_col_types, double &cost); int cost_part_sort(const ObSortCostInfo &cost_info, const ObIArray &order_exprs, const ObIArray &order_col_types, double &cost); int cost_part_topn_sort(const ObSortCostInfo &cost_info, const ObIArray &order_exprs, const ObIArray &order_col_types, double &cost); int cost_prefix_sort(const ObSortCostInfo &cost_info, const ObIArray &order_exprs, const int64_t topn_count, double &cost); int cost_topn_sort(const ObSortCostInfo &cost_info, const ObIArray &types, double &cost); int cost_local_order_sort(const ObSortCostInfo &cost_info, const ObIArray &types, double &cost); int cost_topn_sort_inner(const ObIArray &types, double rows, double n, double &cost); //calculate real sort cost (std::sort) int cost_sort_inner(const common::ObIArray &types, double row_count, double &cost); int cost_local_order_sort_inner(const common::ObIArray &types, double row_count, double &cost); // estimate cost for non-virtual table int cost_basic_table(const ObCostTableScanInfo &est_cost_info, const double part_cnt_per_dop, double &cost); int cost_index_scan(const ObCostTableScanInfo &est_cost_info, double row_count, double &prefix_filter_sel, double &cost); int cost_index_back(const ObCostTableScanInfo &est_cost_info, double row_count, double &prefix_filter_sel, double &cost); int cost_column_store_index_scan(const ObCostTableScanInfo &est_cost_info, double row_count, double &prefix_filter_sel, double &cost); int cost_column_store_index_back(const ObCostTableScanInfo &est_cost_info, double row_count, double &prefix_filter_sel, double &cost); int cost_row_store_index_scan(const ObCostTableScanInfo &est_cost_info, double row_count, double &cost); int cost_row_store_index_back(const ObCostTableScanInfo &est_cost_info, double row_count, double &cost); // estimate the network transform and rpc cost for global index int cost_global_index_back_with_rp(double row_count, const ObCostTableScanInfo &est_cost_info, double &cost); int cost_range_scan(const ObCostTableScanInfo &est_cost_info, bool is_scan_index, double row_count, double &cost); int cost_range_get(const ObCostTableScanInfo &est_cost_info, bool is_scan_index, double row_count, double &cost); int range_get_io_cost(const ObCostTableScanInfo &est_cost_info, bool is_scan_index, double row_count, double &cost); int range_scan_io_cost(const ObCostTableScanInfo &est_cost_info, bool is_scan_index, double row_count, double &cost); int range_scan_cpu_cost(const ObCostTableScanInfo &est_cost_info, bool is_scan_index, double row_count, bool is_get, double &cost); protected: const ObOptCostModelParameter &cost_params_; const OptSystemStat &sys_stat_; DISALLOW_COPY_AND_ASSIGN(ObOptEstCostModel); }; } } #endif /* OCEANBASE_SQL_OPTIMIZER_OB_OPT_EST_COST_MODEL_ */