Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit96ca8ff

Browse files
committed
Fix problems with subselects used in GROUP BY expressions, per gripe
from Philip Warner. Side effect of change is that GROUP BY expressionswill not be re-evaluated at multiple plan levels anymore, whereas thissometimes happened with old code.
1 parent512a3ae commit96ca8ff

File tree

4 files changed

+167
-103
lines changed

4 files changed

+167
-103
lines changed

‎src/backend/optimizer/plan/planner.c‎

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
*
99
*
1010
* IDENTIFICATION
11-
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.111 2001/10/28 06:25:45 momjian Exp $
11+
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.112 2001/10/30 19:58:58 tgl Exp $
1212
*
1313
*-------------------------------------------------------------------------
1414
*/
@@ -173,6 +173,17 @@ subquery_planner(Query *parse, double tuple_fraction)
173173
parse->havingQual=preprocess_expression(parse,parse->havingQual,
174174
EXPRKIND_HAVING);
175175

176+
/*
177+
* Check for ungrouped variables passed to subplans in targetlist and
178+
* HAVING clause (but not in WHERE or JOIN/ON clauses, since those are
179+
* evaluated before grouping). We can't do this any earlier because
180+
* we must use the preprocessed targetlist for comparisons of grouped
181+
* expressions.
182+
*/
183+
if (parse->hasSubLinks&&
184+
(parse->groupClause!=NIL||parse->hasAggs))
185+
check_subplans_for_ungrouped_vars(parse);
186+
176187
/*
177188
* A HAVING clause without aggregates is equivalent to a WHERE clause
178189
* (except it can only refer to grouped fields). Transfer any
@@ -623,23 +634,10 @@ preprocess_expression(Query *parse, Node *expr, int kind)
623634
#endif
624635
}
625636

637+
/* Expand SubLinks to SubPlans */
626638
if (parse->hasSubLinks)
627-
{
628-
/* Expand SubLinks to SubPlans */
629639
expr=SS_process_sublinks(expr);
630640

631-
if (kind!=EXPRKIND_WHERE&&
632-
(parse->groupClause!=NIL||parse->hasAggs))
633-
{
634-
/*
635-
* Check for ungrouped variables passed to subplans. Note we
636-
* do NOT do this for subplans in WHERE (or JOIN/ON); it's
637-
* legal there because WHERE is evaluated pre-GROUP.
638-
*/
639-
check_subplans_for_ungrouped_vars(expr,parse);
640-
}
641-
}
642-
643641
/* Replace uplevel vars with Param nodes */
644642
if (PlannerQueryLevel>1)
645643
expr=SS_replace_correlation_vars(expr);
@@ -1122,12 +1120,11 @@ grouping_planner(Query *parse, double tuple_fraction)
11221120

11231121
/*
11241122
* If there are aggregates then the Group node should just return
1125-
* the same set of vars as the subplan did (but we can exclude any
1126-
* GROUP BY expressions). If there are no aggregates then the
1127-
* Group node had better compute the final tlist.
1123+
* the same set of vars as the subplan did. If there are no aggs
1124+
* then the Group node had better compute the final tlist.
11281125
*/
11291126
if (parse->hasAggs)
1130-
group_tlist=flatten_tlist(result_plan->targetlist);
1127+
group_tlist=new_unsorted_tlist(result_plan->targetlist);
11311128
else
11321129
group_tlist=tlist;
11331130

@@ -1234,7 +1231,10 @@ grouping_planner(Query *parse, double tuple_fraction)
12341231
* where the a+b target will be used by the Sort/Group steps, and the
12351232
* other targets will be used for computing the final results.(In the
12361233
* above example we could theoretically suppress the a and b targets and
1237-
* use only a+b, but it's not really worth the trouble.)
1234+
* pass down only c,d,a+b, but it's not really worth the trouble to
1235+
* eliminate simple var references from the subplan. We will avoid doing
1236+
* the extra computation to recompute a+b at the outer level; see
1237+
* replace_vars_with_subplan_refs() in setrefs.c.)
12381238
*
12391239
* 'parse' is the query being processed.
12401240
* 'tlist' is the query's target list.

‎src/backend/optimizer/plan/setrefs.c‎

Lines changed: 78 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@
99
*
1010
*
1111
* IDENTIFICATION
12-
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.71 2001/03/22 03:59:37 momjian Exp $
12+
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.72 2001/10/30 19:58:58 tgl Exp $
1313
*
1414
*-------------------------------------------------------------------------
1515
*/
@@ -33,7 +33,8 @@ typedef struct
3333
typedefstruct
3434
{
3535
Indexsubvarno;
36-
List*subplanTargetList;
36+
List*subplan_targetlist;
37+
booltlist_has_non_vars;
3738
}replace_vars_with_subplan_refs_context;
3839

3940
staticvoidfix_expr_references(Plan*plan,Node*node);
@@ -43,7 +44,8 @@ static Node *join_references_mutator(Node *node,
4344
join_references_context*context);
4445
staticNode*replace_vars_with_subplan_refs(Node*node,
4546
Indexsubvarno,
46-
List*subplanTargetList);
47+
List*subplan_targetlist,
48+
booltlist_has_non_vars);
4749
staticNode*replace_vars_with_subplan_refs_mutator(Node*node,
4850
replace_vars_with_subplan_refs_context*context);
4951
staticboolfix_opids_walker(Node*node,void*context);
@@ -278,75 +280,62 @@ set_join_references(Join *join)
278280
* qual expressions with elements of the subplan's tlist (which was
279281
* generated by flatten_tlist() from these selfsame expressions, so it
280282
* should have all the required variables). There is an important exception,
281-
* however: a GROUP BY expression that is also an output expression will
282-
* have been pushed into the subplan tlist unflattened. We want to detect
283-
* this case and reference the subplan output directly. Therefore, check
284-
* for equality of the whole tlist expression to any subplan element before
285-
* we resort to picking the expression apart for individual Vars.
283+
* however: GROUP BY and ORDER BY expressions will have been pushed into the
284+
* subplan tlist unflattened. If these values are also needed in the output
285+
* then we want to reference the subplan tlist element rather than recomputing
286+
* the expression.
286287
*/
287288
staticvoid
288289
set_uppernode_references(Plan*plan,Indexsubvarno)
289290
{
290291
Plan*subplan=plan->lefttree;
291-
List*subplanTargetList,
292-
*outputTargetList,
292+
List*subplan_targetlist,
293+
*output_targetlist,
293294
*l;
295+
booltlist_has_non_vars;
294296

295297
if (subplan!=NULL)
296-
subplanTargetList=subplan->targetlist;
298+
subplan_targetlist=subplan->targetlist;
297299
else
298-
subplanTargetList=NIL;
300+
subplan_targetlist=NIL;
299301

300-
outputTargetList=NIL;
301-
foreach(l,plan->targetlist)
302+
/*
303+
* Detect whether subplan tlist has any non-Vars (typically it won't
304+
* because it's been flattened). This allows us to save comparisons
305+
* in common cases.
306+
*/
307+
tlist_has_non_vars= false;
308+
foreach(l,subplan_targetlist)
302309
{
303310
TargetEntry*tle= (TargetEntry*)lfirst(l);
304-
TargetEntry*subplantle;
305-
Node*newexpr;
306-
307-
subplantle=tlistentry_member(tle->expr,subplanTargetList);
308-
if (subplantle)
309-
{
310-
/* Found a matching subplan output expression */
311-
Resdom*resdom=subplantle->resdom;
312-
Var*newvar;
313311

314-
newvar=makeVar(subvarno,
315-
resdom->resno,
316-
resdom->restype,
317-
resdom->restypmod,
318-
0);
319-
/* If we're just copying a simple Var, copy up original info */
320-
if (subplantle->expr&&IsA(subplantle->expr,Var))
321-
{
322-
Var*subvar= (Var*)subplantle->expr;
323-
324-
newvar->varnoold=subvar->varnoold;
325-
newvar->varoattno=subvar->varoattno;
326-
}
327-
else
328-
{
329-
newvar->varnoold=0;
330-
newvar->varoattno=0;
331-
}
332-
newexpr= (Node*)newvar;
333-
}
334-
else
312+
if (tle->expr&& !IsA(tle->expr,Var))
335313
{
336-
/* No matching expression, so replace individual Vars */
337-
newexpr=replace_vars_with_subplan_refs(tle->expr,
338-
subvarno,
339-
subplanTargetList);
314+
tlist_has_non_vars= true;
315+
break;
340316
}
341-
outputTargetList=lappend(outputTargetList,
342-
makeTargetEntry(tle->resdom,newexpr));
343317
}
344-
plan->targetlist=outputTargetList;
318+
319+
output_targetlist=NIL;
320+
foreach(l,plan->targetlist)
321+
{
322+
TargetEntry*tle= (TargetEntry*)lfirst(l);
323+
Node*newexpr;
324+
325+
newexpr=replace_vars_with_subplan_refs(tle->expr,
326+
subvarno,
327+
subplan_targetlist,
328+
tlist_has_non_vars);
329+
output_targetlist=lappend(output_targetlist,
330+
makeTargetEntry(tle->resdom,newexpr));
331+
}
332+
plan->targetlist=output_targetlist;
345333

346334
plan->qual= (List*)
347335
replace_vars_with_subplan_refs((Node*)plan->qual,
348336
subvarno,
349-
subplanTargetList);
337+
subplan_targetlist,
338+
tlist_has_non_vars);
350339
}
351340

352341
/*
@@ -439,9 +428,16 @@ join_references_mutator(Node *node,
439428
* --- so this routine should only be applied to nodes whose subplans'
440429
* targetlists were generated via flatten_tlist() or some such method.
441430
*
442-
* 'node': the tree to be fixed (a targetlist or qual list)
431+
* If tlist_has_non_vars is true, then we try to match whole subexpressions
432+
* against elements of the subplan tlist, so that we can avoid recomputing
433+
* expressions that were already computed by the subplan. (This is relatively
434+
* expensive, so we don't want to try it in the common case where the
435+
* subplan tlist is just a flattened list of Vars.)
436+
*
437+
* 'node': the tree to be fixed (a target item or qual)
443438
* 'subvarno': varno to be assigned to all Vars
444-
* 'subplanTargetList': target list for subplan
439+
* 'subplan_targetlist': target list for subplan
440+
* 'tlist_has_non_vars': true if subplan_targetlist contains non-Var exprs
445441
*
446442
* The resulting tree is a copy of the original in which all Var nodes have
447443
* varno = subvarno, varattno = resno of corresponding subplan target.
@@ -450,12 +446,14 @@ join_references_mutator(Node *node,
450446
staticNode*
451447
replace_vars_with_subplan_refs(Node*node,
452448
Indexsubvarno,
453-
List*subplanTargetList)
449+
List*subplan_targetlist,
450+
booltlist_has_non_vars)
454451
{
455452
replace_vars_with_subplan_refs_contextcontext;
456453

457454
context.subvarno=subvarno;
458-
context.subplanTargetList=subplanTargetList;
455+
context.subplan_targetlist=subplan_targetlist;
456+
context.tlist_has_non_vars=tlist_has_non_vars;
459457
returnreplace_vars_with_subplan_refs_mutator(node,&context);
460458
}
461459

@@ -468,17 +466,38 @@ replace_vars_with_subplan_refs_mutator(Node *node,
468466
if (IsA(node,Var))
469467
{
470468
Var*var= (Var*)node;
471-
Var*newvar= (Var*)copyObject(var);
472469
Resdom*resdom;
470+
Var*newvar;
473471

474-
resdom=tlist_member((Node*)var,context->subplanTargetList);
472+
resdom=tlist_member((Node*)var,context->subplan_targetlist);
475473
if (!resdom)
476474
elog(ERROR,"replace_vars_with_subplan_refs: variable not in subplan target list");
477-
475+
newvar= (Var*)copyObject(var);
478476
newvar->varno=context->subvarno;
479477
newvar->varattno=resdom->resno;
480478
return (Node*)newvar;
481479
}
480+
/* Try matching more complex expressions too, if tlist has any */
481+
if (context->tlist_has_non_vars)
482+
{
483+
Resdom*resdom;
484+
485+
resdom=tlist_member(node,context->subplan_targetlist);
486+
if (resdom)
487+
{
488+
/* Found a matching subplan output expression */
489+
Var*newvar;
490+
491+
newvar=makeVar(context->subvarno,
492+
resdom->resno,
493+
resdom->restype,
494+
resdom->restypmod,
495+
0);
496+
newvar->varnoold=0;/* wasn't ever a plain Var */
497+
newvar->varoattno=0;
498+
return (Node*)newvar;
499+
}
500+
}
482501
returnexpression_tree_mutator(node,
483502
replace_vars_with_subplan_refs_mutator,
484503
(void*)context);

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp