* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.272 2004/01/04 03:51:52 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.273 2004/01/05 05:07:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
RestrictInfo *newnode = makeNode(RestrictInfo);
COPY_NODE_FIELD(clause);
- COPY_SCALAR_FIELD(ispusheddown);
- COPY_SCALAR_FIELD(canjoin);
+ COPY_SCALAR_FIELD(is_pushed_down);
+ COPY_SCALAR_FIELD(valid_everywhere);
+ COPY_SCALAR_FIELD(can_join);
COPY_BITMAPSET_FIELD(clause_relids);
COPY_BITMAPSET_FIELD(left_relids);
COPY_BITMAPSET_FIELD(right_relids);
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.211 2003/12/30 23:53:14 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.212 2004/01/05 05:07:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
_equalRestrictInfo(RestrictInfo *a, RestrictInfo *b)
{
COMPARE_NODE_FIELD(clause);
- COMPARE_SCALAR_FIELD(ispusheddown);
+ COMPARE_SCALAR_FIELD(is_pushed_down);
+ COMPARE_SCALAR_FIELD(valid_everywhere);
/*
* We ignore all the remaining fields, since they may not be set yet,
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.225 2004/01/04 03:51:52 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.226 2004/01/05 05:07:35 tgl Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
WRITE_NODE_FIELD(indexqual);
WRITE_NODE_FIELD(indexjoinclauses);
WRITE_ENUM_FIELD(indexscandir, ScanDirection);
- WRITE_FLOAT_FIELD(rows, "%.2f");
+ WRITE_FLOAT_FIELD(rows, "%.0f");
}
static void
/* NB: this isn't a complete set of fields */
WRITE_NODE_FIELD(clause);
- WRITE_BOOL_FIELD(ispusheddown);
- WRITE_BOOL_FIELD(canjoin);
+ WRITE_BOOL_FIELD(is_pushed_down);
+ WRITE_BOOL_FIELD(valid_everywhere);
+ WRITE_BOOL_FIELD(can_join);
WRITE_BITMAPSET_FIELD(clause_relids);
WRITE_BITMAPSET_FIELD(left_relids);
WRITE_BITMAPSET_FIELD(right_relids);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/path/allpaths.c,v 1.110 2003/12/17 17:07:48 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/path/allpaths.c,v 1.111 2004/01/05 05:07:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/* Mark rel with estimated output rows, width, etc */
set_baserel_size_estimates(root, rel);
+ /* Test any partial indexes of rel for applicability */
+ check_partial_indexes(root, rel);
+
+ /*
+ * Check to see if we can extract any restriction conditions from
+ * join quals that are OR-of-AND structures. If so, add them to the
+ * rel's restriction list, and recompute the size estimates.
+ */
+ if (create_or_index_quals(root, rel))
+ set_baserel_size_estimates(root, rel);
+
/*
* Generate paths and add them to the rel's pathlist.
*
/* Consider index paths for both simple and OR index clauses */
create_index_paths(root, rel);
-
- /* create_index_paths must be done before create_or_index_paths */
create_or_index_paths(root, rel);
/* Now find the cheapest of the paths for this rel */
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.119 2004/01/04 03:51:52 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.120 2004/01/05 05:07:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
static bool cost_qual_eval_walker(Node *node, QualCost *total);
static Selectivity approx_selectivity(Query *root, List *quals,
JoinType jointype);
+static Selectivity join_in_selectivity(JoinPath *path, Query *root);
static void set_rel_width(Query *root, RelOptInfo *rel);
static double relation_byte_size(double tuples, int width);
static double page_size(double tuples, int width);
+/*
+ * clamp_row_est
+ * Force a row-count estimate to a sane value.
+ */
+double
+clamp_row_est(double nrows)
+{
+ /*
+ * Force estimate to be at least one row, to make explain output look
+ * better and to avoid possible divide-by-zero when interpolating
+ * costs. Make it an integer, too.
+ */
+ if (nrows < 1.0)
+ nrows = 1.0;
+ else
+ nrows = ceil(nrows);
+
+ return nrows;
+}
+
+
/*
* cost_seqscan
* Determines and returns the cost of scanning a relation sequentially.
*----------
*/
- tuples_fetched = indexSelectivity * baserel->tuples;
- /* Don't believe estimates less than 1... */
- if (tuples_fetched < 1.0)
- tuples_fetched = 1.0;
+ tuples_fetched = clamp_row_est(indexSelectivity * baserel->tuples);
/* This part is the Mackert and Lohman formula */
{
Path *outer_path = path->outerjoinpath;
Path *inner_path = path->innerjoinpath;
- List *restrictlist = path->joinrestrictinfo;
Cost startup_cost = 0;
Cost run_cost = 0;
Cost cpu_per_tuple;
double ntuples;
Selectivity joininfactor;
+ /*
+ * If inner path is an indexscan, be sure to use its estimated output row
+ * count, which may be lower than the restriction-clause-only row count of
+ * its parent. (We don't include this case in the PATH_ROWS macro because
+ * it applies *only* to a nestloop's inner relation.)
+ */
+ if (IsA(inner_path, IndexPath))
+ inner_path_rows = ((IndexPath *) inner_path)->rows;
+
if (!enable_nestloop)
startup_cost += disable_cost;
* If we're doing JOIN_IN then we will stop scanning inner tuples for
* an outer tuple as soon as we have one match. Account for the
* effects of this by scaling down the cost estimates in proportion to
- * the expected output size. (This assumes that all the quals
- * attached to the join are IN quals, which should be true.)
- *
- * Note: it's probably bogus to use the normal selectivity calculation
- * here when either the outer or inner path is a UniquePath.
+ * the JOIN_IN selectivity. (This assumes that all the quals
+ * attached to the join are IN quals, which should be true.) This would
+ * probably be the wrong approach if an input path is a UniquePath, but
+ * we'd never have that with JOIN_IN join type.
*/
- if (path->jointype == JOIN_IN)
- {
- Selectivity qual_selec = approx_selectivity(root, restrictlist,
- path->jointype);
- double qptuples;
-
- qptuples = ceil(qual_selec * outer_path_rows * inner_path_rows);
- if (qptuples > path->path.parent->rows)
- joininfactor = path->path.parent->rows / qptuples;
- else
- joininfactor = 1.0;
- }
- else
- joininfactor = 1.0;
+ joininfactor = join_in_selectivity(path, root);
/* cost of source data */
(inner_path->total_cost - inner_path->startup_cost) * joininfactor;
/*
- * Compute number of tuples processed (not number emitted!). If inner
- * path is an indexscan, be sure to use its estimated output row
- * count, which may be lower than the restriction-clause-only row
- * count of its parent. (We don't include this case in the PATH_ROWS
- * macro because it applies *only* to a nestloop's inner relation.)
- * Note: it is correct to use the unadjusted inner_path_rows in the
- * above calculation for joininfactor, since otherwise we'd be
- * double-counting the selectivity of the join clause being used for
- * the index.
+ * Compute number of tuples processed (not number emitted!)
*/
- if (IsA(inner_path, IndexPath))
- inner_path_rows = ((IndexPath *) inner_path)->rows;
-
- ntuples = inner_path_rows * outer_path_rows;
+ ntuples = outer_path_rows * inner_path_rows * joininfactor;
/* CPU costs */
- cost_qual_eval(&restrict_qual_cost, restrictlist);
+ cost_qual_eval(&restrict_qual_cost, path->joinrestrictinfo);
startup_cost += restrict_qual_cost.startup;
cpu_per_tuple = cpu_tuple_cost + restrict_qual_cost.per_tuple;
run_cost += cpu_per_tuple * ntuples;
{
Path *outer_path = path->jpath.outerjoinpath;
Path *inner_path = path->jpath.innerjoinpath;
- List *restrictlist = path->jpath.joinrestrictinfo;
List *mergeclauses = path->path_mergeclauses;
List *outersortkeys = path->outersortkeys;
List *innersortkeys = path->innersortkeys;
Cost run_cost = 0;
Cost cpu_per_tuple;
Selectivity merge_selec;
- Selectivity qp_selec;
QualCost merge_qual_cost;
QualCost qp_qual_cost;
RestrictInfo *firstclause;
- List *qpquals;
double outer_path_rows = PATH_ROWS(outer_path);
double inner_path_rows = PATH_ROWS(inner_path);
double outer_rows,
inner_rows;
double mergejointuples,
rescannedtuples;
- double qptuples;
double rescanratio;
Selectivity outerscansel,
innerscansel;
merge_selec = approx_selectivity(root, mergeclauses,
path->jpath.jointype);
cost_qual_eval(&merge_qual_cost, mergeclauses);
- qpquals = set_ptrDifference(restrictlist, mergeclauses);
- qp_selec = approx_selectivity(root, qpquals,
- path->jpath.jointype);
- cost_qual_eval(&qp_qual_cost, qpquals);
- freeList(qpquals);
+ cost_qual_eval(&qp_qual_cost, path->jpath.joinrestrictinfo);
+ qp_qual_cost.startup -= merge_qual_cost.startup;
+ qp_qual_cost.per_tuple -= merge_qual_cost.per_tuple;
/* approx # tuples passing the merge quals */
- mergejointuples = ceil(merge_selec * outer_path_rows * inner_path_rows);
- /* approx # tuples passing qpquals as well */
- qptuples = ceil(mergejointuples * qp_selec);
+ mergejointuples = clamp_row_est(merge_selec * outer_path_rows * inner_path_rows);
/*
* When there are equal merge keys in the outer relation, the
}
/* convert selectivity to row count; must scan at least one row */
-
- outer_rows = ceil(outer_path_rows * outerscansel);
- if (outer_rows < 1)
- outer_rows = 1;
- inner_rows = ceil(inner_path_rows * innerscansel);
- if (inner_rows < 1)
- inner_rows = 1;
+ outer_rows = clamp_row_est(outer_path_rows * outerscansel);
+ inner_rows = clamp_row_est(inner_path_rows * innerscansel);
/*
* Readjust scan selectivities to account for above rounding. This is
* for an outer tuple as soon as we have one match. Account for the
* effects of this by scaling down the cost estimates in proportion to
* the expected output size. (This assumes that all the quals
- * attached to the join are IN quals, which should be true.)
+ * attached to the join are IN quals, which should be true.) This would
+ * probably be the wrong approach if an input path is a UniquePath, but
+ * we'd never have that with JOIN_IN join type.
*/
- if (path->jpath.jointype == JOIN_IN &&
- qptuples > path->jpath.path.parent->rows)
- joininfactor = path->jpath.path.parent->rows / qptuples;
- else
- joininfactor = 1.0;
+ joininfactor = join_in_selectivity(&path->jpath, root);
/*
* The number of tuple comparisons needed is approximately number of
{
Path *outer_path = path->jpath.outerjoinpath;
Path *inner_path = path->jpath.innerjoinpath;
- List *restrictlist = path->jpath.joinrestrictinfo;
List *hashclauses = path->path_hashclauses;
Cost startup_cost = 0;
Cost run_cost = 0;
Cost cpu_per_tuple;
Selectivity hash_selec;
- Selectivity qp_selec;
QualCost hash_qual_cost;
QualCost qp_qual_cost;
double hashjointuples;
- double qptuples;
double outer_path_rows = PATH_ROWS(outer_path);
double inner_path_rows = PATH_ROWS(inner_path);
double outerbytes = relation_byte_size(outer_path_rows,
Selectivity innerbucketsize;
Selectivity joininfactor;
List *hcl;
- List *qpquals;
if (!enable_hashjoin)
startup_cost += disable_cost;
hash_selec = approx_selectivity(root, hashclauses,
path->jpath.jointype);
cost_qual_eval(&hash_qual_cost, hashclauses);
- qpquals = set_ptrDifference(restrictlist, hashclauses);
- qp_selec = approx_selectivity(root, qpquals,
- path->jpath.jointype);
- cost_qual_eval(&qp_qual_cost, qpquals);
- freeList(qpquals);
+ cost_qual_eval(&qp_qual_cost, path->jpath.joinrestrictinfo);
+ qp_qual_cost.startup -= hash_qual_cost.startup;
+ qp_qual_cost.per_tuple -= hash_qual_cost.per_tuple;
/* approx # tuples passing the hash quals */
- hashjointuples = ceil(hash_selec * outer_path_rows * inner_path_rows);
- /* approx # tuples passing qpquals as well */
- qptuples = ceil(hashjointuples * qp_selec);
+ hashjointuples = clamp_row_est(hash_selec * outer_path_rows * inner_path_rows);
/* cost of source data */
startup_cost += outer_path->startup_cost;
* an outer tuple as soon as we have one match. Account for the
* effects of this by scaling down the cost estimates in proportion to
* the expected output size. (This assumes that all the quals
- * attached to the join are IN quals, which should be true.)
+ * attached to the join are IN quals, which should be true.) This would
+ * probably be the wrong approach if an input path is a UniquePath, but
+ * we'd never have that with JOIN_IN join type.
*/
- if (path->jpath.jointype == JOIN_IN &&
- qptuples > path->jpath.path.parent->rows)
- joininfactor = path->jpath.path.parent->rows / qptuples;
- else
- joininfactor = 1.0;
+ joininfactor = join_in_selectivity(&path->jpath, root);
/*
* The number of tuple comparisons needed is the number of outer
*/
startup_cost += hash_qual_cost.startup;
run_cost += hash_qual_cost.per_tuple *
- outer_path_rows * ceil(inner_path_rows * innerbucketsize) *
+ outer_path_rows * clamp_row_est(inner_path_rows * innerbucketsize) *
joininfactor;
/*
void
set_baserel_size_estimates(Query *root, RelOptInfo *rel)
{
- double temp;
+ double nrows;
/* Should only be applied to base relations */
Assert(rel->relid > 0);
- temp = rel->tuples *
+ nrows = rel->tuples *
clauselist_selectivity(root,
rel->baserestrictinfo,
0,
JOIN_INNER);
- /*
- * Force estimate to be at least one row, to make explain output look
- * better and to avoid possible divide-by-zero when interpolating
- * cost. Make it an integer, too.
- */
- if (temp < 1.0)
- temp = 1.0;
- else
- temp = ceil(temp);
-
- rel->rows = temp;
+ rel->rows = clamp_row_est(nrows);
cost_qual_eval(&rel->baserestrictcost, rel->baserestrictinfo);
* rel1, JOIN_RIGHT). Also, JOIN_IN should produce the same result as
* JOIN_UNIQUE_INNER, likewise JOIN_REVERSE_IN == JOIN_UNIQUE_OUTER.
*
- * We set the same relnode fields as set_baserel_size_estimates() does.
+ * We set only the rows field here. The width field was already set by
+ * build_joinrel_tlist, and baserestrictcost is not used for join rels.
*/
void
set_joinrel_size_estimates(Query *root, RelOptInfo *rel,
List *restrictlist)
{
Selectivity selec;
- double temp;
+ double nrows;
UniquePath *upath;
/*
switch (jointype)
{
case JOIN_INNER:
- temp = outer_rel->rows * inner_rel->rows * selec;
+ nrows = outer_rel->rows * inner_rel->rows * selec;
break;
case JOIN_LEFT:
- temp = outer_rel->rows * inner_rel->rows * selec;
- if (temp < outer_rel->rows)
- temp = outer_rel->rows;
+ nrows = outer_rel->rows * inner_rel->rows * selec;
+ if (nrows < outer_rel->rows)
+ nrows = outer_rel->rows;
break;
case JOIN_RIGHT:
- temp = outer_rel->rows * inner_rel->rows * selec;
- if (temp < inner_rel->rows)
- temp = inner_rel->rows;
+ nrows = outer_rel->rows * inner_rel->rows * selec;
+ if (nrows < inner_rel->rows)
+ nrows = inner_rel->rows;
break;
case JOIN_FULL:
- temp = outer_rel->rows * inner_rel->rows * selec;
- if (temp < outer_rel->rows)
- temp = outer_rel->rows;
- if (temp < inner_rel->rows)
- temp = inner_rel->rows;
+ nrows = outer_rel->rows * inner_rel->rows * selec;
+ if (nrows < outer_rel->rows)
+ nrows = outer_rel->rows;
+ if (nrows < inner_rel->rows)
+ nrows = inner_rel->rows;
break;
case JOIN_IN:
case JOIN_UNIQUE_INNER:
upath = create_unique_path(root, inner_rel,
inner_rel->cheapest_total_path);
- temp = outer_rel->rows * upath->rows * selec;
- if (temp > outer_rel->rows)
- temp = outer_rel->rows;
+ nrows = outer_rel->rows * upath->rows * selec;
+ if (nrows > outer_rel->rows)
+ nrows = outer_rel->rows;
break;
case JOIN_REVERSE_IN:
case JOIN_UNIQUE_OUTER:
upath = create_unique_path(root, outer_rel,
outer_rel->cheapest_total_path);
- temp = upath->rows * inner_rel->rows * selec;
- if (temp > inner_rel->rows)
- temp = inner_rel->rows;
+ nrows = upath->rows * inner_rel->rows * selec;
+ if (nrows > inner_rel->rows)
+ nrows = inner_rel->rows;
break;
default:
elog(ERROR, "unrecognized join type: %d", (int) jointype);
- temp = 0; /* keep compiler quiet */
+ nrows = 0; /* keep compiler quiet */
break;
}
- /*
- * Force estimate to be at least one row, to make explain output look
- * better and to avoid possible divide-by-zero when interpolating
- * cost. Make it an integer, too.
- */
- if (temp < 1.0)
- temp = 1.0;
- else
- temp = ceil(temp);
+ rel->rows = clamp_row_est(nrows);
+}
+
+/*
+ * join_in_selectivity
+ * Determines the factor by which a JOIN_IN join's result is expected
+ * to be smaller than an ordinary inner join.
+ *
+ * 'path' is already filled in except for the cost fields
+ */
+static Selectivity
+join_in_selectivity(JoinPath *path, Query *root)
+{
+ Selectivity selec;
+ double nrows;
- rel->rows = temp;
+ if (path->jointype != JOIN_IN)
+ return 1.0;
/*
- * We need not compute the output width here, because
- * build_joinrel_tlist already did.
+ * Compute same result set_joinrel_size_estimates would compute
+ * for JOIN_INNER. Note that we use the input rels' absolute size
+ * estimates, not PATH_ROWS() which might be less; if we used PATH_ROWS()
+ * we'd be double-counting the effects of any join clauses used in
+ * input scans.
*/
+ selec = clauselist_selectivity(root,
+ path->joinrestrictinfo,
+ 0,
+ JOIN_INNER);
+ nrows = path->outerjoinpath->parent->rows *
+ path->innerjoinpath->parent->rows * selec;
+
+ nrows = clamp_row_est(nrows);
+
+ /* See if it's larger than the actual JOIN_IN size estimate */
+ if (nrows > path->path.parent->rows)
+ return path->path.parent->rows / nrows;
+ else
+ return 1.0;
}
/*
* The rel's targetlist and restrictinfo list must have been constructed
* already.
*
- * We set the following fields of the rel node:
- * rows: the estimated number of output tuples (after applying
- * restriction clauses).
- * width: the estimated average output tuple width in bytes.
- * baserestrictcost: estimated cost of evaluating baserestrictinfo clauses.
+ * We set the same fields as set_baserel_size_estimates.
*/
void
set_function_size_estimates(Query *root, RelOptInfo *rel)
{
- double temp;
-
/* Should only be applied to base relations that are functions */
Assert(rel->relid > 0);
Assert(rel->rtekind == RTE_FUNCTION);
*/
rel->tuples = 1000;
- /* Now estimate number of output rows */
- temp = rel->tuples *
- clauselist_selectivity(root,
- rel->baserestrictinfo,
- 0,
- JOIN_INNER);
-
- /*
- * Force estimate to be at least one row, to make explain output look
- * better and to avoid possible divide-by-zero when interpolating
- * cost. Make it an integer, too.
- */
- if (temp < 1.0)
- temp = 1.0;
- else
- temp = ceil(temp);
-
- rel->rows = temp;
-
- cost_qual_eval(&rel->baserestrictcost, rel->baserestrictinfo);
-
- set_rel_width(root, rel);
+ /* Now estimate number of output rows, etc */
+ set_baserel_size_estimates(root, rel);
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/path/indxpath.c,v 1.153 2004/01/04 03:51:52 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/path/indxpath.c,v 1.154 2004/01/05 05:07:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
RestrictInfo *rinfo);
static Oid indexable_operator(Expr *clause, Oid opclass,
bool indexkey_on_left);
-static bool pred_test(List *predicate_list, List *restrictinfo_list,
- List *joininfo_list);
+static bool pred_test(List *predicate_list, List *restrictinfo_list);
static bool pred_test_restrict_list(Expr *predicate, List *restrictinfo_list);
static bool pred_test_recurse_clause(Expr *predicate, Node *clause);
static bool pred_test_recurse_pred(Expr *predicate, Node *clause);
* and avoid repeated computation.
*
* 'rel' is the relation for which we want to generate index paths
+ *
+ * Note: check_partial_indexes() must have been run previously.
*/
void
create_index_paths(Query *root, RelOptInfo *rel)
{
- List *restrictinfo_list = rel->baserestrictinfo;
- List *joininfo_list = rel->joininfo;
Relids all_join_outerrelids = NULL;
List *ilist;
bool index_is_ordered;
Relids join_outerrelids;
- /*
- * If this is a partial index, we can only use it if it passes the
- * predicate test.
- */
- if (index->indpred != NIL)
- {
- if (!pred_test(index->indpred, restrictinfo_list, joininfo_list))
- continue;
- index->predOK = true; /* set flag for orindxpaths.c */
- }
+ /* Ignore partial indexes that do not match the query */
+ if (index->indpred != NIL && !index->predOK)
+ continue;
/*
* 1. Match the index against non-OR restriction clauses.
RestrictInfo *rinfo = (RestrictInfo *) lfirst(i);
/* Can't use pushed-down clauses in outer join */
- if (isouterjoin && rinfo->ispusheddown)
+ if (isouterjoin && rinfo->is_pushed_down)
continue;
if (match_clause_to_indexcol(rel,
RestrictInfo *rinfo = (RestrictInfo *) lfirst(j);
/* Can't use pushed-down clauses in outer join */
- if (isouterjoin && rinfo->ispusheddown)
+ if (isouterjoin && rinfo->is_pushed_down)
continue;
if (match_join_clause_to_indexcol(rel,
* ---- ROUTINES TO DO PARTIAL INDEX PREDICATE TESTS ----
****************************************************************************/
+/*
+ * check_partial_indexes
+ * Check each partial index of the relation, and mark it predOK or not
+ * depending on whether the predicate is satisfied for this query.
+ */
+void
+check_partial_indexes(Query *root, RelOptInfo *rel)
+{
+ List *restrictinfo_list = rel->baserestrictinfo;
+ List *ilist;
+
+ foreach(ilist, rel->indexlist)
+ {
+ IndexOptInfo *index = (IndexOptInfo *) lfirst(ilist);
+
+ /*
+ * If this is a partial index, we can only use it if it passes the
+ * predicate test.
+ */
+ if (index->indpred == NIL)
+ continue; /* ignore non-partial indexes */
+
+ index->predOK = pred_test(index->indpred, restrictinfo_list);
+ }
+}
+
/*
* pred_test
* Does the "predicate inclusion test" for partial indexes.
* to CNF format). --Nels, Jan '93
*/
static bool
-pred_test(List *predicate_list, List *restrictinfo_list, List *joininfo_list)
+pred_test(List *predicate_list, List *restrictinfo_list)
{
List *pred;
rel->relid, /* do not use 0! */
JOIN_INNER);
/* Like costsize.c, force estimate to be at least one row */
- if (pathnode->rows < 1.0)
- pathnode->rows = 1.0;
+ pathnode->rows = clamp_row_est(pathnode->rows);
cost_index(&pathnode->path, root, rel, index, indexquals, true);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/path/joinpath.c,v 1.84 2003/12/30 23:53:14 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/path/joinpath.c,v 1.85 2004/01/05 05:07:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
RestrictInfo *restrictinfo = (RestrictInfo *) lfirst(i);
- if (!restrictinfo->canjoin ||
+ if (!restrictinfo->can_join ||
restrictinfo->hashjoinoperator == InvalidOid)
continue; /* not hashjoinable */
* If processing an outer join, only use its own join clauses for
* hashing. For inner joins we need not be so picky.
*/
- if (isouterjoin && restrictinfo->ispusheddown)
+ if (isouterjoin && restrictinfo->is_pushed_down)
continue;
/*
*/
if (isouterjoin)
{
- if (restrictinfo->ispusheddown)
+ if (restrictinfo->is_pushed_down)
continue;
switch (jointype)
{
case JOIN_RIGHT:
- if (!restrictinfo->canjoin ||
+ if (!restrictinfo->can_join ||
restrictinfo->mergejoinoperator == InvalidOid)
return NIL; /* not mergejoinable */
break;
case JOIN_FULL:
- if (!restrictinfo->canjoin ||
+ if (!restrictinfo->can_join ||
restrictinfo->mergejoinoperator == InvalidOid)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
}
}
- if (!restrictinfo->canjoin ||
+ if (!restrictinfo->can_join ||
restrictinfo->mergejoinoperator == InvalidOid)
continue; /* not mergejoinable */
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/path/orindxpath.c,v 1.55 2004/01/04 00:07:32 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/path/orindxpath.c,v 1.56 2004/01/05 05:07:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
+#include "optimizer/clauses.h"
#include "optimizer/cost.h"
#include "optimizer/pathnode.h"
#include "optimizer/paths.h"
#include "optimizer/restrictinfo.h"
-static IndexPath *best_or_subclause_indices(Query *root, RelOptInfo *rel,
+static IndexPath *best_or_subclause_indexes(Query *root, RelOptInfo *rel,
List *subclauses);
static bool best_or_subclause_index(Query *root,
RelOptInfo *rel,
Cost *retTotalCost);
+/*----------
+ * create_or_index_quals
+ * Examine join OR-of-AND quals to see if any useful restriction OR
+ * clauses can be extracted. If so, add them to the query.
+ *
+ * Although a join clause must reference other relations overall,
+ * an OR of ANDs clause might contain sub-clauses that reference just this
+ * relation and can be used to build a restriction clause.
+ * For example consider
+ * WHERE ((a.x = 42 AND b.y = 43) OR (a.x = 44 AND b.z = 45));
+ * We can transform this into
+ * WHERE ((a.x = 42 AND b.y = 43) OR (a.x = 44 AND b.z = 45))
+ * AND (a.x = 42 OR a.x = 44)
+ * AND (b.y = 43 OR b.z = 45);
+ * which opens the potential to build OR indexscans on a and b. In essence
+ * this is a partial transformation to CNF (AND of ORs format). It is not
+ * complete, however, because we do not unravel the original OR --- doing so
+ * would usually bloat the qualification expression to little gain.
+ *
+ * The added quals are partially redundant with the original OR, and therefore
+ * will cause the size of the joinrel to be underestimated when it is finally
+ * formed. (This would be true of a full transformation to CNF as well; the
+ * fault is not really in the transformation, but in clauselist_selectivity's
+ * inability to recognize redundant conditions.) To minimize the collateral
+ * damage, we want to minimize the number of quals added. Therefore we do
+ * not add every possible extracted restriction condition to the query.
+ * Instead, we search for the single restriction condition that generates
+ * the most useful (cheapest) OR indexscan, and add only that condition.
+ * This is a pretty ad-hoc heuristic, but quite useful.
+ *
+ * We can then compensate for the redundancy of the added qual by poking
+ * the recorded selectivity of the original OR clause, thereby ensuring
+ * the added qual doesn't change the estimated size of the joinrel when
+ * it is finally formed. This is a MAJOR HACK: it depends on the fact
+ * that clause selectivities are cached and on the fact that the same
+ * RestrictInfo node will appear in every joininfo list that might be used
+ * when the joinrel is formed. And it probably isn't right in cases where
+ * the size estimation is nonlinear (i.e., outer and IN joins). But it
+ * beats not doing anything.
+ *
+ * NOTE: one might think this messiness could be worked around by generating
+ * the indexscan path with a small path->rows value, and not touching the
+ * rel's baserestrictinfo or rel->rows. However, that does not work.
+ * The optimizer's fundamental design assumes that every general-purpose
+ * Path for a given relation generates the same number of rows. Without
+ * this assumption we'd not be able to optimize solely on the cost of Paths,
+ * but would have to take number of output rows into account as well.
+ * (Perhaps someday that'd be worth doing, but it's a pretty big change...)
+ *
+ * 'rel' is the relation entry for which quals are to be created
+ *
+ * If successful, adds qual(s) to rel->baserestrictinfo and returns TRUE.
+ * If no quals available, returns FALSE and doesn't change rel.
+ *
+ * Note: check_partial_indexes() must have been run previously.
+ *----------
+ */
+bool
+create_or_index_quals(Query *root, RelOptInfo *rel)
+{
+ IndexPath *bestpath = NULL;
+ RestrictInfo *bestrinfo = NULL;
+ FastList orclauses;
+ List *orclause;
+ Expr *indxqual_or_expr;
+ RestrictInfo *or_rinfo;
+ Selectivity or_selec,
+ orig_selec;
+ List *i;
+
+ /*
+ * We use the best_or_subclause_indexes() machinery to locate the
+ * best combination of restriction subclauses. Note we must ignore
+ * any joinclauses that are not marked valid_everywhere, because they
+ * cannot be pushed down due to outer-join rules.
+ */
+ foreach(i, rel->joininfo)
+ {
+ JoinInfo *joininfo = (JoinInfo *) lfirst(i);
+ List *j;
+
+ foreach(j, joininfo->jinfo_restrictinfo)
+ {
+ RestrictInfo *rinfo = (RestrictInfo *) lfirst(j);
+
+ if (restriction_is_or_clause(rinfo) &&
+ rinfo->valid_everywhere)
+ {
+ IndexPath *pathnode;
+
+ pathnode = best_or_subclause_indexes(root,
+ rel,
+ ((BoolExpr *) rinfo->orclause)->args);
+
+ if (pathnode)
+ {
+ if (bestpath == NULL ||
+ pathnode->path.total_cost < bestpath->path.total_cost)
+ {
+ bestpath = pathnode;
+ bestrinfo = rinfo;
+ }
+ }
+ }
+ }
+ }
+
+ /* Fail if no suitable clauses found */
+ if (bestpath == NULL)
+ return false;
+
+ /*
+ * Build an expression representation of the indexqual, expanding
+ * the implicit OR and AND semantics of the first- and
+ * second-level lists.
+ */
+ FastListInit(&orclauses);
+ foreach(orclause, bestpath->indexqual)
+ FastAppend(&orclauses, make_ands_explicit(lfirst(orclause)));
+ indxqual_or_expr = make_orclause(FastListValue(&orclauses));
+
+ /*
+ * And add it to the rel's restriction list.
+ */
+ or_rinfo = make_restrictinfo(indxqual_or_expr, true, true);
+ rel->baserestrictinfo = lappend(rel->baserestrictinfo, or_rinfo);
+
+ /*
+ * Adjust the original OR clause's cached selectivity to compensate
+ * for the selectivity of the added (but redundant) lower-level qual.
+ * This should result in the join rel getting approximately the same
+ * rows estimate as it would have gotten without all these shenanigans.
+ * (XXX major hack alert ... this depends on the assumption that the
+ * selectivity will stay cached ...)
+ */
+ or_selec = clause_selectivity(root, (Node *) or_rinfo,
+ 0, JOIN_INNER);
+ if (or_selec > 0 && or_selec < 1)
+ {
+ orig_selec = clause_selectivity(root, (Node *) bestrinfo,
+ 0, JOIN_INNER);
+ bestrinfo->this_selec = orig_selec / or_selec;
+ /* clamp result to sane range */
+ if (bestrinfo->this_selec > 1)
+ bestrinfo->this_selec = 1;
+ }
+
+ /* Tell caller to recompute rel's rows estimate */
+ return true;
+}
+
/*
* create_or_index_paths
- * Creates multi-scan index paths for indices that match OR clauses.
+ * Creates multi-scan index paths for indexes that match OR clauses.
*
* 'rel' is the relation entry for which the paths are to be created
*
* Returns nothing, but adds paths to rel->pathlist via add_path().
*
- * Note: create_index_paths() must have been run already, since it does
- * the heavy lifting to determine whether partial indexes may be used.
+ * Note: check_partial_indexes() must have been run previously.
*/
void
create_or_index_paths(Query *root, RelOptInfo *rel)
{
IndexPath *pathnode;
- pathnode = best_or_subclause_indices(root,
+ pathnode = best_or_subclause_indexes(root,
rel,
((BoolExpr *) rinfo->orclause)->args);
add_path(rel, (Path *) pathnode);
}
}
-
- /*
- * Also consider join clauses that are ORs. Although a join clause
- * must reference other relations overall, an OR of ANDs clause might
- * contain sub-clauses that reference just our relation and can be
- * used to build a non-join indexscan. For example consider
- * WHERE (a.x = 42 AND b.y = 43) OR (a.x = 44 AND b.z = 45);
- * We could build an OR indexscan on a.x using those subclauses.
- *
- * XXX don't enable this code quite yet. Although the plans it creates
- * are correct, and possibly even useful, we are totally confused about
- * the number of rows returned, leading to poor choices of join plans
- * above the indexscan. Need to restructure the way join sizes are
- * calculated before this will really work.
- */
-#ifdef NOT_YET
- foreach(i, rel->joininfo)
- {
- JoinInfo *joininfo = (JoinInfo *) lfirst(i);
- List *j;
-
- foreach(j, joininfo->jinfo_restrictinfo)
- {
- RestrictInfo *rinfo = (RestrictInfo *) lfirst(j);
-
- if (restriction_is_or_clause(rinfo))
- {
- IndexPath *pathnode;
-
- pathnode = best_or_subclause_indices(root,
- rel,
- ((BoolExpr *) rinfo->orclause)->args);
-
- if (pathnode)
- add_path(rel, (Path *) pathnode);
- }
- }
- }
-#endif
}
/*
- * best_or_subclause_indices
+ * best_or_subclause_indexes
* Determine the best index to be used in conjunction with each subclause
* of an OR clause, and build a Path for a multi-index scan.
*
* single tuple more than once).
*/
static IndexPath *
-best_or_subclause_indices(Query *root,
+best_or_subclause_indexes(Query *root,
RelOptInfo *rel,
List *subclauses)
{
/* We don't actually care what order the index scans in. */
pathnode->indexscandir = NoMovementScanDirection;
- /* XXX this may be wrong when using join OR clauses... */
+ /*
+ * The number of rows is the same as the parent rel's estimate, since
+ * this isn't a join inner indexscan.
+ */
pathnode->rows = rel->rows;
return pathnode;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.161 2003/11/29 19:51:50 pgsql Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.162 2004/01/05 05:07:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
plan = (Plan *) make_unique(my_tlist, plan, sortList);
}
+ /* Adjust output size estimate (other fields should be OK already) */
plan->plan_rows = best_path->rows;
return plan;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/plan/initsplan.c,v 1.96 2004/01/04 03:51:52 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/plan/initsplan.c,v 1.97 2004/01/05 05:07:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
static void mark_baserels_for_outer_join(Query *root, Relids rels,
Relids outerrels);
static void distribute_qual_to_rels(Query *root, Node *clause,
- bool ispusheddown,
+ bool is_pushed_down,
bool isdeduced,
Relids outerjoin_nonnullable,
Relids qualscope);
* equijoined vars.
*
* 'clause': the qual clause to be distributed
- * 'ispusheddown': if TRUE, force the clause to be marked 'ispusheddown'
+ * 'is_pushed_down': if TRUE, force the clause to be marked 'is_pushed_down'
* (this indicates the clause came from a FromExpr, not a JoinExpr)
* 'isdeduced': TRUE if the qual came from implied-equality deduction
* 'outerjoin_nonnullable': NULL if not an outer-join qual, else the set of
*
* 'qualscope' identifies what level of JOIN the qual came from. For a top
* level qual (WHERE qual), qualscope lists all baserel ids and in addition
- * 'ispusheddown' will be TRUE.
+ * 'is_pushed_down' will be TRUE.
*/
static void
distribute_qual_to_rels(Query *root, Node *clause,
- bool ispusheddown,
+ bool is_pushed_down,
bool isdeduced,
Relids outerjoin_nonnullable,
Relids qualscope)
{
Relids relids;
+ bool valid_everywhere;
bool can_be_equijoin;
RestrictInfo *restrictinfo;
RelOptInfo *rel;
* the vars were equal).
*/
Assert(bms_equal(relids, qualscope));
+ valid_everywhere = true;
can_be_equijoin = true;
}
else if (bms_overlap(relids, outerjoin_nonnullable))
* result, so we treat it the same as an ordinary inner-join qual.
*/
relids = qualscope;
+ valid_everywhere = false;
can_be_equijoin = false;
}
else
* time we are called, the outerjoinset of each baserel will show
* exactly those outer joins that are below the qual in the join
* tree.
+ *
+ * We also need to determine whether the qual is "valid everywhere",
+ * which is true if the qual mentions no variables that are involved
+ * in lower-level outer joins (this may be an overly strong test).
*/
Relids addrelids = NULL;
Relids tmprelids;
int relno;
+ valid_everywhere = true;
tmprelids = bms_copy(relids);
while ((relno = bms_first_member(tmprelids)) >= 0)
{
RelOptInfo *rel = find_base_rel(root, relno);
if (rel->outerjoinset != NULL)
+ {
addrelids = bms_add_members(addrelids, rel->outerjoinset);
+ valid_everywhere = false;
+ }
}
bms_free(tmprelids);
* same joinrel. A qual originating from WHERE is always considered
* "pushed down".
*/
- if (!ispusheddown)
- ispusheddown = !bms_equal(relids, qualscope);
+ if (!is_pushed_down)
+ is_pushed_down = !bms_equal(relids, qualscope);
/*
* Build the RestrictInfo node itself.
*/
- restrictinfo = make_restrictinfo((Expr *) clause, ispusheddown);
+ restrictinfo = make_restrictinfo((Expr *) clause,
+ is_pushed_down,
+ valid_everywhere);
/*
* Figure out where to attach it.
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.96 2003/11/29 19:51:51 pgsql Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.97 2004/01/05 05:07:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
pathnode->rows = rel->rows;
- /*
- * Not sure if this is necessary, but it should help if the statistics
- * are too far off
- */
- if (index->indpred && index->tuples < pathnode->rows)
- pathnode->rows = index->tuples;
-
cost_index(&pathnode->path, root, rel, index, indexquals, false);
return pathnode;
pathnode->path.pathtype = T_TidScan;
pathnode->path.parent = rel;
pathnode->path.pathkeys = NIL;
+
pathnode->tideval = tideval;
cost_tidscan(&pathnode->path, root, rel, tideval);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/util/restrictinfo.c,v 1.23 2004/01/04 03:51:52 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/util/restrictinfo.c,v 1.24 2004/01/05 05:07:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/var.h"
-static Expr *make_sub_restrictinfos(Expr *clause, bool ispusheddown);
+static Expr *make_sub_restrictinfos(Expr *clause, bool is_pushed_down,
+ bool valid_everywhere);
static bool join_clause_is_redundant(Query *root,
RestrictInfo *rinfo,
List *reference_list,
*
* Build a RestrictInfo node containing the given subexpression.
*
- * The ispusheddown flag must be supplied by the caller. We initialize
- * fields that depend only on the given subexpression, leaving others that
- * depend on context (or may never be needed at all) to be filled later.
+ * The is_pushed_down and valid_everywhere flags must be supplied by the
+ * caller.
+ *
+ * We initialize fields that depend only on the given subexpression, leaving
+ * others that depend on context (or may never be needed at all) to be filled
+ * later.
*/
RestrictInfo *
-make_restrictinfo(Expr *clause, bool ispusheddown)
+make_restrictinfo(Expr *clause, bool is_pushed_down, bool valid_everywhere)
{
RestrictInfo *restrictinfo = makeNode(RestrictInfo);
restrictinfo->clause = clause;
- restrictinfo->ispusheddown = ispusheddown;
- restrictinfo->canjoin = false; /* may get set below */
+ restrictinfo->is_pushed_down = is_pushed_down;
+ restrictinfo->valid_everywhere = valid_everywhere;
+ restrictinfo->can_join = false; /* may get set below */
/*
* If it's a binary opclause, set up left/right relids info.
!bms_is_empty(restrictinfo->right_relids) &&
!bms_overlap(restrictinfo->left_relids,
restrictinfo->right_relids))
- restrictinfo->canjoin = true;
+ restrictinfo->can_join = true;
}
else
{
*/
if (or_clause((Node *) clause))
{
- restrictinfo->orclause = make_sub_restrictinfos(clause, ispusheddown);
+ restrictinfo->orclause = make_sub_restrictinfos(clause,
+ is_pushed_down,
+ valid_everywhere);
}
else
{
* Recursively insert sub-RestrictInfo nodes into a boolean expression.
*/
static Expr *
-make_sub_restrictinfos(Expr *clause, bool ispusheddown)
+make_sub_restrictinfos(Expr *clause, bool is_pushed_down,
+ bool valid_everywhere)
{
if (or_clause((Node *) clause))
{
foreach(temp, ((BoolExpr *) clause)->args)
orlist = lappend(orlist,
make_sub_restrictinfos(lfirst(temp),
- ispusheddown));
+ is_pushed_down,
+ valid_everywhere));
return make_orclause(orlist);
}
else if (and_clause((Node *) clause))
foreach(temp, ((BoolExpr *) clause)->args)
andlist = lappend(andlist,
make_sub_restrictinfos(lfirst(temp),
- ispusheddown));
+ is_pushed_down,
+ valid_everywhere));
return make_andclause(andlist);
}
else
- return (Expr *) make_restrictinfo(clause, ispusheddown);
+ return (Expr *) make_restrictinfo(clause,
+ is_pushed_down,
+ valid_everywhere);
}
/*
{
RestrictInfo *clause = (RestrictInfo *) lfirst(temp);
- if (clause->ispusheddown)
+ if (clause->is_pushed_down)
*otherquals = lappend(*otherquals, clause->clause);
else
*joinquals = lappend(*joinquals, clause->clause);
if (refrinfo->mergejoinoperator != InvalidOid &&
rinfo->left_pathkey == refrinfo->left_pathkey &&
rinfo->right_pathkey == refrinfo->right_pathkey &&
- (rinfo->ispusheddown == refrinfo->ispusheddown ||
+ (rinfo->is_pushed_down == refrinfo->is_pushed_down ||
!IS_OUTER_JOIN(jointype)))
{
redundant = true;
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/nodes/relation.h,v 1.90 2004/01/04 03:51:52 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/nodes/relation.h,v 1.91 2004/01/05 05:07:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
NodeTag type;
+ NodeTag pathtype; /* tag identifying scan/join method */
+
RelOptInfo *parent; /* the relation this path can build */
/* estimated execution costs for path (see costsize.c for more info) */
Cost total_cost; /* total cost (assuming all tuples
* fetched) */
- NodeTag pathtype; /* tag identifying scan/join method */
-
List *pathkeys; /* sort ordering of path's output */
/* pathkeys is a List of Lists of PathKeyItem nodes; see above */
} Path;
/*
* TidPath represents a scan by TID
+ *
+ * tideval is an implicitly OR'ed list of quals of the form CTID = something.
+ * Note they are bare quals, not RestrictInfos.
*/
typedef struct TidPath
{
* When we do form the outer join's joinrel, we still need to distinguish
* those quals that are actually in that join's JOIN/ON condition from those
* that appeared higher in the tree and were pushed down to the join rel
- * because they used no other rels. That's what the ispusheddown flag is for;
- * it tells us that a qual came from a point above the join of the specific
- * set of base rels that it uses (or that the JoinInfo structures claim it
- * uses). A clause that originally came from WHERE will *always* have its
- * ispusheddown flag set; a clause that came from an INNER JOIN condition,
- * but doesn't use all the rels being joined, will also have ispusheddown set
- * because it will get attached to some lower joinrel.
+ * because they used no other rels. That's what the is_pushed_down flag is
+ * for; it tells us that a qual came from a point above the join of the
+ * specific set of base rels that it uses (or that the JoinInfo structures
+ * claim it uses). A clause that originally came from WHERE will *always*
+ * have its is_pushed_down flag set; a clause that came from an INNER JOIN
+ * condition, but doesn't use all the rels being joined, will also have
+ * is_pushed_down set because it will get attached to some lower joinrel.
+ *
+ * We also store a valid_everywhere flag, which says that the clause is not
+ * affected by any lower-level outer join, and therefore any conditions it
+ * asserts can be presumed true throughout the plan tree.
*
* In general, the referenced clause might be arbitrarily complex. The
* kinds of clauses we can handle as indexscan quals, mergejoin clauses,
Expr *clause; /* the represented clause of WHERE or JOIN */
- bool ispusheddown; /* TRUE if clause was pushed down in level */
+ bool is_pushed_down; /* TRUE if clause was pushed down in level */
+
+ bool valid_everywhere; /* TRUE if valid on every level */
/*
* This flag is set true if the clause looks potentially useful as a
* (Whether the operator is actually merge or hash joinable isn't
* checked, however.)
*/
- bool canjoin;
+ bool can_join;
/* The set of relids (varnos) referenced in the clause: */
Relids clause_relids;
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/optimizer/cost.h,v 1.59 2004/01/04 03:51:52 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/optimizer/cost.h,v 1.60 2004/01/05 05:07:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern bool enable_mergejoin;
extern bool enable_hashjoin;
+extern double clamp_row_est(double nrows);
extern void cost_seqscan(Path *path, Query *root,
RelOptInfo *baserel);
extern void cost_index(Path *path, Query *root,
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/optimizer/paths.h,v 1.71 2004/01/04 00:07:32 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/optimizer/paths.h,v 1.72 2004/01/05 05:07:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Expr *orsubclause);
extern List *expand_indexqual_conditions(IndexOptInfo *index,
List *clausegroups);
+extern void check_partial_indexes(Query *root, RelOptInfo *rel);
/*
* orindxpath.c
* additional routines for indexable OR clauses
*/
+extern bool create_or_index_quals(Query *root, RelOptInfo *rel);
extern void create_or_index_paths(Query *root, RelOptInfo *rel);
/*
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/optimizer/restrictinfo.h,v 1.21 2004/01/04 00:07:32 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/optimizer/restrictinfo.h,v 1.22 2004/01/05 05:07:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/relation.h"
-extern RestrictInfo *make_restrictinfo(Expr *clause, bool ispusheddown);
+extern RestrictInfo *make_restrictinfo(Expr *clause, bool is_pushed_down,
+ bool valid_everywhere);
extern bool restriction_is_or_clause(RestrictInfo *restrictinfo);
extern List *get_actual_clauses(List *restrictinfo_list);
extern void get_actual_join_clauses(List *restrictinfo_list,
projects / postgresql.git / commitdiff