mirror of
https://git.postgresql.org/git/postgresql.git
synced 2026-02-16 11:26:59 +08:00
69f4b9c85f
Evaluation of set returning functions (SRFs_ in the targetlist (like SELECT generate_series(1,5)) so far was done in the expression evaluation (i.e. ExecEvalExpr()) and projection (i.e. ExecProject/ExecTargetList) code. This meant that most executor nodes performing projection, and most expression evaluation functions, had to deal with the possibility that an evaluated expression could return a set of return values. That's bad because it leads to repeated code in a lot of places. It also, and that's my (Andres's) motivation, made it a lot harder to implement a more efficient way of doing expression evaluation. To fix this, introduce a new executor node (ProjectSet) that can evaluate targetlists containing one or more SRFs. To avoid the complexity of the old way of handling nested expressions returning sets (e.g. having to pass up ExprDoneCond, and dealing with arguments to functions returning sets etc.), those SRFs can only be at the top level of the node's targetlist. The planner makes sure (via split_pathtarget_at_srfs()) that SRF evaluation is only necessary in ProjectSet nodes and that SRFs are only present at the top level of the node's targetlist. If there are nested SRFs the planner creates multiple stacked ProjectSet nodes. The ProjectSet nodes always get input from an underlying node. We also discussed and prototyped evaluating targetlist SRFs using ROWS FROM(), but that turned out to be more complicated than we'd hoped. While moving SRF evaluation to ProjectSet would allow to retain the old "least common multiple" behavior when multiple SRFs are present in one targetlist (i.e. continue returning rows until all SRFs are at the end of their input at the same time), we decided to instead only return rows till all SRFs are exhausted, returning NULL for already exhausted ones. We deemed the previous behavior to be too confusing, unexpected and actually not particularly useful. As a side effect, the previously prohibited case of multiple set returning arguments to a function, is now allowed. Not because it's particularly desirable, but because it ends up working and there seems to be no argument for adding code to prohibit it. Currently the behavior for COALESCE and CASE containing SRFs has changed, returning multiple rows from the expression, even when the SRF containing "arm" of the expression is not evaluated. That's because the SRFs are evaluated in a separate ProjectSet node. As that's quite confusing, we're likely to instead prohibit SRFs in those places. But that's still being discussed, and the code would reside in places not touched here, so that's a task for later. There's a lot of, now superfluous, code dealing with set return expressions around. But as the changes to get rid of those are verbose largely boring, it seems better for readability to keep the cleanup as a separate commit. Author: Tom Lane and Andres Freund Discussion: https://postgr.es/m/20160822214023.aaxz5l4igypowyri@alap3.anarazel.de
73 lines
2.7 KiB
C
73 lines
2.7 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* tlist.h
|
|
* prototypes for tlist.c.
|
|
*
|
|
*
|
|
* Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
* src/include/optimizer/tlist.h
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#ifndef TLIST_H
|
|
#define TLIST_H
|
|
|
|
#include "nodes/relation.h"
|
|
|
|
|
|
extern TargetEntry *tlist_member(Node *node, List *targetlist);
|
|
extern TargetEntry *tlist_member_ignore_relabel(Node *node, List *targetlist);
|
|
|
|
extern List *add_to_flat_tlist(List *tlist, List *exprs);
|
|
|
|
extern List *get_tlist_exprs(List *tlist, bool includeJunk);
|
|
|
|
extern int count_nonjunk_tlist_entries(List *tlist);
|
|
|
|
extern bool tlist_same_exprs(List *tlist1, List *tlist2);
|
|
|
|
extern bool tlist_same_datatypes(List *tlist, List *colTypes, bool junkOK);
|
|
extern bool tlist_same_collations(List *tlist, List *colCollations, bool junkOK);
|
|
|
|
extern void apply_tlist_labeling(List *dest_tlist, List *src_tlist);
|
|
|
|
extern TargetEntry *get_sortgroupref_tle(Index sortref,
|
|
List *targetList);
|
|
extern TargetEntry *get_sortgroupclause_tle(SortGroupClause *sgClause,
|
|
List *targetList);
|
|
extern Node *get_sortgroupclause_expr(SortGroupClause *sgClause,
|
|
List *targetList);
|
|
extern List *get_sortgrouplist_exprs(List *sgClauses,
|
|
List *targetList);
|
|
|
|
extern SortGroupClause *get_sortgroupref_clause(Index sortref,
|
|
List *clauses);
|
|
extern SortGroupClause *get_sortgroupref_clause_noerr(Index sortref,
|
|
List *clauses);
|
|
|
|
extern Oid *extract_grouping_ops(List *groupClause);
|
|
extern AttrNumber *extract_grouping_cols(List *groupClause, List *tlist);
|
|
extern bool grouping_is_sortable(List *groupClause);
|
|
extern bool grouping_is_hashable(List *groupClause);
|
|
|
|
extern PathTarget *make_pathtarget_from_tlist(List *tlist);
|
|
extern List *make_tlist_from_pathtarget(PathTarget *target);
|
|
extern PathTarget *copy_pathtarget(PathTarget *src);
|
|
extern PathTarget *create_empty_pathtarget(void);
|
|
extern void add_column_to_pathtarget(PathTarget *target,
|
|
Expr *expr, Index sortgroupref);
|
|
extern void add_new_column_to_pathtarget(PathTarget *target, Expr *expr);
|
|
extern void add_new_columns_to_pathtarget(PathTarget *target, List *exprs);
|
|
extern void apply_pathtarget_labeling_to_tlist(List *tlist, PathTarget *target);
|
|
extern void split_pathtarget_at_srfs(PlannerInfo *root,
|
|
PathTarget *target, PathTarget *input_target,
|
|
List **targets, List **targets_contain_srfs);
|
|
|
|
/* Convenience macro to get a PathTarget with valid cost/width fields */
|
|
#define create_pathtarget(root, tlist) \
|
|
set_pathtarget_cost_width(root, make_pathtarget_from_tlist(tlist))
|
|
|
|
#endif /* TLIST_H */
|