PostgreSQL Source Code  git master
selfuncs.h File Reference
#include "access/htup.h"
#include "fmgr.h"
#include "nodes/pathnodes.h"
Include dependency graph for selfuncs.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  EstimationInfo
 
struct  VariableStatData
 
struct  GenericCosts
 

Macros

#define DEFAULT_EQ_SEL   0.005
 
#define DEFAULT_INEQ_SEL   0.3333333333333333
 
#define DEFAULT_RANGE_INEQ_SEL   0.005
 
#define DEFAULT_MULTIRANGE_INEQ_SEL   0.005
 
#define DEFAULT_MATCH_SEL   0.005
 
#define DEFAULT_MATCHING_SEL   0.010
 
#define DEFAULT_NUM_DISTINCT   200
 
#define DEFAULT_UNK_SEL   0.005
 
#define DEFAULT_NOT_UNK_SEL   (1.0 - DEFAULT_UNK_SEL)
 
#define CLAMP_PROBABILITY(p)
 
#define SELFLAG_USED_DEFAULT
 
#define ReleaseVariableStats(vardata)
 

Typedefs

typedef struct EstimationInfo EstimationInfo
 
typedef struct VariableStatData VariableStatData
 
typedef bool(* get_relation_stats_hook_type) (PlannerInfo *root, RangeTblEntry *rte, AttrNumber attnum, VariableStatData *vardata)
 
typedef bool(* get_index_stats_hook_type) (PlannerInfo *root, Oid indexOid, AttrNumber indexattnum, VariableStatData *vardata)
 

Functions

void examine_variable (PlannerInfo *root, Node *node, int varRelid, VariableStatData *vardata)
 
bool statistic_proc_security_check (VariableStatData *vardata, Oid func_oid)
 
bool get_restriction_variable (PlannerInfo *root, List *args, int varRelid, VariableStatData *vardata, Node **other, bool *varonleft)
 
void get_join_variables (PlannerInfo *root, List *args, SpecialJoinInfo *sjinfo, VariableStatData *vardata1, VariableStatData *vardata2, bool *join_is_reversed)
 
double get_variable_numdistinct (VariableStatData *vardata, bool *isdefault)
 
double mcv_selectivity (VariableStatData *vardata, FmgrInfo *opproc, Oid collation, Datum constval, bool varonleft, double *sumcommonp)
 
double histogram_selectivity (VariableStatData *vardata, FmgrInfo *opproc, Oid collation, Datum constval, bool varonleft, int min_hist_size, int n_skip, int *hist_size)
 
double generic_restriction_selectivity (PlannerInfo *root, Oid oproid, Oid collation, List *args, int varRelid, double default_selectivity)
 
double ineq_histogram_selectivity (PlannerInfo *root, VariableStatData *vardata, Oid opoid, FmgrInfo *opproc, bool isgt, bool iseq, Oid collation, Datum constval, Oid consttype)
 
double var_eq_const (VariableStatData *vardata, Oid oproid, Oid collation, Datum constval, bool constisnull, bool varonleft, bool negate)
 
double var_eq_non_const (VariableStatData *vardata, Oid oproid, Oid collation, Node *other, bool varonleft, bool negate)
 
Selectivity boolvarsel (PlannerInfo *root, Node *arg, int varRelid)
 
Selectivity booltestsel (PlannerInfo *root, BoolTestType booltesttype, Node *arg, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo)
 
Selectivity nulltestsel (PlannerInfo *root, NullTestType nulltesttype, Node *arg, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo)
 
Selectivity scalararraysel (PlannerInfo *root, ScalarArrayOpExpr *clause, bool is_join_clause, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo)
 
double estimate_array_length (PlannerInfo *root, Node *arrayexpr)
 
Selectivity rowcomparesel (PlannerInfo *root, RowCompareExpr *clause, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo)
 
void mergejoinscansel (PlannerInfo *root, Node *clause, Oid opfamily, int strategy, bool nulls_first, Selectivity *leftstart, Selectivity *leftend, Selectivity *rightstart, Selectivity *rightend)
 
double estimate_num_groups (PlannerInfo *root, List *groupExprs, double input_rows, List **pgset, EstimationInfo *estinfo)
 
void estimate_hash_bucket_stats (PlannerInfo *root, Node *hashkey, double nbuckets, Selectivity *mcv_freq, Selectivity *bucketsize_frac)
 
double estimate_hashagg_tablesize (PlannerInfo *root, Path *path, const AggClauseCosts *agg_costs, double dNumGroups)
 
Listget_quals_from_indexclauses (List *indexclauses)
 
Cost index_other_operands_eval_cost (PlannerInfo *root, List *indexquals)
 
Listadd_predicate_to_index_quals (IndexOptInfo *index, List *indexQuals)
 
void genericcostestimate (PlannerInfo *root, IndexPath *path, double loop_count, GenericCosts *costs)
 
Selectivity scalararraysel_containment (PlannerInfo *root, Node *leftop, Node *rightop, Oid elemtype, bool isEquality, bool useOr, int varRelid)
 

Variables

PGDLLIMPORT get_relation_stats_hook_type get_relation_stats_hook
 
PGDLLIMPORT get_index_stats_hook_type get_index_stats_hook
 

Macro Definition Documentation

◆ CLAMP_PROBABILITY

#define CLAMP_PROBABILITY (   p)
Value:
do { \
if (p < 0.0) \
p = 0.0; \
else if (p > 1.0) \
p = 1.0; \
} while (0)

Definition at line 63 of file selfuncs.h.

◆ DEFAULT_EQ_SEL

#define DEFAULT_EQ_SEL   0.005

Definition at line 34 of file selfuncs.h.

◆ DEFAULT_INEQ_SEL

#define DEFAULT_INEQ_SEL   0.3333333333333333

Definition at line 37 of file selfuncs.h.

◆ DEFAULT_MATCH_SEL

#define DEFAULT_MATCH_SEL   0.005

Definition at line 46 of file selfuncs.h.

◆ DEFAULT_MATCHING_SEL

#define DEFAULT_MATCHING_SEL   0.010

Definition at line 49 of file selfuncs.h.

◆ DEFAULT_MULTIRANGE_INEQ_SEL

#define DEFAULT_MULTIRANGE_INEQ_SEL   0.005

Definition at line 43 of file selfuncs.h.

◆ DEFAULT_NOT_UNK_SEL

#define DEFAULT_NOT_UNK_SEL   (1.0 - DEFAULT_UNK_SEL)

Definition at line 56 of file selfuncs.h.

◆ DEFAULT_NUM_DISTINCT

#define DEFAULT_NUM_DISTINCT   200

Definition at line 52 of file selfuncs.h.

◆ DEFAULT_RANGE_INEQ_SEL

#define DEFAULT_RANGE_INEQ_SEL   0.005

Definition at line 40 of file selfuncs.h.

◆ DEFAULT_UNK_SEL

#define DEFAULT_UNK_SEL   0.005

Definition at line 55 of file selfuncs.h.

◆ ReleaseVariableStats

#define ReleaseVariableStats (   vardata)
Value:
do { \
if (HeapTupleIsValid((vardata).statsTuple)) \
(vardata).freefunc((vardata).statsTuple); \
} while(0)
#define HeapTupleIsValid(tuple)
Definition: htup.h:78

Definition at line 99 of file selfuncs.h.

◆ SELFLAG_USED_DEFAULT

#define SELFLAG_USED_DEFAULT
Value:
(1 << 0) /* Estimation fell back on one
* of the DEFAULTs as defined
* above. */

Definition at line 76 of file selfuncs.h.

Typedef Documentation

◆ EstimationInfo

◆ get_index_stats_hook_type

typedef bool(* get_index_stats_hook_type) (PlannerInfo *root, Oid indexOid, AttrNumber indexattnum, VariableStatData *vardata)

Definition at line 143 of file selfuncs.h.

◆ get_relation_stats_hook_type

typedef bool(* get_relation_stats_hook_type) (PlannerInfo *root, RangeTblEntry *rte, AttrNumber attnum, VariableStatData *vardata)

Definition at line 138 of file selfuncs.h.

◆ VariableStatData

Function Documentation

◆ add_predicate_to_index_quals()

List* add_predicate_to_index_quals ( IndexOptInfo index,
List indexQuals 
)

Definition at line 6767 of file selfuncs.c.

6768 {
6769  List *predExtraQuals = NIL;
6770  ListCell *lc;
6771 
6772  if (index->indpred == NIL)
6773  return indexQuals;
6774 
6775  foreach(lc, index->indpred)
6776  {
6777  Node *predQual = (Node *) lfirst(lc);
6778  List *oneQual = list_make1(predQual);
6779 
6780  if (!predicate_implied_by(oneQual, indexQuals, false))
6781  predExtraQuals = list_concat(predExtraQuals, oneQual);
6782  }
6783  return list_concat(predExtraQuals, indexQuals);
6784 }
List * list_concat(List *list1, const List *list2)
Definition: list.c:561
#define lfirst(lc)
Definition: pg_list.h:172
#define NIL
Definition: pg_list.h:68
#define list_make1(x1)
Definition: pg_list.h:212
bool predicate_implied_by(List *predicate_list, List *clause_list, bool weak)
Definition: predtest.c:152
Definition: pg_list.h:54
Definition: nodes.h:129
Definition: type.h:95

References lfirst, list_concat(), list_make1, NIL, and predicate_implied_by().

Referenced by btcostestimate(), genericcostestimate(), and gincostestimate().

◆ booltestsel()

Selectivity booltestsel ( PlannerInfo root,
BoolTestType  booltesttype,
Node arg,
int  varRelid,
JoinType  jointype,
SpecialJoinInfo sjinfo 
)

Definition at line 1540 of file selfuncs.c.

1542 {
1543  VariableStatData vardata;
1544  double selec;
1545 
1546  examine_variable(root, arg, varRelid, &vardata);
1547 
1548  if (HeapTupleIsValid(vardata.statsTuple))
1549  {
1550  Form_pg_statistic stats;
1551  double freq_null;
1552  AttStatsSlot sslot;
1553 
1554  stats = (Form_pg_statistic) GETSTRUCT(vardata.statsTuple);
1555  freq_null = stats->stanullfrac;
1556 
1557  if (get_attstatsslot(&sslot, vardata.statsTuple,
1558  STATISTIC_KIND_MCV, InvalidOid,
1560  && sslot.nnumbers > 0)
1561  {
1562  double freq_true;
1563  double freq_false;
1564 
1565  /*
1566  * Get first MCV frequency and derive frequency for true.
1567  */
1568  if (DatumGetBool(sslot.values[0]))
1569  freq_true = sslot.numbers[0];
1570  else
1571  freq_true = 1.0 - sslot.numbers[0] - freq_null;
1572 
1573  /*
1574  * Next derive frequency for false. Then use these as appropriate
1575  * to derive frequency for each case.
1576  */
1577  freq_false = 1.0 - freq_true - freq_null;
1578 
1579  switch (booltesttype)
1580  {
1581  case IS_UNKNOWN:
1582  /* select only NULL values */
1583  selec = freq_null;
1584  break;
1585  case IS_NOT_UNKNOWN:
1586  /* select non-NULL values */
1587  selec = 1.0 - freq_null;
1588  break;
1589  case IS_TRUE:
1590  /* select only TRUE values */
1591  selec = freq_true;
1592  break;
1593  case IS_NOT_TRUE:
1594  /* select non-TRUE values */
1595  selec = 1.0 - freq_true;
1596  break;
1597  case IS_FALSE:
1598  /* select only FALSE values */
1599  selec = freq_false;
1600  break;
1601  case IS_NOT_FALSE:
1602  /* select non-FALSE values */
1603  selec = 1.0 - freq_false;
1604  break;
1605  default:
1606  elog(ERROR, "unrecognized booltesttype: %d",
1607  (int) booltesttype);
1608  selec = 0.0; /* Keep compiler quiet */
1609  break;
1610  }
1611 
1612  free_attstatsslot(&sslot);
1613  }
1614  else
1615  {
1616  /*
1617  * No most-common-value info available. Still have null fraction
1618  * information, so use it for IS [NOT] UNKNOWN. Otherwise adjust
1619  * for null fraction and assume a 50-50 split of TRUE and FALSE.
1620  */
1621  switch (booltesttype)
1622  {
1623  case IS_UNKNOWN:
1624  /* select only NULL values */
1625  selec = freq_null;
1626  break;
1627  case IS_NOT_UNKNOWN:
1628  /* select non-NULL values */
1629  selec = 1.0 - freq_null;
1630  break;
1631  case IS_TRUE:
1632  case IS_FALSE:
1633  /* Assume we select half of the non-NULL values */
1634  selec = (1.0 - freq_null) / 2.0;
1635  break;
1636  case IS_NOT_TRUE:
1637  case IS_NOT_FALSE:
1638  /* Assume we select NULLs plus half of the non-NULLs */
1639  /* equiv. to freq_null + (1.0 - freq_null) / 2.0 */
1640  selec = (freq_null + 1.0) / 2.0;
1641  break;
1642  default:
1643  elog(ERROR, "unrecognized booltesttype: %d",
1644  (int) booltesttype);
1645  selec = 0.0; /* Keep compiler quiet */
1646  break;
1647  }
1648  }
1649  }
1650  else
1651  {
1652  /*
1653  * If we can't get variable statistics for the argument, perhaps
1654  * clause_selectivity can do something with it. We ignore the
1655  * possibility of a NULL value when using clause_selectivity, and just
1656  * assume the value is either TRUE or FALSE.
1657  */
1658  switch (booltesttype)
1659  {
1660  case IS_UNKNOWN:
1661  selec = DEFAULT_UNK_SEL;
1662  break;
1663  case IS_NOT_UNKNOWN:
1664  selec = DEFAULT_NOT_UNK_SEL;
1665  break;
1666  case IS_TRUE:
1667  case IS_NOT_FALSE:
1668  selec = (double) clause_selectivity(root, arg,
1669  varRelid,
1670  jointype, sjinfo);
1671  break;
1672  case IS_FALSE:
1673  case IS_NOT_TRUE:
1674  selec = 1.0 - (double) clause_selectivity(root, arg,
1675  varRelid,
1676  jointype, sjinfo);
1677  break;
1678  default:
1679  elog(ERROR, "unrecognized booltesttype: %d",
1680  (int) booltesttype);
1681  selec = 0.0; /* Keep compiler quiet */
1682  break;
1683  }
1684  }
1685 
1686  ReleaseVariableStats(vardata);
1687 
1688  /* result should be in range, but make sure... */
1689  CLAMP_PROBABILITY(selec);
1690 
1691  return (Selectivity) selec;
1692 }
Selectivity clause_selectivity(PlannerInfo *root, Node *clause, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo)
Definition: clausesel.c:667
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
void free_attstatsslot(AttStatsSlot *sslot)
Definition: lsyscache.c:3322
bool get_attstatsslot(AttStatsSlot *sslot, HeapTuple statstuple, int reqkind, Oid reqop, int flags)
Definition: lsyscache.c:3212
#define ATTSTATSSLOT_NUMBERS
Definition: lsyscache.h:43
#define ATTSTATSSLOT_VALUES
Definition: lsyscache.h:42
double Selectivity
Definition: nodes.h:250
void * arg
FormData_pg_statistic * Form_pg_statistic
Definition: pg_statistic.h:135
static bool DatumGetBool(Datum X)
Definition: postgres.h:90
#define InvalidOid
Definition: postgres_ext.h:36
@ IS_NOT_TRUE
Definition: primnodes.h:1945
@ IS_NOT_FALSE
Definition: primnodes.h:1945
@ IS_NOT_UNKNOWN
Definition: primnodes.h:1945
@ IS_TRUE
Definition: primnodes.h:1945
@ IS_UNKNOWN
Definition: primnodes.h:1945
@ IS_FALSE
Definition: primnodes.h:1945
tree ctl root
Definition: radixtree.h:1880
void examine_variable(PlannerInfo *root, Node *node, int varRelid, VariableStatData *vardata)
Definition: selfuncs.c:5012
#define DEFAULT_NOT_UNK_SEL
Definition: selfuncs.h:56
#define ReleaseVariableStats(vardata)
Definition: selfuncs.h:99
#define CLAMP_PROBABILITY(p)
Definition: selfuncs.h:63
#define DEFAULT_UNK_SEL
Definition: selfuncs.h:55
Datum * values
Definition: lsyscache.h:53
float4 * numbers
Definition: lsyscache.h:56
int nnumbers
Definition: lsyscache.h:57
HeapTuple statsTuple
Definition: selfuncs.h:89

References arg, ATTSTATSSLOT_NUMBERS, ATTSTATSSLOT_VALUES, CLAMP_PROBABILITY, clause_selectivity(), DatumGetBool(), DEFAULT_NOT_UNK_SEL, DEFAULT_UNK_SEL, elog, ERROR, examine_variable(), free_attstatsslot(), get_attstatsslot(), GETSTRUCT, HeapTupleIsValid, InvalidOid, IS_FALSE, IS_NOT_FALSE, IS_NOT_TRUE, IS_NOT_UNKNOWN, IS_TRUE, IS_UNKNOWN, AttStatsSlot::nnumbers, AttStatsSlot::numbers, ReleaseVariableStats, root, VariableStatData::statsTuple, and AttStatsSlot::values.

Referenced by clause_selectivity_ext().

◆ boolvarsel()

Selectivity boolvarsel ( PlannerInfo root,
Node arg,
int  varRelid 
)

Definition at line 1512 of file selfuncs.c.

1513 {
1514  VariableStatData vardata;
1515  double selec;
1516 
1517  examine_variable(root, arg, varRelid, &vardata);
1518  if (HeapTupleIsValid(vardata.statsTuple))
1519  {
1520  /*
1521  * A boolean variable V is equivalent to the clause V = 't', so we
1522  * compute the selectivity as if that is what we have.
1523  */
1524  selec = var_eq_const(&vardata, BooleanEqualOperator, InvalidOid,
1525  BoolGetDatum(true), false, true, false);
1526  }
1527  else
1528  {
1529  /* Otherwise, the default estimate is 0.5 */
1530  selec = 0.5;
1531  }
1532  ReleaseVariableStats(vardata);
1533  return selec;
1534 }
static Datum BoolGetDatum(bool X)
Definition: postgres.h:102
double var_eq_const(VariableStatData *vardata, Oid oproid, Oid collation, Datum constval, bool constisnull, bool varonleft, bool negate)
Definition: selfuncs.c:295

References arg, BoolGetDatum(), examine_variable(), HeapTupleIsValid, InvalidOid, ReleaseVariableStats, root, VariableStatData::statsTuple, and var_eq_const().

Referenced by clause_selectivity_ext().

◆ estimate_array_length()

double estimate_array_length ( PlannerInfo root,
Node arrayexpr 
)

Definition at line 2136 of file selfuncs.c.

2137 {
2138  /* look through any binary-compatible relabeling of arrayexpr */
2139  arrayexpr = strip_array_coercion(arrayexpr);
2140 
2141  if (arrayexpr && IsA(arrayexpr, Const))
2142  {
2143  Datum arraydatum = ((Const *) arrayexpr)->constvalue;
2144  bool arrayisnull = ((Const *) arrayexpr)->constisnull;
2145  ArrayType *arrayval;
2146 
2147  if (arrayisnull)
2148  return 0;
2149  arrayval = DatumGetArrayTypeP(arraydatum);
2150  return ArrayGetNItems(ARR_NDIM(arrayval), ARR_DIMS(arrayval));
2151  }
2152  else if (arrayexpr && IsA(arrayexpr, ArrayExpr) &&
2153  !((ArrayExpr *) arrayexpr)->multidims)
2154  {
2155  return list_length(((ArrayExpr *) arrayexpr)->elements);
2156  }
2157  else if (arrayexpr)
2158  {
2159  /* See if we can find any statistics about it */
2160  VariableStatData vardata;
2161  AttStatsSlot sslot;
2162  double nelem = 0;
2163 
2164  examine_variable(root, arrayexpr, 0, &vardata);
2165  if (HeapTupleIsValid(vardata.statsTuple))
2166  {
2167  /*
2168  * Found stats, so use the average element count, which is stored
2169  * in the last stanumbers element of the DECHIST statistics.
2170  * Actually that is the average count of *distinct* elements;
2171  * perhaps we should scale it up somewhat?
2172  */
2173  if (get_attstatsslot(&sslot, vardata.statsTuple,
2174  STATISTIC_KIND_DECHIST, InvalidOid,
2176  {
2177  if (sslot.nnumbers > 0)
2178  nelem = clamp_row_est(sslot.numbers[sslot.nnumbers - 1]);
2179  free_attstatsslot(&sslot);
2180  }
2181  }
2182  ReleaseVariableStats(vardata);
2183 
2184  if (nelem > 0)
2185  return nelem;
2186  }
2187 
2188  /* Else use a default guess --- this should match scalararraysel */
2189  return 10;
2190 }
#define ARR_NDIM(a)
Definition: array.h:290
#define DatumGetArrayTypeP(X)
Definition: array.h:261
#define ARR_DIMS(a)
Definition: array.h:294
int ArrayGetNItems(int ndim, const int *dims)
Definition: arrayutils.c:57
double clamp_row_est(double nrows)
Definition: costsize.c:202
#define IsA(nodeptr, _type_)
Definition: nodes.h:158
static int list_length(const List *l)
Definition: pg_list.h:152
uintptr_t Datum
Definition: postgres.h:64
static Node * strip_array_coercion(Node *node)
Definition: selfuncs.c:1783

References ARR_DIMS, ARR_NDIM, ArrayGetNItems(), ATTSTATSSLOT_NUMBERS, clamp_row_est(), DatumGetArrayTypeP, examine_variable(), free_attstatsslot(), get_attstatsslot(), HeapTupleIsValid, InvalidOid, IsA, list_length(), AttStatsSlot::nnumbers, AttStatsSlot::numbers, ReleaseVariableStats, root, VariableStatData::statsTuple, and strip_array_coercion().

Referenced by array_unnest_support(), btcostestimate(), cost_qual_eval_walker(), cost_tidscan(), genericcostestimate(), and gincost_scalararrayopexpr().

◆ estimate_hash_bucket_stats()

void estimate_hash_bucket_stats ( PlannerInfo root,
Node hashkey,
double  nbuckets,
Selectivity mcv_freq,
Selectivity bucketsize_frac 
)

Definition at line 3798 of file selfuncs.c.

3801 {
3802  VariableStatData vardata;
3803  double estfract,
3804  ndistinct,
3805  stanullfrac,
3806  avgfreq;
3807  bool isdefault;
3808  AttStatsSlot sslot;
3809 
3810  examine_variable(root, hashkey, 0, &vardata);
3811 
3812  /* Look up the frequency of the most common value, if available */
3813  *mcv_freq = 0.0;
3814 
3815  if (HeapTupleIsValid(vardata.statsTuple))
3816  {
3817  if (get_attstatsslot(&sslot, vardata.statsTuple,
3818  STATISTIC_KIND_MCV, InvalidOid,
3820  {
3821  /*
3822  * The first MCV stat is for the most common value.
3823  */
3824  if (sslot.nnumbers > 0)
3825  *mcv_freq = sslot.numbers[0];
3826  free_attstatsslot(&sslot);
3827  }
3828  }
3829 
3830  /* Get number of distinct values */
3831  ndistinct = get_variable_numdistinct(&vardata, &isdefault);
3832 
3833  /*
3834  * If ndistinct isn't real, punt. We normally return 0.1, but if the
3835  * mcv_freq is known to be even higher than that, use it instead.
3836  */
3837  if (isdefault)
3838  {
3839  *bucketsize_frac = (Selectivity) Max(0.1, *mcv_freq);
3840  ReleaseVariableStats(vardata);
3841  return;
3842  }
3843 
3844  /* Get fraction that are null */
3845  if (HeapTupleIsValid(vardata.statsTuple))
3846  {
3847  Form_pg_statistic stats;
3848 
3849  stats = (Form_pg_statistic) GETSTRUCT(vardata.statsTuple);
3850  stanullfrac = stats->stanullfrac;
3851  }
3852  else
3853  stanullfrac = 0.0;
3854 
3855  /* Compute avg freq of all distinct data values in raw relation */
3856  avgfreq = (1.0 - stanullfrac) / ndistinct;
3857 
3858  /*
3859  * Adjust ndistinct to account for restriction clauses. Observe we are
3860  * assuming that the data distribution is affected uniformly by the
3861  * restriction clauses!
3862  *
3863  * XXX Possibly better way, but much more expensive: multiply by
3864  * selectivity of rel's restriction clauses that mention the target Var.
3865  */
3866  if (vardata.rel && vardata.rel->tuples > 0)
3867  {
3868  ndistinct *= vardata.rel->rows / vardata.rel->tuples;
3869  ndistinct = clamp_row_est(ndistinct);
3870  }
3871 
3872  /*
3873  * Initial estimate of bucketsize fraction is 1/nbuckets as long as the
3874  * number of buckets is less than the expected number of distinct values;
3875  * otherwise it is 1/ndistinct.
3876  */
3877  if (ndistinct > nbuckets)
3878  estfract = 1.0 / nbuckets;
3879  else
3880  estfract = 1.0 / ndistinct;
3881 
3882  /*
3883  * Adjust estimated bucketsize upward to account for skewed distribution.
3884  */
3885  if (avgfreq > 0.0 && *mcv_freq > avgfreq)
3886  estfract *= *mcv_freq / avgfreq;
3887 
3888  /*
3889  * Clamp bucketsize to sane range (the above adjustment could easily
3890  * produce an out-of-range result). We set the lower bound a little above
3891  * zero, since zero isn't a very sane result.
3892  */
3893  if (estfract < 1.0e-6)
3894  estfract = 1.0e-6;
3895  else if (estfract > 1.0)
3896  estfract = 1.0;
3897 
3898  *bucketsize_frac = (Selectivity) estfract;
3899 
3900  ReleaseVariableStats(vardata);
3901 }
#define Max(x, y)
Definition: c.h:998
double get_variable_numdistinct(VariableStatData *vardata, bool *isdefault)
Definition: selfuncs.c:5764
Cardinality tuples
Definition: pathnodes.h:939
Cardinality rows
Definition: pathnodes.h:867
RelOptInfo * rel
Definition: selfuncs.h:88

References ATTSTATSSLOT_NUMBERS, clamp_row_est(), examine_variable(), free_attstatsslot(), get_attstatsslot(), get_variable_numdistinct(), GETSTRUCT, HeapTupleIsValid, InvalidOid, Max, AttStatsSlot::nnumbers, AttStatsSlot::numbers, VariableStatData::rel, ReleaseVariableStats, root, RelOptInfo::rows, VariableStatData::statsTuple, and RelOptInfo::tuples.

Referenced by final_cost_hashjoin().

◆ estimate_hashagg_tablesize()

double estimate_hashagg_tablesize ( PlannerInfo root,
Path path,
const AggClauseCosts agg_costs,
double  dNumGroups 
)

Definition at line 3917 of file selfuncs.c.

3919 {
3920  Size hashentrysize;
3921 
3922  hashentrysize = hash_agg_entry_size(list_length(root->aggtransinfos),
3923  path->pathtarget->width,
3924  agg_costs->transitionSpace);
3925 
3926  /*
3927  * Note that this disregards the effect of fill-factor and growth policy
3928  * of the hash table. That's probably ok, given that the default
3929  * fill-factor is relatively high. It'd be hard to meaningfully factor in
3930  * "double-in-size" growth policies here.
3931  */
3932  return hashentrysize * dNumGroups;
3933 }
size_t Size
Definition: c.h:605
Size hash_agg_entry_size(int numTrans, Size tupleWidth, Size transitionSpace)
Definition: nodeAgg.c:1694
Size transitionSpace
Definition: pathnodes.h:62

References hash_agg_entry_size(), list_length(), root, and AggClauseCosts::transitionSpace.

Referenced by consider_groupingsets_paths().

◆ estimate_num_groups()

double estimate_num_groups ( PlannerInfo root,
List groupExprs,
double  input_rows,
List **  pgset,
EstimationInfo estinfo 
)

Definition at line 3416 of file selfuncs.c.

3418 {
3419  List *varinfos = NIL;
3420  double srf_multiplier = 1.0;
3421  double numdistinct;
3422  ListCell *l;
3423  int i;
3424 
3425  /* Zero the estinfo output parameter, if non-NULL */
3426  if (estinfo != NULL)
3427  memset(estinfo, 0, sizeof(EstimationInfo));
3428 
3429  /*
3430  * We don't ever want to return an estimate of zero groups, as that tends
3431  * to lead to division-by-zero and other unpleasantness. The input_rows
3432  * estimate is usually already at least 1, but clamp it just in case it
3433  * isn't.
3434  */
3435  input_rows = clamp_row_est(input_rows);
3436 
3437  /*
3438  * If no grouping columns, there's exactly one group. (This can't happen
3439  * for normal cases with GROUP BY or DISTINCT, but it is possible for
3440  * corner cases with set operations.)
3441  */
3442  if (groupExprs == NIL || (pgset && *pgset == NIL))
3443  return 1.0;
3444 
3445  /*
3446  * Count groups derived from boolean grouping expressions. For other
3447  * expressions, find the unique Vars used, treating an expression as a Var
3448  * if we can find stats for it. For each one, record the statistical
3449  * estimate of number of distinct values (total in its table, without
3450  * regard for filtering).
3451  */
3452  numdistinct = 1.0;
3453 
3454  i = 0;
3455  foreach(l, groupExprs)
3456  {
3457  Node *groupexpr = (Node *) lfirst(l);
3458  double this_srf_multiplier;
3459  VariableStatData vardata;
3460  List *varshere;
3461  ListCell *l2;
3462 
3463  /* is expression in this grouping set? */
3464  if (pgset && !list_member_int(*pgset, i++))
3465  continue;
3466 
3467  /*
3468  * Set-returning functions in grouping columns are a bit problematic.
3469  * The code below will effectively ignore their SRF nature and come up
3470  * with a numdistinct estimate as though they were scalar functions.
3471  * We compensate by scaling up the end result by the largest SRF
3472  * rowcount estimate. (This will be an overestimate if the SRF
3473  * produces multiple copies of any output value, but it seems best to
3474  * assume the SRF's outputs are distinct. In any case, it's probably
3475  * pointless to worry too much about this without much better
3476  * estimates for SRF output rowcounts than we have today.)
3477  */
3478  this_srf_multiplier = expression_returns_set_rows(root, groupexpr);
3479  if (srf_multiplier < this_srf_multiplier)
3480  srf_multiplier = this_srf_multiplier;
3481 
3482  /* Short-circuit for expressions returning boolean */
3483  if (exprType(groupexpr) == BOOLOID)
3484  {
3485  numdistinct *= 2.0;
3486  continue;
3487  }
3488 
3489  /*
3490  * If examine_variable is able to deduce anything about the GROUP BY
3491  * expression, treat it as a single variable even if it's really more
3492  * complicated.
3493  *
3494  * XXX This has the consequence that if there's a statistics object on
3495  * the expression, we don't split it into individual Vars. This
3496  * affects our selection of statistics in
3497  * estimate_multivariate_ndistinct, because it's probably better to
3498  * use more accurate estimate for each expression and treat them as
3499  * independent, than to combine estimates for the extracted variables
3500  * when we don't know how that relates to the expressions.
3501  */
3502  examine_variable(root, groupexpr, 0, &vardata);
3503  if (HeapTupleIsValid(vardata.statsTuple) || vardata.isunique)
3504  {
3505  varinfos = add_unique_group_var(root, varinfos,
3506  groupexpr, &vardata);
3507  ReleaseVariableStats(vardata);
3508  continue;
3509  }
3510  ReleaseVariableStats(vardata);
3511 
3512  /*
3513  * Else pull out the component Vars. Handle PlaceHolderVars by
3514  * recursing into their arguments (effectively assuming that the
3515  * PlaceHolderVar doesn't change the number of groups, which boils
3516  * down to ignoring the possible addition of nulls to the result set).
3517  */
3518  varshere = pull_var_clause(groupexpr,
3522 
3523  /*
3524  * If we find any variable-free GROUP BY item, then either it is a
3525  * constant (and we can ignore it) or it contains a volatile function;
3526  * in the latter case we punt and assume that each input row will
3527  * yield a distinct group.
3528  */
3529  if (varshere == NIL)
3530  {
3531  if (contain_volatile_functions(groupexpr))
3532  return input_rows;
3533  continue;
3534  }
3535 
3536  /*
3537  * Else add variables to varinfos list
3538  */
3539  foreach(l2, varshere)
3540  {
3541  Node *var = (Node *) lfirst(l2);
3542 
3543  examine_variable(root, var, 0, &vardata);
3544  varinfos = add_unique_group_var(root, varinfos, var, &vardata);
3545  ReleaseVariableStats(vardata);
3546  }
3547  }
3548 
3549  /*
3550  * If now no Vars, we must have an all-constant or all-boolean GROUP BY
3551  * list.
3552  */
3553  if (varinfos == NIL)
3554  {
3555  /* Apply SRF multiplier as we would do in the long path */
3556  numdistinct *= srf_multiplier;
3557  /* Round off */
3558  numdistinct = ceil(numdistinct);
3559  /* Guard against out-of-range answers */
3560  if (numdistinct > input_rows)
3561  numdistinct = input_rows;
3562  if (numdistinct < 1.0)
3563  numdistinct = 1.0;
3564  return numdistinct;
3565  }
3566 
3567  /*
3568  * Group Vars by relation and estimate total numdistinct.
3569  *
3570  * For each iteration of the outer loop, we process the frontmost Var in
3571  * varinfos, plus all other Vars in the same relation. We remove these
3572  * Vars from the newvarinfos list for the next iteration. This is the
3573  * easiest way to group Vars of same rel together.
3574  */
3575  do
3576  {
3577  GroupVarInfo *varinfo1 = (GroupVarInfo *) linitial(varinfos);
3578  RelOptInfo *rel = varinfo1->rel;
3579  double reldistinct = 1;
3580  double relmaxndistinct = reldistinct;
3581  int relvarcount = 0;
3582  List *newvarinfos = NIL;
3583  List *relvarinfos = NIL;
3584 
3585  /*
3586  * Split the list of varinfos in two - one for the current rel, one
3587  * for remaining Vars on other rels.
3588  */
3589  relvarinfos = lappend(relvarinfos, varinfo1);
3590  for_each_from(l, varinfos, 1)
3591  {
3592  GroupVarInfo *varinfo2 = (GroupVarInfo *) lfirst(l);
3593 
3594  if (varinfo2->rel == varinfo1->rel)
3595  {
3596  /* varinfos on current rel */
3597  relvarinfos = lappend(relvarinfos, varinfo2);
3598  }
3599  else
3600  {
3601  /* not time to process varinfo2 yet */
3602  newvarinfos = lappend(newvarinfos, varinfo2);
3603  }
3604  }
3605 
3606  /*
3607  * Get the numdistinct estimate for the Vars of this rel. We
3608  * iteratively search for multivariate n-distinct with maximum number
3609  * of vars; assuming that each var group is independent of the others,
3610  * we multiply them together. Any remaining relvarinfos after no more
3611  * multivariate matches are found are assumed independent too, so
3612  * their individual ndistinct estimates are multiplied also.
3613  *
3614  * While iterating, count how many separate numdistinct values we
3615  * apply. We apply a fudge factor below, but only if we multiplied
3616  * more than one such values.
3617  */
3618  while (relvarinfos)
3619  {
3620  double mvndistinct;
3621 
3622  if (estimate_multivariate_ndistinct(root, rel, &relvarinfos,
3623  &mvndistinct))
3624  {
3625  reldistinct *= mvndistinct;
3626  if (relmaxndistinct < mvndistinct)
3627  relmaxndistinct = mvndistinct;
3628  relvarcount++;
3629  }
3630  else
3631  {
3632  foreach(l, relvarinfos)
3633  {
3634  GroupVarInfo *varinfo2 = (GroupVarInfo *) lfirst(l);
3635 
3636  reldistinct *= varinfo2->ndistinct;
3637  if (relmaxndistinct < varinfo2->ndistinct)
3638  relmaxndistinct = varinfo2->ndistinct;
3639  relvarcount++;
3640 
3641  /*
3642  * When varinfo2's isdefault is set then we'd better set
3643  * the SELFLAG_USED_DEFAULT bit in the EstimationInfo.
3644  */
3645  if (estinfo != NULL && varinfo2->isdefault)
3646  estinfo->flags |= SELFLAG_USED_DEFAULT;
3647  }
3648 
3649  /* we're done with this relation */
3650  relvarinfos = NIL;
3651  }
3652  }
3653 
3654  /*
3655  * Sanity check --- don't divide by zero if empty relation.
3656  */
3657  Assert(IS_SIMPLE_REL(rel));
3658  if (rel->tuples > 0)
3659  {
3660  /*
3661  * Clamp to size of rel, or size of rel / 10 if multiple Vars. The
3662  * fudge factor is because the Vars are probably correlated but we
3663  * don't know by how much. We should never clamp to less than the
3664  * largest ndistinct value for any of the Vars, though, since
3665  * there will surely be at least that many groups.
3666  */
3667  double clamp = rel->tuples;
3668 
3669  if (relvarcount > 1)
3670  {
3671  clamp *= 0.1;
3672  if (clamp < relmaxndistinct)
3673  {
3674  clamp = relmaxndistinct;
3675  /* for sanity in case some ndistinct is too large: */
3676  if (clamp > rel->tuples)
3677  clamp = rel->tuples;
3678  }
3679  }
3680  if (reldistinct > clamp)
3681  reldistinct = clamp;
3682 
3683  /*
3684  * Update the estimate based on the restriction selectivity,
3685  * guarding against division by zero when reldistinct is zero.
3686  * Also skip this if we know that we are returning all rows.
3687  */
3688  if (reldistinct > 0 && rel->rows < rel->tuples)
3689  {
3690  /*
3691  * Given a table containing N rows with n distinct values in a
3692  * uniform distribution, if we select p rows at random then
3693  * the expected number of distinct values selected is
3694  *
3695  * n * (1 - product((N-N/n-i)/(N-i), i=0..p-1))
3696  *
3697  * = n * (1 - (N-N/n)! / (N-N/n-p)! * (N-p)! / N!)
3698  *
3699  * See "Approximating block accesses in database
3700  * organizations", S. B. Yao, Communications of the ACM,
3701  * Volume 20 Issue 4, April 1977 Pages 260-261.
3702  *
3703  * Alternatively, re-arranging the terms from the factorials,
3704  * this may be written as
3705  *
3706  * n * (1 - product((N-p-i)/(N-i), i=0..N/n-1))
3707  *
3708  * This form of the formula is more efficient to compute in
3709  * the common case where p is larger than N/n. Additionally,
3710  * as pointed out by Dell'Era, if i << N for all terms in the
3711  * product, it can be approximated by
3712  *
3713  * n * (1 - ((N-p)/N)^(N/n))
3714  *
3715  * See "Expected distinct values when selecting from a bag
3716  * without replacement", Alberto Dell'Era,
3717  * http://www.adellera.it/investigations/distinct_balls/.
3718  *
3719  * The condition i << N is equivalent to n >> 1, so this is a
3720  * good approximation when the number of distinct values in
3721  * the table is large. It turns out that this formula also
3722  * works well even when n is small.
3723  */
3724  reldistinct *=
3725  (1 - pow((rel->tuples - rel->rows) / rel->tuples,
3726  rel->tuples / reldistinct));
3727  }
3728  reldistinct = clamp_row_est(reldistinct);
3729 
3730  /*
3731  * Update estimate of total distinct groups.
3732  */
3733  numdistinct *= reldistinct;
3734  }
3735 
3736  varinfos = newvarinfos;
3737  } while (varinfos != NIL);
3738 
3739  /* Now we can account for the effects of any SRFs */
3740  numdistinct *= srf_multiplier;
3741 
3742  /* Round off */
3743  numdistinct = ceil(numdistinct);
3744 
3745  /* Guard against out-of-range answers */
3746  if (numdistinct > input_rows)
3747  numdistinct = input_rows;
3748  if (numdistinct < 1.0)
3749  numdistinct = 1.0;
3750 
3751  return numdistinct;
3752 }
#define Assert(condition)
Definition: c.h:858
bool contain_volatile_functions(Node *clause)
Definition: clauses.c:538
double expression_returns_set_rows(PlannerInfo *root, Node *clause)
Definition: clauses.c:289
int i
Definition: isn.c:73
List * lappend(List *list, void *datum)
Definition: list.c:339
bool list_member_int(const List *list, int datum)
Definition: list.c:702
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
#define PVC_RECURSE_AGGREGATES
Definition: optimizer.h:187
#define PVC_RECURSE_PLACEHOLDERS
Definition: optimizer.h:191
#define PVC_RECURSE_WINDOWFUNCS
Definition: optimizer.h:189
#define IS_SIMPLE_REL(rel)
Definition: pathnodes.h:829
#define for_each_from(cell, lst, N)
Definition: pg_list.h:414
#define linitial(l)
Definition: pg_list.h:178
static bool estimate_multivariate_ndistinct(PlannerInfo *root, RelOptInfo *rel, List **varinfos, double *ndistinct)
Definition: selfuncs.c:3954
static List * add_unique_group_var(PlannerInfo *root, List *varinfos, Node *var, VariableStatData *vardata)
Definition: selfuncs.c:3296
#define SELFLAG_USED_DEFAULT
Definition: selfuncs.h:76
uint32 flags
Definition: selfuncs.h:80
RelOptInfo * rel
Definition: selfuncs.c:3290
double ndistinct
Definition: selfuncs.c:3291
bool isdefault
Definition: selfuncs.c:3292
List * pull_var_clause(Node *node, int flags)
Definition: var.c:607

References add_unique_group_var(), Assert, clamp_row_est(), contain_volatile_functions(), estimate_multivariate_ndistinct(), examine_variable(), expression_returns_set_rows(), exprType(), EstimationInfo::flags, for_each_from, HeapTupleIsValid, i, IS_SIMPLE_REL, GroupVarInfo::isdefault, VariableStatData::isunique, lappend(), lfirst, linitial, list_member_int(), GroupVarInfo::ndistinct, NIL, pull_var_clause(), PVC_RECURSE_AGGREGATES, PVC_RECURSE_PLACEHOLDERS, PVC_RECURSE_WINDOWFUNCS, GroupVarInfo::rel, ReleaseVariableStats, root, RelOptInfo::rows, SELFLAG_USED_DEFAULT, VariableStatData::statsTuple, and RelOptInfo::tuples.

Referenced by adjust_rowcount_for_semijoins(), build_setop_child_paths(), cost_incremental_sort(), cost_memoize_rescan(), create_final_distinct_paths(), create_partial_distinct_paths(), create_unique_path(), estimate_path_cost_size(), get_number_of_groups(), and get_windowclause_startup_tuples().

◆ examine_variable()

void examine_variable ( PlannerInfo root,
Node node,
int  varRelid,
VariableStatData vardata 
)

Definition at line 5012 of file selfuncs.c.

5014 {
5015  Node *basenode;
5016  Relids varnos;
5017  RelOptInfo *onerel;
5018 
5019  /* Make sure we don't return dangling pointers in vardata */
5020  MemSet(vardata, 0, sizeof(VariableStatData));
5021 
5022  /* Save the exposed type of the expression */
5023  vardata->vartype = exprType(node);
5024 
5025  /* Look inside any binary-compatible relabeling */
5026 
5027  if (IsA(node, RelabelType))
5028  basenode = (Node *) ((RelabelType *) node)->arg;
5029  else
5030  basenode = node;
5031 
5032  /* Fast path for a simple Var */
5033 
5034  if (IsA(basenode, Var) &&
5035  (varRelid == 0 || varRelid == ((Var *) basenode)->varno))
5036  {
5037  Var *var = (Var *) basenode;
5038 
5039  /* Set up result fields other than the stats tuple */
5040  vardata->var = basenode; /* return Var without relabeling */
5041  vardata->rel = find_base_rel(root, var->varno);
5042  vardata->atttype = var->vartype;
5043  vardata->atttypmod = var->vartypmod;
5044  vardata->isunique = has_unique_index(vardata->rel, var->varattno);
5045 
5046  /* Try to locate some stats */
5047  examine_simple_variable(root, var, vardata);
5048 
5049  return;
5050  }
5051 
5052  /*
5053  * Okay, it's a more complicated expression. Determine variable
5054  * membership. Note that when varRelid isn't zero, only vars of that
5055  * relation are considered "real" vars.
5056  */
5057  varnos = pull_varnos(root, basenode);
5058 
5059  onerel = NULL;
5060 
5061  if (bms_is_empty(varnos))
5062  {
5063  /* No Vars at all ... must be pseudo-constant clause */
5064  }
5065  else
5066  {
5067  int relid;
5068 
5069  if (bms_get_singleton_member(varnos, &relid))
5070  {
5071  if (varRelid == 0 || varRelid == relid)
5072  {
5073  onerel = find_base_rel(root, relid);
5074  vardata->rel = onerel;
5075  node = basenode; /* strip any relabeling */
5076  }
5077  /* else treat it as a constant */
5078  }
5079  else
5080  {
5081  /* varnos has multiple relids */
5082  if (varRelid == 0)
5083  {
5084  /* treat it as a variable of a join relation */
5085  vardata->rel = find_join_rel(root, varnos);
5086  node = basenode; /* strip any relabeling */
5087  }
5088  else if (bms_is_member(varRelid, varnos))
5089  {
5090  /* ignore the vars belonging to other relations */
5091  vardata->rel = find_base_rel(root, varRelid);
5092  node = basenode; /* strip any relabeling */
5093  /* note: no point in expressional-index search here */
5094  }
5095  /* else treat it as a constant */
5096  }
5097  }
5098 
5099  bms_free(varnos);
5100 
5101  vardata->var = node;
5102  vardata->atttype = exprType(node);
5103  vardata->atttypmod = exprTypmod(node);
5104 
5105  if (onerel)
5106  {
5107  /*
5108  * We have an expression in vars of a single relation. Try to match
5109  * it to expressional index columns, in hopes of finding some
5110  * statistics.
5111  *
5112  * Note that we consider all index columns including INCLUDE columns,
5113  * since there could be stats for such columns. But the test for
5114  * uniqueness needs to be warier.
5115  *
5116  * XXX it's conceivable that there are multiple matches with different
5117  * index opfamilies; if so, we need to pick one that matches the
5118  * operator we are estimating for. FIXME later.
5119  */
5120  ListCell *ilist;
5121  ListCell *slist;
5122  Oid userid;
5123 
5124  /*
5125  * Determine the user ID to use for privilege checks: either
5126  * onerel->userid if it's set (e.g., in case we're accessing the table
5127  * via a view), or the current user otherwise.
5128  *
5129  * If we drill down to child relations, we keep using the same userid:
5130  * it's going to be the same anyway, due to how we set up the relation
5131  * tree (q.v. build_simple_rel).
5132  */
5133  userid = OidIsValid(onerel->userid) ? onerel->userid : GetUserId();
5134 
5135  foreach(ilist, onerel->indexlist)
5136  {
5137  IndexOptInfo *index = (IndexOptInfo *) lfirst(ilist);
5138  ListCell *indexpr_item;
5139  int pos;
5140 
5141  indexpr_item = list_head(index->indexprs);
5142  if (indexpr_item == NULL)
5143  continue; /* no expressions here... */
5144 
5145  for (pos = 0; pos < index->ncolumns; pos++)
5146  {
5147  if (index->indexkeys[pos] == 0)
5148  {
5149  Node *indexkey;
5150 
5151  if (indexpr_item == NULL)
5152  elog(ERROR, "too few entries in indexprs list");
5153  indexkey = (Node *) lfirst(indexpr_item);
5154  if (indexkey && IsA(indexkey, RelabelType))
5155  indexkey = (Node *) ((RelabelType *) indexkey)->arg;
5156  if (equal(node, indexkey))
5157  {
5158  /*
5159  * Found a match ... is it a unique index? Tests here
5160  * should match has_unique_index().
5161  */
5162  if (index->unique &&
5163  index->nkeycolumns == 1 &&
5164  pos == 0 &&
5165  (index->indpred == NIL || index->predOK))
5166  vardata->isunique = true;
5167 
5168  /*
5169  * Has it got stats? We only consider stats for
5170  * non-partial indexes, since partial indexes probably
5171  * don't reflect whole-relation statistics; the above
5172  * check for uniqueness is the only info we take from
5173  * a partial index.
5174  *
5175  * An index stats hook, however, must make its own
5176  * decisions about what to do with partial indexes.
5177  */
5179  (*get_index_stats_hook) (root, index->indexoid,
5180  pos + 1, vardata))
5181  {
5182  /*
5183  * The hook took control of acquiring a stats
5184  * tuple. If it did supply a tuple, it'd better
5185  * have supplied a freefunc.
5186  */
5187  if (HeapTupleIsValid(vardata->statsTuple) &&
5188  !vardata->freefunc)
5189  elog(ERROR, "no function provided to release variable stats with");
5190  }
5191  else if (index->indpred == NIL)
5192  {
5193  vardata->statsTuple =
5194  SearchSysCache3(STATRELATTINH,
5195  ObjectIdGetDatum(index->indexoid),
5196  Int16GetDatum(pos + 1),
5197  BoolGetDatum(false));
5198  vardata->freefunc = ReleaseSysCache;
5199 
5200  if (HeapTupleIsValid(vardata->statsTuple))
5201  {
5202  /* Get index's table for permission check */
5203  RangeTblEntry *rte;
5204 
5205  rte = planner_rt_fetch(index->rel->relid, root);
5206  Assert(rte->rtekind == RTE_RELATION);
5207 
5208  /*
5209  * For simplicity, we insist on the whole
5210  * table being selectable, rather than trying
5211  * to identify which column(s) the index
5212  * depends on. Also require all rows to be
5213  * selectable --- there must be no
5214  * securityQuals from security barrier views
5215  * or RLS policies.
5216  */
5217  vardata->acl_ok =
5218  rte->securityQuals == NIL &&
5219  (pg_class_aclcheck(rte->relid, userid,
5220  ACL_SELECT) == ACLCHECK_OK);
5221 
5222  /*
5223  * If the user doesn't have permissions to
5224  * access an inheritance child relation, check
5225  * the permissions of the table actually
5226  * mentioned in the query, since most likely
5227  * the user does have that permission. Note
5228  * that whole-table select privilege on the
5229  * parent doesn't quite guarantee that the
5230  * user could read all columns of the child.
5231  * But in practice it's unlikely that any
5232  * interesting security violation could result
5233  * from allowing access to the expression
5234  * index's stats, so we allow it anyway. See
5235  * similar code in examine_simple_variable()
5236  * for additional comments.
5237  */
5238  if (!vardata->acl_ok &&
5239  root->append_rel_array != NULL)
5240  {
5241  AppendRelInfo *appinfo;
5242  Index varno = index->rel->relid;
5243 
5244  appinfo = root->append_rel_array[varno];
5245  while (appinfo &&
5246  planner_rt_fetch(appinfo->parent_relid,
5247  root)->rtekind == RTE_RELATION)
5248  {
5249  varno = appinfo->parent_relid;
5250  appinfo = root->append_rel_array[varno];
5251  }
5252  if (varno != index->rel->relid)
5253  {
5254  /* Repeat access check on this rel */
5255  rte = planner_rt_fetch(varno, root);
5256  Assert(rte->rtekind == RTE_RELATION);
5257 
5258  vardata->acl_ok =
5259  rte->securityQuals == NIL &&
5260  (pg_class_aclcheck(rte->relid,
5261  userid,
5262  ACL_SELECT) == ACLCHECK_OK);
5263  }
5264  }
5265  }
5266  else
5267  {
5268  /* suppress leakproofness checks later */
5269  vardata->acl_ok = true;
5270  }
5271  }
5272  if (vardata->statsTuple)
5273  break;
5274  }
5275  indexpr_item = lnext(index->indexprs, indexpr_item);
5276  }
5277  }
5278  if (vardata->statsTuple)
5279  break;
5280  }
5281 
5282  /*
5283  * Search extended statistics for one with a matching expression.
5284  * There might be multiple ones, so just grab the first one. In the
5285  * future, we might consider the statistics target (and pick the most
5286  * accurate statistics) and maybe some other parameters.
5287  */
5288  foreach(slist, onerel->statlist)
5289  {
5290  StatisticExtInfo *info = (StatisticExtInfo *) lfirst(slist);
5291  RangeTblEntry *rte = planner_rt_fetch(onerel->relid, root);
5292  ListCell *expr_item;
5293  int pos;
5294 
5295  /*
5296  * Stop once we've found statistics for the expression (either
5297  * from extended stats, or for an index in the preceding loop).
5298  */
5299  if (vardata->statsTuple)
5300  break;
5301 
5302  /* skip stats without per-expression stats */
5303  if (info->kind != STATS_EXT_EXPRESSIONS)
5304  continue;
5305 
5306  /* skip stats with mismatching stxdinherit value */
5307  if (info->inherit != rte->inh)
5308  continue;
5309 
5310  pos = 0;
5311  foreach(expr_item, info->exprs)
5312  {
5313  Node *expr = (Node *) lfirst(expr_item);
5314 
5315  Assert(expr);
5316 
5317  /* strip RelabelType before comparing it */
5318  if (expr && IsA(expr, RelabelType))
5319  expr = (Node *) ((RelabelType *) expr)->arg;
5320 
5321  /* found a match, see if we can extract pg_statistic row */
5322  if (equal(node, expr))
5323  {
5324  /*
5325  * XXX Not sure if we should cache the tuple somewhere.
5326  * Now we just create a new copy every time.
5327  */
5328  vardata->statsTuple =
5329  statext_expressions_load(info->statOid, rte->inh, pos);
5330 
5331  vardata->freefunc = ReleaseDummy;
5332 
5333  /*
5334  * For simplicity, we insist on the whole table being
5335  * selectable, rather than trying to identify which
5336  * column(s) the statistics object depends on. Also
5337  * require all rows to be selectable --- there must be no
5338  * securityQuals from security barrier views or RLS
5339  * policies.
5340  */
5341  vardata->acl_ok =
5342  rte->securityQuals == NIL &&
5343  (pg_class_aclcheck(rte->relid, userid,
5344  ACL_SELECT) == ACLCHECK_OK);
5345 
5346  /*
5347  * If the user doesn't have permissions to access an
5348  * inheritance child relation, check the permissions of
5349  * the table actually mentioned in the query, since most
5350  * likely the user does have that permission. Note that
5351  * whole-table select privilege on the parent doesn't
5352  * quite guarantee that the user could read all columns of
5353  * the child. But in practice it's unlikely that any
5354  * interesting security violation could result from
5355  * allowing access to the expression stats, so we allow it
5356  * anyway. See similar code in examine_simple_variable()
5357  * for additional comments.
5358  */
5359  if (!vardata->acl_ok &&
5360  root->append_rel_array != NULL)
5361  {
5362  AppendRelInfo *appinfo;
5363  Index varno = onerel->relid;
5364 
5365  appinfo = root->append_rel_array[varno];
5366  while (appinfo &&
5367  planner_rt_fetch(appinfo->parent_relid,
5368  root)->rtekind == RTE_RELATION)
5369  {
5370  varno = appinfo->parent_relid;
5371  appinfo = root->append_rel_array[varno];
5372  }
5373  if (varno != onerel->relid)
5374  {
5375  /* Repeat access check on this rel */
5376  rte = planner_rt_fetch(varno, root);
5377  Assert(rte->rtekind == RTE_RELATION);
5378 
5379  vardata->acl_ok =
5380  rte->securityQuals == NIL &&
5381  (pg_class_aclcheck(rte->relid,
5382  userid,
5383  ACL_SELECT) == ACLCHECK_OK);
5384  }
5385  }
5386 
5387  break;
5388  }
5389 
5390  pos++;
5391  }
5392  }
5393  }
5394 }
@ ACLCHECK_OK
Definition: acl.h:183
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
Definition: aclchk.c:4079
void bms_free(Bitmapset *a)
Definition: bitmapset.c:239
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:510
bool bms_get_singleton_member(const Bitmapset *a, int *member)
Definition: bitmapset.c:715
#define bms_is_empty(a)
Definition: bitmapset.h:118
unsigned int Index
Definition: c.h:614
#define MemSet(start, val, len)
Definition: c.h:1020
#define OidIsValid(objectId)
Definition: c.h:775
bool equal(const void *a, const void *b)
Definition: equalfuncs.c:223
HeapTuple statext_expressions_load(Oid stxoid, bool inh, int idx)
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
Oid GetUserId(void)
Definition: miscinit.c:514
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:298
@ RTE_RELATION
Definition: parsenodes.h:1028
#define ACL_SELECT
Definition: parsenodes.h:77
#define planner_rt_fetch(rti, root)
Definition: pathnodes.h:560
static ListCell * list_head(const List *l)
Definition: pg_list.h:128
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:343
bool has_unique_index(RelOptInfo *rel, AttrNumber attno)
Definition: plancat.c:2191
static Datum Int16GetDatum(int16 X)
Definition: postgres.h:172
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
unsigned int Oid
Definition: postgres_ext.h:31
RelOptInfo * find_base_rel(PlannerInfo *root, int relid)
Definition: relnode.c:414
RelOptInfo * find_join_rel(PlannerInfo *root, Relids relids)
Definition: relnode.c:527
static void examine_simple_variable(PlannerInfo *root, Var *var, VariableStatData *vardata)
Definition: selfuncs.c:5406
get_index_stats_hook_type get_index_stats_hook
Definition: selfuncs.c:148
static void ReleaseDummy(HeapTuple tuple)
Definition: selfuncs.c:4971
Index parent_relid
Definition: pathnodes.h:2957
RTEKind rtekind
Definition: parsenodes.h:1057
Index relid
Definition: pathnodes.h:908
List * statlist
Definition: pathnodes.h:936
List * indexlist
Definition: pathnodes.h:934
Oid userid
Definition: pathnodes.h:956
Definition: primnodes.h:248
AttrNumber varattno
Definition: primnodes.h:260
int varno
Definition: primnodes.h:255
int32 atttypmod
Definition: selfuncs.h:94
void(* freefunc)(HeapTuple tuple)
Definition: selfuncs.h:91
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:266
HeapTuple SearchSysCache3(int cacheId, Datum key1, Datum key2, Datum key3)
Definition: syscache.c:240
Relids pull_varnos(PlannerInfo *root, Node *node)
Definition: var.c:108

References VariableStatData::acl_ok, ACL_SELECT, ACLCHECK_OK, arg, Assert, VariableStatData::atttype, VariableStatData::atttypmod, bms_free(), bms_get_singleton_member(), bms_is_empty, bms_is_member(), BoolGetDatum(), elog, equal(), ERROR, examine_simple_variable(), StatisticExtInfo::exprs, exprType(), exprTypmod(), find_base_rel(), find_join_rel(), VariableStatData::freefunc, get_index_stats_hook, GetUserId(), has_unique_index(), HeapTupleIsValid, if(), RelOptInfo::indexlist, RangeTblEntry::inh, StatisticExtInfo::inherit, Int16GetDatum(), IsA, VariableStatData::isunique, StatisticExtInfo::kind, lfirst, list_head(), lnext(), MemSet, NIL, ObjectIdGetDatum(), OidIsValid, AppendRelInfo::parent_relid, pg_class_aclcheck(), planner_rt_fetch, pull_varnos(), VariableStatData::rel, ReleaseDummy(), ReleaseSysCache(), RangeTblEntry::relid, RelOptInfo::relid, root, RTE_RELATION, RangeTblEntry::rtekind, SearchSysCache3(), statext_expressions_load(), RelOptInfo::statlist, StatisticExtInfo::statOid, VariableStatData::statsTuple, RelOptInfo::userid, VariableStatData::var, Var::varattno, Var::varno, and VariableStatData::vartype.

Referenced by booltestsel(), boolvarsel(), estimate_array_length(), estimate_hash_bucket_stats(), estimate_num_groups(), get_join_variables(), get_restriction_variable(), mergejoinscansel(), nulltestsel(), and scalararraysel_containment().

◆ generic_restriction_selectivity()

double generic_restriction_selectivity ( PlannerInfo root,
Oid  oproid,
Oid  collation,
List args,
int  varRelid,
double  default_selectivity 
)

Definition at line 914 of file selfuncs.c.

917 {
918  double selec;
919  VariableStatData vardata;
920  Node *other;
921  bool varonleft;
922 
923  /*
924  * If expression is not variable OP something or something OP variable,
925  * then punt and return the default estimate.
926  */
927  if (!get_restriction_variable(root, args, varRelid,
928  &vardata, &other, &varonleft))
929  return default_selectivity;
930 
931  /*
932  * If the something is a NULL constant, assume operator is strict and
933  * return zero, ie, operator will never return TRUE.
934  */
935  if (IsA(other, Const) &&
936  ((Const *) other)->constisnull)
937  {
938  ReleaseVariableStats(vardata);
939  return 0.0;
940  }
941 
942  if (IsA(other, Const))
943  {
944  /* Variable is being compared to a known non-null constant */
945  Datum constval = ((Const *) other)->constvalue;
946  FmgrInfo opproc;
947  double mcvsum;
948  double mcvsel;
949  double nullfrac;
950  int hist_size;
951 
952  fmgr_info(get_opcode(oproid), &opproc);
953 
954  /*
955  * Calculate the selectivity for the column's most common values.
956  */
957  mcvsel = mcv_selectivity(&vardata, &opproc, collation,
958  constval, varonleft,
959  &mcvsum);
960 
961  /*
962  * If the histogram is large enough, see what fraction of it matches
963  * the query, and assume that's representative of the non-MCV
964  * population. Otherwise use the default selectivity for the non-MCV
965  * population.
966  */
967  selec = histogram_selectivity(&vardata, &opproc, collation,
968  constval, varonleft,
969  10, 1, &hist_size);
970  if (selec < 0)
971  {
972  /* Nope, fall back on default */
973  selec = default_selectivity;
974  }
975  else if (hist_size < 100)
976  {
977  /*
978  * For histogram sizes from 10 to 100, we combine the histogram
979  * and default selectivities, putting increasingly more trust in
980  * the histogram for larger sizes.
981  */
982  double hist_weight = hist_size / 100.0;
983 
984  selec = selec * hist_weight +
985  default_selectivity * (1.0 - hist_weight);
986  }
987 
988  /* In any case, don't believe extremely small or large estimates. */
989  if (selec < 0.0001)
990  selec = 0.0001;
991  else if (selec > 0.9999)
992  selec = 0.9999;
993 
994  /* Don't forget to account for nulls. */
995  if (HeapTupleIsValid(vardata.statsTuple))
996  nullfrac = ((Form_pg_statistic) GETSTRUCT(vardata.statsTuple))->stanullfrac;
997  else
998  nullfrac = 0.0;
999 
1000  /*
1001  * Now merge the results from the MCV and histogram calculations,
1002  * realizing that the histogram covers only the non-null values that
1003  * are not listed in MCV.
1004  */
1005  selec *= 1.0 - nullfrac - mcvsum;
1006  selec += mcvsel;
1007  }
1008  else
1009  {
1010  /* Comparison value is not constant, so we can't do anything */
1011  selec = default_selectivity;
1012  }
1013 
1014  ReleaseVariableStats(vardata);
1015 
1016  /* result should be in range, but make sure... */
1017  CLAMP_PROBABILITY(selec);
1018 
1019  return selec;
1020 }
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Definition: fmgr.c:127
RegProcedure get_opcode(Oid opno)
Definition: lsyscache.c:1263
bool get_restriction_variable(PlannerInfo *root, List *args, int varRelid, VariableStatData *vardata, Node **other, bool *varonleft)
Definition: selfuncs.c:4883
double mcv_selectivity(VariableStatData *vardata, FmgrInfo *opproc, Oid collation, Datum constval, bool varonleft, double *sumcommonp)
Definition: selfuncs.c:732
double histogram_selectivity(VariableStatData *vardata, FmgrInfo *opproc, Oid collation, Datum constval, bool varonleft, int min_hist_size, int n_skip, int *hist_size)
Definition: selfuncs.c:823
Definition: fmgr.h:57

References generate_unaccent_rules::args, CLAMP_PROBABILITY, fmgr_info(), get_opcode(), get_restriction_variable(), GETSTRUCT, HeapTupleIsValid, histogram_selectivity(), IsA, mcv_selectivity(), ReleaseVariableStats, root, and VariableStatData::statsTuple.

Referenced by ltreeparentsel(), and matchingsel().

◆ genericcostestimate()

void genericcostestimate ( PlannerInfo root,
IndexPath path,
double  loop_count,
GenericCosts costs 
)

Definition at line 6544 of file selfuncs.c.

6548 {
6549  IndexOptInfo *index = path->indexinfo;
6550  List *indexQuals = get_quals_from_indexclauses(path->indexclauses);
6551  List *indexOrderBys = path->indexorderbys;
6552  Cost indexStartupCost;
6553  Cost indexTotalCost;
6554  Selectivity indexSelectivity;
6555  double indexCorrelation;
6556  double numIndexPages;
6557  double numIndexTuples;
6558  double spc_random_page_cost;
6559  double num_sa_scans;
6560  double num_outer_scans;
6561  double num_scans;
6562  double qual_op_cost;
6563  double qual_arg_cost;
6564  List *selectivityQuals;
6565  ListCell *l;
6566 
6567  /*
6568  * If the index is partial, AND the index predicate with the explicitly
6569  * given indexquals to produce a more accurate idea of the index
6570  * selectivity.
6571  */
6572  selectivityQuals = add_predicate_to_index_quals(index, indexQuals);
6573 
6574  /*
6575  * If caller didn't give us an estimate for ScalarArrayOpExpr index scans,
6576  * just assume that the number of index descents is the number of distinct
6577  * combinations of array elements from all of the scan's SAOP clauses.
6578  */
6579  num_sa_scans = costs->num_sa_scans;
6580  if (num_sa_scans < 1)
6581  {
6582  num_sa_scans = 1;
6583  foreach(l, indexQuals)
6584  {
6585  RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
6586 
6587  if (IsA(rinfo->clause, ScalarArrayOpExpr))
6588  {
6589  ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) rinfo->clause;
6590  double alength = estimate_array_length(root, lsecond(saop->args));
6591 
6592  if (alength > 1)
6593  num_sa_scans *= alength;
6594  }
6595  }
6596  }
6597 
6598  /* Estimate the fraction of main-table tuples that will be visited */
6599  indexSelectivity = clauselist_selectivity(root, selectivityQuals,
6600  index->rel->relid,
6601  JOIN_INNER,
6602  NULL);
6603 
6604  /*
6605  * If caller didn't give us an estimate, estimate the number of index
6606  * tuples that will be visited. We do it in this rather peculiar-looking
6607  * way in order to get the right answer for partial indexes.
6608  */
6609  numIndexTuples = costs->numIndexTuples;
6610  if (numIndexTuples <= 0.0)
6611  {
6612  numIndexTuples = indexSelectivity * index->rel->tuples;
6613 
6614  /*
6615  * The above calculation counts all the tuples visited across all
6616  * scans induced by ScalarArrayOpExpr nodes. We want to consider the
6617  * average per-indexscan number, so adjust. This is a handy place to
6618  * round to integer, too. (If caller supplied tuple estimate, it's
6619  * responsible for handling these considerations.)
6620  */
6621  numIndexTuples = rint(numIndexTuples / num_sa_scans);
6622  }
6623 
6624  /*
6625  * We can bound the number of tuples by the index size in any case. Also,
6626  * always estimate at least one tuple is touched, even when
6627  * indexSelectivity estimate is tiny.
6628  */
6629  if (numIndexTuples > index->tuples)
6630  numIndexTuples = index->tuples;
6631  if (numIndexTuples < 1.0)
6632  numIndexTuples = 1.0;
6633 
6634  /*
6635  * Estimate the number of index pages that will be retrieved.
6636  *
6637  * We use the simplistic method of taking a pro-rata fraction of the total
6638  * number of index pages. In effect, this counts only leaf pages and not
6639  * any overhead such as index metapage or upper tree levels.
6640  *
6641  * In practice access to upper index levels is often nearly free because
6642  * those tend to stay in cache under load; moreover, the cost involved is
6643  * highly dependent on index type. We therefore ignore such costs here
6644  * and leave it to the caller to add a suitable charge if needed.
6645  */
6646  if (index->pages > 1 && index->tuples > 1)
6647  numIndexPages = ceil(numIndexTuples * index->pages / index->tuples);
6648  else
6649  numIndexPages = 1.0;
6650 
6651  /* fetch estimated page cost for tablespace containing index */
6652  get_tablespace_page_costs(index->reltablespace,
6653  &spc_random_page_cost,
6654  NULL);
6655 
6656  /*
6657  * Now compute the disk access costs.
6658  *
6659  * The above calculations are all per-index-scan. However, if we are in a
6660  * nestloop inner scan, we can expect the scan to be repeated (with
6661  * different search keys) for each row of the outer relation. Likewise,
6662  * ScalarArrayOpExpr quals result in multiple index scans. This creates
6663  * the potential for cache effects to reduce the number of disk page
6664  * fetches needed. We want to estimate the average per-scan I/O cost in
6665  * the presence of caching.
6666  *
6667  * We use the Mackert-Lohman formula (see costsize.c for details) to
6668  * estimate the total number of page fetches that occur. While this
6669  * wasn't what it was designed for, it seems a reasonable model anyway.
6670  * Note that we are counting pages not tuples anymore, so we take N = T =
6671  * index size, as if there were one "tuple" per page.
6672  */
6673  num_outer_scans = loop_count;
6674  num_scans = num_sa_scans * num_outer_scans;
6675 
6676  if (num_scans > 1)
6677  {
6678  double pages_fetched;
6679 
6680  /* total page fetches ignoring cache effects */
6681  pages_fetched = numIndexPages * num_scans;
6682 
6683  /* use Mackert and Lohman formula to adjust for cache effects */
6684  pages_fetched = index_pages_fetched(pages_fetched,
6685  index->pages,
6686  (double) index->pages,
6687  root);
6688 
6689  /*
6690  * Now compute the total disk access cost, and then report a pro-rated
6691  * share for each outer scan. (Don't pro-rate for ScalarArrayOpExpr,
6692  * since that's internal to the indexscan.)
6693  */
6694  indexTotalCost = (pages_fetched * spc_random_page_cost)
6695  / num_outer_scans;
6696  }
6697  else
6698  {
6699  /*
6700  * For a single index scan, we just charge spc_random_page_cost per
6701  * page touched.
6702  */
6703  indexTotalCost = numIndexPages * spc_random_page_cost;
6704  }
6705 
6706  /*
6707  * CPU cost: any complex expressions in the indexquals will need to be
6708  * evaluated once at the start of the scan to reduce them to runtime keys
6709  * to pass to the index AM (see nodeIndexscan.c). We model the per-tuple
6710  * CPU costs as cpu_index_tuple_cost plus one cpu_operator_cost per
6711  * indexqual operator. Because we have numIndexTuples as a per-scan
6712  * number, we have to multiply by num_sa_scans to get the correct result
6713  * for ScalarArrayOpExpr cases. Similarly add in costs for any index
6714  * ORDER BY expressions.
6715  *
6716  * Note: this neglects the possible costs of rechecking lossy operators.
6717  * Detecting that that might be needed seems more expensive than it's
6718  * worth, though, considering all the other inaccuracies here ...
6719  */
6720  qual_arg_cost = index_other_operands_eval_cost(root, indexQuals) +
6721  index_other_operands_eval_cost(root, indexOrderBys);
6722  qual_op_cost = cpu_operator_cost *
6723  (list_length(indexQuals) + list_length(indexOrderBys));
6724 
6725  indexStartupCost = qual_arg_cost;
6726  indexTotalCost += qual_arg_cost;
6727  indexTotalCost += numIndexTuples * num_sa_scans * (cpu_index_tuple_cost + qual_op_cost);
6728 
6729  /*
6730  * Generic assumption about index correlation: there isn't any.
6731  */
6732  indexCorrelation = 0.0;
6733 
6734  /*
6735  * Return everything to caller.
6736  */
6737  costs->indexStartupCost = indexStartupCost;
6738  costs->indexTotalCost = indexTotalCost;
6739  costs->indexSelectivity = indexSelectivity;
6740  costs->indexCorrelation = indexCorrelation;
6741  costs->numIndexPages = numIndexPages;
6742  costs->numIndexTuples = numIndexTuples;
6743  costs->spc_random_page_cost = spc_random_page_cost;
6744  costs->num_sa_scans = num_sa_scans;
6745 }
Selectivity clauselist_selectivity(PlannerInfo *root, List *clauses, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo)
Definition: clausesel.c:100
double cpu_operator_cost
Definition: costsize.c:123
double index_pages_fetched(double tuples_fetched, BlockNumber pages, double index_pages, PlannerInfo *root)
Definition: costsize.c:898
double cpu_index_tuple_cost
Definition: costsize.c:122
double Cost
Definition: nodes.h:251
@ JOIN_INNER
Definition: nodes.h:293
#define lsecond(l)
Definition: pg_list.h:183
List * get_quals_from_indexclauses(List *indexclauses)
Definition: selfuncs.c:6460
double estimate_array_length(PlannerInfo *root, Node *arrayexpr)
Definition: selfuncs.c:2136
List * add_predicate_to_index_quals(IndexOptInfo *index, List *indexQuals)
Definition: selfuncs.c:6767
Cost index_other_operands_eval_cost(PlannerInfo *root, List *indexquals)
Definition: selfuncs.c:6490
void get_tablespace_page_costs(Oid spcid, double *spc_random_page_cost, double *spc_seq_page_cost)
Definition: spccache.c:182
Selectivity indexSelectivity
Definition: selfuncs.h:127
Cost indexStartupCost
Definition: selfuncs.h:125
double indexCorrelation
Definition: selfuncs.h:128
double spc_random_page_cost
Definition: selfuncs.h:133
double num_sa_scans
Definition: selfuncs.h:134
Cost indexTotalCost
Definition: selfuncs.h:126
double numIndexPages
Definition: selfuncs.h:131
double numIndexTuples
Definition: selfuncs.h:132
List * indexclauses
Definition: pathnodes.h:1700
List * indexorderbys
Definition: pathnodes.h:1701
IndexOptInfo * indexinfo
Definition: pathnodes.h:1699
Expr * clause
Definition: pathnodes.h:2552

References add_predicate_to_index_quals(), ScalarArrayOpExpr::args, RestrictInfo::clause, clauselist_selectivity(), cpu_index_tuple_cost, cpu_operator_cost, estimate_array_length(), get_quals_from_indexclauses(), get_tablespace_page_costs(), index_other_operands_eval_cost(), index_pages_fetched(), IndexPath::indexclauses, GenericCosts::indexCorrelation, IndexPath::indexinfo, IndexPath::indexorderbys, GenericCosts::indexSelectivity, GenericCosts::indexStartupCost, GenericCosts::indexTotalCost, IsA, JOIN_INNER, lfirst, list_length(), lsecond, GenericCosts::num_sa_scans, GenericCosts::numIndexPages, GenericCosts::numIndexTuples, root, and GenericCosts::spc_random_page_cost.

Referenced by blcostestimate(), btcostestimate(), gistcostestimate(), hashcostestimate(), and spgcostestimate().

◆ get_join_variables()

void get_join_variables ( PlannerInfo root,
List args,
SpecialJoinInfo sjinfo,
VariableStatData vardata1,
VariableStatData vardata2,
bool join_is_reversed 
)

Definition at line 4943 of file selfuncs.c.

4946 {
4947  Node *left,
4948  *right;
4949 
4950  if (list_length(args) != 2)
4951  elog(ERROR, "join operator should take two arguments");
4952 
4953  left = (Node *) linitial(args);
4954  right = (Node *) lsecond(args);
4955 
4956  examine_variable(root, left, 0, vardata1);
4957  examine_variable(root, right, 0, vardata2);
4958 
4959  if (vardata1->rel &&
4960  bms_is_subset(vardata1->rel->relids, sjinfo->syn_righthand))
4961  *join_is_reversed = true; /* var1 is on RHS */
4962  else if (vardata2->rel &&
4963  bms_is_subset(vardata2->rel->relids, sjinfo->syn_lefthand))
4964  *join_is_reversed = true; /* var2 is on LHS */
4965  else
4966  *join_is_reversed = false;
4967 }
bool bms_is_subset(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:412
Relids relids
Definition: pathnodes.h:861
Relids syn_lefthand
Definition: pathnodes.h:2884
Relids syn_righthand
Definition: pathnodes.h:2885

References generate_unaccent_rules::args, bms_is_subset(), elog, ERROR, examine_variable(), linitial, list_length(), lsecond, VariableStatData::rel, RelOptInfo::relids, root, SpecialJoinInfo::syn_lefthand, and SpecialJoinInfo::syn_righthand.

Referenced by eqjoinsel(), neqjoinsel(), and networkjoinsel().

◆ get_quals_from_indexclauses()

List* get_quals_from_indexclauses ( List indexclauses)

Definition at line 6460 of file selfuncs.c.

6461 {
6462  List *result = NIL;
6463  ListCell *lc;
6464 
6465  foreach(lc, indexclauses)
6466  {
6467  IndexClause *iclause = lfirst_node(IndexClause, lc);
6468  ListCell *lc2;
6469 
6470  foreach(lc2, iclause->indexquals)
6471  {
6472  RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc2);
6473 
6474  result = lappend(result, rinfo);
6475  }
6476  }
6477  return result;
6478 }
#define lfirst_node(type, lc)
Definition: pg_list.h:176
List * indexquals
Definition: pathnodes.h:1748

References IndexClause::indexquals, lappend(), lfirst_node, and NIL.

Referenced by brincostestimate(), genericcostestimate(), and gincostestimate().

◆ get_restriction_variable()

bool get_restriction_variable ( PlannerInfo root,
List args,
int  varRelid,
VariableStatData vardata,
Node **  other,
bool varonleft 
)

Definition at line 4883 of file selfuncs.c.

4886 {
4887  Node *left,
4888  *right;
4889  VariableStatData rdata;
4890 
4891  /* Fail if not a binary opclause (probably shouldn't happen) */
4892  if (list_length(args) != 2)
4893  return false;
4894 
4895  left = (Node *) linitial(args);
4896  right = (Node *) lsecond(args);
4897 
4898  /*
4899  * Examine both sides. Note that when varRelid is nonzero, Vars of other
4900  * relations will be treated as pseudoconstants.
4901  */
4902  examine_variable(root, left, varRelid, vardata);
4903  examine_variable(root, right, varRelid, &rdata);
4904 
4905  /*
4906  * If one side is a variable and the other not, we win.
4907  */
4908  if (vardata->rel && rdata.rel == NULL)
4909  {
4910  *varonleft = true;
4911  *other = estimate_expression_value(root, rdata.var);
4912  /* Assume we need no ReleaseVariableStats(rdata) here */
4913  return true;
4914  }
4915 
4916  if (vardata->rel == NULL && rdata.rel)
4917  {
4918  *varonleft = false;
4919  *other = estimate_expression_value(root, vardata->var);
4920  /* Assume we need no ReleaseVariableStats(*vardata) here */
4921  *vardata = rdata;
4922  return true;
4923  }
4924 
4925  /* Oops, clause has wrong structure (probably var op var) */
4926  ReleaseVariableStats(*vardata);
4927  ReleaseVariableStats(rdata);
4928 
4929  return false;
4930 }
Node * estimate_expression_value(PlannerInfo *root, Node *node)
Definition: clauses.c:2395

References generate_unaccent_rules::args, estimate_expression_value(), examine_variable(), linitial, list_length(), lsecond, VariableStatData::rel, ReleaseVariableStats, root, and VariableStatData::var.

Referenced by _int_matchsel(), arraycontsel(), eqsel_internal(), generic_restriction_selectivity(), multirangesel(), networksel(), patternsel_common(), rangesel(), scalarineqsel_wrapper(), and tsmatchsel().

◆ get_variable_numdistinct()

double get_variable_numdistinct ( VariableStatData vardata,
bool isdefault 
)

Definition at line 5764 of file selfuncs.c.

5765 {
5766  double stadistinct;
5767  double stanullfrac = 0.0;
5768  double ntuples;
5769 
5770  *isdefault = false;
5771 
5772  /*
5773  * Determine the stadistinct value to use. There are cases where we can
5774  * get an estimate even without a pg_statistic entry, or can get a better
5775  * value than is in pg_statistic. Grab stanullfrac too if we can find it
5776  * (otherwise, assume no nulls, for lack of any better idea).
5777  */
5778  if (HeapTupleIsValid(vardata->statsTuple))
5779  {
5780  /* Use the pg_statistic entry */
5781  Form_pg_statistic stats;
5782 
5783  stats = (Form_pg_statistic) GETSTRUCT(vardata->statsTuple);
5784  stadistinct = stats->stadistinct;
5785  stanullfrac = stats->stanullfrac;
5786  }
5787  else if (vardata->vartype == BOOLOID)
5788  {
5789  /*
5790  * Special-case boolean columns: presumably, two distinct values.
5791  *
5792  * Are there any other datatypes we should wire in special estimates
5793  * for?
5794  */
5795  stadistinct = 2.0;
5796  }
5797  else if (vardata->rel && vardata->rel->rtekind == RTE_VALUES)
5798  {
5799  /*
5800  * If the Var represents a column of a VALUES RTE, assume it's unique.
5801  * This could of course be very wrong, but it should tend to be true
5802  * in well-written queries. We could consider examining the VALUES'
5803  * contents to get some real statistics; but that only works if the
5804  * entries are all constants, and it would be pretty expensive anyway.
5805  */
5806  stadistinct = -1.0; /* unique (and all non null) */
5807  }
5808  else
5809  {
5810  /*
5811  * We don't keep statistics for system columns, but in some cases we
5812  * can infer distinctness anyway.
5813  */
5814  if (vardata->var && IsA(vardata->var, Var))
5815  {
5816  switch (((Var *) vardata->var)->varattno)
5817  {
5819  stadistinct = -1.0; /* unique (and all non null) */
5820  break;
5822  stadistinct = 1.0; /* only 1 value */
5823  break;
5824  default:
5825  stadistinct = 0.0; /* means "unknown" */
5826  break;
5827  }
5828  }
5829  else
5830  stadistinct = 0.0; /* means "unknown" */
5831 
5832  /*
5833  * XXX consider using estimate_num_groups on expressions?
5834  */
5835  }
5836 
5837  /*
5838  * If there is a unique index or DISTINCT clause for the variable, assume
5839  * it is unique no matter what pg_statistic says; the statistics could be
5840  * out of date, or we might have found a partial unique index that proves
5841  * the var is unique for this query. However, we'd better still believe
5842  * the null-fraction statistic.
5843  */
5844  if (vardata->isunique)
5845  stadistinct = -1.0 * (1.0 - stanullfrac);
5846 
5847  /*
5848  * If we had an absolute estimate, use that.
5849  */
5850  if (stadistinct > 0.0)
5851  return clamp_row_est(stadistinct);
5852 
5853  /*
5854  * Otherwise we need to get the relation size; punt if not available.
5855  */
5856  if (vardata->rel == NULL)
5857  {
5858  *isdefault = true;
5859  return DEFAULT_NUM_DISTINCT;
5860  }
5861  ntuples = vardata->rel->tuples;
5862  if (ntuples <= 0.0)
5863  {
5864  *isdefault = true;
5865  return DEFAULT_NUM_DISTINCT;
5866  }
5867 
5868  /*
5869  * If we had a relative estimate, use that.
5870  */
5871  if (stadistinct < 0.0)
5872  return clamp_row_est(-stadistinct * ntuples);
5873 
5874  /*
5875  * With no data, estimate ndistinct = ntuples if the table is small, else
5876  * use default. We use DEFAULT_NUM_DISTINCT as the cutoff for "small" so
5877  * that the behavior isn't discontinuous.
5878  */
5879  if (ntuples < DEFAULT_NUM_DISTINCT)
5880  return clamp_row_est(ntuples);
5881 
5882  *isdefault = true;
5883  return DEFAULT_NUM_DISTINCT;
5884 }
@ RTE_VALUES
Definition: parsenodes.h:1033
#define DEFAULT_NUM_DISTINCT
Definition: selfuncs.h:52
RTEKind rtekind
Definition: pathnodes.h:912
#define TableOidAttributeNumber
Definition: sysattr.h:26
#define SelfItemPointerAttributeNumber
Definition: sysattr.h:21

References clamp_row_est(), DEFAULT_NUM_DISTINCT, GETSTRUCT, HeapTupleIsValid, IsA, VariableStatData::isunique, VariableStatData::rel, RTE_VALUES, RelOptInfo::rtekind, SelfItemPointerAttributeNumber, VariableStatData::statsTuple, TableOidAttributeNumber, RelOptInfo::tuples, VariableStatData::var, and VariableStatData::vartype.

Referenced by add_unique_group_var(), eqjoinsel(), estimate_hash_bucket_stats(), ineq_histogram_selectivity(), var_eq_const(), and var_eq_non_const().

◆ histogram_selectivity()

double histogram_selectivity ( VariableStatData vardata,
FmgrInfo opproc,
Oid  collation,
Datum  constval,
bool  varonleft,
int  min_hist_size,
int  n_skip,
int *  hist_size 
)

Definition at line 823 of file selfuncs.c.

828 {
829  double result;
830  AttStatsSlot sslot;
831 
832  /* check sanity of parameters */
833  Assert(n_skip >= 0);
834  Assert(min_hist_size > 2 * n_skip);
835 
836  if (HeapTupleIsValid(vardata->statsTuple) &&
837  statistic_proc_security_check(vardata, opproc->fn_oid) &&
838  get_attstatsslot(&sslot, vardata->statsTuple,
839  STATISTIC_KIND_HISTOGRAM, InvalidOid,
841  {
842  *hist_size = sslot.nvalues;
843  if (sslot.nvalues >= min_hist_size)
844  {
845  LOCAL_FCINFO(fcinfo, 2);
846  int nmatch = 0;
847  int i;
848 
849  /*
850  * We invoke the opproc "by hand" so that we won't fail on NULL
851  * results. Such cases won't arise for normal comparison
852  * functions, but generic_restriction_selectivity could perhaps be
853  * used with operators that can return NULL. A small side benefit
854  * is to not need to re-initialize the fcinfo struct from scratch
855  * each time.
856  */
857  InitFunctionCallInfoData(*fcinfo, opproc, 2, collation,
858  NULL, NULL);
859  fcinfo->args[0].isnull = false;
860  fcinfo->args[1].isnull = false;
861  /* be careful to apply operator right way 'round */
862  if (varonleft)
863  fcinfo->args[1].value = constval;
864  else
865  fcinfo->args[0].value = constval;
866 
867  for (i = n_skip; i < sslot.nvalues - n_skip; i++)
868  {
869  Datum fresult;
870 
871  if (varonleft)
872  fcinfo->args[0].value = sslot.values[i];
873  else
874  fcinfo->args[1].value = sslot.values[i];
875  fcinfo->isnull = false;
876  fresult = FunctionCallInvoke(fcinfo);
877  if (!fcinfo->isnull && DatumGetBool(fresult))
878  nmatch++;
879  }
880  result = ((double) nmatch) / ((double) (sslot.nvalues - 2 * n_skip));
881  }
882  else
883  result = -1;
884  free_attstatsslot(&sslot);
885  }
886  else
887  {
888  *hist_size = 0;
889  result = -1;
890  }
891 
892  return result;
893 }
#define InitFunctionCallInfoData(Fcinfo, Flinfo, Nargs, Collation, Context, Resultinfo)
Definition: fmgr.h:150
#define LOCAL_FCINFO(name, nargs)
Definition: fmgr.h:110
#define FunctionCallInvoke(fcinfo)
Definition: fmgr.h:172
bool statistic_proc_security_check(VariableStatData *vardata, Oid func_oid)
Definition: selfuncs.c:5735
Oid fn_oid
Definition: fmgr.h:59

References Assert, ATTSTATSSLOT_VALUES, DatumGetBool(), FmgrInfo::fn_oid, free_attstatsslot(), FunctionCallInvoke, get_attstatsslot(), HeapTupleIsValid, i, InitFunctionCallInfoData, InvalidOid, LOCAL_FCINFO, AttStatsSlot::nvalues, statistic_proc_security_check(), VariableStatData::statsTuple, and AttStatsSlot::values.

Referenced by generic_restriction_selectivity(), and patternsel_common().

◆ index_other_operands_eval_cost()

Cost index_other_operands_eval_cost ( PlannerInfo root,
List indexquals 
)

Definition at line 6490 of file selfuncs.c.

6491 {
6492  Cost qual_arg_cost = 0;
6493  ListCell *lc;
6494 
6495  foreach(lc, indexquals)
6496  {
6497  Expr *clause = (Expr *) lfirst(lc);
6498  Node *other_operand;
6499  QualCost index_qual_cost;
6500 
6501  /*
6502  * Index quals will have RestrictInfos, indexorderbys won't. Look
6503  * through RestrictInfo if present.
6504  */
6505  if (IsA(clause, RestrictInfo))
6506  clause = ((RestrictInfo *) clause)->clause;
6507 
6508  if (IsA(clause, OpExpr))
6509  {
6510  OpExpr *op = (OpExpr *) clause;
6511 
6512  other_operand = (Node *) lsecond(op->args);
6513  }
6514  else if (IsA(clause, RowCompareExpr))
6515  {
6516  RowCompareExpr *rc = (RowCompareExpr *) clause;
6517 
6518  other_operand = (Node *) rc->rargs;
6519  }
6520  else if (IsA(clause, ScalarArrayOpExpr))
6521  {
6522  ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) clause;
6523 
6524  other_operand = (Node *) lsecond(saop->args);
6525  }
6526  else if (IsA(clause, NullTest))
6527  {
6528  other_operand = NULL;
6529  }
6530  else
6531  {
6532  elog(ERROR, "unsupported indexqual type: %d",
6533  (int) nodeTag(clause));
6534  other_operand = NULL; /* keep compiler quiet */
6535  }
6536 
6537  cost_qual_eval_node(&index_qual_cost, other_operand, root);
6538  qual_arg_cost += index_qual_cost.startup + index_qual_cost.per_tuple;
6539  }
6540  return qual_arg_cost;
6541 }
void cost_qual_eval_node(QualCost *cost, Node *qual, PlannerInfo *root)
Definition: costsize.c:4666
#define nodeTag(nodeptr)
Definition: nodes.h:133
List * args
Definition: primnodes.h:806
Cost per_tuple
Definition: pathnodes.h:48
Cost startup
Definition: pathnodes.h:47

References OpExpr::args, ScalarArrayOpExpr::args, cost_qual_eval_node(), elog, ERROR, IsA, lfirst, lsecond, nodeTag, QualCost::per_tuple, RowCompareExpr::rargs, root, and QualCost::startup.

Referenced by brincostestimate(), genericcostestimate(), and gincostestimate().

◆ ineq_histogram_selectivity()

double ineq_histogram_selectivity ( PlannerInfo root,
VariableStatData vardata,
Oid  opoid,
FmgrInfo opproc,
bool  isgt,
bool  iseq,
Oid  collation,
Datum  constval,
Oid  consttype 
)

Definition at line 1041 of file selfuncs.c.

1046 {
1047  double hist_selec;
1048  AttStatsSlot sslot;
1049 
1050  hist_selec = -1.0;
1051 
1052  /*
1053  * Someday, ANALYZE might store more than one histogram per rel/att,
1054  * corresponding to more than one possible sort ordering defined for the
1055  * column type. Right now, we know there is only one, so just grab it and
1056  * see if it matches the query.
1057  *
1058  * Note that we can't use opoid as search argument; the staop appearing in
1059  * pg_statistic will be for the relevant '<' operator, but what we have
1060  * might be some other inequality operator such as '>='. (Even if opoid
1061  * is a '<' operator, it could be cross-type.) Hence we must use
1062  * comparison_ops_are_compatible() to see if the operators match.
1063  */
1064  if (HeapTupleIsValid(vardata->statsTuple) &&
1065  statistic_proc_security_check(vardata, opproc->fn_oid) &&
1066  get_attstatsslot(&sslot, vardata->statsTuple,
1067  STATISTIC_KIND_HISTOGRAM, InvalidOid,
1069  {
1070  if (sslot.nvalues > 1 &&
1071  sslot.stacoll == collation &&
1072  comparison_ops_are_compatible(sslot.staop, opoid))
1073  {
1074  /*
1075  * Use binary search to find the desired location, namely the
1076  * right end of the histogram bin containing the comparison value,
1077  * which is the leftmost entry for which the comparison operator
1078  * succeeds (if isgt) or fails (if !isgt).
1079  *
1080  * In this loop, we pay no attention to whether the operator iseq
1081  * or not; that detail will be mopped up below. (We cannot tell,
1082  * anyway, whether the operator thinks the values are equal.)
1083  *
1084  * If the binary search accesses the first or last histogram
1085  * entry, we try to replace that endpoint with the true column min
1086  * or max as found by get_actual_variable_range(). This
1087  * ameliorates misestimates when the min or max is moving as a
1088  * result of changes since the last ANALYZE. Note that this could
1089  * result in effectively including MCVs into the histogram that
1090  * weren't there before, but we don't try to correct for that.
1091  */
1092  double histfrac;
1093  int lobound = 0; /* first possible slot to search */
1094  int hibound = sslot.nvalues; /* last+1 slot to search */
1095  bool have_end = false;
1096 
1097  /*
1098  * If there are only two histogram entries, we'll want up-to-date
1099  * values for both. (If there are more than two, we need at most
1100  * one of them to be updated, so we deal with that within the
1101  * loop.)
1102  */
1103  if (sslot.nvalues == 2)
1104  have_end = get_actual_variable_range(root,
1105  vardata,
1106  sslot.staop,
1107  collation,
1108  &sslot.values[0],
1109  &sslot.values[1]);
1110 
1111  while (lobound < hibound)
1112  {
1113  int probe = (lobound + hibound) / 2;
1114  bool ltcmp;
1115 
1116  /*
1117  * If we find ourselves about to compare to the first or last
1118  * histogram entry, first try to replace it with the actual
1119  * current min or max (unless we already did so above).
1120  */
1121  if (probe == 0 && sslot.nvalues > 2)
1122  have_end = get_actual_variable_range(root,
1123  vardata,
1124  sslot.staop,
1125  collation,
1126  &sslot.values[0],
1127  NULL);
1128  else if (probe == sslot.nvalues - 1 && sslot.nvalues > 2)
1129  have_end = get_actual_variable_range(root,
1130  vardata,
1131  sslot.staop,
1132  collation,
1133  NULL,
1134  &sslot.values[probe]);
1135 
1136  ltcmp = DatumGetBool(FunctionCall2Coll(opproc,
1137  collation,
1138  sslot.values[probe],
1139  constval));
1140  if (isgt)
1141  ltcmp = !ltcmp;
1142  if (ltcmp)
1143  lobound = probe + 1;
1144  else
1145  hibound = probe;
1146  }
1147 
1148  if (lobound <= 0)
1149  {
1150  /*
1151  * Constant is below lower histogram boundary. More
1152  * precisely, we have found that no entry in the histogram
1153  * satisfies the inequality clause (if !isgt) or they all do
1154  * (if isgt). We estimate that that's true of the entire
1155  * table, so set histfrac to 0.0 (which we'll flip to 1.0
1156  * below, if isgt).
1157  */
1158  histfrac = 0.0;
1159  }
1160  else if (lobound >= sslot.nvalues)
1161  {
1162  /*
1163  * Inverse case: constant is above upper histogram boundary.
1164  */
1165  histfrac = 1.0;
1166  }
1167  else
1168  {
1169  /* We have values[i-1] <= constant <= values[i]. */
1170  int i = lobound;
1171  double eq_selec = 0;
1172  double val,
1173  high,
1174  low;
1175  double binfrac;
1176 
1177  /*
1178  * In the cases where we'll need it below, obtain an estimate
1179  * of the selectivity of "x = constval". We use a calculation
1180  * similar to what var_eq_const() does for a non-MCV constant,
1181  * ie, estimate that all distinct non-MCV values occur equally
1182  * often. But multiplication by "1.0 - sumcommon - nullfrac"
1183  * will be done by our caller, so we shouldn't do that here.
1184  * Therefore we can't try to clamp the estimate by reference
1185  * to the least common MCV; the result would be too small.
1186  *
1187  * Note: since this is effectively assuming that constval
1188  * isn't an MCV, it's logically dubious if constval in fact is
1189  * one. But we have to apply *some* correction for equality,
1190  * and anyway we cannot tell if constval is an MCV, since we
1191  * don't have a suitable equality operator at hand.
1192  */
1193  if (i == 1 || isgt == iseq)
1194  {
1195  double otherdistinct;
1196  bool isdefault;
1197  AttStatsSlot mcvslot;
1198 
1199  /* Get estimated number of distinct values */
1200  otherdistinct = get_variable_numdistinct(vardata,
1201  &isdefault);
1202 
1203  /* Subtract off the number of known MCVs */
1204  if (get_attstatsslot(&mcvslot, vardata->statsTuple,
1205  STATISTIC_KIND_MCV, InvalidOid,
1207  {
1208  otherdistinct -= mcvslot.nnumbers;
1209  free_attstatsslot(&mcvslot);
1210  }
1211 
1212  /* If result doesn't seem sane, leave eq_selec at 0 */
1213  if (otherdistinct > 1)
1214  eq_selec = 1.0 / otherdistinct;
1215  }
1216 
1217  /*
1218  * Convert the constant and the two nearest bin boundary
1219  * values to a uniform comparison scale, and do a linear
1220  * interpolation within this bin.
1221  */
1222  if (convert_to_scalar(constval, consttype, collation,
1223  &val,
1224  sslot.values[i - 1], sslot.values[i],
1225  vardata->vartype,
1226  &low, &high))
1227  {
1228  if (high <= low)
1229  {
1230  /* cope if bin boundaries appear identical */
1231  binfrac = 0.5;
1232  }
1233  else if (val <= low)
1234  binfrac = 0.0;
1235  else if (val >= high)
1236  binfrac = 1.0;
1237  else
1238  {
1239  binfrac = (val - low) / (high - low);
1240 
1241  /*
1242  * Watch out for the possibility that we got a NaN or
1243  * Infinity from the division. This can happen
1244  * despite the previous checks, if for example "low"
1245  * is -Infinity.
1246  */
1247  if (isnan(binfrac) ||
1248  binfrac < 0.0 || binfrac > 1.0)
1249  binfrac = 0.5;
1250  }
1251  }
1252  else
1253  {
1254  /*
1255  * Ideally we'd produce an error here, on the grounds that
1256  * the given operator shouldn't have scalarXXsel
1257  * registered as its selectivity func unless we can deal
1258  * with its operand types. But currently, all manner of
1259  * stuff is invoking scalarXXsel, so give a default
1260  * estimate until that can be fixed.
1261  */
1262  binfrac = 0.5;
1263  }
1264 
1265  /*
1266  * Now, compute the overall selectivity across the values
1267  * represented by the histogram. We have i-1 full bins and
1268  * binfrac partial bin below the constant.
1269  */
1270  histfrac = (double) (i - 1) + binfrac;
1271  histfrac /= (double) (sslot.nvalues - 1);
1272 
1273  /*
1274  * At this point, histfrac is an estimate of the fraction of
1275  * the population represented by the histogram that satisfies
1276  * "x <= constval". Somewhat remarkably, this statement is
1277  * true regardless of which operator we were doing the probes
1278  * with, so long as convert_to_scalar() delivers reasonable
1279  * results. If the probe constant is equal to some histogram
1280  * entry, we would have considered the bin to the left of that
1281  * entry if probing with "<" or ">=", or the bin to the right
1282  * if probing with "<=" or ">"; but binfrac would have come
1283  * out as 1.0 in the first case and 0.0 in the second, leading
1284  * to the same histfrac in either case. For probe constants
1285  * between histogram entries, we find the same bin and get the
1286  * same estimate with any operator.
1287  *
1288  * The fact that the estimate corresponds to "x <= constval"
1289  * and not "x < constval" is because of the way that ANALYZE
1290  * constructs the histogram: each entry is, effectively, the
1291  * rightmost value in its sample bucket. So selectivity
1292  * values that are exact multiples of 1/(histogram_size-1)
1293  * should be understood as estimates including a histogram
1294  * entry plus everything to its left.
1295  *
1296  * However, that breaks down for the first histogram entry,
1297  * which necessarily is the leftmost value in its sample
1298  * bucket. That means the first histogram bin is slightly
1299  * narrower than the rest, by an amount equal to eq_selec.
1300  * Another way to say that is that we want "x <= leftmost" to
1301  * be estimated as eq_selec not zero. So, if we're dealing
1302  * with the first bin (i==1), rescale to make that true while
1303  * adjusting the rest of that bin linearly.
1304  */
1305  if (i == 1)
1306  histfrac += eq_selec * (1.0 - binfrac);
1307 
1308  /*
1309  * "x <= constval" is good if we want an estimate for "<=" or
1310  * ">", but if we are estimating for "<" or ">=", we now need
1311  * to decrease the estimate by eq_selec.
1312  */
1313  if (isgt == iseq)
1314  histfrac -= eq_selec;
1315  }
1316 
1317  /*
1318  * Now the estimate is finished for "<" and "<=" cases. If we are
1319  * estimating for ">" or ">=", flip it.
1320  */
1321  hist_selec = isgt ? (1.0 - histfrac) : histfrac;
1322 
1323  /*
1324  * The histogram boundaries are only approximate to begin with,
1325  * and may well be out of date anyway. Therefore, don't believe
1326  * extremely small or large selectivity estimates --- unless we
1327  * got actual current endpoint values from the table, in which
1328  * case just do the usual sanity clamp. Somewhat arbitrarily, we
1329  * set the cutoff for other cases at a hundredth of the histogram
1330  * resolution.
1331  */
1332  if (have_end)
1333  CLAMP_PROBABILITY(hist_selec);
1334  else
1335  {
1336  double cutoff = 0.01 / (double) (sslot.nvalues - 1);
1337 
1338  if (hist_selec < cutoff)
1339  hist_selec = cutoff;
1340  else if (hist_selec > 1.0 - cutoff)
1341  hist_selec = 1.0 - cutoff;
1342  }
1343  }
1344  else if (sslot.nvalues > 1)
1345  {
1346  /*
1347  * If we get here, we have a histogram but it's not sorted the way
1348  * we want. Do a brute-force search to see how many of the
1349  * entries satisfy the comparison condition, and take that
1350  * fraction as our estimate. (This is identical to the inner loop
1351  * of histogram_selectivity; maybe share code?)
1352  */
1353  LOCAL_FCINFO(fcinfo, 2);
1354  int nmatch = 0;
1355 
1356  InitFunctionCallInfoData(*fcinfo, opproc, 2, collation,
1357  NULL, NULL);
1358  fcinfo->args[0].isnull = false;
1359  fcinfo->args[1].isnull = false;
1360  fcinfo->args[1].value = constval;
1361  for (int i = 0; i < sslot.nvalues; i++)
1362  {
1363  Datum fresult;
1364 
1365  fcinfo->args[0].value = sslot.values[i];
1366  fcinfo->isnull = false;
1367  fresult = FunctionCallInvoke(fcinfo);
1368  if (!fcinfo->isnull && DatumGetBool(fresult))
1369  nmatch++;
1370  }
1371  hist_selec = ((double) nmatch) / ((double) sslot.nvalues);
1372 
1373  /*
1374  * As above, clamp to a hundredth of the histogram resolution.
1375  * This case is surely even less trustworthy than the normal one,
1376  * so we shouldn't believe exact 0 or 1 selectivity. (Maybe the
1377  * clamp should be more restrictive in this case?)
1378  */
1379  {
1380  double cutoff = 0.01 / (double) (sslot.nvalues - 1);
1381 
1382  if (hist_selec < cutoff)
1383  hist_selec = cutoff;
1384  else if (hist_selec > 1.0 - cutoff)
1385  hist_selec = 1.0 - cutoff;
1386  }
1387  }
1388 
1389  free_attstatsslot(&sslot);
1390  }
1391 
1392  return hist_selec;
1393 }
Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
Definition: fmgr.c:1149
long val
Definition: informix.c:670
bool comparison_ops_are_compatible(Oid opno1, Oid opno2)
Definition: lsyscache.c:749
static bool convert_to_scalar(Datum value, Oid valuetypid, Oid collid, double *scaledvalue, Datum lobound, Datum hibound, Oid boundstypid, double *scaledlobound, double *scaledhibound)
Definition: selfuncs.c:4305
static bool get_actual_variable_range(PlannerInfo *root, VariableStatData *vardata, Oid sortop, Oid collation, Datum *min, Datum *max)
Definition: selfuncs.c:6087

References ATTSTATSSLOT_NUMBERS, ATTSTATSSLOT_VALUES, CLAMP_PROBABILITY, comparison_ops_are_compatible(), convert_to_scalar(), DatumGetBool(), FmgrInfo::fn_oid, free_attstatsslot(), FunctionCall2Coll(), FunctionCallInvoke, get_actual_variable_range(), get_attstatsslot(), get_variable_numdistinct(), HeapTupleIsValid, i, InitFunctionCallInfoData, InvalidOid, LOCAL_FCINFO, AttStatsSlot::nnumbers, AttStatsSlot::nvalues, root, AttStatsSlot::stacoll, AttStatsSlot::staop, statistic_proc_security_check(), VariableStatData::statsTuple, val, AttStatsSlot::values, and VariableStatData::vartype.

Referenced by prefix_selectivity(), and scalarineqsel().

◆ mcv_selectivity()

double mcv_selectivity ( VariableStatData vardata,
FmgrInfo opproc,
Oid  collation,
Datum  constval,
bool  varonleft,
double *  sumcommonp 
)

Definition at line 732 of file selfuncs.c.

735 {
736  double mcv_selec,
737  sumcommon;
738  AttStatsSlot sslot;
739  int i;
740 
741  mcv_selec = 0.0;
742  sumcommon = 0.0;
743 
744  if (HeapTupleIsValid(vardata->statsTuple) &&
745  statistic_proc_security_check(vardata, opproc->fn_oid) &&
746  get_attstatsslot(&sslot, vardata->statsTuple,
747  STATISTIC_KIND_MCV, InvalidOid,
749  {
750  LOCAL_FCINFO(fcinfo, 2);
751 
752  /*
753  * We invoke the opproc "by hand" so that we won't fail on NULL
754  * results. Such cases won't arise for normal comparison functions,
755  * but generic_restriction_selectivity could perhaps be used with
756  * operators that can return NULL. A small side benefit is to not
757  * need to re-initialize the fcinfo struct from scratch each time.
758  */
759  InitFunctionCallInfoData(*fcinfo, opproc, 2, collation,
760  NULL, NULL);
761  fcinfo->args[0].isnull = false;
762  fcinfo->args[1].isnull = false;
763  /* be careful to apply operator right way 'round */
764  if (varonleft)
765  fcinfo->args[1].value = constval;
766  else
767  fcinfo->args[0].value = constval;
768 
769  for (i = 0; i < sslot.nvalues; i++)
770  {
771  Datum fresult;
772 
773  if (varonleft)
774  fcinfo->args[0].value = sslot.values[i];
775  else
776  fcinfo->args[1].value = sslot.values[i];
777  fcinfo->isnull = false;
778  fresult = FunctionCallInvoke(fcinfo);
779  if (!fcinfo->isnull && DatumGetBool(fresult))
780  mcv_selec += sslot.numbers[i];
781  sumcommon += sslot.numbers[i];
782  }
783  free_attstatsslot(&sslot);
784  }
785 
786  *sumcommonp = sumcommon;
787  return mcv_selec;
788 }

References ATTSTATSSLOT_NUMBERS, ATTSTATSSLOT_VALUES, DatumGetBool(), FmgrInfo::fn_oid, free_attstatsslot(), FunctionCallInvoke, get_attstatsslot(), HeapTupleIsValid, i, InitFunctionCallInfoData, InvalidOid, LOCAL_FCINFO, AttStatsSlot::numbers, AttStatsSlot::nvalues, statistic_proc_security_check(), VariableStatData::statsTuple, and AttStatsSlot::values.

Referenced by generic_restriction_selectivity(), networksel(), patternsel_common(), and scalarineqsel().

◆ mergejoinscansel()

void mergejoinscansel ( PlannerInfo root,
Node clause,
Oid  opfamily,
int  strategy,
bool  nulls_first,
Selectivity leftstart,
Selectivity leftend,
Selectivity rightstart,
Selectivity rightend 
)

Definition at line 2952 of file selfuncs.c.

2956 {
2957  Node *left,
2958  *right;
2959  VariableStatData leftvar,
2960  rightvar;
2961  int op_strategy;
2962  Oid op_lefttype;
2963  Oid op_righttype;
2964  Oid opno,
2965  collation,
2966  lsortop,
2967  rsortop,
2968  lstatop,
2969  rstatop,
2970  ltop,
2971  leop,
2972  revltop,
2973  revleop;
2974  bool isgt;
2975  Datum leftmin,
2976  leftmax,
2977  rightmin,
2978  rightmax;
2979  double selec;
2980 
2981  /* Set default results if we can't figure anything out. */
2982  /* XXX should default "start" fraction be a bit more than 0? */
2983  *leftstart = *rightstart = 0.0;
2984  *leftend = *rightend = 1.0;
2985 
2986  /* Deconstruct the merge clause */
2987  if (!is_opclause(clause))
2988  return; /* shouldn't happen */
2989  opno = ((OpExpr *) clause)->opno;
2990  collation = ((OpExpr *) clause)->inputcollid;
2991  left = get_leftop((Expr *) clause);
2992  right = get_rightop((Expr *) clause);
2993  if (!right)
2994  return; /* shouldn't happen */
2995 
2996  /* Look for stats for the inputs */
2997  examine_variable(root, left, 0, &leftvar);
2998  examine_variable(root, right, 0, &rightvar);
2999 
3000  /* Extract the operator's declared left/right datatypes */
3001  get_op_opfamily_properties(opno, opfamily, false,
3002  &op_strategy,
3003  &op_lefttype,
3004  &op_righttype);
3005  Assert(op_strategy == BTEqualStrategyNumber);
3006 
3007  /*
3008  * Look up the various operators we need. If we don't find them all, it
3009  * probably means the opfamily is broken, but we just fail silently.
3010  *
3011  * Note: we expect that pg_statistic histograms will be sorted by the '<'
3012  * operator, regardless of which sort direction we are considering.
3013  */
3014  switch (strategy)
3015  {
3016  case BTLessStrategyNumber:
3017  isgt = false;
3018  if (op_lefttype == op_righttype)
3019  {
3020  /* easy case */
3021  ltop = get_opfamily_member(opfamily,
3022  op_lefttype, op_righttype,
3024  leop = get_opfamily_member(opfamily,
3025  op_lefttype, op_righttype,
3027  lsortop = ltop;
3028  rsortop = ltop;
3029  lstatop = lsortop;
3030  rstatop = rsortop;
3031  revltop = ltop;
3032  revleop = leop;
3033  }
3034  else
3035  {
3036  ltop = get_opfamily_member(opfamily,
3037  op_lefttype, op_righttype,
3039  leop = get_opfamily_member(opfamily,
3040  op_lefttype, op_righttype,
3042  lsortop = get_opfamily_member(opfamily,
3043  op_lefttype, op_lefttype,
3045  rsortop = get_opfamily_member(opfamily,
3046  op_righttype, op_righttype,
3048  lstatop = lsortop;
3049  rstatop = rsortop;
3050  revltop = get_opfamily_member(opfamily,
3051  op_righttype, op_lefttype,
3053  revleop = get_opfamily_member(opfamily,
3054  op_righttype, op_lefttype,
3056  }
3057  break;
3059  /* descending-order case */
3060  isgt = true;
3061  if (op_lefttype == op_righttype)
3062  {
3063  /* easy case */
3064  ltop = get_opfamily_member(opfamily,
3065  op_lefttype, op_righttype,
3067  leop = get_opfamily_member(opfamily,
3068  op_lefttype, op_righttype,
3070  lsortop = ltop;
3071  rsortop = ltop;
3072  lstatop = get_opfamily_member(opfamily,
3073  op_lefttype, op_lefttype,
3075  rstatop = lstatop;
3076  revltop = ltop;
3077  revleop = leop;
3078  }
3079  else
3080  {
3081  ltop = get_opfamily_member(opfamily,
3082  op_lefttype, op_righttype,
3084  leop = get_opfamily_member(opfamily,
3085  op_lefttype, op_righttype,
3087  lsortop = get_opfamily_member(opfamily,
3088  op_lefttype, op_lefttype,
3090  rsortop = get_opfamily_member(opfamily,
3091  op_righttype, op_righttype,
3093  lstatop = get_opfamily_member(opfamily,
3094  op_lefttype, op_lefttype,
3096  rstatop = get_opfamily_member(opfamily,
3097  op_righttype, op_righttype,
3099  revltop = get_opfamily_member(opfamily,
3100  op_righttype, op_lefttype,
3102  revleop = get_opfamily_member(opfamily,
3103  op_righttype, op_lefttype,
3105  }
3106  break;
3107  default:
3108  goto fail; /* shouldn't get here */
3109  }
3110 
3111  if (!OidIsValid(lsortop) ||
3112  !OidIsValid(rsortop) ||
3113  !OidIsValid(lstatop) ||
3114  !OidIsValid(rstatop) ||
3115  !OidIsValid(ltop) ||
3116  !OidIsValid(leop) ||
3117  !OidIsValid(revltop) ||
3118  !OidIsValid(revleop))
3119  goto fail; /* insufficient info in catalogs */
3120 
3121  /* Try to get ranges of both inputs */
3122  if (!isgt)
3123  {
3124  if (!get_variable_range(root, &leftvar, lstatop, collation,
3125  &leftmin, &leftmax))
3126  goto fail; /* no range available from stats */
3127  if (!get_variable_range(root, &rightvar, rstatop, collation,
3128  &rightmin, &rightmax))
3129  goto fail; /* no range available from stats */
3130  }
3131  else
3132  {
3133  /* need to swap the max and min */
3134  if (!get_variable_range(root, &leftvar, lstatop, collation,
3135  &leftmax, &leftmin))
3136  goto fail; /* no range available from stats */
3137  if (!get_variable_range(root, &rightvar, rstatop, collation,
3138  &rightmax, &rightmin))
3139  goto fail; /* no range available from stats */
3140  }
3141 
3142  /*
3143  * Now, the fraction of the left variable that will be scanned is the
3144  * fraction that's <= the right-side maximum value. But only believe
3145  * non-default estimates, else stick with our 1.0.
3146  */
3147  selec = scalarineqsel(root, leop, isgt, true, collation, &leftvar,
3148  rightmax, op_righttype);
3149  if (selec != DEFAULT_INEQ_SEL)
3150  *leftend = selec;
3151 
3152  /* And similarly for the right variable. */
3153  selec = scalarineqsel(root, revleop, isgt, true, collation, &rightvar,
3154  leftmax, op_lefttype);
3155  if (selec != DEFAULT_INEQ_SEL)
3156  *rightend = selec;
3157 
3158  /*
3159  * Only one of the two "end" fractions can really be less than 1.0;
3160  * believe the smaller estimate and reset the other one to exactly 1.0. If
3161  * we get exactly equal estimates (as can easily happen with self-joins),
3162  * believe neither.
3163  */
3164  if (*leftend > *rightend)
3165  *leftend = 1.0;
3166  else if (*leftend < *rightend)
3167  *rightend = 1.0;
3168  else
3169  *leftend = *rightend = 1.0;
3170 
3171  /*
3172  * Also, the fraction of the left variable that will be scanned before the
3173  * first join pair is found is the fraction that's < the right-side
3174  * minimum value. But only believe non-default estimates, else stick with
3175  * our own default.
3176  */
3177  selec = scalarineqsel(root, ltop, isgt, false, collation, &leftvar,
3178  rightmin, op_righttype);
3179  if (selec != DEFAULT_INEQ_SEL)
3180  *leftstart = selec;
3181 
3182  /* And similarly for the right variable. */
3183  selec = scalarineqsel(root, revltop, isgt, false, collation, &rightvar,
3184  leftmin, op_lefttype);
3185  if (selec != DEFAULT_INEQ_SEL)
3186  *rightstart = selec;
3187 
3188  /*
3189  * Only one of the two "start" fractions can really be more than zero;
3190  * believe the larger estimate and reset the other one to exactly 0.0. If
3191  * we get exactly equal estimates (as can easily happen with self-joins),
3192  * believe neither.
3193  */
3194  if (*leftstart < *rightstart)
3195  *leftstart = 0.0;
3196  else if (*leftstart > *rightstart)
3197  *rightstart = 0.0;
3198  else
3199  *leftstart = *rightstart = 0.0;
3200 
3201  /*
3202  * If the sort order is nulls-first, we're going to have to skip over any
3203  * nulls too. These would not have been counted by scalarineqsel, and we
3204  * can safely add in this fraction regardless of whether we believe
3205  * scalarineqsel's results or not. But be sure to clamp the sum to 1.0!
3206  */
3207  if (nulls_first)
3208  {
3209  Form_pg_statistic stats;
3210 
3211  if (HeapTupleIsValid(leftvar.statsTuple))
3212  {
3213  stats = (Form_pg_statistic) GETSTRUCT(leftvar.statsTuple);
3214  *leftstart += stats->stanullfrac;
3215  CLAMP_PROBABILITY(*leftstart);
3216  *leftend += stats->stanullfrac;
3217  CLAMP_PROBABILITY(*leftend);
3218  }
3219  if (HeapTupleIsValid(rightvar.statsTuple))
3220  {
3221  stats = (Form_pg_statistic) GETSTRUCT(rightvar.statsTuple);
3222  *rightstart += stats->stanullfrac;
3223  CLAMP_PROBABILITY(*rightstart);
3224  *rightend += stats->stanullfrac;
3225  CLAMP_PROBABILITY(*rightend);
3226  }
3227  }
3228 
3229  /* Disbelieve start >= end, just in case that can happen */
3230  if (*leftstart >= *leftend)
3231  {
3232  *leftstart = 0.0;
3233  *leftend = 1.0;
3234  }
3235  if (*rightstart >= *rightend)
3236  {
3237  *rightstart = 0.0;
3238  *rightend = 1.0;
3239  }
3240 
3241 fail:
3242  ReleaseVariableStats(leftvar);
3243  ReleaseVariableStats(rightvar);
3244 }
void get_op_opfamily_properties(Oid opno, Oid opfamily, bool ordering_op, int *strategy, Oid *lefttype, Oid *righttype)
Definition: lsyscache.c:136
Oid get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype, int16 strategy)
Definition: lsyscache.c:166
static bool is_opclause(const void *clause)
Definition: nodeFuncs.h:74
static Node * get_rightop(const void *clause)
Definition: nodeFuncs.h:93
static Node * get_leftop(const void *clause)
Definition: nodeFuncs.h:81
static bool get_variable_range(PlannerInfo *root, VariableStatData *vardata, Oid sortop, Oid collation, Datum *min, Datum *max)
Definition: selfuncs.c:5897
static double scalarineqsel(PlannerInfo *root, Oid operator, bool isgt, bool iseq, Oid collation, VariableStatData *vardata, Datum constval, Oid consttype)
Definition: selfuncs.c:580
#define DEFAULT_INEQ_SEL
Definition: selfuncs.h:37
#define BTGreaterStrategyNumber
Definition: stratnum.h:33
#define BTLessStrategyNumber
Definition: stratnum.h:29
#define BTEqualStrategyNumber
Definition: stratnum.h:31
#define BTLessEqualStrategyNumber
Definition: stratnum.h:30
#define BTGreaterEqualStrategyNumber
Definition: stratnum.h:32

References Assert, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, CLAMP_PROBABILITY, DEFAULT_INEQ_SEL, examine_variable(), get_leftop(), get_op_opfamily_properties(), get_opfamily_member(), get_rightop(), get_variable_range(), GETSTRUCT, HeapTupleIsValid, is_opclause(), OidIsValid, ReleaseVariableStats, root, scalarineqsel(), and VariableStatData::statsTuple.

Referenced by cached_scansel().

◆ nulltestsel()

Selectivity nulltestsel ( PlannerInfo root,
NullTestType  nulltesttype,
Node arg,
int  varRelid,
JoinType  jointype,
SpecialJoinInfo sjinfo 
)

Definition at line 1698 of file selfuncs.c.

1700 {
1701  VariableStatData vardata;
1702  double selec;
1703 
1704  examine_variable(root, arg, varRelid, &vardata);
1705 
1706  if (HeapTupleIsValid(vardata.statsTuple))
1707  {
1708  Form_pg_statistic stats;
1709  double freq_null;
1710 
1711  stats = (Form_pg_statistic) GETSTRUCT(vardata.statsTuple);
1712  freq_null = stats->stanullfrac;
1713 
1714  switch (nulltesttype)
1715  {
1716  case IS_NULL:
1717 
1718  /*
1719  * Use freq_null directly.
1720  */
1721  selec = freq_null;
1722  break;
1723  case IS_NOT_NULL:
1724 
1725  /*
1726  * Select not unknown (not null) values. Calculate from
1727  * freq_null.
1728  */
1729  selec = 1.0 - freq_null;
1730  break;
1731  default:
1732  elog(ERROR, "unrecognized nulltesttype: %d",
1733  (int) nulltesttype);
1734  return (Selectivity) 0; /* keep compiler quiet */
1735  }
1736  }
1737  else if (vardata.var && IsA(vardata.var, Var) &&
1738  ((Var *) vardata.var)->varattno < 0)
1739  {
1740  /*
1741  * There are no stats for system columns, but we know they are never
1742  * NULL.
1743  */
1744  selec = (nulltesttype == IS_NULL) ? 0.0 : 1.0;
1745  }
1746  else
1747  {
1748  /*
1749  * No ANALYZE stats available, so make a guess
1750  */
1751  switch (nulltesttype)
1752  {
1753  case IS_NULL:
1754  selec = DEFAULT_UNK_SEL;
1755  break;
1756  case IS_NOT_NULL:
1757  selec = DEFAULT_NOT_UNK_SEL;
1758  break;
1759  default:
1760  elog(ERROR, "unrecognized nulltesttype: %d",
1761  (int) nulltesttype);
1762  return (Selectivity) 0; /* keep compiler quiet */
1763  }
1764  }
1765 
1766  ReleaseVariableStats(vardata);
1767 
1768  /* result should be in range, but make sure... */
1769  CLAMP_PROBABILITY(selec);
1770 
1771  return (Selectivity) selec;
1772 }
@ IS_NULL
Definition: primnodes.h:1921
@ IS_NOT_NULL
Definition: primnodes.h:1921

References arg, CLAMP_PROBABILITY, DEFAULT_NOT_UNK_SEL, DEFAULT_UNK_SEL, elog, ERROR, examine_variable(), GETSTRUCT, HeapTupleIsValid, IS_NOT_NULL, IS_NULL, IsA, ReleaseVariableStats, root, VariableStatData::statsTuple, and VariableStatData::var.

Referenced by clause_selectivity_ext(), and clauselist_selectivity_ext().

◆ rowcomparesel()

Selectivity rowcomparesel ( PlannerInfo root,
RowCompareExpr clause,
int  varRelid,
JoinType  jointype,
SpecialJoinInfo sjinfo 
)

Definition at line 2202 of file selfuncs.c.

2205 {
2206  Selectivity s1;
2207  Oid opno = linitial_oid(clause->opnos);
2208  Oid inputcollid = linitial_oid(clause->inputcollids);
2209  List *opargs;
2210  bool is_join_clause;
2211 
2212  /* Build equivalent arg list for single operator */
2213  opargs = list_make2(linitial(clause->largs), linitial(clause->rargs));
2214 
2215  /*
2216  * Decide if it's a join clause. This should match clausesel.c's
2217  * treat_as_join_clause(), except that we intentionally consider only the
2218  * leading columns and not the rest of the clause.
2219  */
2220  if (varRelid != 0)
2221  {
2222  /*
2223  * Caller is forcing restriction mode (eg, because we are examining an
2224  * inner indexscan qual).
2225  */
2226  is_join_clause = false;
2227  }
2228  else if (sjinfo == NULL)
2229  {
2230  /*
2231  * It must be a restriction clause, since it's being evaluated at a
2232  * scan node.
2233  */
2234  is_join_clause = false;
2235  }
2236  else
2237  {
2238  /*
2239  * Otherwise, it's a join if there's more than one base relation used.
2240  */
2241  is_join_clause = (NumRelids(root, (Node *) opargs) > 1);
2242  }
2243 
2244  if (is_join_clause)
2245  {
2246  /* Estimate selectivity for a join clause. */
2247  s1 = join_selectivity(root, opno,
2248  opargs,
2249  inputcollid,
2250  jointype,
2251  sjinfo);
2252  }
2253  else
2254  {
2255  /* Estimate selectivity for a restriction clause. */
2257  opargs,
2258  inputcollid,
2259  varRelid);
2260  }
2261 
2262  return s1;
2263 }
int NumRelids(PlannerInfo *root, Node *clause)
Definition: clauses.c:2130
#define linitial_oid(l)
Definition: pg_list.h:180
#define list_make2(x1, x2)
Definition: pg_list.h:214
Selectivity restriction_selectivity(PlannerInfo *root, Oid operatorid, List *args, Oid inputcollid, int varRelid)
Definition: plancat.c:1930
Selectivity join_selectivity(PlannerInfo *root, Oid operatorid, List *args, Oid inputcollid, JoinType jointype, SpecialJoinInfo *sjinfo)
Definition: plancat.c:1969
char * s1

References join_selectivity(), RowCompareExpr::largs, linitial, linitial_oid, list_make2, NumRelids(), RowCompareExpr::rargs, restriction_selectivity(), root, and s1.

Referenced by clause_selectivity_ext().

◆ scalararraysel()

Selectivity scalararraysel ( PlannerInfo root,
ScalarArrayOpExpr clause,
bool  is_join_clause,
int  varRelid,
JoinType  jointype,
SpecialJoinInfo sjinfo 
)

Definition at line 1816 of file selfuncs.c.

1822 {
1823  Oid operator = clause->opno;
1824  bool useOr = clause->useOr;
1825  bool isEquality = false;
1826  bool isInequality = false;
1827  Node *leftop;
1828  Node *rightop;
1829  Oid nominal_element_type;
1830  Oid nominal_element_collation;
1831  TypeCacheEntry *typentry;
1832  RegProcedure oprsel;
1833  FmgrInfo oprselproc;
1834  Selectivity s1;
1835  Selectivity s1disjoint;
1836 
1837  /* First, deconstruct the expression */
1838  Assert(list_length(clause->args) == 2);
1839  leftop = (Node *) linitial(clause->args);
1840  rightop = (Node *) lsecond(clause->args);
1841 
1842  /* aggressively reduce both sides to constants */
1843  leftop = estimate_expression_value(root, leftop);
1844  rightop = estimate_expression_value(root, rightop);
1845 
1846  /* get nominal (after relabeling) element type of rightop */
1847  nominal_element_type = get_base_element_type(exprType(rightop));
1848  if (!OidIsValid(nominal_element_type))
1849  return (Selectivity) 0.5; /* probably shouldn't happen */
1850  /* get nominal collation, too, for generating constants */
1851  nominal_element_collation = exprCollation(rightop);
1852 
1853  /* look through any binary-compatible relabeling of rightop */
1854  rightop = strip_array_coercion(rightop);
1855 
1856  /*
1857  * Detect whether the operator is the default equality or inequality
1858  * operator of the array element type.
1859  */
1860  typentry = lookup_type_cache(nominal_element_type, TYPECACHE_EQ_OPR);
1861  if (OidIsValid(typentry->eq_opr))
1862  {
1863  if (operator == typentry->eq_opr)
1864  isEquality = true;
1865  else if (get_negator(operator) == typentry->eq_opr)
1866  isInequality = true;
1867  }
1868 
1869  /*
1870  * If it is equality or inequality, we might be able to estimate this as a
1871  * form of array containment; for instance "const = ANY(column)" can be
1872  * treated as "ARRAY[const] <@ column". scalararraysel_containment tries
1873  * that, and returns the selectivity estimate if successful, or -1 if not.
1874  */
1875  if ((isEquality || isInequality) && !is_join_clause)
1876  {
1877  s1 = scalararraysel_containment(root, leftop, rightop,
1878  nominal_element_type,
1879  isEquality, useOr, varRelid);
1880  if (s1 >= 0.0)
1881  return s1;
1882  }
1883 
1884  /*
1885  * Look up the underlying operator's selectivity estimator. Punt if it
1886  * hasn't got one.
1887  */
1888  if (is_join_clause)
1889  oprsel = get_oprjoin(operator);
1890  else
1891  oprsel = get_oprrest(operator);
1892  if (!oprsel)
1893  return (Selectivity) 0.5;
1894  fmgr_info(oprsel, &oprselproc);
1895 
1896  /*
1897  * In the array-containment check above, we must only believe that an
1898  * operator is equality or inequality if it is the default btree equality
1899  * operator (or its negator) for the element type, since those are the
1900  * operators that array containment will use. But in what follows, we can
1901  * be a little laxer, and also believe that any operators using eqsel() or
1902  * neqsel() as selectivity estimator act like equality or inequality.
1903  */
1904  if (oprsel == F_EQSEL || oprsel == F_EQJOINSEL)
1905  isEquality = true;
1906  else if (oprsel == F_NEQSEL || oprsel == F_NEQJOINSEL)
1907  isInequality = true;
1908 
1909  /*
1910  * We consider three cases:
1911  *
1912  * 1. rightop is an Array constant: deconstruct the array, apply the
1913  * operator's selectivity function for each array element, and merge the
1914  * results in the same way that clausesel.c does for AND/OR combinations.
1915  *
1916  * 2. rightop is an ARRAY[] construct: apply the operator's selectivity
1917  * function for each element of the ARRAY[] construct, and merge.
1918  *
1919  * 3. otherwise, make a guess ...
1920  */
1921  if (rightop && IsA(rightop, Const))
1922  {
1923  Datum arraydatum = ((Const *) rightop)->constvalue;
1924  bool arrayisnull = ((Const *) rightop)->constisnull;
1925  ArrayType *arrayval;
1926  int16 elmlen;
1927  bool elmbyval;
1928  char elmalign;
1929  int num_elems;
1930  Datum *elem_values;
1931  bool *elem_nulls;
1932  int i;
1933 
1934  if (arrayisnull) /* qual can't succeed if null array */
1935  return (Selectivity) 0.0;
1936  arrayval = DatumGetArrayTypeP(arraydatum);
1938  &elmlen, &elmbyval, &elmalign);
1939  deconstruct_array(arrayval,
1940  ARR_ELEMTYPE(arrayval),
1941  elmlen, elmbyval, elmalign,
1942  &elem_values, &elem_nulls, &num_elems);
1943 
1944  /*
1945  * For generic operators, we assume the probability of success is
1946  * independent for each array element. But for "= ANY" or "<> ALL",
1947  * if the array elements are distinct (which'd typically be the case)
1948  * then the probabilities are disjoint, and we should just sum them.
1949  *
1950  * If we were being really tense we would try to confirm that the
1951  * elements are all distinct, but that would be expensive and it
1952  * doesn't seem to be worth the cycles; it would amount to penalizing
1953  * well-written queries in favor of poorly-written ones. However, we
1954  * do protect ourselves a little bit by checking whether the
1955  * disjointness assumption leads to an impossible (out of range)
1956  * probability; if so, we fall back to the normal calculation.
1957  */
1958  s1 = s1disjoint = (useOr ? 0.0 : 1.0);
1959 
1960  for (i = 0; i < num_elems; i++)
1961  {
1962  List *args;
1963  Selectivity s2;
1964 
1965  args = list_make2(leftop,
1966  makeConst(nominal_element_type,
1967  -1,
1968  nominal_element_collation,
1969  elmlen,
1970  elem_values[i],
1971  elem_nulls[i],
1972  elmbyval));
1973  if (is_join_clause)
1974  s2 = DatumGetFloat8(FunctionCall5Coll(&oprselproc,
1975  clause->inputcollid,
1977  ObjectIdGetDatum(operator),
1979  Int16GetDatum(jointype),
1980  PointerGetDatum(sjinfo)));
1981  else
1982  s2 = DatumGetFloat8(FunctionCall4Coll(&oprselproc,
1983  clause->inputcollid,
1985  ObjectIdGetDatum(operator),
1987  Int32GetDatum(varRelid)));
1988 
1989  if (useOr)
1990  {
1991  s1 = s1 + s2 - s1 * s2;
1992  if (isEquality)
1993  s1disjoint += s2;
1994  }
1995  else
1996  {
1997  s1 = s1 * s2;
1998  if (isInequality)
1999  s1disjoint += s2 - 1.0;
2000  }
2001  }
2002 
2003  /* accept disjoint-probability estimate if in range */
2004  if ((useOr ? isEquality : isInequality) &&
2005  s1disjoint >= 0.0 && s1disjoint <= 1.0)
2006  s1 = s1disjoint;
2007  }
2008  else if (rightop && IsA(rightop, ArrayExpr) &&
2009  !((ArrayExpr *) rightop)->multidims)
2010  {
2011  ArrayExpr *arrayexpr = (ArrayExpr *) rightop;
2012  int16 elmlen;
2013  bool elmbyval;
2014  ListCell *l;
2015 
2016  get_typlenbyval(arrayexpr->element_typeid,
2017  &elmlen, &elmbyval);
2018 
2019  /*
2020  * We use the assumption of disjoint probabilities here too, although
2021  * the odds of equal array elements are rather higher if the elements
2022  * are not all constants (which they won't be, else constant folding
2023  * would have reduced the ArrayExpr to a Const). In this path it's
2024  * critical to have the sanity check on the s1disjoint estimate.
2025  */
2026  s1 = s1disjoint = (useOr ? 0.0 : 1.0);
2027 
2028  foreach(l, arrayexpr->elements)
2029  {
2030  Node *elem = (Node *) lfirst(l);
2031  List *args;
2032  Selectivity s2;
2033 
2034  /*
2035  * Theoretically, if elem isn't of nominal_element_type we should
2036  * insert a RelabelType, but it seems unlikely that any operator
2037  * estimation function would really care ...
2038  */
2039  args = list_make2(leftop, elem);
2040  if (is_join_clause)
2041  s2 = DatumGetFloat8(FunctionCall5Coll(&oprselproc,
2042  clause->inputcollid,
2044  ObjectIdGetDatum(operator),
2046  Int16GetDatum(jointype),
2047  PointerGetDatum(sjinfo)));
2048  else
2049  s2 = DatumGetFloat8(FunctionCall4Coll(&oprselproc,
2050  clause->inputcollid,
2052  ObjectIdGetDatum(operator),
2054  Int32GetDatum(varRelid)));
2055 
2056  if (useOr)
2057  {
2058  s1 = s1 + s2 - s1 * s2;
2059  if (isEquality)
2060  s1disjoint += s2;
2061  }
2062  else
2063  {
2064  s1 = s1 * s2;
2065  if (isInequality)
2066  s1disjoint += s2 - 1.0;
2067  }
2068  }
2069 
2070  /* accept disjoint-probability estimate if in range */
2071  if ((useOr ? isEquality : isInequality) &&
2072  s1disjoint >= 0.0 && s1disjoint <= 1.0)
2073  s1 = s1disjoint;
2074  }
2075  else
2076  {
2077  CaseTestExpr *dummyexpr;
2078  List *args;
2079  Selectivity s2;
2080  int i;
2081 
2082  /*
2083  * We need a dummy rightop to pass to the operator selectivity
2084  * routine. It can be pretty much anything that doesn't look like a
2085  * constant; CaseTestExpr is a convenient choice.
2086  */
2087  dummyexpr = makeNode(CaseTestExpr);
2088  dummyexpr->typeId = nominal_element_type;
2089  dummyexpr->typeMod = -1;
2090  dummyexpr->collation = clause->inputcollid;
2091  args = list_make2(leftop, dummyexpr);
2092  if (is_join_clause)
2093  s2 = DatumGetFloat8(FunctionCall5Coll(&oprselproc,
2094  clause->inputcollid,
2096  ObjectIdGetDatum(operator),
2098  Int16GetDatum(jointype),
2099  PointerGetDatum(sjinfo)));
2100  else
2101  s2 = DatumGetFloat8(FunctionCall4Coll(&oprselproc,
2102  clause->inputcollid,
2104  ObjectIdGetDatum(operator),
2106  Int32GetDatum(varRelid)));
2107  s1 = useOr ? 0.0 : 1.0;
2108 
2109  /*
2110  * Arbitrarily assume 10 elements in the eventual array value (see
2111  * also estimate_array_length). We don't risk an assumption of
2112  * disjoint probabilities here.
2113  */
2114  for (i = 0; i < 10; i++)
2115  {
2116  if (useOr)
2117  s1 = s1 + s2 - s1 * s2;
2118  else
2119  s1 = s1 * s2;
2120  }
2121  }
2122 
2123  /* result should be in range, but make sure... */
2125 
2126  return s1;
2127 }
#define ARR_ELEMTYPE(a)
Definition: array.h:292
Selectivity scalararraysel_containment(PlannerInfo *root, Node *leftop, Node *rightop, Oid elemtype, bool isEquality, bool useOr, int varRelid)
void deconstruct_array(ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition: arrayfuncs.c:3612
signed short int16
Definition: c.h:493
regproc RegProcedure
Definition: c.h:650
Datum FunctionCall4Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4)
Definition: fmgr.c:1196
Datum FunctionCall5Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5)
Definition: fmgr.c:1223
RegProcedure get_oprrest(Oid opno)
Definition: lsyscache.c:1535
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
Definition: lsyscache.c:2249
RegProcedure get_oprjoin(Oid opno)
Definition: lsyscache.c:1559
void get_typlenbyval(Oid typid, int16 *typlen, bool *typbyval)
Definition: lsyscache.c:2229
Oid get_base_element_type(Oid typid)
Definition: lsyscache.c:2810
Oid get_negator(Oid opno)
Definition: lsyscache.c:1511
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
Definition: makefuncs.c:301
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:816
#define makeNode(_type_)
Definition: nodes.h:155
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
static float8 DatumGetFloat8(Datum X)
Definition: postgres.h:494
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:212
char * s2
List * elements
Definition: primnodes.h:1350
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition: typcache.c:346
#define TYPECACHE_EQ_OPR
Definition: typcache.h:137

References generate_unaccent_rules::args, ScalarArrayOpExpr::args, ARR_ELEMTYPE, Assert, CLAMP_PROBABILITY, DatumGetArrayTypeP, DatumGetFloat8(), deconstruct_array(), ArrayExpr::elements, TypeCacheEntry::eq_opr, estimate_expression_value(), exprCollation(), exprType(), fmgr_info(), FunctionCall4Coll(), FunctionCall5Coll(), get_base_element_type(), get_negator(), get_oprjoin(), get_oprrest(), get_typlenbyval(), get_typlenbyvalalign(), i, Int16GetDatum(), Int32GetDatum(), IsA, lfirst, linitial, list_length(), list_make2, lookup_type_cache(), lsecond, makeConst(), makeNode, ObjectIdGetDatum(), OidIsValid, ScalarArrayOpExpr::opno, PointerGetDatum(), root, s1, s2, scalararraysel_containment(), strip_array_coercion(), TYPECACHE_EQ_OPR, CaseTestExpr::typeId, and ScalarArrayOpExpr::useOr.

Referenced by clause_selectivity_ext().

◆ scalararraysel_containment()

Selectivity scalararraysel_containment ( PlannerInfo root,
Node leftop,
Node rightop,
Oid  elemtype,
bool  isEquality,
bool  useOr,
int  varRelid 
)

Definition at line 81 of file array_selfuncs.c.

85 {
86  Selectivity selec;
87  VariableStatData vardata;
88  Datum constval;
89  TypeCacheEntry *typentry;
90  FmgrInfo *cmpfunc;
91 
92  /*
93  * rightop must be a variable, else punt.
94  */
95  examine_variable(root, rightop, varRelid, &vardata);
96  if (!vardata.rel)
97  {
98  ReleaseVariableStats(vardata);
99  return -1.0;
100  }
101 
102  /*
103  * leftop must be a constant, else punt.
104  */
105  if (!IsA(leftop, Const))
106  {
107  ReleaseVariableStats(vardata);
108  return -1.0;
109  }
110  if (((Const *) leftop)->constisnull)
111  {
112  /* qual can't succeed if null on left */
113  ReleaseVariableStats(vardata);
114  return (Selectivity) 0.0;
115  }
116  constval = ((Const *) leftop)->constvalue;
117 
118  /* Get element type's default comparison function */
119  typentry = lookup_type_cache(elemtype, TYPECACHE_CMP_PROC_FINFO);
120  if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
121  {
122  ReleaseVariableStats(vardata);
123  return -1.0;
124  }
125  cmpfunc = &typentry->cmp_proc_finfo;
126 
127  /*
128  * If the operator is <>, swap ANY/ALL, then invert the result later.
129  */
130  if (!isEquality)
131  useOr = !useOr;
132 
133  /* Get array element stats for var, if available */
134  if (HeapTupleIsValid(vardata.statsTuple) &&
135  statistic_proc_security_check(&vardata, cmpfunc->fn_oid))
136  {
137  Form_pg_statistic stats;
138  AttStatsSlot sslot;
139  AttStatsSlot hslot;
140 
141  stats = (Form_pg_statistic) GETSTRUCT(vardata.statsTuple);
142 
143  /* MCELEM will be an array of same type as element */
144  if (get_attstatsslot(&sslot, vardata.statsTuple,
145  STATISTIC_KIND_MCELEM, InvalidOid,
147  {
148  /* For ALL case, also get histogram of distinct-element counts */
149  if (useOr ||
150  !get_attstatsslot(&hslot, vardata.statsTuple,
151  STATISTIC_KIND_DECHIST, InvalidOid,
153  memset(&hslot, 0, sizeof(hslot));
154 
155  /*
156  * For = ANY, estimate as var @> ARRAY[const].
157  *
158  * For = ALL, estimate as var <@ ARRAY[const].
159  */
160  if (useOr)
162  sslot.nvalues,
163  sslot.numbers,
164  sslot.nnumbers,
165  &constval, 1,
166  OID_ARRAY_CONTAINS_OP,
167  typentry);
168  else
169  selec = mcelem_array_contained_selec(sslot.values,
170  sslot.nvalues,
171  sslot.numbers,
172  sslot.nnumbers,
173  &constval, 1,
174  hslot.numbers,
175  hslot.nnumbers,
176  OID_ARRAY_CONTAINED_OP,
177  typentry);
178 
179  free_attstatsslot(&hslot);
180  free_attstatsslot(&sslot);
181  }
182  else
183  {
184  /* No most-common-elements info, so do without */
185  if (useOr)
186  selec = mcelem_array_contain_overlap_selec(NULL, 0,
187  NULL, 0,
188  &constval, 1,
189  OID_ARRAY_CONTAINS_OP,
190  typentry);
191  else
192  selec = mcelem_array_contained_selec(NULL, 0,
193  NULL, 0,
194  &constval, 1,
195  NULL, 0,
196  OID_ARRAY_CONTAINED_OP,
197  typentry);
198  }
199 
200  /*
201  * MCE stats count only non-null rows, so adjust for null rows.
202  */
203  selec *= (1.0 - stats->stanullfrac);
204  }
205  else
206  {
207  /* No stats at all, so do without */
208  if (useOr)
209  selec = mcelem_array_contain_overlap_selec(NULL, 0,
210  NULL, 0,
211  &constval, 1,
212  OID_ARRAY_CONTAINS_OP,
213  typentry);
214  else
215  selec = mcelem_array_contained_selec(NULL, 0,
216  NULL, 0,
217  &constval, 1,
218  NULL, 0,
219  OID_ARRAY_CONTAINED_OP,
220  typentry);
221  /* we assume no nulls here, so no stanullfrac correction */
222  }
223 
224  ReleaseVariableStats(vardata);
225 
226  /*
227  * If the operator is <>, invert the results.
228  */
229  if (!isEquality)
230  selec = 1.0 - selec;
231 
232  CLAMP_PROBABILITY(selec);
233 
234  return selec;
235 }
static Selectivity mcelem_array_contained_selec(Datum *mcelem, int nmcelem, float4 *numbers, int nnumbers, Datum *array_data, int nitems, float4 *hist, int nhist, Oid operator, TypeCacheEntry *typentry)
static Selectivity mcelem_array_contain_overlap_selec(Datum *mcelem, int nmcelem, float4 *numbers, int nnumbers, Datum *array_data, int nitems, Oid operator, TypeCacheEntry *typentry)
FmgrInfo cmp_proc_finfo
Definition: typcache.h:76
#define TYPECACHE_CMP_PROC_FINFO
Definition: typcache.h:143

References ATTSTATSSLOT_NUMBERS, ATTSTATSSLOT_VALUES, CLAMP_PROBABILITY, TypeCacheEntry::cmp_proc_finfo, examine_variable(), FmgrInfo::fn_oid, free_attstatsslot(), get_attstatsslot(), GETSTRUCT, HeapTupleIsValid, InvalidOid, IsA, lookup_type_cache(), mcelem_array_contain_overlap_selec(), mcelem_array_contained_selec(), AttStatsSlot::nnumbers, AttStatsSlot::numbers, AttStatsSlot::nvalues, OidIsValid, VariableStatData::rel, ReleaseVariableStats, root, statistic_proc_security_check(), VariableStatData::statsTuple, TYPECACHE_CMP_PROC_FINFO, and AttStatsSlot::values.

Referenced by scalararraysel().

◆ statistic_proc_security_check()

bool statistic_proc_security_check ( VariableStatData vardata,
Oid  func_oid 
)

Definition at line 5735 of file selfuncs.c.

5736 {
5737  if (vardata->acl_ok)
5738  return true;
5739 
5740  if (!OidIsValid(func_oid))
5741  return false;
5742 
5743  if (get_func_leakproof(func_oid))
5744  return true;
5745 
5746  ereport(DEBUG2,
5747  (errmsg_internal("not using statistics because function \"%s\" is not leak-proof",
5748  get_func_name(func_oid))));
5749  return false;
5750 }
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1159
#define DEBUG2
Definition: elog.h:29
#define ereport(elevel,...)
Definition: elog.h:149
char * get_func_name(Oid funcid)
Definition: lsyscache.c:1586
bool get_func_leakproof(Oid funcid)
Definition: lsyscache.c:1815

References VariableStatData::acl_ok, DEBUG2, ereport, errmsg_internal(), get_func_leakproof(), get_func_name(), and OidIsValid.

Referenced by calc_arraycontsel(), calc_hist_selectivity(), eqjoinsel(), get_variable_range(), histogram_selectivity(), ineq_histogram_selectivity(), mcv_selectivity(), scalararraysel_containment(), and var_eq_const().

◆ var_eq_const()

double var_eq_const ( VariableStatData vardata,
Oid  oproid,
Oid  collation,
Datum  constval,
bool  constisnull,
bool  varonleft,
bool  negate 
)

Definition at line 295 of file selfuncs.c.

298 {
299  double selec;
300  double nullfrac = 0.0;
301  bool isdefault;
302  Oid opfuncoid;
303 
304  /*
305  * If the constant is NULL, assume operator is strict and return zero, ie,
306  * operator will never return TRUE. (It's zero even for a negator op.)
307  */
308  if (constisnull)
309  return 0.0;
310 
311  /*
312  * Grab the nullfrac for use below. Note we allow use of nullfrac
313  * regardless of security check.
314  */
315  if (HeapTupleIsValid(vardata->statsTuple))
316  {
317  Form_pg_statistic stats;
318 
319  stats = (Form_pg_statistic) GETSTRUCT(vardata->statsTuple);
320  nullfrac = stats->stanullfrac;
321  }
322 
323  /*
324  * If we matched the var to a unique index or DISTINCT clause, assume
325  * there is exactly one match regardless of anything else. (This is
326  * slightly bogus, since the index or clause's equality operator might be
327  * different from ours, but it's much more likely to be right than
328  * ignoring the information.)
329  */
330  if (vardata->isunique && vardata->rel && vardata->rel->tuples >= 1.0)
331  {
332  selec = 1.0 / vardata->rel->tuples;
333  }
334  else if (HeapTupleIsValid(vardata->statsTuple) &&
336  (opfuncoid = get_opcode(oproid))))
337  {
338  AttStatsSlot sslot;
339  bool match = false;
340  int i;
341 
342  /*
343  * Is the constant "=" to any of the column's most common values?
344  * (Although the given operator may not really be "=", we will assume
345  * that seeing whether it returns TRUE is an appropriate test. If you
346  * don't like this, maybe you shouldn't be using eqsel for your
347  * operator...)
348  */
349  if (get_attstatsslot(&sslot, vardata->statsTuple,
350  STATISTIC_KIND_MCV, InvalidOid,
352  {
353  LOCAL_FCINFO(fcinfo, 2);
354  FmgrInfo eqproc;
355 
356  fmgr_info(opfuncoid, &eqproc);
357 
358  /*
359  * Save a few cycles by setting up the fcinfo struct just once.
360  * Using FunctionCallInvoke directly also avoids failure if the
361  * eqproc returns NULL, though really equality functions should
362  * never do that.
363  */
364  InitFunctionCallInfoData(*fcinfo, &eqproc, 2, collation,
365  NULL, NULL);
366  fcinfo->args[0].isnull = false;
367  fcinfo->args[1].isnull = false;
368  /* be careful to apply operator right way 'round */
369  if (varonleft)
370  fcinfo->args[1].value = constval;
371  else
372  fcinfo->args[0].value = constval;
373 
374  for (i = 0; i < sslot.nvalues; i++)
375  {
376  Datum fresult;
377 
378  if (varonleft)
379  fcinfo->args[0].value = sslot.values[i];
380  else
381  fcinfo->args[1].value = sslot.values[i];
382  fcinfo->isnull = false;
383  fresult = FunctionCallInvoke(fcinfo);
384  if (!fcinfo->isnull && DatumGetBool(fresult))
385  {
386  match = true;
387  break;
388  }
389  }
390  }
391  else
392  {
393  /* no most-common-value info available */
394  i = 0; /* keep compiler quiet */
395  }
396 
397  if (match)
398  {
399  /*
400  * Constant is "=" to this common value. We know selectivity
401  * exactly (or as exactly as ANALYZE could calculate it, anyway).
402  */
403  selec = sslot.numbers[i];
404  }
405  else
406  {
407  /*
408  * Comparison is against a constant that is neither NULL nor any
409  * of the common values. Its selectivity cannot be more than
410  * this:
411  */
412  double sumcommon = 0.0;
413  double otherdistinct;
414 
415  for (i = 0; i < sslot.nnumbers; i++)
416  sumcommon += sslot.numbers[i];
417  selec = 1.0 - sumcommon - nullfrac;
418  CLAMP_PROBABILITY(selec);
419 
420  /*
421  * and in fact it's probably a good deal less. We approximate that
422  * all the not-common values share this remaining fraction
423  * equally, so we divide by the number of other distinct values.
424  */
425  otherdistinct = get_variable_numdistinct(vardata, &isdefault) -
426  sslot.nnumbers;
427  if (otherdistinct > 1)
428  selec /= otherdistinct;
429 
430  /*
431  * Another cross-check: selectivity shouldn't be estimated as more
432  * than the least common "most common value".
433  */
434  if (sslot.nnumbers > 0 && selec > sslot.numbers[sslot.nnumbers - 1])
435  selec = sslot.numbers[sslot.nnumbers - 1];
436  }
437 
438  free_attstatsslot(&sslot);
439  }
440  else
441  {
442  /*
443  * No ANALYZE stats available, so make a guess using estimated number
444  * of distinct values and assuming they are equally common. (The guess
445  * is unlikely to be very good, but we do know a few special cases.)
446  */
447  selec = 1.0 / get_variable_numdistinct(vardata, &isdefault);
448  }
449 
450  /* now adjust if we wanted <> rather than = */
451  if (negate)
452  selec = 1.0 - selec - nullfrac;
453 
454  /* result should be in range, but make sure... */
455  CLAMP_PROBABILITY(selec);
456 
457  return selec;
458 }

References ATTSTATSSLOT_NUMBERS, ATTSTATSSLOT_VALUES, CLAMP_PROBABILITY, DatumGetBool(), fmgr_info(), free_attstatsslot(), FunctionCallInvoke, get_attstatsslot(), get_opcode(), get_variable_numdistinct(), GETSTRUCT, HeapTupleIsValid, i, InitFunctionCallInfoData, InvalidOid, VariableStatData::isunique, LOCAL_FCINFO, AttStatsSlot::nnumbers, AttStatsSlot::numbers, AttStatsSlot::nvalues, VariableStatData::rel, statistic_proc_security_check(), VariableStatData::statsTuple, RelOptInfo::tuples, and AttStatsSlot::values.

Referenced by boolvarsel(), eqsel_internal(), patternsel_common(), and prefix_selectivity().

◆ var_eq_non_const()

double var_eq_non_const ( VariableStatData vardata,
Oid  oproid,
Oid  collation,
Node other,
bool  varonleft,
bool  negate 
)

Definition at line 466 of file selfuncs.c.

469 {
470  double selec;
471  double nullfrac = 0.0;
472  bool isdefault;
473 
474  /*
475  * Grab the nullfrac for use below.
476  */
477  if (HeapTupleIsValid(vardata->statsTuple))
478  {
479  Form_pg_statistic stats;
480 
481  stats = (Form_pg_statistic) GETSTRUCT(vardata->statsTuple);
482  nullfrac = stats->stanullfrac;
483  }
484 
485  /*
486  * If we matched the var to a unique index or DISTINCT clause, assume
487  * there is exactly one match regardless of anything else. (This is
488  * slightly bogus, since the index or clause's equality operator might be
489  * different from ours, but it's much more likely to be right than
490  * ignoring the information.)
491  */
492  if (vardata->isunique && vardata->rel && vardata->rel->tuples >= 1.0)
493  {
494  selec = 1.0 / vardata->rel->tuples;
495  }
496  else if (HeapTupleIsValid(vardata->statsTuple))
497  {
498  double ndistinct;
499  AttStatsSlot sslot;
500 
501  /*
502  * Search is for a value that we do not know a priori, but we will
503  * assume it is not NULL. Estimate the selectivity as non-null
504  * fraction divided by number of distinct values, so that we get a
505  * result averaged over all possible values whether common or
506  * uncommon. (Essentially, we are assuming that the not-yet-known
507  * comparison value is equally likely to be any of the possible
508  * values, regardless of their frequency in the table. Is that a good
509  * idea?)
510  */
511  selec = 1.0 - nullfrac;
512  ndistinct = get_variable_numdistinct(vardata, &isdefault);
513  if (ndistinct > 1)
514  selec /= ndistinct;
515 
516  /*
517  * Cross-check: selectivity should never be estimated as more than the
518  * most common value's.
519  */
520  if (get_attstatsslot(&sslot, vardata->statsTuple,
521  STATISTIC_KIND_MCV, InvalidOid,
523  {
524  if (sslot.nnumbers > 0 && selec > sslot.numbers[0])
525  selec = sslot.numbers[0];
526  free_attstatsslot(&sslot);
527  }
528  }
529  else
530  {
531  /*
532  * No ANALYZE stats available, so make a guess using estimated number
533  * of distinct values and assuming they are equally common. (The guess
534  * is unlikely to be very good, but we do know a few special cases.)
535  */
536  selec = 1.0 / get_variable_numdistinct(vardata, &isdefault);
537  }
538 
539  /* now adjust if we wanted <> rather than = */
540  if (negate)
541  selec = 1.0 - selec - nullfrac;
542 
543  /* result should be in range, but make sure... */
544  CLAMP_PROBABILITY(selec);
545 
546  return selec;
547 }

References ATTSTATSSLOT_NUMBERS, CLAMP_PROBABILITY, free_attstatsslot(), get_attstatsslot(), get_variable_numdistinct(), GETSTRUCT, HeapTupleIsValid, InvalidOid, VariableStatData::isunique, AttStatsSlot::nnumbers, AttStatsSlot::numbers, VariableStatData::rel, VariableStatData::statsTuple, and RelOptInfo::tuples.

Referenced by eqsel_internal().

Variable Documentation

◆ get_index_stats_hook

PGDLLIMPORT get_index_stats_hook_type get_index_stats_hook
extern

Definition at line 148 of file selfuncs.c.

Referenced by brincostestimate(), btcostestimate(), and examine_variable().

◆ get_relation_stats_hook

PGDLLIMPORT get_relation_stats_hook_type get_relation_stats_hook
extern

Definition at line 147 of file selfuncs.c.

Referenced by brincostestimate(), btcostestimate(), and examine_simple_variable().