rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix oversight in planning for multiple indexscans driven by 

ScalarArrayOpExpr index quals: we were estimating the right total
number of rows returned, but treating the index-access part of the
cost as if a single scan were fetching that many consecutive index
tuples.  Actually we should treat it as a multiple indexscan, and
if there are enough of 'em the Mackert-Lohman discount should kick in.
This commit is contained in:
Tom Lane 2006-07-01 22:07:23 +00:00
parent cffd89ca73
commit 08ccdf020e
3 changed files with 84 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
src/backend/optimizer/path/costsize.c
View File

@ -54,7 +54,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.159 2006/07/01 18:38:32 tgl Exp $
* $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.160 2006/07/01 22:07:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -112,7 +112,6 @@ bool enable_hashjoin = true;
static bool cost_qual_eval_walker(Node *node, QualCost *total);
static int estimate_array_length(Node *arrayexpr);
static Selectivity approx_selectivity(PlannerInfo *root, List *quals,
JoinType jointype);
static Selectivity join_in_selectivity(JoinPath *path, PlannerInfo *root);
@ -691,34 +690,6 @@ cost_tidscan(Path *path, PlannerInfo *root,
path->total_cost = startup_cost + run_cost;
}
/*
* Estimate number of elements in the array yielded by an expression.
*/
static int
estimate_array_length(Node *arrayexpr)
{
if (arrayexpr && IsA(arrayexpr, Const))
{
Datum arraydatum = ((Const *) arrayexpr)->constvalue;
bool arrayisnull = ((Const *) arrayexpr)->constisnull;
ArrayType *arrayval;
if (arrayisnull)
return 0;
arrayval = DatumGetArrayTypeP(arraydatum);
return ArrayGetNItems(ARR_NDIM(arrayval), ARR_DIMS(arrayval));
}
else if (arrayexpr && IsA(arrayexpr, ArrayExpr))
{
return list_length(((ArrayExpr *) arrayexpr)->elements);
}
else
{
/* default guess */
return 10;
}
}
/*
* cost_subqueryscan
* Determines and returns the cost of scanning a subquery RTE.

89
src/backend/utils/adt/selfuncs.c
View File

@ -15,7 +15,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.207 2006/06/06 17:59:57 tgl Exp $
* $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.208 2006/07/01 22:07:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -1394,7 +1394,6 @@ scalararraysel(PlannerInfo *root,
{
oprsel = get_oprjoin(operator);
selarg4 = Int16GetDatum(jointype);
}
else
{
@ -1519,6 +1518,7 @@ scalararraysel(PlannerInfo *root,
s1 = useOr ? 0.0 : 1.0;
/*
* Arbitrarily assume 10 elements in the eventual array value
* (see also estimate_array_length)
*/
for (i = 0; i < 10; i++)
{
@ -1535,6 +1535,37 @@ scalararraysel(PlannerInfo *root,
return s1;
}
/*
* Estimate number of elements in the array yielded by an expression.
*
* It's important that this agree with scalararraysel.
*/
int
estimate_array_length(Node *arrayexpr)
{
if (arrayexpr && IsA(arrayexpr, Const))
{
Datum arraydatum = ((Const *) arrayexpr)->constvalue;
bool arrayisnull = ((Const *) arrayexpr)->constisnull;
ArrayType *arrayval;
if (arrayisnull)
return 0;
arrayval = DatumGetArrayTypeP(arraydatum);
return ArrayGetNItems(ARR_NDIM(arrayval), ARR_DIMS(arrayval));
}
else if (arrayexpr && IsA(arrayexpr, ArrayExpr) &&
!((ArrayExpr *) arrayexpr)->multidims)
{
return list_length(((ArrayExpr *) arrayexpr)->elements);
}
else
{
/* default guess --- see also scalararraysel */
return 10;
}
}
/*
* rowcomparesel - Selectivity of RowCompareExpr Node.
*
@ -4473,10 +4504,14 @@ genericcostestimate(PlannerInfo *root,
double *indexCorrelation)
{
double numIndexPages;
double num_sa_scans;
double num_outer_scans;
double num_scans;
QualCost index_qual_cost;
double qual_op_cost;
double qual_arg_cost;
List *selectivityQuals;
ListCell *l;
/*
* If the index is partial, AND the index predicate with the explicitly
@ -4513,6 +4548,25 @@ genericcostestimate(PlannerInfo *root,
else
selectivityQuals = indexQuals;
/*
* Check for ScalarArrayOpExpr index quals, and estimate the number
* of index scans that will be performed.
*/
num_sa_scans = 1;
foreach(l, indexQuals)
{
RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
if (IsA(rinfo->clause, ScalarArrayOpExpr))
{
ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) rinfo->clause;
int alength = estimate_array_length(lsecond(saop->args));
if (alength > 1)
num_sa_scans *= alength;
}
}
/* Estimate the fraction of main-table tuples that will be visited */
*indexSelectivity = clauselist_selectivity(root, selectivityQuals,
index->rel->relid,
@ -4527,8 +4581,15 @@ genericcostestimate(PlannerInfo *root,
numIndexTuples = *indexSelectivity * index->rel->tuples;
/*
* We can bound the number of tuples by the index size in any case. Also,
* always estimate at least one tuple is touched, even when
* The estimate obtained so far counts all the tuples returned by all
* scans of ScalarArrayOpExpr calls. We want to consider the per-scan
* number, so adjust. This is a handy place to round to integer, too.
*/
numIndexTuples = rint(numIndexTuples / num_sa_scans);
/*
* We can bound the number of tuples by the index size in any case.
* Also, always estimate at least one tuple is touched, even when
* indexSelectivity estimate is tiny.
*/
if (numIndexTuples > index->tuples)
@ -4556,7 +4617,8 @@ genericcostestimate(PlannerInfo *root,
*
* The above calculations are all per-index-scan. However, if we are
* in a nestloop inner scan, we can expect the scan to be repeated (with
* different search keys) for each row of the outer relation. This
* different search keys) for each row of the outer relation. Likewise,
* ScalarArrayOpExpr quals result in multiple index scans. This
* creates the potential for cache effects to reduce the number of
* disk page fetches needed. We want to estimate the average per-scan
* I/O cost in the presence of caching.
@ -4569,7 +4631,17 @@ genericcostestimate(PlannerInfo *root,
*/
if (outer_rel != NULL && outer_rel->rows > 1)
{
double num_scans = outer_rel->rows;
num_outer_scans = outer_rel->rows;
num_scans = num_sa_scans * num_outer_scans;
}
else
{
num_outer_scans = 1;
num_scans = num_sa_scans;
}
if (num_scans > 1)
{
double pages_fetched;
/* total page fetches ignoring cache effects */
@ -4582,9 +4654,10 @@ genericcostestimate(PlannerInfo *root,
/*
* Now compute the total disk access cost, and then report a
* pro-rated share for one index scan.
* pro-rated share for each outer scan. (Don't pro-rate for
* ScalarArrayOpExpr, since that's internal to the indexscan.)
*/
*indexTotalCost = (pages_fetched * random_page_cost) / num_scans;
*indexTotalCost = (pages_fetched * random_page_cost) / num_outer_scans;
}
else
{

3
src/include/utils/selfuncs.h
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/utils/selfuncs.h,v 1.33 2006/05/02 11:28:55 teodor Exp $
* $PostgreSQL: pgsql/src/include/utils/selfuncs.h,v 1.34 2006/07/01 22:07:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -151,6 +151,7 @@ extern Selectivity scalararraysel(PlannerInfo *root,
ScalarArrayOpExpr *clause,
bool is_join_clause,
int varRelid, JoinType jointype);
extern int estimate_array_length(Node *arrayexpr);
extern Selectivity rowcomparesel(PlannerInfo *root,
RowCompareExpr *clause,
int varRelid, JoinType jointype);