mirrors/postgres
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix another place that wasn't maintaining AND/OR flatness of an

Browse Source 
already-canonicalized qual expression.
This commit is contained in:
Tom Lane 2004-01-12 22:20:28 +00:00
parent 5590be0a9e
commit 67af5bace5
2 changed files with 65 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/backend/optimizer/plan/planner.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.163 2003/12/28 21:57:36 tgl Exp $ * $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.164 2004/01/12 22:20:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -380,6 +380,10 @@ preprocess_expression(Query *parse, Node *expr, int kind)
* If it's a qual or havingQual, canonicalize it. It seems most useful * If it's a qual or havingQual, canonicalize it. It seems most useful
* to do this before applying eval_const_expressions, since the latter * to do this before applying eval_const_expressions, since the latter
* can optimize flattened AND/ORs better than unflattened ones. * can optimize flattened AND/ORs better than unflattened ones.
*
* Note: all processing of a qual expression after this point must be
* careful to maintain AND/OR flatness --- that is, do not generate a
* tree with AND directly under AND, nor OR directly under OR.
*/ */
if (kind == EXPRKIND_QUAL) if (kind == EXPRKIND_QUAL)
{ {
@ -396,14 +400,6 @@ preprocess_expression(Query *parse, Node *expr, int kind)
*/ */
expr = eval_const_expressions(expr); expr = eval_const_expressions(expr);
/*
* If it's a qual or havingQual, convert it to implicit-AND format.
* (We don't want to do this before eval_const_expressions, since the
* latter would be unable to simplify a top-level AND correctly.)
*/
if (kind == EXPRKIND_QUAL)
expr = (Node *) make_ands_implicit((Expr *) expr);
/* Expand SubLinks to SubPlans */ /* Expand SubLinks to SubPlans */
if (parse->hasSubLinks) if (parse->hasSubLinks)
expr = SS_process_sublinks(expr, (kind == EXPRKIND_QUAL)); expr = SS_process_sublinks(expr, (kind == EXPRKIND_QUAL));
@ -417,6 +413,15 @@ preprocess_expression(Query *parse, Node *expr, int kind)
if (PlannerQueryLevel > 1) if (PlannerQueryLevel > 1)
expr = SS_replace_correlation_vars(expr); expr = SS_replace_correlation_vars(expr);
/*
* If it's a qual or havingQual, convert it to implicit-AND format.
* (We don't want to do this before eval_const_expressions, since the
* latter would be unable to simplify a top-level AND correctly. Also,
* SS_process_sublinks expects explicit-AND format.)
*/
if (kind == EXPRKIND_QUAL)
expr = (Node *) make_ands_implicit((Expr *) expr);
return expr; return expr;
} }

57
src/backend/optimizer/plan/subselect.c
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/plan/subselect.c,v 1.86 2003/11/29 19:51:50 pgsql Exp $ * $PostgreSQL: pgsql/src/backend/optimizer/plan/subselect.c,v 1.87 2004/01/12 22:20:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -848,13 +848,58 @@ process_sublinks_mutator(Node *node, bool *isTopQual)
Assert(!IsA(node, Query)); Assert(!IsA(node, Query));
/* /*
* If we recurse down through anything other than a List node, we are * Because make_subplan() could return an AND or OR clause, we have to
* definitely not at top qual level anymore. * take steps to preserve AND/OR flatness of a qual. We assume the input
* has been AND/OR flattened and so we need no recursion here.
*
* If we recurse down through anything other than an AND node,
* we are definitely not at top qual level anymore. (Due to the coding
* here, we will not get called on the List subnodes of an AND, so no
* check is needed for List.)
*/ */
if (IsA(node, List)) if (and_clause(node))
{
List *newargs = NIL;
List *l;
/* Still at qual top-level */
locTopQual = *isTopQual; locTopQual = *isTopQual;
else
locTopQual = false; foreach(l, ((BoolExpr *) node)->args)
{
Node *newarg;
newarg = process_sublinks_mutator(lfirst(l),
(void *) &locTopQual);
if (and_clause(newarg))
newargs = nconc(newargs, ((BoolExpr *) newarg)->args);
else
newargs = lappend(newargs, newarg);
}
return (Node *) make_andclause(newargs);
}
/* otherwise not at qual top-level */
locTopQual = false;
if (or_clause(node))
{
List *newargs = NIL;
List *l;
foreach(l, ((BoolExpr *) node)->args)
{
Node *newarg;
newarg = process_sublinks_mutator(lfirst(l),
(void *) &locTopQual);
if (or_clause(newarg))
newargs = nconc(newargs, ((BoolExpr *) newarg)->args);
else
newargs = lappend(newargs, newarg);
}
return (Node *) make_orclause(newargs);
}
return expression_tree_mutator(node, return expression_tree_mutator(node,
process_sublinks_mutator, process_sublinks_mutator,