Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * nodeProjectSet.c
4 : * support for evaluating targetlists containing set-returning functions
5 : *
6 : * DESCRIPTION
7 : *
8 : * ProjectSet nodes are inserted by the planner to evaluate set-returning
9 : * functions in the targetlist. It's guaranteed that all set-returning
10 : * functions are directly at the top level of the targetlist, i.e. they
11 : * can't be inside more-complex expressions. If that'd otherwise be
12 : * the case, the planner adds additional ProjectSet nodes.
13 : *
14 : * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
15 : * Portions Copyright (c) 1994, Regents of the University of California
16 : *
17 : * IDENTIFICATION
18 : * src/backend/executor/nodeProjectSet.c
19 : *
20 : *-------------------------------------------------------------------------
21 : */
22 :
23 : #include "postgres.h"
24 :
25 : #include "executor/executor.h"
26 : #include "executor/nodeProjectSet.h"
27 : #include "miscadmin.h"
28 : #include "nodes/nodeFuncs.h"
29 :
30 :
31 : static TupleTableSlot *ExecProjectSRF(ProjectSetState *node, bool continuing);
32 :
33 :
34 : /* ----------------------------------------------------------------
35 : * ExecProjectSet(node)
36 : *
37 : * Return tuples after evaluating the targetlist (which contains set
38 : * returning functions).
39 : * ----------------------------------------------------------------
40 : */
41 : static TupleTableSlot *
42 2736450 : ExecProjectSet(PlanState *pstate)
43 : {
44 2736450 : ProjectSetState *node = castNode(ProjectSetState, pstate);
45 : TupleTableSlot *outerTupleSlot;
46 : TupleTableSlot *resultSlot;
47 : PlanState *outerPlan;
48 : ExprContext *econtext;
49 :
50 2736450 : CHECK_FOR_INTERRUPTS();
51 :
52 2736450 : econtext = node->ps.ps_ExprContext;
53 :
54 : /*
55 : * Reset per-tuple context to free expression-evaluation storage allocated
56 : * for a potentially previously returned tuple. Note that the SRF argument
57 : * context has a different lifetime and is reset below.
58 : */
59 2736450 : ResetExprContext(econtext);
60 :
61 : /*
62 : * Check to see if we're still projecting out tuples from a previous scan
63 : * tuple (because there is a function-returning-set in the projection
64 : * expressions). If so, try to project another one.
65 : */
66 2736450 : if (node->pending_srf_tuples)
67 : {
68 2695630 : resultSlot = ExecProjectSRF(node, true);
69 :
70 2695630 : if (resultSlot != NULL)
71 2599476 : return resultSlot;
72 : }
73 :
74 : /*
75 : * Get another input tuple and project SRFs from it.
76 : */
77 : for (;;)
78 : {
79 : /*
80 : * Reset argument context to free any expression evaluation storage
81 : * allocated in the previous tuple cycle. Note this can't happen
82 : * until we're done projecting out tuples from a scan tuple, as
83 : * ValuePerCall functions are allowed to reference the arguments for
84 : * each returned tuple. However, if we loop around after finding that
85 : * no rows are produced from a scan tuple, we should reset, to avoid
86 : * leaking memory when many successive scan tuples produce no rows.
87 : */
88 222540 : MemoryContextReset(node->argcontext);
89 :
90 : /*
91 : * Retrieve tuples from the outer plan until there are no more.
92 : */
93 222540 : outerPlan = outerPlanState(node);
94 222540 : outerTupleSlot = ExecProcNode(outerPlan);
95 :
96 222540 : if (TupIsNull(outerTupleSlot))
97 39202 : return NULL;
98 :
99 : /*
100 : * Prepare to compute projection expressions, which will expect to
101 : * access the input tuples as varno OUTER.
102 : */
103 183338 : econtext->ecxt_outertuple = outerTupleSlot;
104 :
105 : /* Evaluate the expressions */
106 183338 : resultSlot = ExecProjectSRF(node, false);
107 :
108 : /*
109 : * Return the tuple unless the projection produced no rows (due to an
110 : * empty set), in which case we must loop back to see if there are
111 : * more outerPlan tuples.
112 : */
113 181828 : if (resultSlot)
114 96262 : return resultSlot;
115 :
116 : /*
117 : * When we do loop back, we'd better reset the econtext again, just in
118 : * case the SRF leaked some memory there.
119 : */
120 85566 : ResetExprContext(econtext);
121 : }
122 :
123 : return NULL;
124 : }
125 :
126 : /* ----------------------------------------------------------------
127 : * ExecProjectSRF
128 : *
129 : * Project a targetlist containing one or more set-returning functions.
130 : *
131 : * 'continuing' indicates whether to continue projecting rows for the
132 : * same input tuple; or whether a new input tuple is being projected.
133 : *
134 : * Returns NULL if no output tuple has been produced.
135 : *
136 : * ----------------------------------------------------------------
137 : */
138 : static TupleTableSlot *
139 2878968 : ExecProjectSRF(ProjectSetState *node, bool continuing)
140 : {
141 2878968 : TupleTableSlot *resultSlot = node->ps.ps_ResultTupleSlot;
142 2878968 : ExprContext *econtext = node->ps.ps_ExprContext;
143 : MemoryContext oldcontext;
144 : bool hassrf PG_USED_FOR_ASSERTS_ONLY;
145 : bool hasresult;
146 : int argno;
147 :
148 2878968 : ExecClearTuple(resultSlot);
149 :
150 : /* Call SRFs, as well as plain expressions, in per-tuple context */
151 2878968 : oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
152 :
153 : /*
154 : * Assume no further tuples are produced unless an ExprMultipleResult is
155 : * encountered from a set returning function.
156 : */
157 2878968 : node->pending_srf_tuples = false;
158 :
159 2878968 : hassrf = hasresult = false;
160 8138116 : for (argno = 0; argno < node->nelems; argno++)
161 : {
162 5260658 : Node *elem = node->elems[argno];
163 5260658 : ExprDoneCond *isdone = &node->elemdone[argno];
164 5260658 : Datum *result = &resultSlot->tts_values[argno];
165 5260658 : bool *isnull = &resultSlot->tts_isnull[argno];
166 :
167 5260658 : if (continuing && *isdone == ExprEndResult)
168 : {
169 : /*
170 : * If we're continuing to project output rows from a source tuple,
171 : * return NULLs once the SRF has been exhausted.
172 : */
173 30020 : *result = (Datum) 0;
174 30020 : *isnull = true;
175 30020 : hassrf = true;
176 : }
177 5230638 : else if (IsA(elem, SetExprState))
178 : {
179 : /*
180 : * Evaluate SRF - possibly continuing previously started output.
181 : */
182 3050216 : *result = ExecMakeFunctionResultSet((SetExprState *) elem,
183 : econtext, node->argcontext,
184 : isnull, isdone);
185 :
186 3048706 : if (*isdone != ExprEndResult)
187 2861192 : hasresult = true;
188 3048706 : if (*isdone == ExprMultipleResult)
189 2861186 : node->pending_srf_tuples = true;
190 3048706 : hassrf = true;
191 : }
192 : else
193 : {
194 : /* Non-SRF tlist expression, just evaluate normally. */
195 2180422 : *result = ExecEvalExpr((ExprState *) elem, econtext, isnull);
196 2180422 : *isdone = ExprSingleResult;
197 : }
198 : }
199 :
200 2877458 : MemoryContextSwitchTo(oldcontext);
201 :
202 : /* ProjectSet should not be used if there's no SRFs */
203 : Assert(hassrf);
204 :
205 : /*
206 : * If all the SRFs returned ExprEndResult, we consider that as no row
207 : * being produced.
208 : */
209 2877458 : if (hasresult)
210 : {
211 2695738 : ExecStoreVirtualTuple(resultSlot);
212 2695738 : return resultSlot;
213 : }
214 :
215 181720 : return NULL;
216 : }
217 :
218 : /* ----------------------------------------------------------------
219 : * ExecInitProjectSet
220 : *
221 : * Creates the run-time state information for the ProjectSet node
222 : * produced by the planner and initializes outer relations
223 : * (child nodes).
224 : * ----------------------------------------------------------------
225 : */
226 : ProjectSetState *
227 14192 : ExecInitProjectSet(ProjectSet *node, EState *estate, int eflags)
228 : {
229 : ProjectSetState *state;
230 : ListCell *lc;
231 : int off;
232 :
233 : /* check for unsupported flags */
234 : Assert(!(eflags & (EXEC_FLAG_MARK | EXEC_FLAG_BACKWARD)));
235 :
236 : /*
237 : * create state structure
238 : */
239 14192 : state = makeNode(ProjectSetState);
240 14192 : state->ps.plan = (Plan *) node;
241 14192 : state->ps.state = estate;
242 14192 : state->ps.ExecProcNode = ExecProjectSet;
243 :
244 14192 : state->pending_srf_tuples = false;
245 :
246 : /*
247 : * Miscellaneous initialization
248 : *
249 : * create expression context for node
250 : */
251 14192 : ExecAssignExprContext(estate, &state->ps);
252 :
253 : /*
254 : * initialize child nodes
255 : */
256 14192 : outerPlanState(state) = ExecInitNode(outerPlan(node), estate, eflags);
257 :
258 : /*
259 : * we don't use inner plan
260 : */
261 : Assert(innerPlan(node) == NULL);
262 :
263 : /*
264 : * tuple table and result type initialization
265 : */
266 14192 : ExecInitResultTupleSlotTL(&state->ps, &TTSOpsVirtual);
267 :
268 : /* Create workspace for per-tlist-entry expr state & SRF-is-done state */
269 14192 : state->nelems = list_length(node->plan.targetlist);
270 14192 : state->elems = (Node **)
271 14192 : palloc(sizeof(Node *) * state->nelems);
272 14192 : state->elemdone = (ExprDoneCond *)
273 14192 : palloc(sizeof(ExprDoneCond) * state->nelems);
274 :
275 : /*
276 : * Build expressions to evaluate targetlist. We can't use
277 : * ExecBuildProjectionInfo here, since that doesn't deal with SRFs.
278 : * Instead compile each expression separately, using
279 : * ExecInitFunctionResultSet where applicable.
280 : */
281 14192 : off = 0;
282 30318 : foreach(lc, node->plan.targetlist)
283 : {
284 16128 : TargetEntry *te = (TargetEntry *) lfirst(lc);
285 16128 : Expr *expr = te->expr;
286 :
287 16128 : if ((IsA(expr, FuncExpr) && ((FuncExpr *) expr)->funcretset) ||
288 1770 : (IsA(expr, OpExpr) && ((OpExpr *) expr)->opretset))
289 : {
290 14362 : state->elems[off] = (Node *)
291 14364 : ExecInitFunctionResultSet(expr, state->ps.ps_ExprContext,
292 : &state->ps);
293 : }
294 : else
295 : {
296 : Assert(!expression_returns_set((Node *) expr));
297 1764 : state->elems[off] = (Node *) ExecInitExpr(expr, &state->ps);
298 : }
299 :
300 16126 : off++;
301 : }
302 :
303 : /* We don't support any qual on ProjectSet nodes */
304 : Assert(node->plan.qual == NIL);
305 :
306 : /*
307 : * Create a memory context that ExecMakeFunctionResultSet can use to
308 : * evaluate function arguments in. We can't use the per-tuple context for
309 : * this because it gets reset too often; but we don't want to leak
310 : * evaluation results into the query-lifespan context either. We use one
311 : * context for the arguments of all tSRFs, as they have roughly equivalent
312 : * lifetimes.
313 : */
314 14190 : state->argcontext = AllocSetContextCreate(CurrentMemoryContext,
315 : "tSRF function arguments",
316 : ALLOCSET_DEFAULT_SIZES);
317 :
318 14190 : return state;
319 : }
320 :
321 : /* ----------------------------------------------------------------
322 : * ExecEndProjectSet
323 : *
324 : * frees up storage allocated through C routines
325 : * ----------------------------------------------------------------
326 : */
327 : void
328 12672 : ExecEndProjectSet(ProjectSetState *node)
329 : {
330 : /*
331 : * shut down subplans
332 : */
333 12672 : ExecEndNode(outerPlanState(node));
334 12672 : }
335 :
336 : void
337 29658 : ExecReScanProjectSet(ProjectSetState *node)
338 : {
339 29658 : PlanState *outerPlan = outerPlanState(node);
340 :
341 : /* Forget any incompletely-evaluated SRFs */
342 29658 : node->pending_srf_tuples = false;
343 :
344 : /*
345 : * If chgParam of subnode is not null then plan will be re-scanned by
346 : * first ExecProcNode.
347 : */
348 29658 : if (outerPlan->chgParam == NULL)
349 29658 : ExecReScan(outerPlan);
350 29658 : }
|
