* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.337 2006/06/27 03:43:19 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.338 2006/07/01 18:38:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
COPY_SCALAR_FIELD(is_pushed_down);
COPY_SCALAR_FIELD(outerjoin_delayed);
COPY_SCALAR_FIELD(can_join);
+ COPY_SCALAR_FIELD(pseudoconstant);
COPY_BITMAPSET_FIELD(clause_relids);
COPY_BITMAPSET_FIELD(required_relids);
COPY_BITMAPSET_FIELD(left_relids);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.274 2006/04/30 18:30:39 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.275 2006/07/01 18:38:32 tgl Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
_outPathInfo(str, (Path *) node);
- WRITE_NODE_FIELD(subpath);
- WRITE_NODE_FIELD(constantqual);
+ WRITE_NODE_FIELD(quals);
}
static void
WRITE_BOOL_FIELD(hasJoinRTEs);
WRITE_BOOL_FIELD(hasOuterJoins);
WRITE_BOOL_FIELD(hasHavingQual);
+ WRITE_BOOL_FIELD(hasPseudoConstantQuals);
}
static void
WRITE_BOOL_FIELD(is_pushed_down);
WRITE_BOOL_FIELD(outerjoin_delayed);
WRITE_BOOL_FIELD(can_join);
+ WRITE_BOOL_FIELD(pseudoconstant);
WRITE_BITMAPSET_FIELD(clause_relids);
WRITE_BITMAPSET_FIELD(required_relids);
WRITE_BITMAPSET_FIELD(left_relids);
BitmapHeapPath - top of a bitmapped index scan
TidPath - scan by CTID
AppendPath - append multiple subpaths together
- ResultPath - a Result plan node (used for variable-free tlist or qual)
+ ResultPath - a Result plan node (used for FROM-less SELECT)
MaterialPath - a Material plan node
UniquePath - remove duplicate rows
NestPath - nested-loop joins
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/path/allpaths.c,v 1.146 2006/05/02 04:34:18 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/path/allpaths.c,v 1.147 2006/07/01 18:38:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* There are several cases where we cannot push down clauses. Restrictions
* involving the subquery are checked by subquery_is_pushdown_safe().
* Restrictions on individual clauses are checked by
- * qual_is_pushdown_safe().
+ * qual_is_pushdown_safe(). Also, we don't want to push down
+ * pseudoconstant clauses; better to have the gating node above the
+ * subquery.
*
* Non-pushed-down clauses will get evaluated as qpquals of the
* SubqueryScan node.
RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
Node *clause = (Node *) rinfo->clause;
- if (qual_is_pushdown_safe(subquery, rti, clause, differentTypes))
+ if (!rinfo->pseudoconstant &&
+ qual_is_pushdown_safe(subquery, rti, clause, differentTypes))
{
/* Push it down */
subquery_push_qual(subquery, rte, rti, clause);
break;
case T_ResultPath:
ptype = "Result";
- subpath = ((ResultPath *) path)->subpath;
break;
case T_MaterialPath:
ptype = "Material";
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/path/clausesel.c,v 1.79 2006/03/07 01:00:15 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/path/clausesel.c,v 1.80 2006/07/01 18:38:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* Check for being passed a RestrictInfo.
+ *
+ * If it's a pseudoconstant RestrictInfo, then s2 is either 1.0 or
+ * 0.0; just use that rather than looking for range pairs.
*/
if (IsA(clause, RestrictInfo))
{
rinfo = (RestrictInfo *) clause;
+ if (rinfo->pseudoconstant)
+ {
+ s1 = s1 * s2;
+ continue;
+ }
clause = (Node *) rinfo->clause;
}
else
{
rinfo = (RestrictInfo *) clause;
+ /*
+ * If the clause is marked pseudoconstant, then it will be used as
+ * a gating qual and should not affect selectivity estimates; hence
+ * return 1.0. The only exception is that a constant FALSE may
+ * be taken as having selectivity 0.0, since it will surely mean
+ * no rows out of the plan. This case is simple enough that we
+ * need not bother caching the result.
+ */
+ if (rinfo->pseudoconstant)
+ {
+ if (! IsA(rinfo->clause, Const))
+ return s1;
+ }
+
/*
* If possible, cache the result of the selectivity calculation for
* the clause. We can cache if varRelid is zero or the clause
else if (IsA(clause, Const))
{
/* bool constant is pretty easy... */
- s1 = ((bool) ((Const *) clause)->constvalue) ? 1.0 : 0.0;
+ Const *con = (Const *) clause;
+
+ s1 = con->constisnull ? 0.0 :
+ DatumGetBool(con->constvalue) ? 1.0 : 0.0;
}
else if (IsA(clause, Param))
{
if (IsA(subst, Const))
{
/* bool constant is pretty easy... */
- s1 = ((bool) ((Const *) subst)->constvalue) ? 1.0 : 0.0;
+ Const *con = (Const *) subst;
+
+ s1 = con->constisnull ? 0.0 :
+ DatumGetBool(con->constvalue) ? 1.0 : 0.0;
}
else
{
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.158 2006/06/06 17:59:57 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.159 2006/07/01 18:38:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* routine's use, so that it's not necessary to evaluate the qual
* clause's cost more than once. If the clause's cost hasn't been
* computed yet, the field's startup value will contain -1.
+ *
+ * If the RestrictInfo is marked pseudoconstant, it will be tested
+ * only once, so treat its cost as all startup cost.
*/
if (qual && IsA(qual, RestrictInfo))
{
- RestrictInfo *restrictinfo = (RestrictInfo *) qual;
+ RestrictInfo *rinfo = (RestrictInfo *) qual;
- if (restrictinfo->eval_cost.startup < 0)
+ if (rinfo->eval_cost.startup < 0)
{
- restrictinfo->eval_cost.startup = 0;
- restrictinfo->eval_cost.per_tuple = 0;
- cost_qual_eval_walker((Node *) restrictinfo->clause,
- &restrictinfo->eval_cost);
+ rinfo->eval_cost.startup = 0;
+ rinfo->eval_cost.per_tuple = 0;
+ cost_qual_eval_walker((Node *) rinfo->clause,
+ &rinfo->eval_cost);
+ if (rinfo->pseudoconstant)
+ {
+ /* count one execution during startup */
+ rinfo->eval_cost.startup += rinfo->eval_cost.per_tuple;
+ rinfo->eval_cost.per_tuple = 0;
+ }
}
- cost->startup += restrictinfo->eval_cost.startup;
- cost->per_tuple += restrictinfo->eval_cost.per_tuple;
+ cost->startup += rinfo->eval_cost.startup;
+ cost->per_tuple += rinfo->eval_cost.per_tuple;
}
else
{
*
* If we are doing an outer join, take that into account: the output must
* be at least as large as the non-nullable input. (Is there any chance
- * of being even smarter?)
+ * of being even smarter?) (XXX this is not really right, because it
+ * assumes all the restriction clauses are join clauses; we should figure
+ * pushed-down clauses separately.)
*
* For JOIN_IN and variants, the Cartesian product is figured with respect
* to a unique-ified input, and then we can clamp to the size of the other
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/path/indxpath.c,v 1.208 2006/06/07 17:08:07 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/path/indxpath.c,v 1.209 2006/07/01 18:38:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Oid expr_op;
bool plain_op;
+ /*
+ * Never match pseudoconstants to indexes. (Normally this could not
+ * happen anyway, since a pseudoconstant clause couldn't contain a
+ * Var, but what if someone builds an expression index on a constant?
+ * It's not totally unreasonable to do so with a partial index, either.)
+ */
+ if (rinfo->pseudoconstant)
+ return false;
+
/* First check for boolean-index cases. */
if (IsBooleanOpclass(opclass))
{
make_restrictinfo(boolqual,
true,
false,
+ false,
NULL));
continue;
}
matching_cols);
rc->rargs = list_truncate((List *) copyObject(clause->rargs),
matching_cols);
- return make_restrictinfo((Expr *) rc, true, false, NULL);
+ return make_restrictinfo((Expr *) rc, true, false, false, NULL);
}
else
{
opexpr = make_opclause(linitial_oid(new_ops), BOOLOID, false,
copyObject(linitial(clause->largs)),
copyObject(linitial(clause->rargs)));
- return make_restrictinfo(opexpr, true, false, NULL);
+ return make_restrictinfo(opexpr, true, false, false, NULL);
}
}
elog(ERROR, "no = operator for opclass %u", opclass);
expr = make_opclause(oproid, BOOLOID, false,
(Expr *) leftop, (Expr *) prefix_const);
- result = list_make1(make_restrictinfo(expr, true, false, NULL));
+ result = list_make1(make_restrictinfo(expr, true, false, false, NULL));
return result;
}
elog(ERROR, "no >= operator for opclass %u", opclass);
expr = make_opclause(oproid, BOOLOID, false,
(Expr *) leftop, (Expr *) prefix_const);
- result = list_make1(make_restrictinfo(expr, true, false, NULL));
+ result = list_make1(make_restrictinfo(expr, true, false, false, NULL));
/*-------
* 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, make_restrictinfo(expr, true, false, NULL));
+ result = lappend(result,
+ make_restrictinfo(expr, true, false, false, NULL));
}
return result;
(Expr *) leftop,
(Expr *) makeConst(datatype, -1, opr1right,
false, false));
- result = list_make1(make_restrictinfo(expr, true, false, NULL));
+ result = list_make1(make_restrictinfo(expr, true, false, false, NULL));
/* create clause "key <= network_scan_last( rightop )" */
(Expr *) leftop,
(Expr *) makeConst(datatype, -1, opr2right,
false, false));
- result = lappend(result, make_restrictinfo(expr, true, false, NULL));
+ result = lappend(result,
+ make_restrictinfo(expr, true, false, false, NULL));
return result;
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.211 2006/05/18 18:57:31 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.212 2006/07/01 18:38:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/syscache.h"
-static Scan *create_scan_plan(PlannerInfo *root, Path *best_path);
+static Plan *create_scan_plan(PlannerInfo *root, Path *best_path);
static List *build_relation_tlist(RelOptInfo *rel);
static bool use_physical_tlist(RelOptInfo *rel);
static void disuse_physical_tlist(Plan *plan, Path *path);
-static Join *create_join_plan(PlannerInfo *root, JoinPath *best_path);
+static Plan *create_gating_plan(PlannerInfo *root, Plan *plan, List *quals);
+static Plan *create_join_plan(PlannerInfo *root, JoinPath *best_path);
static Plan *create_append_plan(PlannerInfo *root, AppendPath *best_path);
static Result *create_result_plan(PlannerInfo *root, ResultPath *best_path);
static Material *create_material_plan(PlannerInfo *root, MaterialPath *best_path);
static Node *fix_indexqual_operand(Node *node, IndexOptInfo *index,
Oid *opclass);
static List *get_switched_clauses(List *clauses, Relids outerrelids);
+static List *order_qual_clauses(PlannerInfo *root, List *clauses);
static void copy_path_costsize(Plan *dest, Path *src);
static void copy_plan_costsize(Plan *dest, Plan *src);
static SeqScan *make_seqscan(List *qptlist, List *qpqual, Index scanrelid);
case T_TidScan:
case T_SubqueryScan:
case T_FunctionScan:
- plan = (Plan *) create_scan_plan(root, best_path);
+ plan = create_scan_plan(root, best_path);
break;
case T_HashJoin:
case T_MergeJoin:
case T_NestLoop:
- plan = (Plan *) create_join_plan(root,
- (JoinPath *) best_path);
+ plan = create_join_plan(root,
+ (JoinPath *) best_path);
break;
case T_Append:
- plan = (Plan *) create_append_plan(root,
- (AppendPath *) best_path);
+ plan = create_append_plan(root,
+ (AppendPath *) best_path);
break;
case T_Result:
plan = (Plan *) create_result_plan(root,
(MaterialPath *) best_path);
break;
case T_Unique:
- plan = (Plan *) create_unique_plan(root,
- (UniquePath *) best_path);
+ plan = create_unique_plan(root,
+ (UniquePath *) best_path);
break;
default:
elog(ERROR, "unrecognized node type: %d",
/*
* create_scan_plan
* Create a scan plan for the parent relation of 'best_path'.
- *
- * Returns a Plan node.
*/
-static Scan *
+static Plan *
create_scan_plan(PlannerInfo *root, Path *best_path)
{
RelOptInfo *rel = best_path->parent;
List *tlist;
List *scan_clauses;
- Scan *plan;
+ Plan *plan;
/*
* For table scans, rather than using the relation targetlist (which is
tlist = build_relation_tlist(rel);
/*
- * Extract the relevant restriction clauses from the parent relation; the
- * executor must apply all these restrictions during the scan.
+ * Extract the relevant restriction clauses from the parent relation.
+ * The executor must apply all these restrictions during the scan,
+ * except for pseudoconstants which we'll take care of below.
*/
scan_clauses = rel->baserestrictinfo;
switch (best_path->pathtype)
{
case T_SeqScan:
- plan = (Scan *) create_seqscan_plan(root,
+ plan = (Plan *) create_seqscan_plan(root,
best_path,
tlist,
scan_clauses);
break;
case T_IndexScan:
- plan = (Scan *) create_indexscan_plan(root,
+ plan = (Plan *) create_indexscan_plan(root,
(IndexPath *) best_path,
tlist,
scan_clauses,
break;
case T_BitmapHeapScan:
- plan = (Scan *) create_bitmap_scan_plan(root,
+ plan = (Plan *) create_bitmap_scan_plan(root,
(BitmapHeapPath *) best_path,
tlist,
scan_clauses);
break;
case T_TidScan:
- plan = (Scan *) create_tidscan_plan(root,
+ plan = (Plan *) create_tidscan_plan(root,
(TidPath *) best_path,
tlist,
scan_clauses);
break;
case T_SubqueryScan:
- plan = (Scan *) create_subqueryscan_plan(root,
+ plan = (Plan *) create_subqueryscan_plan(root,
best_path,
tlist,
scan_clauses);
break;
case T_FunctionScan:
- plan = (Scan *) create_functionscan_plan(root,
+ plan = (Plan *) create_functionscan_plan(root,
best_path,
tlist,
scan_clauses);
break;
}
+ /*
+ * If there are any pseudoconstant clauses attached to this node,
+ * insert a gating Result node that evaluates the pseudoconstants
+ * as one-time quals.
+ */
+ if (root->hasPseudoConstantQuals)
+ plan = create_gating_plan(root, plan, scan_clauses);
+
return plan;
}
}
}
+/*
+ * create_gating_plan
+ * Deal with pseudoconstant qual clauses
+ *
+ * If the node's quals list includes any pseudoconstant quals, put them
+ * into a gating Result node atop the already-built plan. Otherwise,
+ * return the plan as-is.
+ *
+ * Note that we don't change cost or size estimates when doing gating.
+ * The costs of qual eval were already folded into the plan's startup cost.
+ * Leaving the size alone amounts to assuming that the gating qual will
+ * succeed, which is the conservative estimate for planning upper queries.
+ * We certainly don't want to assume the output size is zero (unless the
+ * gating qual is actually constant FALSE, and that case is dealt with in
+ * clausesel.c). Interpolating between the two cases is silly, because
+ * it doesn't reflect what will really happen at runtime, and besides which
+ * in most cases we have only a very bad idea of the probability of the gating
+ * qual being true.
+ */
+static Plan *
+create_gating_plan(PlannerInfo *root, Plan *plan, List *quals)
+{
+ List *pseudoconstants;
+
+ /* Pull out any pseudoconstant quals from the RestrictInfo list */
+ pseudoconstants = extract_actual_clauses(quals, true);
+
+ if (!pseudoconstants)
+ return plan;
+
+ pseudoconstants = order_qual_clauses(root, pseudoconstants);
+
+ return (Plan *) make_result((List *) copyObject(plan->targetlist),
+ (Node *) pseudoconstants,
+ plan);
+}
+
/*
* create_join_plan
* Create a join plan for 'best_path' and (recursively) plans for its
* inner and outer paths.
- *
- * Returns a Plan node.
*/
-static Join *
+static Plan *
create_join_plan(PlannerInfo *root, JoinPath *best_path)
{
Plan *outer_plan;
Plan *inner_plan;
- Join *plan;
+ Plan *plan;
outer_plan = create_plan(root, best_path->outerjoinpath);
inner_plan = create_plan(root, best_path->innerjoinpath);
switch (best_path->path.pathtype)
{
case T_MergeJoin:
- plan = (Join *) create_mergejoin_plan(root,
+ plan = (Plan *) create_mergejoin_plan(root,
(MergePath *) best_path,
outer_plan,
inner_plan);
break;
case T_HashJoin:
- plan = (Join *) create_hashjoin_plan(root,
+ plan = (Plan *) create_hashjoin_plan(root,
(HashPath *) best_path,
outer_plan,
inner_plan);
break;
case T_NestLoop:
- plan = (Join *) create_nestloop_plan(root,
+ plan = (Plan *) create_nestloop_plan(root,
(NestPath *) best_path,
outer_plan,
inner_plan);
break;
}
+ /*
+ * If there are any pseudoconstant clauses attached to this node,
+ * insert a gating Result node that evaluates the pseudoconstants
+ * as one-time quals.
+ */
+ if (root->hasPseudoConstantQuals)
+ plan = create_gating_plan(root, plan, best_path->joinrestrictinfo);
+
#ifdef NOT_USED
/*
/*
* create_result_plan
- * Create a Result plan for 'best_path' and (recursively) plans
- * for its subpaths.
+ * Create a Result plan for 'best_path'.
+ * This is only used for the case of a query with an empty jointree.
*
* Returns a Plan node.
*/
static Result *
create_result_plan(PlannerInfo *root, ResultPath *best_path)
{
- Result *plan;
List *tlist;
- List *constclauses;
- Plan *subplan;
+ List *quals;
- if (best_path->path.parent)
- tlist = build_relation_tlist(best_path->path.parent);
- else
- tlist = NIL; /* will be filled in later */
-
- if (best_path->subpath)
- subplan = create_plan(root, best_path->subpath);
- else
- subplan = NULL;
+ /* The tlist will be installed later, since we have no RelOptInfo */
+ Assert(best_path->path.parent == NULL);
+ tlist = NIL;
- constclauses = order_qual_clauses(root, best_path->constantqual);
+ quals = order_qual_clauses(root, best_path->quals);
- plan = make_result(tlist, (Node *) constclauses, subplan);
-
- return plan;
+ return make_result(tlist, (Node *) quals, NULL);
}
/*
Assert(scan_relid > 0);
Assert(best_path->parent->rtekind == RTE_RELATION);
- /* Reduce RestrictInfo list to bare expressions */
- scan_clauses = get_actual_clauses(scan_clauses);
+ /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
+ scan_clauses = extract_actual_clauses(scan_clauses, false);
/* Sort clauses into best execution order */
scan_clauses = order_qual_clauses(root, scan_clauses);
* plan so that they'll be properly rechecked by EvalPlanQual testing.
*
* While at it, we strip off the RestrictInfos to produce a list of plain
- * expressions.
+ * expressions (this loop replaces extract_actual_clauses used in the
+ * other routines in this file). We have to ignore pseudoconstants.
*/
qpqual = NIL;
foreach(l, scan_clauses)
RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
Assert(IsA(rinfo, RestrictInfo));
+ if (rinfo->pseudoconstant)
+ continue;
if (list_member_ptr(nonlossy_indexquals, rinfo))
continue;
if (!contain_mutable_functions((Node *) rinfo->clause))
bitmapqualplan = create_bitmap_subplan(root, best_path->bitmapqual,
&bitmapqualorig, &indexquals);
- /* Reduce RestrictInfo list to bare expressions */
- scan_clauses = get_actual_clauses(scan_clauses);
+ /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
+ scan_clauses = extract_actual_clauses(scan_clauses, false);
/*
* If this is a innerjoin scan, the indexclauses will contain join clauses
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);
+ /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
+ scan_clauses = extract_actual_clauses(scan_clauses, false);
/*
* Remove any clauses that are TID quals. This is a bit tricky since
Assert(scan_relid > 0);
Assert(best_path->parent->rtekind == RTE_SUBQUERY);
- /* Reduce RestrictInfo list to bare expressions */
- scan_clauses = get_actual_clauses(scan_clauses);
+ /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
+ scan_clauses = extract_actual_clauses(scan_clauses, false);
/* Sort clauses into best execution order */
scan_clauses = order_qual_clauses(root, scan_clauses);
Assert(scan_relid > 0);
Assert(best_path->parent->rtekind == RTE_FUNCTION);
- /* Reduce RestrictInfo list to bare expressions */
- scan_clauses = get_actual_clauses(scan_clauses);
+ /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
+ scan_clauses = extract_actual_clauses(scan_clauses, false);
/* Sort clauses into best execution order */
scan_clauses = order_qual_clauses(root, scan_clauses);
}
/* Get the join qual clauses (in plain expression form) */
+ /* Any pseudoconstant clauses are ignored here */
if (IS_OUTER_JOIN(best_path->jointype))
{
- get_actual_join_clauses(joinrestrictclauses,
- &joinclauses, &otherclauses);
+ extract_actual_join_clauses(joinrestrictclauses,
+ &joinclauses, &otherclauses);
}
else
{
/* We can treat all clauses alike for an inner join */
- joinclauses = get_actual_clauses(joinrestrictclauses);
+ joinclauses = extract_actual_clauses(joinrestrictclauses, false);
otherclauses = NIL;
}
MergeJoin *join_plan;
/* Get the join qual clauses (in plain expression form) */
+ /* Any pseudoconstant clauses are ignored here */
if (IS_OUTER_JOIN(best_path->jpath.jointype))
{
- get_actual_join_clauses(best_path->jpath.joinrestrictinfo,
- &joinclauses, &otherclauses);
+ extract_actual_join_clauses(best_path->jpath.joinrestrictinfo,
+ &joinclauses, &otherclauses);
}
else
{
/* We can treat all clauses alike for an inner join */
- joinclauses = get_actual_clauses(best_path->jpath.joinrestrictinfo);
+ joinclauses = extract_actual_clauses(best_path->jpath.joinrestrictinfo,
+ false);
otherclauses = NIL;
}
Hash *hash_plan;
/* Get the join qual clauses (in plain expression form) */
+ /* Any pseudoconstant clauses are ignored here */
if (IS_OUTER_JOIN(best_path->jpath.jointype))
{
- get_actual_join_clauses(best_path->jpath.joinrestrictinfo,
- &joinclauses, &otherclauses);
+ extract_actual_join_clauses(best_path->jpath.joinrestrictinfo,
+ &joinclauses, &otherclauses);
}
else
{
/* We can treat all clauses alike for an inner join */
- joinclauses = get_actual_clauses(best_path->jpath.joinrestrictinfo);
+ joinclauses = extract_actual_clauses(best_path->jpath.joinrestrictinfo,
+ false);
otherclauses = NIL;
}
* For now, we just move any quals that contain SubPlan references (but not
* InitPlan references) to the end of the list.
*/
-List *
+static List *
order_qual_clauses(PlannerInfo *root, List *clauses)
{
List *nosubplans;
return node;
}
+/*
+ * make_result
+ * Build a Result plan node
+ *
+ * If we have a subplan, assume that any evaluation costs for the gating qual
+ * were already factored into the subplan's startup cost, and just copy the
+ * subplan cost. If there's no subplan, we should include the qual eval
+ * cost. In either case, tlist eval cost is not to be included here.
+ */
Result *
make_result(List *tlist,
Node *resconstantqual,
plan->startup_cost = 0;
plan->total_cost = cpu_tuple_cost;
plan->plan_rows = 1; /* wrong if we have a set-valued function? */
- plan->plan_width = 0; /* XXX try to be smarter? */
- }
-
- if (resconstantqual)
- {
- QualCost qual_cost;
+ plan->plan_width = 0; /* XXX is it worth being smarter? */
+ if (resconstantqual)
+ {
+ QualCost qual_cost;
- cost_qual_eval(&qual_cost, (List *) resconstantqual);
- /* resconstantqual is evaluated once at startup */
- plan->startup_cost += qual_cost.startup + qual_cost.per_tuple;
- plan->total_cost += qual_cost.startup + qual_cost.per_tuple;
+ cost_qual_eval(&qual_cost, (List *) resconstantqual);
+ /* resconstantqual is evaluated once at startup */
+ plan->startup_cost += qual_cost.startup + qual_cost.per_tuple;
+ plan->total_cost += qual_cost.startup + qual_cost.per_tuple;
+ }
}
plan->targetlist = tlist;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/plan/initsplan.c,v 1.117 2006/03/14 22:48:19 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/plan/initsplan.c,v 1.118 2006/07/01 18:38:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/pathnode.h"
#include "optimizer/paths.h"
#include "optimizer/planmain.h"
+#include "optimizer/prep.h"
#include "optimizer/restrictinfo.h"
#include "optimizer/tlist.h"
#include "optimizer/var.h"
* the base relations (ie, table, subquery, and function RTEs)
* appearing in the jointree.
*
+ * The initial invocation must pass root->parse->jointree as the value of
+ * jtnode. Internally, the function recurses through the jointree.
+ *
* At the end of this process, there should be one baserel RelOptInfo for
* every non-join RTE that is used in the query. Therefore, this routine
* is the only place that should call build_simple_rel with reloptkind
{
Relids relids;
bool outerjoin_delayed;
+ bool pseudoconstant = false;
bool maybe_equijoin;
bool maybe_outer_join;
RestrictInfo *restrictinfo;
elog(ERROR, "JOIN qualification may not refer to other relations");
/*
- * If the clause is variable-free, we force it to be evaluated at its
- * original syntactic level. Note that this should not happen for
- * top-level clauses, because query_planner() special-cases them. But it
- * will happen for variable-free JOIN/ON clauses. We don't have to be
- * real smart about such a case, we just have to be correct. Also note
- * that for an outer-join clause, we must force it to the OJ's semantic
- * level, not the syntactic scope.
+ * If the clause is variable-free, our normal heuristic for pushing it
+ * down to just the mentioned rels doesn't work, because there are none.
+ *
+ * If the clause is an outer-join clause, we must force it to the OJ's
+ * semantic level to preserve semantics.
+ *
+ * Otherwise, when the clause contains volatile functions, we force it
+ * to be evaluated at its original syntactic level. This preserves the
+ * expected semantics.
+ *
+ * When the clause contains no volatile functions either, it is actually
+ * a pseudoconstant clause that will not change value during any one
+ * execution of the plan, and hence can be used as a one-time qual in
+ * a gating Result plan node. We put such a clause into the regular
+ * RestrictInfo lists for the moment, but eventually createplan.c will
+ * pull it out and make a gating Result node immediately above whatever
+ * plan node the pseudoconstant clause is assigned to. It's usually
+ * best to put a gating node as high in the plan tree as possible.
+ * If we are not below an outer join, we can actually push the
+ * pseudoconstant qual all the way to the top of the tree. If we are
+ * below an outer join, we leave the qual at its original syntactic level
+ * (we could push it up to just below the outer join, but that seems more
+ * complex than it's worth).
*/
if (bms_is_empty(relids))
- relids = ojscope ? ojscope : qualscope;
+ {
+ if (ojscope)
+ {
+ /* clause is attached to outer join, eval it there */
+ relids = ojscope;
+ /* mustn't use as gating qual, so don't mark pseudoconstant */
+ }
+ else
+ {
+ /* eval at original syntactic level */
+ relids = qualscope;
+ if (!contain_volatile_functions(clause))
+ {
+ /* mark as gating qual */
+ pseudoconstant = true;
+ /* tell createplan.c to check for gating quals */
+ root->hasPseudoConstantQuals = true;
+ /* if not below outer join, push it to top of tree */
+ if (!below_outer_join)
+ {
+ relids = get_relids_in_jointree((Node *) root->parse->jointree);
+ is_pushed_down = true;
+ }
+ }
+ }
+ }
/*
* Check to see if clause application must be delayed by outer-join
*/
Assert(bms_equal(relids, qualscope));
Assert(!ojscope);
+ Assert(!pseudoconstant);
/* Needn't feed it back for more deductions */
outerjoin_delayed = false;
maybe_equijoin = false;
Assert(ojscope);
relids = ojscope;
outerjoin_delayed = true;
+ Assert(!pseudoconstant);
/*
* We can't use such a clause to deduce equijoin (the left and right
restrictinfo = make_restrictinfo((Expr *) clause,
is_pushed_down,
outerjoin_delayed,
+ pseudoconstant,
relids);
/*
leftOp,
rightOp;
+ if (restrictinfo->pseudoconstant)
+ return;
if (!is_opclause(clause))
return;
if (list_length(((OpExpr *) clause)->args) != 2)
Expr *clause = restrictinfo->clause;
Oid opno;
+ if (restrictinfo->pseudoconstant)
+ return;
if (!is_opclause(clause))
return;
if (list_length(((OpExpr *) clause)->args) != 2)
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/plan/planagg.c,v 1.15 2006/06/06 17:59:57 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/plan/planagg.c,v 1.16 2006/07/01 18:38:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
MinMaxAggInfo *info);
static ScanDirection match_agg_to_index_col(MinMaxAggInfo *info,
IndexOptInfo *index, int indexcol);
-static void make_agg_subplan(PlannerInfo *root, MinMaxAggInfo *info,
- List *constant_quals);
+static void make_agg_subplan(PlannerInfo *root, MinMaxAggInfo *info);
static Node *replace_aggs_with_params_mutator(Node *node, List **context);
static Oid fetch_agg_sort_op(Oid aggfnoid);
Plan *plan;
Node *hqual;
QualCost tlist_cost;
- List *constant_quals;
/* Nothing to do if query has no aggregates */
if (!parse->hasAggs)
return NULL; /* too expensive */
/*
- * OK, we are going to generate an optimized plan. The first thing we
- * need to do is look for any non-variable WHERE clauses that
- * query_planner might have removed from the basic plan. (Normal WHERE
- * clauses will be properly incorporated into the sub-plans by
- * create_plan.) If there are any, they will be in a gating Result node
- * atop the best_path. They have to be incorporated into a gating Result
- * in each sub-plan in order to produce the semantically correct result.
+ * OK, we are going to generate an optimized plan.
*/
- if (IsA(best_path, ResultPath))
- {
- constant_quals = ((ResultPath *) best_path)->constantqual;
- /* no need to do this more than once: */
- constant_quals = order_qual_clauses(root, constant_quals);
- }
- else
- constant_quals = NIL;
/* Pass 3: generate subplans and output Param nodes */
foreach(l, aggs_list)
{
- make_agg_subplan(root, (MinMaxAggInfo *) lfirst(l), constant_quals);
+ make_agg_subplan(root, (MinMaxAggInfo *) lfirst(l));
}
/*
* Construct a suitable plan for a converted aggregate query
*/
static void
-make_agg_subplan(PlannerInfo *root, MinMaxAggInfo *info, List *constant_quals)
+make_agg_subplan(PlannerInfo *root, MinMaxAggInfo *info)
{
PlannerInfo subroot;
Query *subparse;
Plan *plan;
+ Plan *iplan;
TargetEntry *tle;
SortClause *sortcl;
NullTest *ntest;
/*
* Generate the plan for the subquery. We already have a Path for the
* basic indexscan, but we have to convert it to a Plan and attach a LIMIT
- * node above it. We might need a gating Result, too, to handle any
- * non-variable qual clauses.
+ * node above it.
*
* Also we must add a "WHERE foo IS NOT NULL" restriction to the
* indexscan, to be sure we don't return a NULL, which'd be contrary to
* earlier, so that the selectivity of the restriction could be included
* in our cost estimates. But that looks painful, and in most cases the
* fraction of NULLs isn't high enough to change the decision.
+ *
+ * The NOT NULL qual has to go on the actual indexscan; create_plan
+ * might have stuck a gating Result atop that, if there were any
+ * pseudoconstant quals.
*/
plan = create_plan(&subroot, (Path *) info->path);
plan->targetlist = copyObject(subparse->targetList);
+ if (IsA(plan, Result))
+ iplan = plan->lefttree;
+ else
+ iplan = plan;
+ Assert(IsA(iplan, IndexScan));
+
ntest = makeNode(NullTest);
ntest->nulltesttype = IS_NOT_NULL;
ntest->arg = copyObject(info->target);
- plan->qual = lcons(ntest, plan->qual);
-
- if (constant_quals)
- plan = (Plan *) make_result(copyObject(plan->targetlist),
- copyObject(constant_quals),
- plan);
+ iplan->qual = lcons(ntest, iplan->qual);
plan = (Plan *) make_limit(plan,
subparse->limitOffset,
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/plan/planmain.c,v 1.93 2006/03/05 15:58:29 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/plan/planmain.c,v 1.94 2006/07/01 18:38:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
double *num_groups)
{
Query *parse = root->parse;
- List *constant_quals;
List *joinlist;
RelOptInfo *final_rel;
Path *cheapestpath;
*/
if (parse->jointree->fromlist == NIL)
{
- *cheapest_path = (Path *) create_result_path(NULL, NULL,
- (List *) parse->jointree->quals);
+ *cheapest_path = (Path *)
+ create_result_path((List *) parse->jointree->quals);
*sorted_path = NULL;
return;
}
- /*
- * Pull out any non-variable WHERE clauses so these can be put in a
- * toplevel "Result" node, where they will gate execution of the whole
- * plan (the Result will not invoke its descendant plan unless the quals
- * are true). Note that any *really* non-variable quals will have been
- * optimized away by eval_const_expressions(). What we're mostly
- * interested in here is quals that depend only on outer-level vars,
- * although if the qual reduces to "WHERE FALSE" this path will also be
- * taken.
- */
- parse->jointree->quals = (Node *)
- pull_constant_clauses((List *) parse->jointree->quals,
- &constant_quals);
-
/*
* Init planner lists to empty, and set up the array to hold RelOptInfos
* for "simple" rels.
}
}
- /*
- * If we have constant quals, add a toplevel Result step to process them.
- */
- if (constant_quals)
- {
- cheapestpath = (Path *) create_result_path(final_rel,
- cheapestpath,
- constant_quals);
- if (sortedpath)
- sortedpath = (Path *) create_result_path(final_rel,
- sortedpath,
- constant_quals);
- }
-
*cheapest_path = cheapestpath;
*sorted_path = sortedpath;
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.200 2006/06/28 20:04:38 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.201 2006/07/01 18:38:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
root->hasHavingQual = (parse->havingQual != NULL);
+ /* Clear this flag; might get set in distribute_qual_to_rels */
+ root->hasPseudoConstantQuals = false;
+
/*
* Do expression preprocessing on targetlist and quals.
*/
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.212 2006/06/16 18:42:22 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.213 2006/07/01 18:38:33 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
/*
* is_pseudo_constant_clause
- * Detect whether a clause is "constant", ie, it contains no variables
- * of the current query level and no uses of volatile functions.
- * Such a clause is not necessarily a true constant: it can still contain
+ * Detect whether an expression is "pseudo constant", ie, it contains no
+ * variables of the current query level and no uses of volatile functions.
+ * Such an expr is not necessarily a true constant: it can still contain
* Params and outer-level Vars, not to mention functions whose results
- * may vary from one statement to the next. However, the clause's value
+ * may vary from one statement to the next. However, the expr's value
* will be constant over any one scan of the current query, so it can be
- * used as an indexscan key or (if a top-level qual) can be pushed up to
- * become a gating qual.
+ * used as, eg, an indexscan key.
*/
bool
is_pseudo_constant_clause(Node *clause)
/*
* is_pseudo_constant_clause_relids
* Same as above, except caller already has available the var membership
- * of the clause; this lets us avoid the contain_var_clause() scan.
+ * of the expression; this lets us avoid the contain_var_clause() scan.
*/
bool
is_pseudo_constant_clause_relids(Node *clause, Relids relids)
return false;
}
-/*
- * pull_constant_clauses
- * Scan through a list of qualifications and separate "constant" quals
- * from those that are not.
- *
- * Returns a list of the pseudo-constant clauses in constantQual and the
- * remaining quals as the return value.
- */
-List *
-pull_constant_clauses(List *quals, List **constantQual)
-{
- List *constqual = NIL,
- *restqual = NIL;
- ListCell *q;
-
- foreach(q, quals)
- {
- Node *qual = (Node *) lfirst(q);
-
- if (is_pseudo_constant_clause(qual))
- constqual = lappend(constqual, qual);
- else
- restqual = lappend(restqual, qual);
- }
- *constantQual = constqual;
- return restqual;
-}
-
/*****************************************************************************
* Tests on clauses of queries
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.128 2006/06/06 17:59:57 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.129 2006/07/01 18:38:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* create_result_path
- * Creates a path corresponding to a Result plan, returning the
- * pathnode.
+ * Creates a path representing a Result-and-nothing-else plan.
+ * This is only used for the case of a query with an empty jointree.
*/
ResultPath *
-create_result_path(RelOptInfo *rel, Path *subpath, List *constantqual)
+create_result_path(List *quals)
{
ResultPath *pathnode = makeNode(ResultPath);
pathnode->path.pathtype = T_Result;
- pathnode->path.parent = rel; /* may be NULL */
-
- if (subpath)
- pathnode->path.pathkeys = subpath->pathkeys;
- else
- pathnode->path.pathkeys = NIL;
-
- pathnode->subpath = subpath;
- pathnode->constantqual = constantqual;
+ pathnode->path.parent = NULL;
+ pathnode->path.pathkeys = NIL;
+ pathnode->quals = quals;
/* Ideally should define cost_result(), but I'm too lazy */
- if (subpath)
- {
- pathnode->path.startup_cost = subpath->startup_cost;
- pathnode->path.total_cost = subpath->total_cost;
- }
- else
- {
- pathnode->path.startup_cost = 0;
- pathnode->path.total_cost = cpu_tuple_cost;
- }
+ pathnode->path.startup_cost = 0;
+ pathnode->path.total_cost = cpu_tuple_cost;
+ /*
+ * In theory we should include the qual eval cost as well, but
+ * at present that doesn't accomplish much except duplicate work that
+ * will be done again in make_result; since this is only used for
+ * degenerate cases, nothing interesting will be done with the path
+ * cost values...
+ */
return pathnode;
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/util/restrictinfo.c,v 1.47 2006/04/07 17:05:39 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/util/restrictinfo.c,v 1.48 2006/07/01 18:38:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Expr *orclause,
bool is_pushed_down,
bool outerjoin_delayed,
+ bool pseudoconstant,
Relids required_relids);
static Expr *make_sub_restrictinfos(Expr *clause,
bool is_pushed_down,
bool outerjoin_delayed,
+ bool pseudoconstant,
Relids required_relids);
static RestrictInfo *join_clause_is_redundant(PlannerInfo *root,
RestrictInfo *rinfo,
*
* Build a RestrictInfo node containing the given subexpression.
*
- * The is_pushed_down and outerjoin_delayed flags must be supplied by the
- * caller. required_relids can be NULL, in which case it defaults to the
- * actual clause contents (i.e., clause_relids).
+ * The is_pushed_down, outerjoin_delayed, and pseudoconstant flags for the
+ * RestrictInfo must be supplied by the caller. required_relids can be NULL,
+ * in which case it defaults to the actual clause contents (i.e.,
+ * clause_relids).
*
* 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
make_restrictinfo(Expr *clause,
bool is_pushed_down,
bool outerjoin_delayed,
+ bool pseudoconstant,
Relids required_relids)
{
/*
return (RestrictInfo *) make_sub_restrictinfos(clause,
is_pushed_down,
outerjoin_delayed,
+ pseudoconstant,
required_relids);
/* Shouldn't be an AND clause, else AND/OR flattening messed up */
Assert(!and_clause((Node *) clause));
- return make_restrictinfo_internal(clause, NULL,
- is_pushed_down, outerjoin_delayed,
+ return make_restrictinfo_internal(clause,
+ NULL,
+ is_pushed_down,
+ outerjoin_delayed,
+ pseudoconstant,
required_relids);
}
* RestrictInfos.
*
* The caller must pass is_pushed_down, but we assume outerjoin_delayed
- * is false (no such qual should ever get into a bitmapqual).
+ * and pseudoconstant are false (no such qual should ever get into a
+ * bitmapqual).
*
* If include_predicates is true, we add any partial index predicates to
* the explicit index quals. When this is not true, we return a condition
make_orclause(withris),
is_pushed_down,
false,
+ false,
NULL));
}
}
make_restrictinfo(pred,
is_pushed_down,
false,
+ false,
NULL));
}
}
* Common code for the main entry points and the recursive cases.
*/
static RestrictInfo *
-make_restrictinfo_internal(Expr *clause, Expr *orclause,
- bool is_pushed_down, bool outerjoin_delayed,
+make_restrictinfo_internal(Expr *clause,
+ Expr *orclause,
+ bool is_pushed_down,
+ bool outerjoin_delayed,
+ bool pseudoconstant,
Relids required_relids)
{
RestrictInfo *restrictinfo = makeNode(RestrictInfo);
restrictinfo->orclause = orclause;
restrictinfo->is_pushed_down = is_pushed_down;
restrictinfo->outerjoin_delayed = outerjoin_delayed;
+ restrictinfo->pseudoconstant = pseudoconstant;
restrictinfo->can_join = false; /* may get set below */
/*
!bms_is_empty(restrictinfo->right_relids) &&
!bms_overlap(restrictinfo->left_relids,
restrictinfo->right_relids))
+ {
restrictinfo->can_join = true;
+ /* pseudoconstant should certainly not be true */
+ Assert(!restrictinfo->pseudoconstant);
+ }
}
else
{
* implicit-AND lists at top level of RestrictInfo lists. Only ORs and
* simple clauses are valid RestrictInfos.
*
+ * The same is_pushed_down, outerjoin_delayed, and pseudoconstant flag
+ * values can be applied to all RestrictInfo nodes in the result.
+ *
* The given required_relids are attached to our top-level output,
* but any OR-clause constituents are allowed to default to just the
* contained rels.
*/
static Expr *
make_sub_restrictinfos(Expr *clause,
- bool is_pushed_down, bool outerjoin_delayed,
+ bool is_pushed_down,
+ bool outerjoin_delayed,
+ bool pseudoconstant,
Relids required_relids)
{
if (or_clause((Node *) clause))
make_sub_restrictinfos(lfirst(temp),
is_pushed_down,
outerjoin_delayed,
+ pseudoconstant,
NULL));
return (Expr *) make_restrictinfo_internal(clause,
make_orclause(orlist),
is_pushed_down,
outerjoin_delayed,
+ pseudoconstant,
required_relids);
}
else if (and_clause((Node *) clause))
make_sub_restrictinfos(lfirst(temp),
is_pushed_down,
outerjoin_delayed,
+ pseudoconstant,
required_relids));
return make_andclause(andlist);
}
NULL,
is_pushed_down,
outerjoin_delayed,
+ pseudoconstant,
required_relids);
}
* get_actual_clauses
*
* Returns a list containing the bare clauses from 'restrictinfo_list'.
+ *
+ * This is only to be used in cases where none of the RestrictInfos can
+ * be pseudoconstant clauses (for instance, it's OK on indexqual lists).
*/
List *
get_actual_clauses(List *restrictinfo_list)
{
List *result = NIL;
- ListCell *temp;
+ ListCell *l;
- foreach(temp, restrictinfo_list)
+ foreach(l, restrictinfo_list)
{
- RestrictInfo *rinfo = (RestrictInfo *) lfirst(temp);
+ RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
Assert(IsA(rinfo, RestrictInfo));
+ Assert(!rinfo->pseudoconstant);
+
result = lappend(result, rinfo->clause);
}
return result;
}
/*
- * get_actual_join_clauses
+ * extract_actual_clauses
*
- * Extract clauses from 'restrictinfo_list', separating those that
+ * Extract bare clauses from 'restrictinfo_list', returning either the
+ * regular ones or the pseudoconstant ones per 'pseudoconstant'.
+ */
+List *
+extract_actual_clauses(List *restrictinfo_list,
+ bool pseudoconstant)
+{
+ List *result = NIL;
+ ListCell *l;
+
+ foreach(l, restrictinfo_list)
+ {
+ RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
+
+ Assert(IsA(rinfo, RestrictInfo));
+
+ if (rinfo->pseudoconstant == pseudoconstant)
+ result = lappend(result, rinfo->clause);
+ }
+ return result;
+}
+
+/*
+ * extract_actual_join_clauses
+ *
+ * Extract bare clauses from 'restrictinfo_list', separating those that
* syntactically match the join level from those that were pushed down.
+ * Pseudoconstant clauses are excluded from the results.
+ *
+ * This is only used at outer joins, since for plain joins we don't care
+ * about pushed-down-ness.
*/
void
-get_actual_join_clauses(List *restrictinfo_list,
- List **joinquals, List **otherquals)
+extract_actual_join_clauses(List *restrictinfo_list,
+ List **joinquals,
+ List **otherquals)
{
- ListCell *temp;
+ ListCell *l;
*joinquals = NIL;
*otherquals = NIL;
- foreach(temp, restrictinfo_list)
+ foreach(l, restrictinfo_list)
{
- RestrictInfo *clause = (RestrictInfo *) lfirst(temp);
+ RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
+
+ Assert(IsA(rinfo, RestrictInfo));
- if (clause->is_pushed_down)
- *otherquals = lappend(*otherquals, clause->clause);
+ if (rinfo->is_pushed_down)
+ {
+ if (!rinfo->pseudoconstant)
+ *otherquals = lappend(*otherquals, rinfo->clause);
+ }
else
- *joinquals = lappend(*joinquals, clause->clause);
+ {
+ /* joinquals shouldn't have been marked pseudoconstant */
+ Assert(!rinfo->pseudoconstant);
+ *joinquals = lappend(*joinquals, rinfo->clause);
+ }
}
}
* Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/nodes/relation.h,v 1.125 2006/06/06 17:59:58 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/nodes/relation.h,v 1.126 2006/07/01 18:38:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
bool hasJoinRTEs; /* true if any RTEs are RTE_JOIN kind */
bool hasOuterJoins; /* true if any RTEs are outer joins */
bool hasHavingQual; /* true if havingQual was non-null */
+ bool hasPseudoConstantQuals; /* true if any RestrictInfo has
+ * pseudoconstant = true */
} PlannerInfo;
} AppendPath;
/*
- * ResultPath represents use of a Result plan node. There are several
- * applications for this:
- * * To compute a variable-free targetlist (a "SELECT expressions" query).
- * In this case subpath and path.parent will both be NULL. constantqual
- * might or might not be empty ("SELECT expressions WHERE something").
- * * To gate execution of a subplan with a one-time (variable-free) qual
- * condition. path.parent is copied from the subpath.
- * * To substitute for a scan plan when we have proven that no rows in
- * a table will satisfy the query. subpath is NULL but path.parent
- * references the not-to-be-scanned relation, and constantqual is
- * a constant FALSE.
- *
- * Note that constantqual is a list of bare clauses, not RestrictInfos.
+ * ResultPath represents use of a Result plan node to compute a variable-free
+ * targetlist with no underlying tables (a "SELECT expressions" query).
+ * The query could have a WHERE clause, too, represented by "quals".
+ *
+ * Note that quals is a list of bare clauses, not RestrictInfos.
*/
typedef struct ResultPath
{
Path path;
- Path *subpath;
- List *constantqual;
+ List *quals;
} ResultPath;
/*
* OR/AND structure. This is a convenience for OR indexscan processing:
* indexquals taken from either the top level or an OR subclause will have
* associated RestrictInfo nodes.
+ *
+ * The can_join flag is set true if the clause looks potentially useful as
+ * a merge or hash join clause, that is if it is a binary opclause with
+ * nonoverlapping sets of relids referenced in the left and right sides.
+ * (Whether the operator is actually merge or hash joinable isn't checked,
+ * however.)
+ *
+ * The pseudoconstant flag is set true if the clause contains no Vars of
+ * the current query level and no volatile functions. Such a clause can be
+ * pulled out and used as a one-time qual in a gating Result node. We keep
+ * pseudoconstant clauses in the same lists as other RestrictInfos so that
+ * the regular clause-pushing machinery can assign them to the correct join
+ * level, but they need to be treated specially for cost and selectivity
+ * estimates. Note that a pseudoconstant clause can never be an indexqual
+ * or merge or hash join clause, so it's of no interest to large parts of
+ * the planner.
*/
typedef struct RestrictInfo
bool outerjoin_delayed; /* TRUE if delayed by outer join */
- /*
- * This flag is set true if the clause looks potentially useful as a merge
- * or hash join clause, that is if it is a binary opclause with
- * nonoverlapping sets of relids referenced in the left and right sides.
- * (Whether the operator is actually merge or hash joinable isn't checked,
- * however.)
- */
- bool can_join;
+ bool can_join; /* see comment above */
+
+ bool pseudoconstant; /* see comment above */
/* The set of relids (varnos) actually referenced in the clause: */
Relids clause_relids;
* Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/optimizer/clauses.h,v 1.83 2006/03/05 15:58:57 momjian Exp $
+ * $PostgreSQL: pgsql/src/include/optimizer/clauses.h,v 1.84 2006/07/01 18:38:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern bool is_pseudo_constant_clause(Node *clause);
extern bool is_pseudo_constant_clause_relids(Node *clause, Relids relids);
-extern List *pull_constant_clauses(List *quals, List **constantQual);
extern bool has_distinct_clause(Query *query);
extern bool has_distinct_on_clause(Query *query);
* Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/optimizer/pathnode.h,v 1.68 2006/06/06 17:59:58 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/optimizer/pathnode.h,v 1.69 2006/07/01 18:38:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern TidPath *create_tidscan_path(PlannerInfo *root, RelOptInfo *rel,
List *tidquals);
extern AppendPath *create_append_path(RelOptInfo *rel, List *subpaths);
-extern ResultPath *create_result_path(RelOptInfo *rel, Path *subpath,
- List *constantqual);
+extern ResultPath *create_result_path(List *quals);
extern MaterialPath *create_material_path(RelOptInfo *rel, Path *subpath);
extern UniquePath *create_unique_path(PlannerInfo *root, RelOptInfo *rel,
Path *subpath);
* Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/optimizer/planmain.h,v 1.92 2006/03/05 15:58:57 momjian Exp $
+ * $PostgreSQL: pgsql/src/include/optimizer/planmain.h,v 1.93 2006/07/01 18:38:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Plan *lefttree);
extern Sort *make_sort_from_groupcols(PlannerInfo *root, List *groupcls,
AttrNumber *grpColIdx, Plan *lefttree);
-extern List *order_qual_clauses(PlannerInfo *root, List *clauses);
extern Agg *make_agg(PlannerInfo *root, List *tlist, List *qual,
AggStrategy aggstrategy,
int numGroupCols, AttrNumber *grpColIdx,
* Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/optimizer/restrictinfo.h,v 1.36 2006/03/05 15:58:57 momjian Exp $
+ * $PostgreSQL: pgsql/src/include/optimizer/restrictinfo.h,v 1.37 2006/07/01 18:38:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern RestrictInfo *make_restrictinfo(Expr *clause,
bool is_pushed_down,
bool outerjoin_delayed,
+ bool pseudoconstant,
Relids required_relids);
extern List *make_restrictinfo_from_bitmapqual(Path *bitmapqual,
bool is_pushed_down,
bool include_predicates);
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,
- List **joinquals, List **otherquals);
+extern List *extract_actual_clauses(List *restrictinfo_list,
+ bool pseudoconstant);
+extern void extract_actual_join_clauses(List *restrictinfo_list,
+ List **joinquals,
+ List **otherquals);
extern List *remove_redundant_join_clauses(PlannerInfo *root,
List *restrictinfo_list,
bool isouterjoin);
projects / postgresql / commitdiff