*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.227 2004/01/05 18:04:38 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.228 2004/01/05 23:39:53 tgl Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
_outPathInfo(str, (Path *) node);
WRITE_NODE_FIELD(indexinfo);
- WRITE_NODE_FIELD(indexqual);
- WRITE_NODE_FIELD(indexjoinclauses);
+ WRITE_NODE_FIELD(indexclauses);
+ WRITE_NODE_FIELD(indexquals);
+ WRITE_BOOL_FIELD(isjoininner);
WRITE_ENUM_FIELD(indexscandir, ScanDirection);
WRITE_FLOAT_FIELD(rows, "%.0f");
}
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.120 2004/01/05 05:07:35 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.121 2004/01/05 23:39:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* Any additional quals evaluated as qpquals may reduce the number of returned
* tuples, but they won't reduce the number of tuples we have to fetch from
* the table, so they don't reduce the scan cost.
+ *
+ * NOTE: as of 7.5, indexQuals is a list of RestrictInfo nodes, where formerly
+ * it was a list of bare clause expressions.
*/
void
cost_index(Path *path, Query *root,
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/path/indxpath.c,v 1.154 2004/01/05 05:07:35 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/path/indxpath.c,v 1.155 2004/01/05 23:39:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
RelOptInfo *rel, IndexOptInfo *index);
static bool match_special_index_operator(Expr *clause, Oid opclass,
bool indexkey_on_left);
-static List *expand_indexqual_condition(Expr *clause, Oid opclass);
+static List *expand_indexqual_condition(RestrictInfo *rinfo, Oid opclass);
static List *prefix_quals(Node *leftop, Oid opclass,
Const *prefix, Pattern_Prefix_Status pstatus);
static List *network_prefix_quals(Node *leftop, Oid expr_op, Oid opclass,
{
IndexPath *pathnode = makeNode(IndexPath);
List *indexquals,
- *allclauses,
- *l;
+ *allclauses;
/* XXX perhaps this code should be merged with create_index_path? */
*/
pathnode->path.pathkeys = NIL;
- /* Convert RestrictInfo nodes to indexquals the executor can handle */
+ /* Convert clauses to indexquals the executor can handle */
indexquals = expand_indexqual_conditions(index, clausegroups);
- /*
- * Also make a flattened list of the RestrictInfo nodes; createplan.c
- * will need this later. We assume here that we can destructively
- * modify the passed-in clausegroups list structure.
- */
- allclauses = NIL;
- foreach(l, clausegroups)
- {
- /* nconc okay here since same clause couldn't be in two sublists */
- allclauses = nconc(allclauses, (List *) lfirst(l));
- }
+ /* Flatten the clausegroups list to produce indexclauses list */
+ allclauses = flatten_clausegroups_list(clausegroups);
/*
* Note that we are making a pathnode for a single-scan indexscan;
- * therefore, indexinfo and indexqual should be single-element lists.
+ * therefore, indexinfo etc should be single-element lists.
*/
pathnode->indexinfo = makeList1(index);
- pathnode->indexqual = makeList1(indexquals);
- pathnode->indexjoinclauses = makeList1(allclauses);
+ pathnode->indexclauses = makeList1(allclauses);
+ pathnode->indexquals = makeList1(indexquals);
+
+ pathnode->isjoininner = true;
/* We don't actually care what order the index scans in ... */
pathnode->indexscandir = NoMovementScanDirection;
return (Path *) pathnode;
}
+/*
+ * flatten_clausegroups_list
+ * Given a list of lists of RestrictInfos, flatten it to a list
+ * of RestrictInfos.
+ *
+ * This is used to flatten out the result of group_clauses_by_indexkey()
+ * or one of its sibling routines, to produce an indexclauses list.
+ */
+List *
+flatten_clausegroups_list(List *clausegroups)
+{
+ List *allclauses = NIL;
+ List *l;
+
+ foreach(l, clausegroups)
+ {
+ allclauses = nconc(allclauses, listCopy((List *) lfirst(l)));
+ }
+ return allclauses;
+}
+
+/*
+ * make_expr_from_indexclauses()
+ * Given an indexclauses structure, produce an ordinary boolean expression.
+ *
+ * This consists of stripping out the RestrictInfo nodes and inserting
+ * explicit AND and OR nodes as needed. There's not much to it, but
+ * the functionality is needed in a few places, so centralize the logic.
+ */
+Expr *
+make_expr_from_indexclauses(List *indexclauses)
+{
+ List *orclauses = NIL;
+ List *orlist;
+
+ /* There's no such thing as an indexpath with zero scans */
+ Assert(indexclauses != NIL);
+
+ foreach(orlist, indexclauses)
+ {
+ List *andlist = (List *) lfirst(orlist);
+
+ /* Strip RestrictInfos */
+ andlist = get_actual_clauses(andlist);
+ /* Insert AND node if needed, and add to orclauses list */
+ orclauses = lappend(orclauses, make_ands_explicit(andlist));
+ }
+
+ if (length(orclauses) > 1)
+ return make_orclause(orclauses);
+ else
+ return (Expr *) lfirst(orclauses);
+}
+
+
/****************************************************************************
* ---- ROUTINES TO CHECK OPERANDS ----
****************************************************************************/
RestrictInfo *rinfo = (RestrictInfo *) lfirst(i);
FastConc(&resultquals,
- expand_indexqual_condition(rinfo->clause,
- curClass));
+ expand_indexqual_condition(rinfo, curClass));
}
clausegroups = lnext(clausegroups);
/*
* expand_indexqual_condition --- expand a single indexqual condition
+ *
+ * The input is a single RestrictInfo, the output a list of RestrictInfos
*/
static List *
-expand_indexqual_condition(Expr *clause, Oid opclass)
+expand_indexqual_condition(RestrictInfo *rinfo, Oid opclass)
{
+ Expr *clause = rinfo->clause;
/* we know these will succeed */
Node *leftop = get_leftop(clause);
Node *rightop = get_rightop(clause);
break;
default:
- result = makeList1(clause);
+ result = makeList1(rinfo);
break;
}
elog(ERROR, "no = operator for opclass %u", opclass);
expr = make_opclause(oproid, BOOLOID, false,
(Expr *) leftop, (Expr *) prefix_const);
- result = makeList1(expr);
+ result = makeList1(make_restrictinfo(expr, true, true));
return result;
}
elog(ERROR, "no >= operator for opclass %u", opclass);
expr = make_opclause(oproid, BOOLOID, false,
(Expr *) leftop, (Expr *) prefix_const);
- result = makeList1(expr);
+ result = makeList1(make_restrictinfo(expr, true, true));
/*-------
* If we can create a string larger than the prefix, we can say
elog(ERROR, "no < operator for opclass %u", opclass);
expr = make_opclause(oproid, BOOLOID, false,
(Expr *) leftop, (Expr *) greaterstr);
- result = lappend(result, expr);
+ result = lappend(result, make_restrictinfo(expr, true, true));
}
return result;
(Expr *) leftop,
(Expr *) makeConst(datatype, -1, opr1right,
false, false));
- result = makeList1(expr);
+ result = makeList1(make_restrictinfo(expr, true, true));
/* create clause "key <= network_scan_last( rightop )" */
(Expr *) leftop,
(Expr *) makeConst(datatype, -1, opr2right,
false, false));
- result = lappend(result, expr);
+ result = lappend(result, make_restrictinfo(expr, true, true));
return result;
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/path/orindxpath.c,v 1.56 2004/01/05 05:07:35 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/path/orindxpath.c,v 1.57 2004/01/05 23:39:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
RelOptInfo *rel,
Expr *subclause,
IndexOptInfo **retIndexInfo,
- List **retIndexQual,
+ List **retIndexClauses,
+ List **retIndexQuals,
Cost *retStartupCost,
Cost *retTotalCost);
{
IndexPath *bestpath = NULL;
RestrictInfo *bestrinfo = NULL;
- FastList orclauses;
- List *orclause;
- Expr *indxqual_or_expr;
+ List *newrinfos;
RestrictInfo *or_rinfo;
Selectivity or_selec,
orig_selec;
return false;
/*
- * Build an expression representation of the indexqual, expanding
- * the implicit OR and AND semantics of the first- and
- * second-level lists.
+ * Convert the indexclauses structure to a RestrictInfo tree,
+ * and add it to the rel's restriction list.
*/
- 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);
+ newrinfos = make_restrictinfo_from_indexclauses(bestpath->indexclauses,
+ true, true);
+ Assert(length(newrinfos) == 1);
+ or_rinfo = (RestrictInfo *) lfirst(newrinfos);
+ rel->baserestrictinfo = nconc(rel->baserestrictinfo, newrinfos);
/*
* Adjust the original OR clause's cached selectivity to compensate
List *subclauses)
{
FastList infos;
+ FastList clauses;
FastList quals;
Cost path_startup_cost;
Cost path_total_cost;
IndexPath *pathnode;
FastListInit(&infos);
+ FastListInit(&clauses);
FastListInit(&quals);
path_startup_cost = 0;
path_total_cost = 0;
{
Expr *subclause = lfirst(slist);
IndexOptInfo *best_indexinfo;
- List *best_indexqual;
+ List *best_indexclauses;
+ List *best_indexquals;
Cost best_startup_cost;
Cost best_total_cost;
if (!best_or_subclause_index(root, rel, subclause,
- &best_indexinfo, &best_indexqual,
+ &best_indexinfo,
+ &best_indexclauses, &best_indexquals,
&best_startup_cost, &best_total_cost))
return NULL; /* failed to match this subclause */
FastAppend(&infos, best_indexinfo);
- FastAppend(&quals, best_indexqual);
+ FastAppend(&clauses, best_indexclauses);
+ FastAppend(&quals, best_indexquals);
/*
* Path startup_cost is the startup cost for the first index scan only;
* startup costs for later scans will be paid later on, so they just
pathnode->path.pathkeys = NIL;
pathnode->indexinfo = FastListValue(&infos);
- pathnode->indexqual = FastListValue(&quals);
+ pathnode->indexclauses = FastListValue(&clauses);
+ pathnode->indexquals = FastListValue(&quals);
/* It's not an innerjoin path. */
- pathnode->indexjoinclauses = NIL;
+ pathnode->isjoininner = false;
/* We don't actually care what order the index scans in. */
pathnode->indexscandir = NoMovementScanDirection;
* 'subclause' is the OR subclause being considered
*
* '*retIndexInfo' gets the IndexOptInfo of the best index
- * '*retIndexQual' gets a list of the indexqual conditions for the best index
+ * '*retIndexClauses' gets a list of the index clauses for the best index
+ * '*retIndexQuals' gets a list of the expanded indexquals for the best index
* '*retStartupCost' gets the startup cost of a scan with that index
* '*retTotalCost' gets the total cost of a scan with that index
*/
RelOptInfo *rel,
Expr *subclause,
IndexOptInfo **retIndexInfo, /* return value */
- List **retIndexQual, /* return value */
+ List **retIndexClauses, /* return value */
+ List **retIndexQuals, /* return value */
Cost *retStartupCost, /* return value */
Cost *retTotalCost) /* return value */
{
foreach(ilist, rel->indexlist)
{
IndexOptInfo *index = (IndexOptInfo *) lfirst(ilist);
- List *qualrinfos;
+ List *indexclauses;
List *indexquals;
Path subclause_path;
continue;
/* Collect index clauses usable with this index */
- qualrinfos = group_clauses_by_indexkey_for_or(rel, index, subclause);
+ indexclauses = group_clauses_by_indexkey_for_or(rel, index, subclause);
/* Ignore index if it doesn't match the subclause at all */
- if (qualrinfos == NIL)
+ if (indexclauses == NIL)
continue;
- /* Convert RestrictInfo nodes to indexquals the executor can handle */
- indexquals = expand_indexqual_conditions(index, qualrinfos);
+ /* Convert clauses to indexquals the executor can handle */
+ indexquals = expand_indexqual_conditions(index, indexclauses);
cost_index(&subclause_path, root, rel, index, indexquals, false);
if (!found || subclause_path.total_cost < *retTotalCost)
{
*retIndexInfo = index;
- *retIndexQual = indexquals;
+ *retIndexClauses = flatten_clausegroups_list(indexclauses);
+ *retIndexQuals = indexquals;
*retStartupCost = subclause_path.startup_cost;
*retTotalCost = subclause_path.total_cost;
found = true;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.163 2004/01/05 18:04:38 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.164 2004/01/05 23:39:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
static Result *create_result_plan(Query *root, ResultPath *best_path);
static Material *create_material_plan(Query *root, MaterialPath *best_path);
static Plan *create_unique_plan(Query *root, UniquePath *best_path);
-static SeqScan *create_seqscan_plan(Path *best_path, List *tlist,
- List *scan_clauses);
+static SeqScan *create_seqscan_plan(Query *root, Path *best_path,
+ List *tlist, List *scan_clauses);
static IndexScan *create_indexscan_plan(Query *root, IndexPath *best_path,
List *tlist, List *scan_clauses);
-static TidScan *create_tidscan_plan(TidPath *best_path, List *tlist,
- List *scan_clauses);
-static SubqueryScan *create_subqueryscan_plan(Path *best_path,
+static TidScan *create_tidscan_plan(Query *root, TidPath *best_path,
+ List *tlist, List *scan_clauses);
+static SubqueryScan *create_subqueryscan_plan(Query *root, Path *best_path,
List *tlist, List *scan_clauses);
-static FunctionScan *create_functionscan_plan(Path *best_path,
+static FunctionScan *create_functionscan_plan(Query *root, Path *best_path,
List *tlist, List *scan_clauses);
static NestLoop *create_nestloop_plan(Query *root, NestPath *best_path,
Plan *outer_plan, Plan *inner_plan);
* Extract the relevant restriction clauses from the parent relation;
* the executor must apply all these restrictions during the scan.
*/
- scan_clauses = get_actual_clauses(rel->baserestrictinfo);
-
- /* Sort clauses into best execution order */
- scan_clauses = order_qual_clauses(root, scan_clauses);
+ scan_clauses = rel->baserestrictinfo;
switch (best_path->pathtype)
{
case T_SeqScan:
- plan = (Scan *) create_seqscan_plan(best_path,
+ plan = (Scan *) create_seqscan_plan(root,
+ best_path,
tlist,
scan_clauses);
break;
break;
case T_TidScan:
- plan = (Scan *) create_tidscan_plan((TidPath *) best_path,
+ plan = (Scan *) create_tidscan_plan(root,
+ (TidPath *) best_path,
tlist,
scan_clauses);
break;
case T_SubqueryScan:
- plan = (Scan *) create_subqueryscan_plan(best_path,
+ plan = (Scan *) create_subqueryscan_plan(root,
+ best_path,
tlist,
scan_clauses);
break;
case T_FunctionScan:
- plan = (Scan *) create_functionscan_plan(best_path,
+ plan = (Scan *) create_functionscan_plan(root,
+ best_path,
tlist,
scan_clauses);
break;
* with restriction clauses 'scan_clauses' and targetlist 'tlist'.
*/
static SeqScan *
-create_seqscan_plan(Path *best_path, List *tlist, List *scan_clauses)
+create_seqscan_plan(Query *root, Path *best_path,
+ List *tlist, List *scan_clauses)
{
SeqScan *scan_plan;
Index scan_relid = best_path->parent->relid;
Assert(scan_relid > 0);
Assert(best_path->parent->rtekind == RTE_RELATION);
+ /* Reduce RestrictInfo list to bare expressions */
+ scan_clauses = get_actual_clauses(scan_clauses);
+
+ /* Sort clauses into best execution order */
+ scan_clauses = order_qual_clauses(root, scan_clauses);
+
scan_plan = make_seqscan(tlist,
scan_clauses,
scan_relid);
* Returns a indexscan plan for the base relation scanned by 'best_path'
* with restriction clauses 'scan_clauses' and targetlist 'tlist'.
*
- * The indexqual of the path contains a sublist of implicitly-ANDed qual
- * conditions for each scan of the index(es); if there is more than one
- * scan then the retrieved tuple sets are ORed together. The indexqual
+ * The indexquals list of the path contains a sublist of implicitly-ANDed
+ * qual conditions for each scan of the index(es); if there is more than one
+ * scan then the retrieved tuple sets are ORed together. The indexquals
* and indexinfo lists must have the same length, ie, the number of scans
* that will occur. Note it is possible for a qual condition sublist
* to be empty --- then no index restrictions will be applied during that
List *tlist,
List *scan_clauses)
{
- List *indxqual = best_path->indexqual;
+ List *indxquals = best_path->indexquals;
Index baserelid = best_path->path.parent->relid;
List *qpqual;
Expr *indxqual_or_expr = NULL;
- List *fixed_indxqual;
- List *recheck_indxqual;
+ List *stripped_indxquals;
+ List *fixed_indxquals;
+ List *recheck_indxquals;
List *indxstrategy;
List *indxsubtype;
FastList indexids;
- List *ixinfo;
+ List *i;
IndexScan *scan_plan;
/* it should be a base rel... */
Assert(best_path->path.parent->rtekind == RTE_RELATION);
/*
- * Build list of index OIDs.
+ * If this is a innerjoin scan, the indexclauses will contain join
+ * clauses that are not present in scan_clauses (since the passed-in
+ * value is just the rel's baserestrictinfo list). We must add these
+ * clauses to scan_clauses to ensure they get checked. In most cases
+ * we will remove the join clauses again below, but if a join clause
+ * contains a lossy or special operator, we need to make sure it gets
+ * into scan_clauses.
*/
+ if (best_path->isjoininner)
+ {
+ /*
+ * We don't currently support OR indexscans in joins, so we only
+ * need to worry about the plain AND case. Also, pointer comparison
+ * should be enough to determine RestrictInfo matches.
+ */
+ Assert(length(best_path->indexclauses) == 1);
+ scan_clauses = set_ptrUnion(scan_clauses,
+ (List *) lfirst(best_path->indexclauses));
+ }
+
+ /* Reduce RestrictInfo list to bare expressions */
+ scan_clauses = get_actual_clauses(scan_clauses);
+
+ /* Sort clauses into best execution order */
+ scan_clauses = order_qual_clauses(root, scan_clauses);
+
+ /* Build list of index OIDs */
FastListInit(&indexids);
- foreach(ixinfo, best_path->indexinfo)
+ foreach(i, best_path->indexinfo)
{
- IndexOptInfo *index = (IndexOptInfo *) lfirst(ixinfo);
+ IndexOptInfo *index = (IndexOptInfo *) lfirst(i);
FastAppendo(&indexids, index->indexoid);
}
+ /*
+ * Build "stripped" indexquals structure (no RestrictInfos) to pass to
+ * executor as indxqualorig
+ */
+ stripped_indxquals = NIL;
+ foreach(i, indxquals)
+ {
+ List *andlist = (List *) lfirst(i);
+
+ stripped_indxquals = lappend(stripped_indxquals,
+ get_actual_clauses(andlist));
+ }
+
/*
* The qpqual list must contain all restrictions not automatically
- * handled by the index. Normally the predicates in the indxqual are
+ * handled by the index. Normally the predicates in the indexquals are
* checked fully by the index, but if the index is "lossy" for a
* particular operator (as signaled by the amopreqcheck flag in
* pg_amop), then we need to double-check that predicate in qpqual,
* because the index may return more tuples than match the predicate.
*
* Since the indexquals were generated from the restriction clauses given
- * by scan_clauses, there will normally be some duplications between
- * the lists. We get rid of the duplicates, then add back if lossy.
+ * by scan_clauses, there will normally be duplications between the lists.
+ * We get rid of the duplicates, then add back if lossy.
*/
- if (length(indxqual) > 1)
+ if (length(indxquals) > 1)
{
/*
* Build an expression representation of the indexqual, expanding
* the implicit OR and AND semantics of the first- and
* second-level lists.
*/
- FastList orclauses;
- List *orclause;
-
- FastListInit(&orclauses);
- foreach(orclause, indxqual)
- FastAppend(&orclauses, make_ands_explicit(lfirst(orclause)));
- indxqual_or_expr = make_orclause(FastListValue(&orclauses));
-
+ indxqual_or_expr = make_expr_from_indexclauses(indxquals);
qpqual = set_difference(scan_clauses, makeList1(indxqual_or_expr));
}
- else if (indxqual != NIL)
+ else
{
/*
* Here, we can simply treat the first sublist as an independent
* set of qual expressions, since there is no top-level OR
* behavior.
*/
- qpqual = set_difference(scan_clauses, lfirst(indxqual));
+ Assert(stripped_indxquals != NIL);
+ qpqual = set_difference(scan_clauses, lfirst(stripped_indxquals));
}
- else
- qpqual = scan_clauses;
/*
* The executor needs a copy with the indexkey on the left of each
* clause and with index attr numbers substituted for table ones. This
* pass also looks for "lossy" operators.
*/
- fix_indxqual_references(indxqual, best_path,
- &fixed_indxqual, &recheck_indxqual,
+ fix_indxqual_references(indxquals, best_path,
+ &fixed_indxquals, &recheck_indxquals,
&indxstrategy, &indxsubtype);
/*
* appropriate qual clauses to the qpqual. When there is just one
* indexscan being performed (ie, we have simple AND semantics), we
* can just add the lossy clauses themselves to qpqual. If we have
- * OR-of-ANDs, we'd better add the entire original indexqual to make
+ * OR-of-ANDs, we'd better add the entire original indexquals to make
* sure that the semantics are correct.
*/
- if (recheck_indxqual != NIL)
+ if (recheck_indxquals != NIL)
{
if (indxqual_or_expr)
{
else
{
/* Subroutine already copied quals, so just append to list */
- Assert(length(recheck_indxqual) == 1);
- qpqual = nconc(qpqual, (List *) lfirst(recheck_indxqual));
+ Assert(length(recheck_indxquals) == 1);
+ qpqual = nconc(qpqual, (List *) lfirst(recheck_indxquals));
}
}
qpqual,
baserelid,
FastListValue(&indexids),
- fixed_indxqual,
- indxqual,
+ fixed_indxquals,
+ stripped_indxquals,
indxstrategy,
indxsubtype,
best_path->indexscandir);
* with restriction clauses 'scan_clauses' and targetlist 'tlist'.
*/
static TidScan *
-create_tidscan_plan(TidPath *best_path, List *tlist, List *scan_clauses)
+create_tidscan_plan(Query *root, TidPath *best_path,
+ List *tlist, List *scan_clauses)
{
TidScan *scan_plan;
Index scan_relid = best_path->path.parent->relid;
Assert(scan_relid > 0);
Assert(best_path->path.parent->rtekind == RTE_RELATION);
+ /* Reduce RestrictInfo list to bare expressions */
+ scan_clauses = get_actual_clauses(scan_clauses);
+
+ /* Sort clauses into best execution order */
+ scan_clauses = order_qual_clauses(root, scan_clauses);
+
scan_plan = make_tidscan(tlist,
scan_clauses,
scan_relid,
* with restriction clauses 'scan_clauses' and targetlist 'tlist'.
*/
static SubqueryScan *
-create_subqueryscan_plan(Path *best_path, List *tlist, List *scan_clauses)
+create_subqueryscan_plan(Query *root, Path *best_path,
+ List *tlist, List *scan_clauses)
{
SubqueryScan *scan_plan;
Index scan_relid = best_path->parent->relid;
Assert(scan_relid > 0);
Assert(best_path->parent->rtekind == RTE_SUBQUERY);
+ /* Reduce RestrictInfo list to bare expressions */
+ scan_clauses = get_actual_clauses(scan_clauses);
+
+ /* Sort clauses into best execution order */
+ scan_clauses = order_qual_clauses(root, scan_clauses);
+
scan_plan = make_subqueryscan(tlist,
scan_clauses,
scan_relid,
* with restriction clauses 'scan_clauses' and targetlist 'tlist'.
*/
static FunctionScan *
-create_functionscan_plan(Path *best_path, List *tlist, List *scan_clauses)
+create_functionscan_plan(Query *root, Path *best_path,
+ List *tlist, List *scan_clauses)
{
FunctionScan *scan_plan;
Index scan_relid = best_path->parent->relid;
Assert(scan_relid > 0);
Assert(best_path->parent->rtekind == RTE_FUNCTION);
+ /* Reduce RestrictInfo list to bare expressions */
+ scan_clauses = get_actual_clauses(scan_clauses);
+
+ /* Sort clauses into best execution order */
+ scan_clauses = order_qual_clauses(root, scan_clauses);
+
scan_plan = make_functionscan(tlist, scan_clauses, scan_relid);
copy_path_costsize(&scan_plan->scan.plan, best_path);
* have caught this case because the join clauses would never have
* been put in the same joininfo list.
*
- * This would be a waste of time if the indexpath was an ordinary
- * indexpath and not a special innerjoin path. We will skip it in
- * that case since indexjoinclauses is NIL in an ordinary
- * indexpath.
+ * We can skip this if the index path is an ordinary indexpath and
+ * not a special innerjoin path.
*/
IndexPath *innerpath = (IndexPath *) best_path->innerjoinpath;
- List *indexjoinclauses = innerpath->indexjoinclauses;
+ List *indexclauses = innerpath->indexclauses;
- if (length(indexjoinclauses) == 1) /* single indexscan? */
+ if (innerpath->isjoininner &&
+ length(indexclauses) == 1) /* single indexscan? */
{
joinrestrictclauses =
select_nonredundant_join_clauses(root,
joinrestrictclauses,
- lfirst(indexjoinclauses),
+ lfirst(indexclauses),
best_path->jointype);
}
}
* Adjust indexqual clauses to the form the executor's indexqual
* machinery needs, and check for recheckable (lossy) index conditions.
*
- * We have four tasks here:
+ * We have five tasks here:
+ * * Remove RestrictInfo nodes from the input clauses.
* * Index keys must be represented by Var nodes with varattno set to the
* index's attribute number, not the attribute number in the original rel.
* * If the index key is on the right, commute the clause to put it on the
*
* Both the input list and the output lists have the form of lists of sublists
* of qual clauses --- the top-level list has one entry for each indexscan
- * to be performed. The semantics are OR-of-ANDs.
+ * to be performed. The semantics are OR-of-ANDs. Note however that the
+ * input list contains RestrictInfos, while the output lists do not.
*
* fixed_indexquals receives a modified copy of the indexqual list --- the
* original is not changed. Note also that the copy shares no substructure
* with the original; this is needed in case there is a subplan in it (we need
* two separate copies of the subplan tree, or things will go awry).
*
- * recheck_indexquals similarly receives a full copy of whichever clauses
+ * recheck_indexquals similarly receives a copy of whichever clauses
* need rechecking.
*
* indxstrategy receives a list of integer sublists of strategy numbers.
*subtype = NIL;
foreach(i, indexqual)
{
- OpExpr *clause = (OpExpr *) lfirst(i);
+ RestrictInfo *rinfo = (RestrictInfo *) lfirst(i);
+ OpExpr *clause;
OpExpr *newclause;
- Relids leftvarnos;
Oid opclass;
int stratno;
Oid stratsubtype;
bool recheck;
+ Assert(IsA(rinfo, RestrictInfo));
+ clause = (OpExpr *) rinfo->clause;
if (!IsA(clause, OpExpr) ||
length(clause->args) != 2)
elog(ERROR, "indexqual clause is not binary opclause");
* the clause. The indexkey should be the side that refers to
* (only) the base relation.
*/
- leftvarnos = pull_varnos((Node *) lfirst(newclause->args));
- if (!bms_equal(leftvarnos, baserelids))
+ if (!bms_equal(rinfo->left_relids, baserelids))
CommuteClause(newclause);
- bms_free(leftvarnos);
/*
* Now, determine which index attribute this is, change the
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.98 2004/01/05 18:04:39 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.99 2004/01/05 23:39:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
pathnode->path.parent = rel;
pathnode->path.pathkeys = pathkeys;
- /* Convert RestrictInfo nodes to indexquals the executor can handle */
+ /* Convert clauses to indexquals the executor can handle */
indexquals = expand_indexqual_conditions(index, restriction_clauses);
+ /* Flatten the clause-groups list to produce indexclauses list */
+ restriction_clauses = flatten_clausegroups_list(restriction_clauses);
+
/*
* We are making a pathnode for a single-scan indexscan; therefore,
- * both indexinfo and indexqual should be single-element lists.
+ * indexinfo etc should be single-element lists.
*/
pathnode->indexinfo = makeList1(index);
- pathnode->indexqual = makeList1(indexquals);
+ pathnode->indexclauses = makeList1(restriction_clauses);
+ pathnode->indexquals = makeList1(indexquals);
/* It's not an innerjoin path. */
- pathnode->indexjoinclauses = NIL;
+ pathnode->isjoininner = false;
pathnode->indexscandir = indexscandir;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/util/restrictinfo.c,v 1.24 2004/01/05 05:07:36 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/util/restrictinfo.c,v 1.25 2004/01/05 23:39:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/var.h"
-static Expr *make_sub_restrictinfos(Expr *clause, bool is_pushed_down,
+static RestrictInfo *make_restrictinfo_internal(Expr *clause,
+ Expr *orclause,
+ bool is_pushed_down,
+ bool valid_everywhere);
+static Expr *make_sub_restrictinfos(Expr *clause,
+ bool is_pushed_down,
bool valid_everywhere);
static bool join_clause_is_redundant(Query *root,
RestrictInfo *rinfo,
*/
RestrictInfo *
make_restrictinfo(Expr *clause, bool is_pushed_down, bool valid_everywhere)
+{
+ Expr *orclause;
+
+ /*
+ * If it's an OR clause, build a modified copy with RestrictInfos
+ * inserted above each subclause of the top-level AND/OR structure.
+ */
+ if (or_clause((Node *) clause))
+ {
+ orclause = make_sub_restrictinfos(clause,
+ is_pushed_down,
+ valid_everywhere);
+ }
+ else
+ {
+ /* Shouldn't be an AND clause, else flatten_andors messed up */
+ Assert(!and_clause((Node *) clause));
+
+ orclause = NULL;
+ }
+
+ return make_restrictinfo_internal(clause, orclause,
+ is_pushed_down, valid_everywhere);
+}
+
+/*
+ * make_restrictinfo_from_indexclauses
+ *
+ * Given an indexclauses structure, convert to ordinary expression format
+ * and build RestrictInfo node(s).
+ *
+ * The result is a List since we might need to return multiple RestrictInfos.
+ *
+ * This could be done as make_restrictinfo(make_expr_from_indexclauses()),
+ * but if we did it that way then we would strip the original RestrictInfo
+ * nodes from the index clauses and be forced to build new ones. It's better
+ * to have a specialized routine that allows sharing of RestrictInfos.
+ */
+List *
+make_restrictinfo_from_indexclauses(List *indexclauses,
+ bool is_pushed_down,
+ bool valid_everywhere)
+{
+ List *withris = NIL;
+ List *withoutris = NIL;
+ List *orlist;
+
+ /* Empty list probably can't happen, but here's what to do */
+ if (indexclauses == NIL)
+ return NIL;
+ /* If single indexscan, just return the ANDed clauses */
+ if (lnext(indexclauses) == NIL)
+ return (List *) lfirst(indexclauses);
+ /* Else we need an OR RestrictInfo structure */
+ foreach(orlist, indexclauses)
+ {
+ List *andlist = (List *) lfirst(orlist);
+
+ /* Create AND subclause with RestrictInfos */
+ withris = lappend(withris, make_ands_explicit(andlist));
+ /* And one without */
+ andlist = get_actual_clauses(andlist);
+ withoutris = lappend(withoutris, make_ands_explicit(andlist));
+ }
+ return makeList1(make_restrictinfo_internal(make_orclause(withoutris),
+ make_orclause(withris),
+ is_pushed_down,
+ valid_everywhere));
+}
+
+/*
+ * make_restrictinfo_internal
+ *
+ * Common code for the above two entry points.
+ */
+static RestrictInfo *
+make_restrictinfo_internal(Expr *clause, Expr *orclause,
+ bool is_pushed_down, bool valid_everywhere)
{
RestrictInfo *restrictinfo = makeNode(RestrictInfo);
restrictinfo->clause = clause;
+ restrictinfo->orclause = orclause;
restrictinfo->is_pushed_down = is_pushed_down;
restrictinfo->valid_everywhere = valid_everywhere;
restrictinfo->can_join = false; /* may get set below */
restrictinfo->clause_relids = pull_varnos((Node *) clause);
}
- /*
- * If it's an OR clause, set up a modified copy with RestrictInfos
- * inserted above each subclause of the top-level AND/OR structure.
- */
- if (or_clause((Node *) clause))
- {
- restrictinfo->orclause = make_sub_restrictinfos(clause,
- is_pushed_down,
- valid_everywhere);
- }
- else
- {
- /* Shouldn't be an AND clause, else flatten_andors messed up */
- Assert(!and_clause((Node *) clause));
-
- restrictinfo->orclause = NULL;
- }
-
/*
* Fill in all the cacheable fields with "not yet set" markers.
* None of these will be computed until/unless needed. Note in
return make_andclause(andlist);
}
else
- return (Expr *) make_restrictinfo(clause,
- is_pushed_down,
- valid_everywhere);
+ return (Expr *) make_restrictinfo_internal(clause,
+ NULL,
+ is_pushed_down,
+ valid_everywhere);
}
/*
foreach(temp, restrictinfo_list)
{
- RestrictInfo *clause = (RestrictInfo *) lfirst(temp);
+ RestrictInfo *rinfo = (RestrictInfo *) lfirst(temp);
+
+ Assert(IsA(rinfo, RestrictInfo));
- result = lappend(result, clause->clause);
+ result = lappend(result, rinfo->clause);
}
return result;
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.152 2003/12/29 22:22:45 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.153 2004/01/05 23:39:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/paths.h"
#include "optimizer/plancat.h"
#include "optimizer/prep.h"
+#include "optimizer/restrictinfo.h"
#include "optimizer/tlist.h"
#include "optimizer/var.h"
#include "parser/parse_expr.h"
double numIndexTuples;
double numIndexPages;
QualCost index_qual_cost;
- List *selectivityQuals = indexQuals;
+ List *selectivityQuals;
/*
* If the index is partial, AND the index predicate with the
* explicitly given indexquals to produce a more accurate idea of the
- * index selectivity. This may produce redundant clauses. We can get
- * rid of exact duplicates by using set_union(). We expect that most
+ * index selectivity. This may produce redundant clauses. We get rid
+ * of exact duplicates in the code below. We expect that most
* cases of partial redundancy (such as "x < 4" from the qual and
* "x < 5" from the predicate) will be recognized and handled correctly
* by clauselist_selectivity(). This assumption is somewhat fragile,
* necessarily a bad thing. But it'd be nice to do better someday.
*
* Note that index->indpred and indexQuals are both in implicit-AND form,
- * so ANDing them together just takes merging the lists.
+ * so ANDing them together just takes merging the lists. However,
+ * eliminating duplicates is a bit trickier because indexQuals contains
+ * RestrictInfo nodes and the indpred does not. It is okay to pass a
+ * mixed list to clauselist_selectivity, but we have to work a bit to
+ * generate a list without logical duplicates. (We could just set_union
+ * indpred and strippedQuals, but then we'd not get caching of per-qual
+ * selectivity estimates.)
*/
if (index->indpred != NIL)
- selectivityQuals = set_union(index->indpred, indexQuals);
+ {
+ List *strippedQuals;
+ List *predExtraQuals;
+
+ strippedQuals = get_actual_clauses(indexQuals);
+ predExtraQuals = set_difference(index->indpred, strippedQuals);
+ selectivityQuals = nconc(predExtraQuals, indexQuals);
+ }
+ else
+ selectivityQuals = indexQuals;
/* Estimate the fraction of main-table tuples that will be visited */
*indexSelectivity = clauselist_selectivity(root, selectivityQuals,
* 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.92 2004/01/05 18:04:39 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/nodes/relation.h,v 1.93 2004/01/05 23:39:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*
* 'indexinfo' is a list of IndexOptInfo nodes, one per scan to be performed.
*
- * 'indexqual' is a list of index qualifications, also one per scan.
- * Each entry in 'indexqual' is a sublist of qualification expressions with
- * implicit AND semantics across the sublist items. Only expressions that
- * are usable as indexquals (as determined by indxpath.c) may appear here.
- * NOTE that the semantics of the top-level list in 'indexqual' is OR
+ * 'indexclauses' is a list of index qualifications, also one per scan.
+ * Each entry in 'indexclauses' is a sublist of qualification clauses to be
+ * used for that scan, with implicit AND semantics across the sublist items.
+ * NOTE that the semantics of the top-level list in 'indexclauses' is OR
* combination, while the sublists are implicitly AND combinations!
- * Also note that indexquals lists do not contain RestrictInfo nodes,
- * just bare clause expressions.
- *
- * 'indexjoinclauses' is NIL for an ordinary indexpath (one that does not
- * use any join clauses in the index conditions). For an innerjoin indexpath,
- * it has the same structure as 'indexqual', but references the RestrictInfo
- * nodes from which the indexqual was built, rather than the bare clause
- * expressions. (Note: there isn't necessarily a one-to-one correspondence
- * between RestrictInfos and expressions, because of expansion of special
- * indexable operators.) We need this so that we can eliminate redundant
- * join clauses when plans are built.
+ *
+ * 'indexquals' has the same structure as 'indexclauses', but it contains
+ * the actual indexqual conditions that can be used with the index(es).
+ * In simple cases this is identical to 'indexclauses', but when special
+ * indexable operators appear in 'indexclauses', they are replaced by the
+ * derived indexscannable conditions in 'indexquals'.
+ *
+ * Both 'indexclauses' and 'indexquals' are lists of sublists of RestrictInfo
+ * nodes. (Before 7.5, we kept bare operator expressions in these lists, but
+ * storing RestrictInfos is more efficient since selectivities can be cached.)
+ *
+ * 'isjoininner' is TRUE if the path is a nestloop inner scan (that is,
+ * some of the index conditions are join rather than restriction clauses).
*
* 'indexscandir' is one of:
* ForwardScanDirection: forward scan of an ordered index
{
Path path;
List *indexinfo;
- List *indexqual;
- List *indexjoinclauses;
+ List *indexclauses;
+ List *indexquals;
+ bool isjoininner;
ScanDirection indexscandir;
double rows; /* estimated number of result tuples */
} IndexPath;
* 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.72 2004/01/05 05:07:36 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/optimizer/paths.h,v 1.73 2004/01/05 23:39:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern List *expand_indexqual_conditions(IndexOptInfo *index,
List *clausegroups);
extern void check_partial_indexes(Query *root, RelOptInfo *rel);
+extern List *flatten_clausegroups_list(List *clausegroups);
+extern Expr *make_expr_from_indexclauses(List *indexclauses);
/*
* orindxpath.c
* 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.22 2004/01/05 05:07:36 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/optimizer/restrictinfo.h,v 1.23 2004/01/05 23:39:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern RestrictInfo *make_restrictinfo(Expr *clause, bool is_pushed_down,
bool valid_everywhere);
+extern List *make_restrictinfo_from_indexclauses(List *indexclauses,
+ 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