MySQL 8.3.0
Source Code Documentation File Reference


class  anonymous_namespace{}::AggregateRowEstimator
 This class finds disjoint sets of aggregation terms that form prefixes of some non-hash index, and makes row estimates for those sets based on index metadata. More...
struct  anonymous_namespace{}::AggregateRowEstimator::Prefix
 A prefix of some key where each key_part corresponds to an aggregation term. More...


namespace  anonymous_namespace{}


using anonymous_namespace{}::TermArray = Bounds_checked_array< const Item *const >
 Array of aggregation terms. More...


double EstimateCostForRefAccess (THD *thd, TABLE *table, unsigned key_idx, double num_output_rows)
void EstimateSortCost (AccessPath *path)
void AddCost (THD *thd, const ContainedSubquery &subquery, double num_rows, FilterCost *cost)
 Used internally by EstimateFilterCost() only. More...
FilterCost EstimateFilterCost (THD *thd, double num_rows, Item *condition, const Query_block *outer_query_block)
 Estimate the cost of evaluating “condition”, “num_rows” times. More...
void EstimateMaterializeCost (THD *thd, AccessPath *path)
TermArray anonymous_namespace{}::GetAggregationTerms (const JOIN &join)
double anonymous_namespace{}::EstimateDistinctRowsFromStatistics (TermArray terms, double child_rows, string *trace)
 Estimate the number of distinct tuples in the projection defined by 'terms'. More...
template<typename FunctionLow , typename FunctionHigh >
double anonymous_namespace{}::SmoothTransition (FunctionLow function_low, FunctionHigh function_high, double lower_limit, double upper_limit, double argument)
 For a function f(x) such that: f(x) = g(x) for x<=l f(x) = h(x) for x>l. More...
double anonymous_namespace{}::EstimateRollupRowsPrimitively (double aggregate_rows, size_t grouping_expressions)
 Do a cheap rollup row estimate for small result sets. More...
double anonymous_namespace{}::EstimateRollupRowsAdvanced (double aggregate_rows, TermArray terms, string *trace)
 Do more precise rollup row estimate for larger result sets. More...
double anonymous_namespace{}::EstimateAggregateRows (const AccessPath *child, const Query_block *query_block, bool rollup, string *trace)
 Estimate the row count for an aggregate operation (including ROLLUP rows for GROUP BY ... WITH ROLLUP). More...
double EstimateDistinctRows (double child_rows, TermArray terms, string *trace)
void EstimateAggregateCost (AccessPath *path, const Query_block *query_block, string *trace)
void EstimateDeleteRowsCost (AccessPath *path)
void EstimateUpdateRowsCost (AccessPath *path)
void EstimateStreamCost (AccessPath *path)
 Estimate the costs and row count for a STREAM AccessPath. More...
void EstimateLimitOffsetCost (AccessPath *path)
 Estimate the costs and row count for a LIMIT_OFFSET AccessPath. More...
void EstimateWindowCost (AccessPath *path)
 Estimate the costs and row count for a WINDOW AccessPath. More...
double EstimateSemijoinFanOut (double right_rows, const JoinPredicate &edge)
 Estimate the fan out for a left semijoin or a left antijoin. More...

Function Documentation

◆ AddCost()

void AddCost ( THD thd,
const ContainedSubquery subquery,
double  num_rows,
FilterCost cost 

Used internally by EstimateFilterCost() only.

◆ EstimateAggregateCost()

void EstimateAggregateCost ( AccessPath path,
const Query_block query_block,
string *  trace 

◆ EstimateCostForRefAccess()

double EstimateCostForRefAccess ( THD thd,
TABLE table,
unsigned  key_idx,
double  num_output_rows 

◆ EstimateDeleteRowsCost()

void EstimateDeleteRowsCost ( AccessPath path)

◆ EstimateDistinctRows()

double EstimateDistinctRows ( double  child_rows,
TermArray  terms,
string *  trace 

◆ EstimateFilterCost()

FilterCost EstimateFilterCost ( THD thd,
double  num_rows,
Item condition,
const Query_block outer_query_block 

Estimate the cost of evaluating “condition”, “num_rows” times.

This is a fairly rudimentary estimation, but it includes the cost of any subqueries that may be present and that need evaluation.

◆ EstimateLimitOffsetCost()

void EstimateLimitOffsetCost ( AccessPath path)

Estimate the costs and row count for a LIMIT_OFFSET AccessPath.

◆ EstimateMaterializeCost()

void EstimateMaterializeCost ( THD thd,
AccessPath path 

◆ EstimateSemijoinFanOut()

double EstimateSemijoinFanOut ( double  right_rows,
const JoinPredicate edge 

Estimate the fan out for a left semijoin or a left antijoin.

The fan out is defined as the number of result rows, divided by the number of input rows from the left hand relation. For a semijoin, J1:


we know that the fan out of the corresponding inner join J2:

SELECT ... FROM t1, t2 WHERE predicate

is: F(J2) = CARD(t2) * SELECTIVITY(predicate) , where CARD(t2)=right_rows, and SELECTIVITY(predicate)=edge.selectivity. If 'predicate' is a deterministic function of t1 and t2 rows, then J1 is equivalent to an inner join J3:

SELECT ... FROM t1 JOIN (SELECT DISTINCT f1,..fn FROM t2) d ON predicate

where f1,..fn are those fields from t2 that appear in the predicate.

Then F(J1) = F(J3) = F(J2) * CARD(d) / CARD(t2) = CARD(d) * SELECTIVITY(predicate).

This function therefore collects f1..fn and estimates CARD(d). As a special case, 'predicate' may be independent of t2. The query is then equivalent to:

SELECT ... FROM t1 WHERE predicate AND (SELECT COUNT(*) FROM t2) > 0

The fan out is then the selectivity of 'predicate' multiplied by the probability of t2 having at least one row.

right_rowsThe number of input rows from the right hand relation.
edgeJoin edge.
fan out.

◆ EstimateSortCost()

void EstimateSortCost ( AccessPath path)

◆ EstimateStreamCost()

void EstimateStreamCost ( AccessPath path)

Estimate the costs and row count for a STREAM AccessPath.

◆ EstimateUpdateRowsCost()

void EstimateUpdateRowsCost ( AccessPath path)

◆ EstimateWindowCost()

void EstimateWindowCost ( AccessPath path)

Estimate the costs and row count for a WINDOW AccessPath.