open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Push down outer qualification clauses into UNION and INTERSECT subqueries.

Browse Source 
Per pghackers discussion from back around 1-August.
REL7_3_STABLE
Tom Lane 23 years ago
parent d2236800ee
commit 0201dac1c3
3 changed files with 196 additions and 54 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 241
      src/backend/optimizer/path/allpaths.c
  2. 5
      src/backend/optimizer/prep/prepunion.c
  3. 4
      src/include/optimizer/prep.h

241
src/backend/optimizer/path/allpaths.c
Unescape View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.86 2002/06/20 20:29:29 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.87 2002/08/29 16:03:48 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -46,6 +46,11 @@ static void set_function_pathlist(Query *root, RelOptInfo *rel,
RangeTblEntry *rte);
static RelOptInfo *make_one_rel_by_joins(Query *root, int levels_needed,
List *initial_rels);
static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery);
static bool recurse_pushdown_safe(Node *setOp, Query *topquery);
static void subquery_push_qual(Query *subquery, Index rti, Node *qual);
static void recurse_push_qual(Node *setOp, Query *topquery,
Index rti, Node *qual);
/*
@ -297,31 +302,11 @@ set_subquery_pathlist(Query *root, RelOptInfo *rel,
* generate a better plan for the subquery than evaluating all the
* subquery output rows and then filtering them.
*
* There are several cases where we cannot push down clauses:
*
* 1. If the subquery contains set ops (UNION/INTERSECT/EXCEPT) we do not
* push down any qual clauses, since the planner doesn't support quals
* at the top level of a setop. (With suitable analysis we could try
* to push the quals down into the component queries of the setop, but
* getting it right seems nontrivial. Work on this later.)
*
* 2. If the subquery has a LIMIT clause or a DISTINCT ON clause, we must
* not push down any quals, since that could change the set of rows
* returned. (Actually, we could push down quals into a DISTINCT ON
* subquery if they refer only to DISTINCT-ed output columns, but
* checking that seems more work than it's worth. In any case, a
* plain DISTINCT is safe to push down past.)
*
* 3. If the subquery has any functions returning sets in its target list,
* we do not push down any quals, since the quals
* might refer to those tlist items, which would mean we'd introduce
* functions-returning-sets into the subquery's WHERE/HAVING quals.
* (It'd be sufficient to not push down quals that refer to those
* particular tlist items, but that's much clumsier to check.)
*
* 4. We do not push down clauses that contain subselects, mainly because
* I'm not sure it will work correctly (the subplan hasn't yet
* transformed sublinks to subselects).
* There are several cases where we cannot push down clauses.
* Restrictions involving the subquery are checked by
* subquery_is_pushdown_safe(). Also, we do not push down clauses that
* contain subselects, mainly because I'm not sure it will work correctly
* (the subplan hasn't yet transformed sublinks to subselects).
*
* Non-pushed-down clauses will get evaluated as qpquals of the
* SubqueryScan node.
@ -329,11 +314,8 @@ set_subquery_pathlist(Query *root, RelOptInfo *rel,
* XXX Are there any cases where we want to make a policy decision not to
* push down, because it'd result in a worse plan?
*/
if (subquery->setOperations == NULL &&
subquery->limitOffset == NULL &&
subquery->limitCount == NULL &&
!has_distinct_on_clause(subquery) &&
!expression_returns_set((Node *) subquery->targetList))
if (rel->baserestrictinfo != NIL &&
subquery_is_pushdown_safe(subquery, subquery))
{
/* OK to consider pushing down individual quals */
List *upperrestrictlist = NIL;
@ -351,25 +333,8 @@ set_subquery_pathlist(Query *root, RelOptInfo *rel,
}
else
{
/*
* We need to replace Vars in the clause (which must refer
* to outputs of the subquery) with copies of the
* subquery's targetlist expressions. Note that at this
* point, any uplevel Vars in the clause should have been
* replaced with Params, so they need no work.
*/
clause = ResolveNew(clause, rti, 0,
subquery->targetList,
CMD_SELECT, 0);
subquery->havingQual = make_and_qual(subquery->havingQual,
clause);
/*
* We need not change the subquery's hasAggs or
* hasSublinks flags, since we can't be pushing down any
* aggregates that weren't there before, and we don't push
* down subselects at all.
*/
/* Push it down */
subquery_push_qual(subquery, rti, clause);
}
}
rel->baserestrictinfo = upperrestrictlist;
@ -547,7 +512,183 @@ make_one_rel_by_joins(Query *root, int levels_needed, List *initial_rels)
}
/*****************************************************************************
* PUSHING QUALS DOWN INTO SUBQUERIES
*****************************************************************************/
/*
* subquery_is_pushdown_safe - is a subquery safe for pushing down quals?
*
* subquery is the particular component query being checked. topquery
* is the top component of a set-operations tree (the same Query if no
* set-op is involved).
*
* Conditions checked here:
*
* 1. If the subquery has a LIMIT clause or a DISTINCT ON clause, we must
* not push down any quals, since that could change the set of rows
* returned. (Actually, we could push down quals into a DISTINCT ON
* subquery if they refer only to DISTINCT-ed output columns, but
* checking that seems more work than it's worth. In any case, a
* plain DISTINCT is safe to push down past.)
*
* 2. If the subquery has any functions returning sets in its target list,
* we do not push down any quals, since the quals
* might refer to those tlist items, which would mean we'd introduce
* functions-returning-sets into the subquery's WHERE/HAVING quals.
* (It'd be sufficient to not push down quals that refer to those
* particular tlist items, but that's much clumsier to check.)
*
* 3. If the subquery contains EXCEPT or EXCEPT ALL set ops we cannot push
* quals into it, because that would change the results. For subqueries
* using UNION/UNION ALL/INTERSECT/INTERSECT ALL, we can push the quals
* into each component query, so long as all the component queries share
* identical output types. (That restriction could probably be relaxed,
* but it would take much more code to include type coercion code into
* the quals, and I'm also concerned about possible semantic gotchas.)
*/
static bool
subquery_is_pushdown_safe(Query *subquery, Query *topquery)
{
SetOperationStmt *topop;
/* Check points 1 and 2 */
if (subquery->limitOffset != NULL ||
subquery->limitCount != NULL ||
has_distinct_on_clause(subquery) ||
expression_returns_set((Node *) subquery->targetList))
return false;
/* Are we at top level, or looking at a setop component? */
if (subquery == topquery)
{
/* Top level, so check any component queries */
if (subquery->setOperations != NULL)
if (!recurse_pushdown_safe(subquery->setOperations, topquery))
return false;
}
else
{
/* Setop component must not have more components (too weird) */
if (subquery->setOperations != NULL)
return false;
/* Setop component output types must match top level */
topop = (SetOperationStmt *) topquery->setOperations;
Assert(topop && IsA(topop, SetOperationStmt));
if (!tlist_same_datatypes(subquery->targetList,
topop->colTypes,
true))
return false;
}
return true;
}
/*
* Helper routine to recurse through setOperations tree
*/
static bool
recurse_pushdown_safe(Node *setOp, Query *topquery)
{
if (IsA(setOp, RangeTblRef))
{
RangeTblRef *rtr = (RangeTblRef *) setOp;
RangeTblEntry *rte = rt_fetch(rtr->rtindex, topquery->rtable);
Query *subquery = rte->subquery;
Assert(subquery != NULL);
return subquery_is_pushdown_safe(subquery, topquery);
}
else if (IsA(setOp, SetOperationStmt))
{
SetOperationStmt *op = (SetOperationStmt *) setOp;
/* EXCEPT is no good */
if (op->op == SETOP_EXCEPT)
return false;
/* Else recurse */
if (!recurse_pushdown_safe(op->larg, topquery))
return false;
if (!recurse_pushdown_safe(op->rarg, topquery))
return false;
}
else
{
elog(ERROR, "recurse_pushdown_safe: unexpected node %d",
(int) nodeTag(setOp));
}
return true;
}
/*
* subquery_push_qual - push down a qual that we have determined is safe
*/
static void
subquery_push_qual(Query *subquery, Index rti, Node *qual)
{
if (subquery->setOperations != NULL)
{
/* Recurse to push it separately to each component query */
recurse_push_qual(subquery->setOperations, subquery, rti, qual);
}
else
{
/*
* We need to replace Vars in the qual (which must refer
* to outputs of the subquery) with copies of the
* subquery's targetlist expressions. Note that at this
* point, any uplevel Vars in the qual should have been
* replaced with Params, so they need no work.
*
* This step also ensures that when we are pushing into a setop
* tree, each component query gets its own copy of the qual.
*/
qual = ResolveNew(qual, rti, 0,
subquery->targetList,
CMD_SELECT, 0);
subquery->havingQual = make_and_qual(subquery->havingQual,
qual);
/*
* We need not change the subquery's hasAggs or
* hasSublinks flags, since we can't be pushing down any
* aggregates that weren't there before, and we don't push
* down subselects at all.
*/
}
}
/*
* Helper routine to recurse through setOperations tree
*/
static void
recurse_push_qual(Node *setOp, Query *topquery,
Index rti, Node *qual)
{
if (IsA(setOp, RangeTblRef))
{
RangeTblRef *rtr = (RangeTblRef *) setOp;
RangeTblEntry *rte = rt_fetch(rtr->rtindex, topquery->rtable);
Query *subquery = rte->subquery;
Assert(subquery != NULL);
subquery_push_qual(subquery, rti, qual);
}
else if (IsA(setOp, SetOperationStmt))
{
SetOperationStmt *op = (SetOperationStmt *) setOp;
recurse_push_qual(op->larg, topquery, rti, qual);
recurse_push_qual(op->rarg, topquery, rti, qual);
}
else
{
elog(ERROR, "recurse_push_qual: unexpected node %d",
(int) nodeTag(setOp));
}
}
/*****************************************************************************
* DEBUG SUPPORT
*****************************************************************************/
#ifdef OPTIMIZER_DEBUG

5
src/backend/optimizer/prep/prepunion.c
Unescape View File

@ -14,7 +14,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.75 2002/08/02 18:15:06 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.76 2002/08/29 16:03:48 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -66,7 +66,6 @@ static List *generate_setop_tlist(List *colTypes, int flag,
static List *generate_append_tlist(List *colTypes, bool flag,
List *input_plans,
List *refnames_tlist);
static bool tlist_same_datatypes(List *tlist, List *colTypes, bool junkOK);
static Node *adjust_inherited_attrs_mutator(Node *node,
adjust_inherited_attrs_context *context);
@ -579,7 +578,7 @@ generate_append_tlist(List *colTypes, bool flag,
* Resjunk columns are ignored if junkOK is true; otherwise presence of
* a resjunk column will always cause a 'false' result.
*/
static bool
bool
tlist_same_datatypes(List *tlist, List *colTypes, bool junkOK)
{
List *i;

4
src/include/optimizer/prep.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: prep.h,v 1.32 2002/06/20 20:29:51 momjian Exp $
* $Id: prep.h,v 1.33 2002/08/29 16:03:49 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -43,4 +43,6 @@ extern Node *adjust_inherited_attrs(Node *node,
Index old_rt_index, Oid old_relid,
Index new_rt_index, Oid new_relid);
extern bool tlist_same_datatypes(List *tlist, List *colTypes, bool junkOK);
#endif /* PREP_H */

Write Preview
Loading…
Cancel
Save