public:

CostingReceiver(

THD *thd, Query_block *query_block, JoinHypergraph &graph,

const LogicalOrderings *orderings,

const Mem_root_array<SortAheadOrdering> *sort_ahead_orderings,

const Mem_root_array<ActiveIndexInfo> *active_indexes,

const Mem_root_array<FullTextIndexInfo> *fulltext_searches,

NodeMap fulltext_tables, uint64_t sargable_fulltext_predicates,

table_map update_delete_target_tables,

table_map immediate_update_delete_candidates, bool need_rowid,

SecondaryEngineFlags engine_flags, int subgraph_pair_limit,

secondary_engine_modify_access_path_cost_t secondary_engine_cost_hook,

string *trace)

: m_thd(thd),

m_query_block(query_block),

m_access_paths(thd->mem_root),

m_graph(&graph),

m_orderings(orderings),

m_sort_ahead_orderings(sort_ahead_orderings),

m_active_indexes(active_indexes),

m_fulltext_searches(fulltext_searches),

m_fulltext_tables(fulltext_tables),

m_sargable_fulltext_predicates(sargable_fulltext_predicates),

m_update_delete_target_nodes(GetNodeMapFromTableMap(

update_delete_target_tables, graph.table_num_to_node_num)),

m_immediate_update_delete_candidates(GetNodeMapFromTableMap(

immediate_update_delete_candidates, graph.table_num_to_node_num)),

m_need_rowid(need_rowid),

m_engine_flags(engine_flags),

m_subgraph_pair_limit(subgraph_pair_limit),

m_secondary_engine_cost_hook(secondary_engine_cost_hook),

m_trace(trace) {

// At least one join type must be supported.

assert(Overlaps(engine_flags,

MakeSecondaryEngineFlags(

SecondaryEngineFlag::SUPPORTS_HASH_JOIN,

SecondaryEngineFlag::SUPPORTS_NESTED_LOOP_JOIN)));

}

// Not copyable, but movable so that we can reset it after graph

// simplification if needed.

CostingReceiver &operator=(const CostingReceiver &) = delete;

CostingReceiver &operator=(CostingReceiver &&) = default;

CostingReceiver(const CostingReceiver &) = delete;

CostingReceiver(CostingReceiver &&) = default;

bool HasSeen(NodeMap subgraph) const {

return m_access_paths.count(subgraph) != 0;

}

bool FoundSingleNode(int node_idx);

// Called EmitCsgCmp() in the DPhyp paper.

bool FoundSubgraphPair(NodeMap left, NodeMap right, int edge_idx);

const Prealloced_array<AccessPath *, 4> &root_candidates() {

const auto it =

m_access_paths.find(TablesBetween(0, m_graph->nodes.size()));

assert(it != m_access_paths.end());

return it->second.paths;

}

FunctionalDependencySet active_fds_at_root() const {

const auto it =

m_access_paths.find(TablesBetween(0, m_graph->nodes.size()));

assert(it != m_access_paths.end());

return it->second.active_functional_dependencies;

}

size_t num_subplans() const { return m_access_paths.size(); }

size_t num_access_paths() const {

size_t access_paths = 0;

for (const auto &[nodes, pathset] : m_access_paths) {

access_paths += pathset.paths.size();

}

return access_paths;

}

/// True if the result of the join is found to be always empty, typically

/// because of an impossible WHERE clause.

bool always_empty() const {

const auto it =

m_access_paths.find(TablesBetween(0, m_graph->nodes.size()));

return it != m_access_paths.end() && it->second.always_empty;

}

AccessPath *ProposeAccessPath(

AccessPath *path, Prealloced_array<AccessPath *, 4> *existing_paths,

OrderingSet obsolete_orderings, const char *description_for_trace) const;

bool HasSecondaryEngineCostHook() const {

return m_secondary_engine_cost_hook != nullptr;

}

private:

THD *m_thd;

/// The query block we are planning.

Query_block *m_query_block;

/**

struct AccessPathSet {

Prealloced_array<AccessPath *, 4> paths;

FunctionalDependencySet active_functional_dependencies{0};

// Once-interesting orderings that we don't care about anymore,

// e.g. because they were interesting for a semijoin but that semijoin

// is now done (with or without using the ordering). This reduces

// the number of access paths we have to keep in play, since they are

// de-facto equivalent.

//

// Note that if orderings were merged, this could falsely prune out

// orderings that we would actually need, but as long as all of the

// relevant ones are semijoin orderings (which are never identical,

// and never merged with the relevant-at-end orderings), this

// should not happen.

OrderingSet obsolete_orderings{0};

// True if the join of the tables in this set has been found to be always

// empty (typically because of an impossible WHERE clause).

bool always_empty{false};

};

/**

mem_root_unordered_map<NodeMap, AccessPathSet> m_access_paths;

/**

int m_num_seen_subgraph_pairs = 0;

/// The graph we are running over.

JoinHypergraph *m_graph;

/// Whether we have applied clamping due to a multi-column EQ_REF at any

/// point. There is a known issue (see bug #33550360) where this can cause

/// row count estimates to be inconsistent between different access paths.

/// Obviously, we should fix this bug by adjusting the selectivities

/// (and we do for single-column indexes), but for multipart indexes,

/// this is nontrivial. See the bug for details on some ideas, but the

/// gist of it is that we probably will want a linear program to adjust

/// multi-selectivities so that they are consistent, and not above 1/N

/// (for N-row tables) if there are unique indexes on them.

///

/// The only reason why we collect this information, like

/// JoinHypergraph::has_reordered_left_joins, is to be able to assert

/// on inconsistent row counts between APs, excluding this (known) issue.

bool has_clamped_multipart_eq_ref = false;

/// Whether we have a semijoin where the inner child is parameterized on the

/// outer child, and the row estimate of the inner child is possibly clamped,

/// for example because of some other semijoin. In this case, we may see

/// inconsistent row count estimates between the ordinary semijoin plan and

/// the rewrite_semi_to_inner plan, because it's hard to tell how much the

/// already-applied-as-sargable selectivity affected the row count estimate of

/// the child.

///

/// The only reason why we collect this information, is to be able to assert

/// on inconsistent row counts between access paths, excluding this known

/// issue.

bool has_semijoin_with_possibly_clamped_child = false;

/// Keeps track of interesting orderings in this query block.

/// See LogicalOrderings for more information.

const LogicalOrderings *m_orderings;

/// List of all orderings that are candidates for sort-ahead

/// (because they are, or may eventually become, an interesting ordering).

const Mem_root_array<SortAheadOrdering> *m_sort_ahead_orderings;

/// List of all indexes that are active and that we can apply in this query.

/// Indexes can be useful in several ways: We can use them for ref access,

/// for index-only scans, or to get interesting orderings.

const Mem_root_array<ActiveIndexInfo> *m_active_indexes;

/// List of all active full-text indexes that we can apply in this query.

const Mem_root_array<FullTextIndexInfo> *m_fulltext_searches;

/// A map of tables that are referenced by a MATCH function (those tables that

/// have Table_ref::is_fulltext_searched() == true). It is used for

/// preventing hash joins involving tables that are full-text searched.

NodeMap m_fulltext_tables = 0;

/// The set of WHERE predicates which are on a form that can be satisfied by a

/// full-text index scan. This includes calls to MATCH with no comparison

/// operator, and predicates on the form MATCH > const or MATCH >= const

/// (where const must be high enough to make the comparison return false for

/// documents with zero score).

uint64_t m_sargable_fulltext_predicates = 0;

/// The target tables of an UPDATE or DELETE statement.

NodeMap m_update_delete_target_nodes = 0;

/// The set of tables that are candidates for immediate update or delete.

/// Immediate update/delete means that the rows from the table are deleted

/// while reading the rows from the topmost iterator. (As opposed to buffered

/// update/delete, where the row IDs are stored in temporary tables, and only

/// updated or deleted after the topmost iterator has been read to the end.)

/// The candidates are those target tables that are only referenced once in

/// the query. The requirement for immediate deletion is that the deleted row

/// will not have to be read again later. Currently, at most one of the

/// candidate tables is chosen, and it is always the outermost table in the

/// join tree.

NodeMap m_immediate_update_delete_candidates = 0;

/// Whether we will be needing row IDs from our tables, typically for

/// a later sort. If this happens, derived tables cannot use streaming,

/// but need an actual materialization, since filesort expects to be

/// able to go back and ask for a given row. (This is different from

/// when we need row IDs for weedout, which doesn't preclude streaming.

/// The hypergraph optimizer does not use weedout.)

bool m_need_rowid;

/// The flags declared by the secondary engine. In particular, it describes

/// what kind of access path types should not be created.

SecondaryEngineFlags m_engine_flags;

/// The maximum number of pairs of subgraphs we are willing to accept,

/// or -1 if no limit. If this limit gets hit, we stop traversing the graph

/// and return an error; the caller will then have to modify the hypergraph

/// (see GraphSimplifier) to make for a graph with fewer options, so that

/// planning time will come under an acceptable limit.

int m_subgraph_pair_limit;

/// Pointer to a function that modifies the cost estimates of an access path

/// for execution in a secondary storage engine, or nullptr otherwise.

secondary_engine_modify_access_path_cost_t m_secondary_engine_cost_hook;

/// If not nullptr, we store human-readable optimizer trace information here.

string *m_trace;

/// A map of tables that can never be on the right side of any join,

/// ie., they have to be leftmost in the tree. This only affects recursive

/// table references (ie., when WITH RECURSIVE is in use); they work by

/// continuously tailing new records, which wouldn't work if we were to

/// scan them multiple times or put them in a hash table. Naturally,

/// there must be zero or one bit here; the common case is zero.

NodeMap forced_leftmost_table = 0;

/// A special MEM_ROOT for allocating OverflowBitsets that we might end up

/// discarding, ie. for AccessPaths that do not yet live in m_access_paths.

/// For any AccessPath that is to have a permanent life (ie., not be

/// immediately discarded as inferior), the OverflowBitset _must_ be taken

/// out of this MEM_ROOT and onto the regular one, as it is cleared often.

/// (This significantly reduces the amount of memory used in situations

/// where lots of AccessPaths are produced and discarded. Of course,

/// it only matters for queries with >= 64 predicates.)

///

/// The copying is using CommitBitsetsToHeap(). ProposeAccessPath() will

/// automatically call CommitBitsetsToHeap() for accepted access paths,

/// but it will not call it on any of their children. Thus, if you've

/// added more than one AccessPath in the chain (e.g. if you add a join,

/// then a sort of that join, and then propose the sort), you will need

/// to make sure there are no stray bitsets left on this MEM_ROOT.

///

/// Because this can be a source of subtle bugs, you should be conservative

/// about what bitsets you put here; really, only the ones you could be

/// allocating many of (like joins) should be candidates.

MEM_ROOT m_overflow_bitset_mem_root;

/// A special MEM_ROOT for temporary data for the range optimizer.

/// It can be discarded immediately after we've decided on the range scans

/// for a given table (but we reuse its memory as long as there are more

/// tables left to scan).

MEM_ROOT m_range_optimizer_mem_root;

/// For trace use only.

string PrintSet(NodeMap x) const {

std::string ret = "{";

bool first = true;

for (size_t node_idx : BitsSetIn(x)) {

if (!first) {

ret += ",";

}

first = false;

ret += m_graph->nodes[node_idx].table->alias;

}

return ret + "}";

}

/// For trace use only.

string PrintSubgraphHeader(const JoinPredicate *edge,

const AccessPath &join_path, NodeMap left,

NodeMap right) const;

/// Checks whether the given engine flag is active or not.

bool SupportedEngineFlag(SecondaryEngineFlag flag) const {

return Overlaps(m_engine_flags, MakeSecondaryEngineFlags(flag));

}

bool FindIndexRangeScans(int node_idx, bool *impossible,

double *num_output_rows_after_filter);

void ProposeIndexMerge(TABLE *table, int node_idx, const SEL_IMERGE &imerge,

int pred_idx, bool inexact,

bool allow_clustered_primary_key_scan,

int num_where_predicates,

double num_output_rows_after_filter,

RANGE_OPT_PARAM *param,

bool *has_clustered_primary_key_scan);

void TraceAccessPaths(NodeMap nodes);

void ProposeAccessPathForBaseTable(int node_idx,

double force_num_output_rows_after_filter,

const char *description_for_trace,

AccessPath *path);

void ProposeAccessPathForIndex(int node_idx,

OverflowBitset applied_predicates,

OverflowBitset subsumed_predicates,

double force_num_output_rows_after_filter,

const char *description_for_trace,

AccessPath *path);

void ProposeAccessPathWithOrderings(NodeMap nodes,

FunctionalDependencySet fd_set,

OrderingSet obsolete_orderings,

AccessPath *path,

const char *description_for_trace);

bool ProposeTableScan(TABLE *table, int node_idx,

double force_num_output_rows_after_filter);

bool ProposeIndexScan(TABLE *table, int node_idx,

double force_num_output_rows_after_filter,

unsigned key_idx, bool reverse, int ordering_idx);

bool ProposeRefAccess(TABLE *table, int node_idx, unsigned key_idx,

double force_num_output_rows_after_filter, bool reverse,

table_map allowed_parameter_tables, int ordering_idx);

bool ProposeAllUniqueIndexLookupsWithConstantKey(int node_idx, bool *found);

bool RedundantThroughSargable(

OverflowBitset redundant_against_sargable_predicates,

const AccessPath *left_path, const AccessPath *right_path, NodeMap left,

NodeMap right);

inline pair<bool, bool> AlreadyAppliedAsSargable(

Item *condition, const AccessPath *left_path,

const AccessPath *right_path);

bool ProposeAllFullTextIndexScans(TABLE *table, int node_idx,

double force_num_output_rows_after_filter);

bool ProposeFullTextIndexScan(TABLE *table, int node_idx,

Item_func_match *match, int predicate_idx,

int ordering_idx,

double force_num_output_rows_after_filter);

void ProposeNestedLoopJoin(NodeMap left, NodeMap right, AccessPath *left_path,

AccessPath *right_path, const JoinPredicate *edge,

bool rewrite_semi_to_inner,

FunctionalDependencySet new_fd_set,

OrderingSet new_obsolete_orderings,

bool *wrote_trace);

void ProposeHashJoin(NodeMap left, NodeMap right, AccessPath *left_path,

AccessPath *right_path, const JoinPredicate *edge,

FunctionalDependencySet new_fd_set,

OrderingSet new_obsolete_orderings,

bool rewrite_semi_to_inner, bool *wrote_trace);

void ApplyPredicatesForBaseTable(int node_idx,

OverflowBitset applied_predicates,

OverflowBitset subsumed_predicates,

bool materialize_subqueries,

AccessPath *path,

FunctionalDependencySet *new_fd_set);

void ApplyDelayedPredicatesAfterJoin(

NodeMap left, NodeMap right, const AccessPath *left_path,

const AccessPath *right_path, int join_predicate_first,

int join_predicate_last, bool materialize_subqueries,

AccessPath *join_path, FunctionalDependencySet *new_fd_set);

double FindAlreadyAppliedSelectivity(const JoinPredicate *edge,

const AccessPath *left_path,

const AccessPath *right_path,

NodeMap left, NodeMap right);

void CommitBitsetsToHeap(AccessPath *path) const;

bool BitsetsAreCommitted(AccessPath *path) const;

if (const handlerton *secondary_engine = SecondaryEngineHandlerton(thd);

secondary_engine != nullptr) {

return secondary_engine->secondary_engine_flags;

}

return MakeSecondaryEngineFlags(

SecondaryEngineFlag::SUPPORTS_HASH_JOIN,

SecondaryEngineFlag::SUPPORTS_NESTED_LOOP_JOIN);

const THD *thd) {

const handlerton *secondary_engine = SecondaryEngineHandlerton(thd);

if (secondary_engine == nullptr) {

return nullptr;

} else {

return secondary_engine->secondary_engine_modify_access_path_cost;

}

auto it = m_access_paths.find(nodes);

if (it == m_access_paths.end()) {

*m_trace += " - ";

*m_trace += PrintSet(nodes);

*m_trace += " has no access paths (this should not normally happen)\n";

return;

}

*m_trace += " - current access paths for ";

*m_trace += PrintSet(nodes);

*m_trace += ": ";

bool first = true;

for (const AccessPath *path : it->second.paths) {

if (!first) {

*m_trace += ", ";

}

*m_trace += PrintAccessPath(*path, *m_graph, "");

first = false;

}

*m_trace += ")\n";

if (m_thd->is_error()) return true;

m_graph->secondary_engine_costing_flags &=

~SecondaryEngineCostingFlag::HAS_MULTIPLE_BASE_TABLES;

TABLE *table = m_graph->nodes[node_idx].table;

Table_ref *tl = table->pos_in_table_list;

if (m_trace != nullptr) {

*m_trace += StringPrintf("\nFound node %s [rows=%llu]\n",

m_graph->nodes[node_idx].table->alias,

table->file->stats.records);

}

// First look for unique index lookups that use only constants.

{

bool found_eq_ref = false;

if (ProposeAllUniqueIndexLookupsWithConstantKey(node_idx, &found_eq_ref)) {

return true;

}

// If we found an unparameterized EQ_REF path, we can skip looking for

// alternative access methods, like parameterized or non-unique index

// lookups, index range scans or table scans, as they are unlikely to be any

// better. Returning early to reduce time spent planning the query, which is

// especially beneficial for point selects.

if (found_eq_ref) {

if (m_trace != nullptr) {

TraceAccessPaths(TableBitmap(node_idx));

}

return false;

}

}

// We run the range optimizer before anything else, because we can use

// its estimates to adjust predicate selectivity, giving us consistent

// row count estimation between the access paths. (It is also usually

// more precise for complex range conditions than our default estimates.

// This is also the reason why we run it even if HA_NO_INDEX_ACCESS is set.)

double range_optimizer_row_estimate = -1.0;

{

auto cleanup_mem_root = create_scope_guard([this, node_idx] {

if (node_idx == 0) {

// We won't be calling the range optimizer anymore, so we don't need

// to keep its temporary allocations around. Note that FoundSingleNode()

// counts down from N-1 to 0, not up.

m_range_optimizer_mem_root.Clear();

} else {

m_range_optimizer_mem_root.ClearForReuse();

}

});

if (!tl->is_recursive_reference() && m_graph->num_where_predicates > 0) {

// Note that true error returns in itself is not enough to fail the query;

// the range optimizer could be out of RAM easily enough, which is

// nonfatal. That just means we won't be using it for this table.

bool impossible = false;

if (FindIndexRangeScans(node_idx, &impossible,

&range_optimizer_row_estimate) &&

m_thd->is_error()) {

return true;

}

if (impossible) {

const char *const cause = "WHERE condition is always false";

if (!IsBitSet(tl->tableno(), m_graph->tables_inner_to_outer_or_anti)) {

// The entire top-level join is going to be empty, so we can abort the

// planning and return a zero rows plan.

m_query_block->join->zero_result_cause = cause;

return true;

}

AccessPath *table_path =

NewTableScanAccessPath(m_thd, table, /*count_examined_rows=*/false);

AccessPath *zero_path = NewZeroRowsAccessPath(m_thd, table_path, cause);

// We need to get the set of functional dependencies right,

// even though we don't need to actually apply any filters.

FunctionalDependencySet new_fd_set;

ApplyPredicatesForBaseTable(

node_idx,

/*applied_predicates=*/

MutableOverflowBitset{m_thd->mem_root, m_graph->predicates.size()},

/*subsumed_predicates=*/

MutableOverflowBitset{m_thd->mem_root, m_graph->predicates.size()},

/*materialize_subqueries=*/false, zero_path, &new_fd_set);

zero_path->filter_predicates =

MutableOverflowBitset{m_thd->mem_root, m_graph->predicates.size()};

zero_path->ordering_state =

m_orderings->ApplyFDs(zero_path->ordering_state, new_fd_set);

ProposeAccessPathWithOrderings(TableBitmap(node_idx), new_fd_set,

/*obsolete_orderings=*/0, zero_path, "");

if (m_trace != nullptr) {

TraceAccessPaths(TableBitmap(node_idx));

}

return false;

}

}

}

if (ProposeTableScan(table, node_idx, range_optimizer_row_estimate)) {

return true;

}

if (Overlaps(table->file->ha_table_flags(), HA_NO_INDEX_ACCESS) ||

tl->is_recursive_reference()) {

// We can't use any indexes, so end here.

if (m_trace != nullptr) {

TraceAccessPaths(TableBitmap(node_idx));

}

return false;

}

// Propose index scan (for getting interesting orderings).

// We only consider those that are more interesting than a table scan;

// for the others, we don't even need to create the access path and go

// through the tournament.

for (const ActiveIndexInfo &order_info : *m_active_indexes) {

if (order_info.table != table) {

continue;

}

const int forward_order =

m_orderings->RemapOrderingIndex(order_info.forward_order);

const int reverse_order =

m_orderings->RemapOrderingIndex(order_info.reverse_order);

for (bool reverse : {false, true}) {

if (reverse && reverse_order == 0) {

continue;

}

const int order = reverse ? reverse_order : forward_order;

if (order != 0) {

if (ProposeIndexScan(table, node_idx, range_optimizer_row_estimate,

order_info.key_idx, reverse, order)) {

return true;

}

}

// Propose ref access using only sargable predicates that reference no

// other table.

if (ProposeRefAccess(table, node_idx, order_info.key_idx,

range_optimizer_row_estimate, reverse,

/*allowed_parameter_tables=*/0, order)) {

return true;

}

// Propose ref access using all sargable predicates that also refer to

// other tables (e.g. t1.x = t2.x). Such access paths can only be used

// on the inner side of a nested loop join, where all the other

// referenced tables are among the outer tables of the join. Such path

// is called a parameterized path.

//

// Since indexes can have multiple parts, the access path can also end

// up being parameterized on multiple outer tables. However, since

// parameterized paths are less flexible in joining than

// non-parameterized ones, it can be advantageous to not use all parts

// of the index; it's impossible to say locally. Thus, we enumerate all

// possible subsets of table parameters that may be useful, to make sure

// we don't miss any such paths.

table_map want_parameter_tables = 0;

for (const SargablePredicate &sp :

m_graph->nodes[node_idx].sargable_predicates) {

if (sp.field->table == table &&

sp.field->part_of_key.is_set(order_info.key_idx) &&

!Overlaps(sp.other_side->used_tables(),

PSEUDO_TABLE_BITS | table->pos_in_table_list->map())) {

want_parameter_tables |= sp.other_side->used_tables();

}

}

for (table_map allowed_parameter_tables :

NonzeroSubsetsOf(want_parameter_tables)) {

if (ProposeRefAccess(table, node_idx, order_info.key_idx,

range_optimizer_row_estimate, reverse,

allowed_parameter_tables, order)) {

return true;

}

}

}

}

if (tl->is_fulltext_searched()) {

if (ProposeAllFullTextIndexScans(table, node_idx,

range_optimizer_row_estimate)) {

return true;

}

}

if (m_trace != nullptr) {

TraceAccessPaths(TableBitmap(node_idx));

}

return false;

THD *thd, KEY *key, unsigned used_key_parts, unsigned num_exact_key_parts,

TABLE *table, OverflowBitset tree_applied_predicates,

OverflowBitset tree_subsumed_predicates, const JoinHypergraph &graph,

OverflowBitset *applied_predicates_out,

OverflowBitset *subsumed_predicates_out) {

MutableOverflowBitset applied_fields{thd->mem_root, table->s->fields};

MutableOverflowBitset subsumed_fields{thd->mem_root, table->s->fields};

MutableOverflowBitset applied_predicates(thd->mem_root,

graph.predicates.size());

MutableOverflowBitset subsumed_predicates(thd->mem_root,

graph.predicates.size());

for (unsigned keypart_idx = 0; keypart_idx < used_key_parts; ++keypart_idx) {

const KEY_PART_INFO &keyinfo = key->key_part[keypart_idx];

applied_fields.SetBit(keyinfo.field->field_index());

if (keypart_idx < num_exact_key_parts &&

!Overlaps(keyinfo.key_part_flag, HA_PART_KEY_SEG)) {

subsumed_fields.SetBit(keyinfo.field->field_index());

}

}

for (int predicate_idx : BitsSetIn(tree_applied_predicates)) {

Item *condition = graph.predicates[predicate_idx].condition;

bool any_not_applied =

WalkItem(condition, enum_walk::POSTFIX, [&applied_fields](Item *item) {

return item->type() == Item::FIELD_ITEM &&

!IsBitSet(down_cast<Item_field *>(item)->field->field_index(),

applied_fields);

});

if (any_not_applied) {

continue;

}

applied_predicates.SetBit(predicate_idx);

if (IsBitSet(predicate_idx, tree_subsumed_predicates)) {

bool any_not_subsumed = WalkItem(

condition, enum_walk::POSTFIX, [&subsumed_fields](Item *item) {

return item->type() == Item::FIELD_ITEM &&

!IsBitSet(

down_cast<Item_field *>(item)->field->field_index(),

subsumed_fields);

});

if (!any_not_subsumed) {

subsumed_predicates.SetBit(predicate_idx);

}

}

}

*applied_predicates_out = std::move(applied_predicates);

*subsumed_predicates_out = std::move(subsumed_predicates);

unsigned idx;

unsigned mrr_flags;

unsigned mrr_buf_size;

unsigned used_key_parts;

double cost;

ha_rows num_rows;

bool is_ror_scan;

bool is_imerge_scan;

OverflowBitset applied_predicates;

OverflowBitset subsumed_predicates;

Quick_ranges ranges;

THD *thd, SEL_TREE *tree, RANGE_OPT_PARAM *param,

OverflowBitset tree_applied_predicates,

OverflowBitset tree_subsumed_predicates, const JoinHypergraph &graph,

Mem_root_array<PossibleRangeScan> *possible_scans) {

for (unsigned idx = 0; idx < param->keys; idx++) {

SEL_ROOT *root = tree->keys[idx];

if (root == nullptr || root->type == SEL_ROOT::Type::MAYBE_KEY ||

root->root->maybe_flag) {

continue;

}

const uint keynr = param->real_keynr[idx];

const bool covering_index = param->table->covering_keys.is_set(keynr);

unsigned mrr_flags, buf_size;

Cost_estimate cost;

bool is_ror_scan, is_imerge_scan;

// NOTE: We give in ORDER_NOT_RELEVANT now, but will re-run with

// ORDER_ASC/ORDER_DESC when actually proposing the index, if that

// yields an interesting order.

ha_rows num_rows = check_quick_select(

thd, param, idx, covering_index, root, /*update_tbl_stats=*/true,

ORDER_NOT_RELEVANT, /*skip_records_in_range=*/false, &mrr_flags,

&buf_size, &cost, &is_ror_scan, &is_imerge_scan);

if (num_rows == HA_POS_ERROR) {

continue;

}

// TODO(sgunders): See if we could have had a pre-filtering mechanism

// that allowed us to skip extracting these ranges if the path would

// obviously too high cost. As it is, it's a bit hard to just propose

// the path and see if it came in, since we need e.g. num_exact_key_parts

// as an output from this call, and that in turn affects filter cost.

Quick_ranges ranges(param->return_mem_root);

unsigned used_key_parts, num_exact_key_parts;

if (get_ranges_from_tree(param->return_mem_root, param->table,

param->key[idx], keynr, root, MAX_REF_PARTS,

&used_key_parts, &num_exact_key_parts, &ranges)) {

return true;

}

KEY *key = &param->table->key_info[keynr];

PossibleRangeScan scan;

scan.idx = idx;

scan.mrr_flags = mrr_flags;

scan.mrr_buf_size = buf_size;

scan.used_key_parts = used_key_parts;

scan.cost = cost.total_cost();

scan.num_rows = num_rows;

scan.is_ror_scan = is_ror_scan;

scan.is_imerge_scan = is_imerge_scan;

scan.ranges = std::move(ranges);

FindAppliedAndSubsumedPredicatesForRangeScan(

thd, key, used_key_parts, num_exact_key_parts, param->table,

tree_applied_predicates, tree_subsumed_predicates, graph,

&scan.applied_predicates, &scan.subsumed_predicates);

possible_scans->push_back(std::move(scan));

}

return false;