Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * nodeSubplan.c
4 : * routines to support sub-selects appearing in expressions
5 : *
6 : * This module is concerned with executing SubPlan expression nodes, which
7 : * should not be confused with sub-SELECTs appearing in FROM. SubPlans are
8 : * divided into "initplans", which are those that need only one evaluation per
9 : * query (among other restrictions, this requires that they don't use any
10 : * direct correlation variables from the parent plan level), and "regular"
11 : * subplans, which are re-evaluated every time their result is required.
12 : *
13 : *
14 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
15 : * Portions Copyright (c) 1994, Regents of the University of California
16 : *
17 : * IDENTIFICATION
18 : * src/backend/executor/nodeSubplan.c
19 : *
20 : *-------------------------------------------------------------------------
21 : */
22 : /*
23 : * INTERFACE ROUTINES
24 : * ExecSubPlan - process a subselect
25 : * ExecInitSubPlan - initialize a subselect
26 : */
27 : #include "postgres.h"
28 :
29 : #include "access/htup_details.h"
30 : #include "executor/executor.h"
31 : #include "executor/nodeSubplan.h"
32 : #include "miscadmin.h"
33 : #include "nodes/makefuncs.h"
34 : #include "nodes/nodeFuncs.h"
35 : #include "utils/array.h"
36 : #include "utils/lsyscache.h"
37 : #include "utils/memutils.h"
38 :
39 : static Datum ExecHashSubPlan(SubPlanState *node,
40 : ExprContext *econtext,
41 : bool *isNull);
42 : static Datum ExecScanSubPlan(SubPlanState *node,
43 : ExprContext *econtext,
44 : bool *isNull);
45 : static void buildSubPlanHash(SubPlanState *node, ExprContext *econtext);
46 : static bool findPartialMatch(TupleHashTable hashtable, TupleTableSlot *slot,
47 : FmgrInfo *eqfunctions);
48 : static bool slotAllNulls(TupleTableSlot *slot);
49 : static bool slotNoNulls(TupleTableSlot *slot);
50 :
51 :
52 : /* ----------------------------------------------------------------
53 : * ExecSubPlan
54 : *
55 : * This is the main entry point for execution of a regular SubPlan.
56 : * ----------------------------------------------------------------
57 : */
58 : Datum
59 3630190 : ExecSubPlan(SubPlanState *node,
60 : ExprContext *econtext,
61 : bool *isNull)
62 : {
63 3630190 : SubPlan *subplan = node->subplan;
64 3630190 : EState *estate = node->planstate->state;
65 3630190 : ScanDirection dir = estate->es_direction;
66 : Datum retval;
67 :
68 3630190 : CHECK_FOR_INTERRUPTS();
69 :
70 : /* Set non-null as default */
71 3630190 : *isNull = false;
72 :
73 : /* Sanity checks */
74 3630190 : if (subplan->subLinkType == CTE_SUBLINK)
75 0 : elog(ERROR, "CTE subplans should not be executed via ExecSubPlan");
76 3630190 : if (subplan->setParam != NIL && subplan->subLinkType != MULTIEXPR_SUBLINK)
77 0 : elog(ERROR, "cannot set parent params from subquery");
78 :
79 : /* Force forward-scan mode for evaluation */
80 3630190 : estate->es_direction = ForwardScanDirection;
81 :
82 : /* Select appropriate evaluation strategy */
83 3630190 : if (subplan->useHashTable)
84 1916546 : retval = ExecHashSubPlan(node, econtext, isNull);
85 : else
86 1713644 : retval = ExecScanSubPlan(node, econtext, isNull);
87 :
88 : /* restore scan direction */
89 3630184 : estate->es_direction = dir;
90 :
91 3630184 : return retval;
92 : }
93 :
94 : /*
95 : * ExecHashSubPlan: store subselect result in an in-memory hash table
96 : */
97 : static Datum
98 1916546 : ExecHashSubPlan(SubPlanState *node,
99 : ExprContext *econtext,
100 : bool *isNull)
101 : {
102 1916546 : bool result = false;
103 1916546 : SubPlan *subplan = node->subplan;
104 1916546 : PlanState *planstate = node->planstate;
105 : TupleTableSlot *slot;
106 :
107 : /* Shouldn't have any direct correlation Vars */
108 1916546 : if (subplan->parParam != NIL || subplan->args != NIL)
109 0 : elog(ERROR, "hashed subplan with direct correlation not supported");
110 :
111 : /*
112 : * If first time through or we need to rescan the subplan, build the hash
113 : * table.
114 : */
115 1916546 : if (node->hashtable == NULL || planstate->chgParam != NULL)
116 1556 : buildSubPlanHash(node, econtext);
117 :
118 : /*
119 : * The result for an empty subplan is always FALSE; no need to evaluate
120 : * lefthand side.
121 : */
122 1916540 : *isNull = false;
123 1916540 : if (!node->havehashrows && !node->havenullrows)
124 885270 : return BoolGetDatum(false);
125 :
126 : /*
127 : * Evaluate lefthand expressions and form a projection tuple. First we
128 : * have to set the econtext to use (hack alert!).
129 : */
130 1031270 : node->projLeft->pi_exprContext = econtext;
131 1031270 : slot = ExecProject(node->projLeft);
132 :
133 : /*
134 : * If the LHS is all non-null, probe for an exact match in the main hash
135 : * table. If we find one, the result is TRUE. Otherwise, scan the
136 : * partly-null table to see if there are any rows that aren't provably
137 : * unequal to the LHS; if so, the result is UNKNOWN. (We skip that part
138 : * if we don't care about UNKNOWN.) Otherwise, the result is FALSE.
139 : *
140 : * Note: the reason we can avoid a full scan of the main hash table is
141 : * that the combining operators are assumed never to yield NULL when both
142 : * inputs are non-null. If they were to do so, we might need to produce
143 : * UNKNOWN instead of FALSE because of an UNKNOWN result in comparing the
144 : * LHS to some main-table entry --- which is a comparison we will not even
145 : * make, unless there's a chance match of hash keys.
146 : */
147 1031270 : if (slotNoNulls(slot))
148 : {
149 2062444 : if (node->havehashrows &&
150 1031210 : FindTupleHashEntry(node->hashtable,
151 : slot,
152 : node->cur_eq_comp,
153 : node->lhs_hash_expr) != NULL)
154 63292 : result = true;
155 967978 : else if (node->havenullrows &&
156 36 : findPartialMatch(node->hashnulls, slot, node->cur_eq_funcs))
157 18 : *isNull = true;
158 : }
159 :
160 : /*
161 : * When the LHS is partly or wholly NULL, we can never return TRUE. If we
162 : * don't care about UNKNOWN, just return FALSE. Otherwise, if the LHS is
163 : * wholly NULL, immediately return UNKNOWN. (Since the combining
164 : * operators are strict, the result could only be FALSE if the sub-select
165 : * were empty, but we already handled that case.) Otherwise, we must scan
166 : * both the main and partly-null tables to see if there are any rows that
167 : * aren't provably unequal to the LHS; if so, the result is UNKNOWN.
168 : * Otherwise, the result is FALSE.
169 : */
170 36 : else if (node->hashnulls == NULL)
171 : /* just return FALSE */ ;
172 36 : else if (slotAllNulls(slot))
173 0 : *isNull = true;
174 : /* Scan partly-null table first, since more likely to get a match */
175 72 : else if (node->havenullrows &&
176 36 : findPartialMatch(node->hashnulls, slot, node->cur_eq_funcs))
177 18 : *isNull = true;
178 24 : else if (node->havehashrows &&
179 6 : findPartialMatch(node->hashtable, slot, node->cur_eq_funcs))
180 0 : *isNull = true;
181 :
182 : /*
183 : * Note: because we are typically called in a per-tuple context, we have
184 : * to explicitly clear the projected tuple before returning. Otherwise,
185 : * we'll have a double-free situation: the per-tuple context will probably
186 : * be reset before we're called again, and then the tuple slot will think
187 : * it still needs to free the tuple.
188 : */
189 1031270 : ExecClearTuple(slot);
190 :
191 : /* Also must reset the innerecontext after each hashtable lookup. */
192 1031270 : ResetExprContext(node->innerecontext);
193 :
194 1031270 : return BoolGetDatum(result);
195 : }
196 :
197 : /*
198 : * ExecScanSubPlan: default case where we have to rescan subplan each time
199 : */
200 : static Datum
201 1713644 : ExecScanSubPlan(SubPlanState *node,
202 : ExprContext *econtext,
203 : bool *isNull)
204 : {
205 1713644 : SubPlan *subplan = node->subplan;
206 1713644 : PlanState *planstate = node->planstate;
207 1713644 : SubLinkType subLinkType = subplan->subLinkType;
208 : MemoryContext oldcontext;
209 : TupleTableSlot *slot;
210 : Datum result;
211 1713644 : bool found = false; /* true if got at least one subplan tuple */
212 : ListCell *l;
213 1713644 : ArrayBuildStateAny *astate = NULL;
214 :
215 : /* Initialize ArrayBuildStateAny in caller's context, if needed */
216 1713644 : if (subLinkType == ARRAY_SUBLINK)
217 55416 : astate = initArrayResultAny(subplan->firstColType,
218 : CurrentMemoryContext, true);
219 :
220 : /*
221 : * We are probably in a short-lived expression-evaluation context. Switch
222 : * to the per-query context for manipulating the child plan's chgParam,
223 : * calling ExecProcNode on it, etc.
224 : */
225 1713644 : oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
226 :
227 : /*
228 : * We rely on the caller to evaluate plan correlation values, if
229 : * necessary. However we still need to record the fact that the values
230 : * (might have) changed, otherwise the ExecReScan() below won't know that
231 : * nodes need to be rescanned.
232 : */
233 3457942 : foreach(l, subplan->parParam)
234 : {
235 1744298 : int paramid = lfirst_int(l);
236 :
237 1744298 : planstate->chgParam = bms_add_member(planstate->chgParam, paramid);
238 : }
239 :
240 : /* with that done, we can reset the subplan */
241 1713644 : ExecReScan(planstate);
242 :
243 : /*
244 : * For all sublink types except EXPR_SUBLINK and ARRAY_SUBLINK, the result
245 : * is boolean as are the results of the combining operators. We combine
246 : * results across tuples (if the subplan produces more than one) using OR
247 : * semantics for ANY_SUBLINK or AND semantics for ALL_SUBLINK.
248 : * (ROWCOMPARE_SUBLINK doesn't allow multiple tuples from the subplan.)
249 : * NULL results from the combining operators are handled according to the
250 : * usual SQL semantics for OR and AND. The result for no input tuples is
251 : * FALSE for ANY_SUBLINK, TRUE for ALL_SUBLINK, NULL for
252 : * ROWCOMPARE_SUBLINK.
253 : *
254 : * For EXPR_SUBLINK we require the subplan to produce no more than one
255 : * tuple, else an error is raised. If zero tuples are produced, we return
256 : * NULL. Assuming we get a tuple, we just use its first column (there can
257 : * be only one non-junk column in this case).
258 : *
259 : * For MULTIEXPR_SUBLINK, we push the per-column subplan outputs out to
260 : * the setParams and then return a dummy false value. There must not be
261 : * multiple tuples returned from the subplan; if zero tuples are produced,
262 : * set the setParams to NULL.
263 : *
264 : * For ARRAY_SUBLINK we allow the subplan to produce any number of tuples,
265 : * and form an array of the first column's values. Note in particular
266 : * that we produce a zero-element array if no tuples are produced (this is
267 : * a change from pre-8.3 behavior of returning NULL).
268 : */
269 1713644 : result = BoolGetDatum(subLinkType == ALL_SUBLINK);
270 1713644 : *isNull = false;
271 :
272 1713644 : for (slot = ExecProcNode(planstate);
273 2077748 : !TupIsNull(slot);
274 364104 : slot = ExecProcNode(planstate))
275 : {
276 364962 : TupleDesc tdesc = slot->tts_tupleDescriptor;
277 : Datum rowresult;
278 : bool rownull;
279 : int col;
280 : ListCell *plst;
281 :
282 364962 : if (subLinkType == EXISTS_SUBLINK)
283 : {
284 710 : found = true;
285 710 : result = BoolGetDatum(true);
286 858 : break;
287 : }
288 :
289 364252 : if (subLinkType == EXPR_SUBLINK)
290 : {
291 : /* cannot allow multiple input tuples for EXPR sublink */
292 348118 : if (found)
293 0 : ereport(ERROR,
294 : (errcode(ERRCODE_CARDINALITY_VIOLATION),
295 : errmsg("more than one row returned by a subquery used as an expression")));
296 348118 : found = true;
297 :
298 : /*
299 : * We need to copy the subplan's tuple in case the result is of
300 : * pass-by-ref type --- our return value will point into this
301 : * copied tuple! Can't use the subplan's instance of the tuple
302 : * since it won't still be valid after next ExecProcNode() call.
303 : * node->curTuple keeps track of the copied tuple for eventual
304 : * freeing.
305 : */
306 348118 : if (node->curTuple)
307 341942 : heap_freetuple(node->curTuple);
308 348118 : node->curTuple = ExecCopySlotHeapTuple(slot);
309 :
310 348118 : result = heap_getattr(node->curTuple, 1, tdesc, isNull);
311 : /* keep scanning subplan to make sure there's only one tuple */
312 353148 : continue;
313 : }
314 :
315 16134 : if (subLinkType == MULTIEXPR_SUBLINK)
316 : {
317 : /* cannot allow multiple input tuples for MULTIEXPR sublink */
318 240 : if (found)
319 0 : ereport(ERROR,
320 : (errcode(ERRCODE_CARDINALITY_VIOLATION),
321 : errmsg("more than one row returned by a subquery used as an expression")));
322 240 : found = true;
323 :
324 : /*
325 : * We need to copy the subplan's tuple in case any result is of
326 : * pass-by-ref type --- our output values will point into this
327 : * copied tuple! Can't use the subplan's instance of the tuple
328 : * since it won't still be valid after next ExecProcNode() call.
329 : * node->curTuple keeps track of the copied tuple for eventual
330 : * freeing.
331 : */
332 240 : if (node->curTuple)
333 152 : heap_freetuple(node->curTuple);
334 240 : node->curTuple = ExecCopySlotHeapTuple(slot);
335 :
336 : /*
337 : * Now set all the setParam params from the columns of the tuple
338 : */
339 240 : col = 1;
340 714 : foreach(plst, subplan->setParam)
341 : {
342 474 : int paramid = lfirst_int(plst);
343 : ParamExecData *prmdata;
344 :
345 474 : prmdata = &(econtext->ecxt_param_exec_vals[paramid]);
346 : Assert(prmdata->execPlan == NULL);
347 474 : prmdata->value = heap_getattr(node->curTuple, col, tdesc,
348 : &(prmdata->isnull));
349 474 : col++;
350 : }
351 :
352 : /* keep scanning subplan to make sure there's only one tuple */
353 240 : continue;
354 : }
355 :
356 15894 : if (subLinkType == ARRAY_SUBLINK)
357 4790 : {
358 : Datum dvalue;
359 : bool disnull;
360 :
361 4790 : found = true;
362 : /* stash away current value */
363 : Assert(subplan->firstColType == TupleDescAttr(tdesc, 0)->atttypid);
364 4790 : dvalue = slot_getattr(slot, 1, &disnull);
365 4790 : astate = accumArrayResultAny(astate, dvalue, disnull,
366 : subplan->firstColType, oldcontext);
367 : /* keep scanning subplan to collect all values */
368 4790 : continue;
369 : }
370 :
371 : /* cannot allow multiple input tuples for ROWCOMPARE sublink either */
372 11104 : if (subLinkType == ROWCOMPARE_SUBLINK && found)
373 0 : ereport(ERROR,
374 : (errcode(ERRCODE_CARDINALITY_VIOLATION),
375 : errmsg("more than one row returned by a subquery used as an expression")));
376 :
377 11104 : found = true;
378 :
379 : /*
380 : * For ALL, ANY, and ROWCOMPARE sublinks, load up the Params
381 : * representing the columns of the sub-select, and then evaluate the
382 : * combining expression.
383 : */
384 11104 : col = 1;
385 32966 : foreach(plst, subplan->paramIds)
386 : {
387 21862 : int paramid = lfirst_int(plst);
388 : ParamExecData *prmdata;
389 :
390 21862 : prmdata = &(econtext->ecxt_param_exec_vals[paramid]);
391 : Assert(prmdata->execPlan == NULL);
392 21862 : prmdata->value = slot_getattr(slot, col, &(prmdata->isnull));
393 21862 : col++;
394 : }
395 :
396 11104 : rowresult = ExecEvalExprSwitchContext(node->testexpr, econtext,
397 : &rownull);
398 :
399 11104 : if (subLinkType == ANY_SUBLINK)
400 : {
401 : /* combine across rows per OR semantics */
402 10966 : if (rownull)
403 0 : *isNull = true;
404 10966 : else if (DatumGetBool(rowresult))
405 : {
406 124 : result = BoolGetDatum(true);
407 124 : *isNull = false;
408 124 : break; /* needn't look at any more rows */
409 : }
410 : }
411 138 : else if (subLinkType == ALL_SUBLINK)
412 : {
413 : /* combine across rows per AND semantics */
414 90 : if (rownull)
415 0 : *isNull = true;
416 90 : else if (!DatumGetBool(rowresult))
417 : {
418 24 : result = BoolGetDatum(false);
419 24 : *isNull = false;
420 24 : break; /* needn't look at any more rows */
421 : }
422 : }
423 : else
424 : {
425 : /* must be ROWCOMPARE_SUBLINK */
426 48 : result = rowresult;
427 48 : *isNull = rownull;
428 : }
429 : }
430 :
431 1713644 : MemoryContextSwitchTo(oldcontext);
432 :
433 1713644 : if (subLinkType == ARRAY_SUBLINK)
434 : {
435 : /* We return the result in the caller's context */
436 55416 : result = makeArrayResultAny(astate, oldcontext, true);
437 : }
438 1658228 : else if (!found)
439 : {
440 : /*
441 : * deal with empty subplan result. result/isNull were previously
442 : * initialized correctly for all sublink types except EXPR and
443 : * ROWCOMPARE; for those, return NULL.
444 : */
445 1303538 : if (subLinkType == EXPR_SUBLINK ||
446 : subLinkType == ROWCOMPARE_SUBLINK)
447 : {
448 76688 : result = (Datum) 0;
449 76688 : *isNull = true;
450 : }
451 1226850 : else if (subLinkType == MULTIEXPR_SUBLINK)
452 : {
453 : /* We don't care about function result, but set the setParams */
454 18 : foreach(l, subplan->setParam)
455 : {
456 12 : int paramid = lfirst_int(l);
457 : ParamExecData *prmdata;
458 :
459 12 : prmdata = &(econtext->ecxt_param_exec_vals[paramid]);
460 : Assert(prmdata->execPlan == NULL);
461 12 : prmdata->value = (Datum) 0;
462 12 : prmdata->isnull = true;
463 : }
464 : }
465 : }
466 :
467 1713644 : return result;
468 : }
469 :
470 : /*
471 : * buildSubPlanHash: load hash table by scanning subplan output.
472 : */
473 : static void
474 1556 : buildSubPlanHash(SubPlanState *node, ExprContext *econtext)
475 : {
476 1556 : SubPlan *subplan = node->subplan;
477 1556 : PlanState *planstate = node->planstate;
478 1556 : int ncols = node->numCols;
479 1556 : ExprContext *innerecontext = node->innerecontext;
480 : MemoryContext oldcontext;
481 : double nentries;
482 : TupleTableSlot *slot;
483 :
484 : Assert(subplan->subLinkType == ANY_SUBLINK);
485 :
486 : /*
487 : * If we already had any hash tables, reset 'em; otherwise create empty
488 : * hash table(s).
489 : *
490 : * If we need to distinguish accurately between FALSE and UNKNOWN (i.e.,
491 : * NULL) results of the IN operation, then we have to store subplan output
492 : * rows that are partly or wholly NULL. We store such rows in a separate
493 : * hash table that we expect will be much smaller than the main table. (We
494 : * can use hashing to eliminate partly-null rows that are not distinct. We
495 : * keep them separate to minimize the cost of the inevitable full-table
496 : * searches; see findPartialMatch.)
497 : *
498 : * If it's not necessary to distinguish FALSE and UNKNOWN, then we don't
499 : * need to store subplan output rows that contain NULL.
500 : *
501 : * Because the input slot for each hash table is always the slot resulting
502 : * from an ExecProject(), we can use TTSOpsVirtual for the input ops. This
503 : * saves a needless fetch inner op step for the hashing ExprState created
504 : * in BuildTupleHashTable().
505 : */
506 1556 : node->havehashrows = false;
507 1556 : node->havenullrows = false;
508 :
509 1556 : nentries = planstate->plan->plan_rows;
510 :
511 1556 : if (node->hashtable)
512 594 : ResetTupleHashTable(node->hashtable);
513 : else
514 962 : node->hashtable = BuildTupleHashTable(node->parent,
515 : node->descRight,
516 : &TTSOpsVirtual,
517 : ncols,
518 : node->keyColIdx,
519 962 : node->tab_eq_funcoids,
520 : node->tab_hash_funcs,
521 : node->tab_collations,
522 : nentries,
523 : 0, /* no additional data */
524 962 : node->planstate->state->es_query_cxt,
525 : node->tuplesContext,
526 : innerecontext->ecxt_per_tuple_memory,
527 : false);
528 :
529 1556 : if (!subplan->unknownEqFalse)
530 : {
531 772 : if (ncols == 1)
532 722 : nentries = 1; /* there can only be one entry */
533 : else
534 : {
535 50 : nentries /= 16;
536 50 : if (nentries < 1)
537 0 : nentries = 1;
538 : }
539 :
540 772 : if (node->hashnulls)
541 594 : ResetTupleHashTable(node->hashnulls);
542 : else
543 178 : node->hashnulls = BuildTupleHashTable(node->parent,
544 : node->descRight,
545 : &TTSOpsVirtual,
546 : ncols,
547 : node->keyColIdx,
548 178 : node->tab_eq_funcoids,
549 : node->tab_hash_funcs,
550 : node->tab_collations,
551 : nentries,
552 : 0, /* no additional data */
553 178 : node->planstate->state->es_query_cxt,
554 : node->tuplesContext,
555 : innerecontext->ecxt_per_tuple_memory,
556 : false);
557 : }
558 : else
559 784 : node->hashnulls = NULL;
560 :
561 : /*
562 : * We are probably in a short-lived expression-evaluation context. Switch
563 : * to the per-query context for manipulating the child plan.
564 : */
565 1556 : oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
566 :
567 : /*
568 : * Reset subplan to start.
569 : */
570 1556 : ExecReScan(planstate);
571 :
572 : /*
573 : * Scan the subplan and load the hash table(s). Note that when there are
574 : * duplicate rows coming out of the sub-select, only one copy is stored.
575 : */
576 1556 : for (slot = ExecProcNode(planstate);
577 202908 : !TupIsNull(slot);
578 201352 : slot = ExecProcNode(planstate))
579 : {
580 201358 : int col = 1;
581 : ListCell *plst;
582 : bool isnew;
583 :
584 : /*
585 : * Load up the Params representing the raw sub-select outputs, then
586 : * form the projection tuple to store in the hashtable.
587 : */
588 474732 : foreach(plst, subplan->paramIds)
589 : {
590 273374 : int paramid = lfirst_int(plst);
591 : ParamExecData *prmdata;
592 :
593 273374 : prmdata = &(innerecontext->ecxt_param_exec_vals[paramid]);
594 : Assert(prmdata->execPlan == NULL);
595 273374 : prmdata->value = slot_getattr(slot, col,
596 : &(prmdata->isnull));
597 273374 : col++;
598 : }
599 201358 : slot = ExecProject(node->projRight);
600 :
601 : /*
602 : * If result contains any nulls, store separately or not at all.
603 : */
604 201358 : if (slotNoNulls(slot))
605 : {
606 201334 : (void) LookupTupleHashEntry(node->hashtable, slot, &isnew, NULL);
607 201328 : node->havehashrows = true;
608 : }
609 24 : else if (node->hashnulls)
610 : {
611 24 : (void) LookupTupleHashEntry(node->hashnulls, slot, &isnew, NULL);
612 24 : node->havenullrows = true;
613 : }
614 :
615 : /*
616 : * Reset innerecontext after each inner tuple to free any memory used
617 : * during ExecProject and hashtable lookup.
618 : */
619 201352 : ResetExprContext(innerecontext);
620 : }
621 :
622 : /*
623 : * Since the projected tuples are in the sub-query's context and not the
624 : * main context, we'd better clear the tuple slot before there's any
625 : * chance of a reset of the sub-query's context. Else we will have the
626 : * potential for a double free attempt. (XXX possibly no longer needed,
627 : * but can't hurt.)
628 : */
629 1550 : ExecClearTuple(node->projRight->pi_state.resultslot);
630 :
631 1550 : MemoryContextSwitchTo(oldcontext);
632 1550 : }
633 :
634 : /* Planner support routine to estimate space needed for hash table(s) */
635 : Size
636 3868 : EstimateSubplanHashTableSpace(double nentries,
637 : Size tupleWidth,
638 : bool unknownEqFalse)
639 : {
640 : Size tab1space,
641 : tab2space;
642 :
643 : /* Estimate size of main hashtable */
644 3868 : tab1space = EstimateTupleHashTableSpace(nentries,
645 : tupleWidth,
646 : 0 /* no additional data */ );
647 :
648 : /* Give up if that's already too big */
649 3868 : if (tab1space >= SIZE_MAX)
650 6 : return tab1space;
651 :
652 : /* Done if we don't need a hashnulls table */
653 3862 : if (unknownEqFalse)
654 3528 : return tab1space;
655 :
656 : /*
657 : * Adjust the rowcount estimate in the same way that buildSubPlanHash
658 : * will, except that we don't bother with the special case for a single
659 : * hash column. (We skip that detail because it'd be notationally painful
660 : * for our caller to provide the column count, and this table has
661 : * relatively little impact on the total estimate anyway.)
662 : */
663 334 : nentries /= 16;
664 334 : if (nentries < 1)
665 116 : nentries = 1;
666 :
667 : /*
668 : * It might be sane to also reduce the tupleWidth, but on the other hand
669 : * we are not accounting for the space taken by the tuples' null bitmaps.
670 : * Leave it alone for now.
671 : */
672 334 : tab2space = EstimateTupleHashTableSpace(nentries,
673 : tupleWidth,
674 : 0 /* no additional data */ );
675 :
676 : /* Guard against overflow */
677 334 : if (tab2space >= SIZE_MAX - tab1space)
678 0 : return SIZE_MAX;
679 :
680 334 : return tab1space + tab2space;
681 : }
682 :
683 : /*
684 : * execTuplesUnequal
685 : * Return true if two tuples are definitely unequal in the indicated
686 : * fields.
687 : *
688 : * Nulls are neither equal nor unequal to anything else. A true result
689 : * is obtained only if there are non-null fields that compare not-equal.
690 : *
691 : * slot1, slot2: the tuples to compare (must have same columns!)
692 : * numCols: the number of attributes to be examined
693 : * matchColIdx: array of attribute column numbers
694 : * eqFunctions: array of fmgr lookup info for the equality functions to use
695 : * evalContext: short-term memory context for executing the functions
696 : */
697 : static bool
698 78 : execTuplesUnequal(TupleTableSlot *slot1,
699 : TupleTableSlot *slot2,
700 : int numCols,
701 : AttrNumber *matchColIdx,
702 : FmgrInfo *eqfunctions,
703 : const Oid *collations,
704 : MemoryContext evalContext)
705 : {
706 : MemoryContext oldContext;
707 : bool result;
708 : int i;
709 :
710 : /* Reset and switch into the temp context. */
711 78 : MemoryContextReset(evalContext);
712 78 : oldContext = MemoryContextSwitchTo(evalContext);
713 :
714 : /*
715 : * We cannot report a match without checking all the fields, but we can
716 : * report a non-match as soon as we find unequal fields. So, start
717 : * comparing at the last field (least significant sort key). That's the
718 : * most likely to be different if we are dealing with sorted input.
719 : */
720 78 : result = false;
721 :
722 192 : for (i = numCols; --i >= 0;)
723 : {
724 156 : AttrNumber att = matchColIdx[i];
725 : Datum attr1,
726 : attr2;
727 : bool isNull1,
728 : isNull2;
729 :
730 156 : attr1 = slot_getattr(slot1, att, &isNull1);
731 :
732 156 : if (isNull1)
733 78 : continue; /* can't prove anything here */
734 :
735 114 : attr2 = slot_getattr(slot2, att, &isNull2);
736 :
737 114 : if (isNull2)
738 36 : continue; /* can't prove anything here */
739 :
740 : /* Apply the type-specific equality function */
741 78 : if (!DatumGetBool(FunctionCall2Coll(&eqfunctions[i],
742 78 : collations[i],
743 : attr1, attr2)))
744 : {
745 42 : result = true; /* they are unequal */
746 42 : break;
747 : }
748 : }
749 :
750 78 : MemoryContextSwitchTo(oldContext);
751 :
752 78 : return result;
753 : }
754 :
755 : /*
756 : * findPartialMatch: does the hashtable contain an entry that is not
757 : * provably distinct from the tuple?
758 : *
759 : * We have to scan the whole hashtable; we can't usefully use hashkeys
760 : * to guide probing, since we might get partial matches on tuples with
761 : * hashkeys quite unrelated to what we'd get from the given tuple.
762 : *
763 : * Caller must provide the equality functions to use, since in cross-type
764 : * cases these are different from the hashtable's internal functions.
765 : */
766 : static bool
767 78 : findPartialMatch(TupleHashTable hashtable, TupleTableSlot *slot,
768 : FmgrInfo *eqfunctions)
769 : {
770 78 : int numCols = hashtable->numCols;
771 78 : AttrNumber *keyColIdx = hashtable->keyColIdx;
772 : TupleHashIterator hashiter;
773 : TupleHashEntry entry;
774 :
775 78 : InitTupleHashIterator(hashtable, &hashiter);
776 120 : while ((entry = ScanTupleHashTable(hashtable, &hashiter)) != NULL)
777 : {
778 78 : CHECK_FOR_INTERRUPTS();
779 :
780 78 : ExecStoreMinimalTuple(TupleHashEntryGetTuple(entry), hashtable->tableslot, false);
781 78 : if (!execTuplesUnequal(slot, hashtable->tableslot,
782 : numCols, keyColIdx,
783 : eqfunctions,
784 78 : hashtable->tab_collations,
785 : hashtable->tempcxt))
786 : {
787 : TermTupleHashIterator(&hashiter);
788 36 : return true;
789 : }
790 : }
791 : /* No TermTupleHashIterator call needed here */
792 42 : return false;
793 : }
794 :
795 : /*
796 : * slotAllNulls: is the slot completely NULL?
797 : *
798 : * This does not test for dropped columns, which is OK because we only
799 : * use it on projected tuples.
800 : */
801 : static bool
802 36 : slotAllNulls(TupleTableSlot *slot)
803 : {
804 36 : int ncols = slot->tts_tupleDescriptor->natts;
805 : int i;
806 :
807 36 : for (i = 1; i <= ncols; i++)
808 : {
809 36 : if (!slot_attisnull(slot, i))
810 36 : return false;
811 : }
812 0 : return true;
813 : }
814 :
815 : /*
816 : * slotNoNulls: is the slot entirely not NULL?
817 : *
818 : * This does not test for dropped columns, which is OK because we only
819 : * use it on projected tuples.
820 : */
821 : static bool
822 1232628 : slotNoNulls(TupleTableSlot *slot)
823 : {
824 1232628 : int ncols = slot->tts_tupleDescriptor->natts;
825 : int i;
826 :
827 2597398 : for (i = 1; i <= ncols; i++)
828 : {
829 1364830 : if (slot_attisnull(slot, i))
830 60 : return false;
831 : }
832 1232568 : return true;
833 : }
834 :
835 : /* ----------------------------------------------------------------
836 : * ExecInitSubPlan
837 : *
838 : * Create a SubPlanState for a SubPlan; this is the SubPlan-specific part
839 : * of ExecInitExpr(). We split it out so that it can be used for InitPlans
840 : * as well as regular SubPlans. Note that we don't link the SubPlan into
841 : * the parent's subPlan list, because that shouldn't happen for InitPlans.
842 : * Instead, ExecInitExpr() does that one part.
843 : *
844 : * We also rely on ExecInitExpr(), more precisely ExecInitSubPlanExpr(), to
845 : * evaluate input parameters, as that allows them to be evaluated as part of
846 : * the expression referencing the SubPlan.
847 : * ----------------------------------------------------------------
848 : */
849 : SubPlanState *
850 44370 : ExecInitSubPlan(SubPlan *subplan, PlanState *parent)
851 : {
852 44370 : SubPlanState *sstate = makeNode(SubPlanState);
853 44370 : EState *estate = parent->state;
854 :
855 44370 : sstate->subplan = subplan;
856 :
857 : /* Link the SubPlanState to already-initialized subplan */
858 88740 : sstate->planstate = (PlanState *) list_nth(estate->es_subplanstates,
859 44370 : subplan->plan_id - 1);
860 :
861 : /*
862 : * This check can fail if the planner mistakenly puts a parallel-unsafe
863 : * subplan into a parallelized subquery; see ExecSerializePlan.
864 : */
865 44370 : if (sstate->planstate == NULL)
866 0 : elog(ERROR, "subplan \"%s\" was not initialized",
867 : subplan->plan_name);
868 :
869 : /* Link to parent's state, too */
870 44370 : sstate->parent = parent;
871 :
872 : /* Initialize subexpressions */
873 44370 : sstate->testexpr = ExecInitExpr((Expr *) subplan->testexpr, parent);
874 :
875 : /*
876 : * initialize my state
877 : */
878 44370 : sstate->curTuple = NULL;
879 44370 : sstate->curArray = PointerGetDatum(NULL);
880 44370 : sstate->projLeft = NULL;
881 44370 : sstate->projRight = NULL;
882 44370 : sstate->hashtable = NULL;
883 44370 : sstate->hashnulls = NULL;
884 44370 : sstate->tuplesContext = NULL;
885 44370 : sstate->innerecontext = NULL;
886 44370 : sstate->keyColIdx = NULL;
887 44370 : sstate->tab_eq_funcoids = NULL;
888 44370 : sstate->tab_hash_funcs = NULL;
889 44370 : sstate->tab_collations = NULL;
890 44370 : sstate->cur_eq_funcs = NULL;
891 :
892 : /*
893 : * If this is an initplan, it has output parameters that the parent plan
894 : * will use, so mark those parameters as needing evaluation. We don't
895 : * actually run the subplan until we first need one of its outputs.
896 : *
897 : * A CTE subplan's output parameter is never to be evaluated in the normal
898 : * way, so skip this in that case.
899 : *
900 : * Note that we don't set parent->chgParam here: the parent plan hasn't
901 : * been run yet, so no need to force it to re-run.
902 : */
903 44370 : if (subplan->setParam != NIL && subplan->parParam == NIL &&
904 14708 : subplan->subLinkType != CTE_SUBLINK)
905 : {
906 : ListCell *lst;
907 :
908 24144 : foreach(lst, subplan->setParam)
909 : {
910 12096 : int paramid = lfirst_int(lst);
911 12096 : ParamExecData *prm = &(estate->es_param_exec_vals[paramid]);
912 :
913 12096 : prm->execPlan = sstate;
914 : }
915 : }
916 :
917 : /*
918 : * If we are going to hash the subquery output, initialize relevant stuff.
919 : * (We don't create the hashtable until needed, though.)
920 : */
921 44370 : if (subplan->useHashTable)
922 : {
923 : int ncols,
924 : i;
925 : TupleDesc tupDescLeft;
926 : TupleDesc tupDescRight;
927 : Oid *cross_eq_funcoids;
928 : TupleTableSlot *slot;
929 : FmgrInfo *lhs_hash_funcs;
930 : List *oplist,
931 : *lefttlist,
932 : *righttlist;
933 : ListCell *l;
934 :
935 : /* We need a memory context to hold the hash table(s)' tuples */
936 1156 : sstate->tuplesContext =
937 1156 : BumpContextCreate(CurrentMemoryContext,
938 : "SubPlan hashed tuples",
939 : ALLOCSET_DEFAULT_SIZES);
940 : /* and a short-lived exprcontext for function evaluation */
941 1156 : sstate->innerecontext = CreateExprContext(estate);
942 :
943 : /*
944 : * We use ExecProject to evaluate the lefthand and righthand
945 : * expression lists and form tuples. (You might think that we could
946 : * use the sub-select's output tuples directly, but that is not the
947 : * case if we had to insert any run-time coercions of the sub-select's
948 : * output datatypes; anyway this avoids storing any resjunk columns
949 : * that might be in the sub-select's output.) Run through the
950 : * combining expressions to build tlists for the lefthand and
951 : * righthand sides.
952 : *
953 : * We also extract the combining operators themselves to initialize
954 : * the equality and hashing functions for the hash tables.
955 : */
956 1156 : if (IsA(subplan->testexpr, OpExpr))
957 : {
958 : /* single combining operator */
959 1058 : oplist = list_make1(subplan->testexpr);
960 : }
961 98 : else if (is_andclause(subplan->testexpr))
962 : {
963 : /* multiple combining operators */
964 98 : oplist = castNode(BoolExpr, subplan->testexpr)->args;
965 : }
966 : else
967 : {
968 : /* shouldn't see anything else in a hashable subplan */
969 0 : elog(ERROR, "unrecognized testexpr type: %d",
970 : (int) nodeTag(subplan->testexpr));
971 : oplist = NIL; /* keep compiler quiet */
972 : }
973 1156 : ncols = list_length(oplist);
974 :
975 1156 : lefttlist = righttlist = NIL;
976 1156 : sstate->numCols = ncols;
977 1156 : sstate->keyColIdx = (AttrNumber *) palloc(ncols * sizeof(AttrNumber));
978 1156 : sstate->tab_eq_funcoids = (Oid *) palloc(ncols * sizeof(Oid));
979 1156 : sstate->tab_collations = (Oid *) palloc(ncols * sizeof(Oid));
980 1156 : sstate->tab_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
981 1156 : lhs_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
982 1156 : sstate->cur_eq_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
983 : /* we'll need the cross-type equality fns below, but not in sstate */
984 1156 : cross_eq_funcoids = (Oid *) palloc(ncols * sizeof(Oid));
985 :
986 1156 : i = 1;
987 2410 : foreach(l, oplist)
988 : {
989 1254 : OpExpr *opexpr = lfirst_node(OpExpr, l);
990 : Expr *expr;
991 : TargetEntry *tle;
992 : Oid rhs_eq_oper;
993 : Oid left_hashfn;
994 : Oid right_hashfn;
995 :
996 : Assert(list_length(opexpr->args) == 2);
997 :
998 : /* Process lefthand argument */
999 1254 : expr = (Expr *) linitial(opexpr->args);
1000 1254 : tle = makeTargetEntry(expr,
1001 : i,
1002 : NULL,
1003 : false);
1004 1254 : lefttlist = lappend(lefttlist, tle);
1005 :
1006 : /* Process righthand argument */
1007 1254 : expr = (Expr *) lsecond(opexpr->args);
1008 1254 : tle = makeTargetEntry(expr,
1009 : i,
1010 : NULL,
1011 : false);
1012 1254 : righttlist = lappend(righttlist, tle);
1013 :
1014 : /* Lookup the equality function (potentially cross-type) */
1015 1254 : cross_eq_funcoids[i - 1] = opexpr->opfuncid;
1016 1254 : fmgr_info(opexpr->opfuncid, &sstate->cur_eq_funcs[i - 1]);
1017 1254 : fmgr_info_set_expr((Node *) opexpr, &sstate->cur_eq_funcs[i - 1]);
1018 :
1019 : /* Look up the equality function for the RHS type */
1020 1254 : if (!get_compatible_hash_operators(opexpr->opno,
1021 : NULL, &rhs_eq_oper))
1022 0 : elog(ERROR, "could not find compatible hash operator for operator %u",
1023 : opexpr->opno);
1024 1254 : sstate->tab_eq_funcoids[i - 1] = get_opcode(rhs_eq_oper);
1025 :
1026 : /* Lookup the associated hash functions */
1027 1254 : if (!get_op_hash_functions(opexpr->opno,
1028 : &left_hashfn, &right_hashfn))
1029 0 : elog(ERROR, "could not find hash function for hash operator %u",
1030 : opexpr->opno);
1031 1254 : fmgr_info(left_hashfn, &lhs_hash_funcs[i - 1]);
1032 1254 : fmgr_info(right_hashfn, &sstate->tab_hash_funcs[i - 1]);
1033 :
1034 : /* Set collation */
1035 1254 : sstate->tab_collations[i - 1] = opexpr->inputcollid;
1036 :
1037 : /* keyColIdx is just column numbers 1..n */
1038 1254 : sstate->keyColIdx[i - 1] = i;
1039 :
1040 1254 : i++;
1041 : }
1042 :
1043 : /*
1044 : * Construct tupdescs, slots and projection nodes for left and right
1045 : * sides. The lefthand expressions will be evaluated in the parent
1046 : * plan node's exprcontext, which we don't have access to here.
1047 : * Fortunately we can just pass NULL for now and fill it in later
1048 : * (hack alert!). The righthand expressions will be evaluated in our
1049 : * own innerecontext.
1050 : */
1051 1156 : tupDescLeft = ExecTypeFromTL(lefttlist);
1052 1156 : slot = ExecInitExtraTupleSlot(estate, tupDescLeft, &TTSOpsVirtual);
1053 1156 : sstate->projLeft = ExecBuildProjectionInfo(lefttlist,
1054 : NULL,
1055 : slot,
1056 : parent,
1057 : NULL);
1058 :
1059 1156 : sstate->descRight = tupDescRight = ExecTypeFromTL(righttlist);
1060 1156 : slot = ExecInitExtraTupleSlot(estate, tupDescRight, &TTSOpsVirtual);
1061 1156 : sstate->projRight = ExecBuildProjectionInfo(righttlist,
1062 : sstate->innerecontext,
1063 : slot,
1064 : sstate->planstate,
1065 : NULL);
1066 :
1067 : /* Build the ExprState for generating hash values */
1068 1156 : sstate->lhs_hash_expr = ExecBuildHash32FromAttrs(tupDescLeft,
1069 : &TTSOpsVirtual,
1070 : lhs_hash_funcs,
1071 : sstate->tab_collations,
1072 : sstate->numCols,
1073 : sstate->keyColIdx,
1074 : parent,
1075 : 0);
1076 :
1077 : /*
1078 : * Create comparator for lookups of rows in the table (potentially
1079 : * cross-type comparisons).
1080 : */
1081 1156 : sstate->cur_eq_comp = ExecBuildGroupingEqual(tupDescLeft, tupDescRight,
1082 : &TTSOpsVirtual, &TTSOpsMinimalTuple,
1083 : ncols,
1084 1156 : sstate->keyColIdx,
1085 : cross_eq_funcoids,
1086 1156 : sstate->tab_collations,
1087 : parent);
1088 : }
1089 :
1090 44370 : return sstate;
1091 : }
1092 :
1093 : /* ----------------------------------------------------------------
1094 : * ExecSetParamPlan
1095 : *
1096 : * Executes a subplan and sets its output parameters.
1097 : *
1098 : * This is called from ExecEvalParamExec() when the value of a PARAM_EXEC
1099 : * parameter is requested and the param's execPlan field is set (indicating
1100 : * that the param has not yet been evaluated). This allows lazy evaluation
1101 : * of initplans: we don't run the subplan until/unless we need its output.
1102 : * Note that this routine MUST clear the execPlan fields of the plan's
1103 : * output parameters after evaluating them!
1104 : *
1105 : * The results of this function are stored in the EState associated with the
1106 : * ExprContext (particularly, its ecxt_param_exec_vals); any pass-by-ref
1107 : * result Datums are allocated in the EState's per-query memory. The passed
1108 : * econtext can be any ExprContext belonging to that EState; which one is
1109 : * important only to the extent that the ExprContext's per-tuple memory
1110 : * context is used to evaluate any parameters passed down to the subplan.
1111 : * (Thus in principle, the shorter-lived the ExprContext the better, since
1112 : * that data isn't needed after we return. In practice, because initplan
1113 : * parameters are never more complex than Vars, Aggrefs, etc, evaluating them
1114 : * currently never leaks any memory anyway.)
1115 : * ----------------------------------------------------------------
1116 : */
1117 : void
1118 9658 : ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
1119 : {
1120 9658 : SubPlan *subplan = node->subplan;
1121 9658 : PlanState *planstate = node->planstate;
1122 9658 : SubLinkType subLinkType = subplan->subLinkType;
1123 9658 : EState *estate = planstate->state;
1124 9658 : ScanDirection dir = estate->es_direction;
1125 : MemoryContext oldcontext;
1126 : TupleTableSlot *slot;
1127 : ListCell *l;
1128 9658 : bool found = false;
1129 9658 : ArrayBuildStateAny *astate = NULL;
1130 :
1131 9658 : if (subLinkType == ANY_SUBLINK ||
1132 : subLinkType == ALL_SUBLINK)
1133 0 : elog(ERROR, "ANY/ALL subselect unsupported as initplan");
1134 9658 : if (subLinkType == CTE_SUBLINK)
1135 0 : elog(ERROR, "CTE subplans should not be executed via ExecSetParamPlan");
1136 9658 : if (subplan->parParam || subplan->args)
1137 0 : elog(ERROR, "correlated subplans should not be executed via ExecSetParamPlan");
1138 :
1139 : /*
1140 : * Enforce forward scan direction regardless of caller. It's hard but not
1141 : * impossible to get here in backward scan, so make it work anyway.
1142 : */
1143 9658 : estate->es_direction = ForwardScanDirection;
1144 :
1145 : /* Initialize ArrayBuildStateAny in caller's context, if needed */
1146 9658 : if (subLinkType == ARRAY_SUBLINK)
1147 122 : astate = initArrayResultAny(subplan->firstColType,
1148 : CurrentMemoryContext, true);
1149 :
1150 : /*
1151 : * Must switch to per-query memory context.
1152 : */
1153 9658 : oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
1154 :
1155 : /*
1156 : * Run the plan. (If it needs to be rescanned, the first ExecProcNode
1157 : * call will take care of that.)
1158 : */
1159 9658 : for (slot = ExecProcNode(planstate);
1160 30630 : !TupIsNull(slot);
1161 20972 : slot = ExecProcNode(planstate))
1162 : {
1163 21160 : TupleDesc tdesc = slot->tts_tupleDescriptor;
1164 21160 : int i = 1;
1165 :
1166 21160 : if (subLinkType == EXISTS_SUBLINK)
1167 : {
1168 : /* There can be only one setParam... */
1169 170 : int paramid = linitial_int(subplan->setParam);
1170 170 : ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1171 :
1172 170 : prm->execPlan = NULL;
1173 170 : prm->value = BoolGetDatum(true);
1174 170 : prm->isnull = false;
1175 170 : found = true;
1176 170 : break;
1177 : }
1178 :
1179 20990 : if (subLinkType == ARRAY_SUBLINK)
1180 12334 : {
1181 : Datum dvalue;
1182 : bool disnull;
1183 :
1184 12334 : found = true;
1185 : /* stash away current value */
1186 : Assert(subplan->firstColType == TupleDescAttr(tdesc, 0)->atttypid);
1187 12334 : dvalue = slot_getattr(slot, 1, &disnull);
1188 12334 : astate = accumArrayResultAny(astate, dvalue, disnull,
1189 : subplan->firstColType, oldcontext);
1190 : /* keep scanning subplan to collect all values */
1191 12334 : continue;
1192 : }
1193 :
1194 8656 : if (found &&
1195 12 : (subLinkType == EXPR_SUBLINK ||
1196 6 : subLinkType == MULTIEXPR_SUBLINK ||
1197 : subLinkType == ROWCOMPARE_SUBLINK))
1198 18 : ereport(ERROR,
1199 : (errcode(ERRCODE_CARDINALITY_VIOLATION),
1200 : errmsg("more than one row returned by a subquery used as an expression")));
1201 :
1202 8638 : found = true;
1203 :
1204 : /*
1205 : * We need to copy the subplan's tuple into our own context, in case
1206 : * any of the params are pass-by-ref type --- the pointers stored in
1207 : * the param structs will point at this copied tuple! node->curTuple
1208 : * keeps track of the copied tuple for eventual freeing.
1209 : */
1210 8638 : if (node->curTuple)
1211 520 : heap_freetuple(node->curTuple);
1212 8638 : node->curTuple = ExecCopySlotHeapTuple(slot);
1213 :
1214 : /*
1215 : * Now set all the setParam params from the columns of the tuple
1216 : */
1217 17312 : foreach(l, subplan->setParam)
1218 : {
1219 8674 : int paramid = lfirst_int(l);
1220 8674 : ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1221 :
1222 8674 : prm->execPlan = NULL;
1223 8674 : prm->value = heap_getattr(node->curTuple, i, tdesc,
1224 : &(prm->isnull));
1225 8674 : i++;
1226 : }
1227 : }
1228 :
1229 9640 : if (subLinkType == ARRAY_SUBLINK)
1230 : {
1231 : /* There can be only one setParam... */
1232 122 : int paramid = linitial_int(subplan->setParam);
1233 122 : ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1234 :
1235 : /*
1236 : * We build the result array in query context so it won't disappear;
1237 : * to avoid leaking memory across repeated calls, we have to remember
1238 : * the latest value, much as for curTuple above.
1239 : */
1240 122 : if (node->curArray != PointerGetDatum(NULL))
1241 0 : pfree(DatumGetPointer(node->curArray));
1242 122 : node->curArray = makeArrayResultAny(astate,
1243 : econtext->ecxt_per_query_memory,
1244 : true);
1245 122 : prm->execPlan = NULL;
1246 122 : prm->value = node->curArray;
1247 122 : prm->isnull = false;
1248 : }
1249 9518 : else if (!found)
1250 : {
1251 728 : if (subLinkType == EXISTS_SUBLINK)
1252 : {
1253 : /* There can be only one setParam... */
1254 672 : int paramid = linitial_int(subplan->setParam);
1255 672 : ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1256 :
1257 672 : prm->execPlan = NULL;
1258 672 : prm->value = BoolGetDatum(false);
1259 672 : prm->isnull = false;
1260 : }
1261 : else
1262 : {
1263 : /* For other sublink types, set all the output params to NULL */
1264 118 : foreach(l, subplan->setParam)
1265 : {
1266 62 : int paramid = lfirst_int(l);
1267 62 : ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1268 :
1269 62 : prm->execPlan = NULL;
1270 62 : prm->value = (Datum) 0;
1271 62 : prm->isnull = true;
1272 : }
1273 : }
1274 : }
1275 :
1276 9640 : MemoryContextSwitchTo(oldcontext);
1277 :
1278 : /* restore scan direction */
1279 9640 : estate->es_direction = dir;
1280 9640 : }
1281 :
1282 : /*
1283 : * ExecSetParamPlanMulti
1284 : *
1285 : * Apply ExecSetParamPlan to evaluate any not-yet-evaluated initplan output
1286 : * parameters whose ParamIDs are listed in "params". Any listed params that
1287 : * are not initplan outputs are ignored.
1288 : *
1289 : * As with ExecSetParamPlan, any ExprContext belonging to the current EState
1290 : * can be used, but in principle a shorter-lived ExprContext is better than a
1291 : * longer-lived one.
1292 : */
1293 : void
1294 1446 : ExecSetParamPlanMulti(const Bitmapset *params, ExprContext *econtext)
1295 : {
1296 : int paramid;
1297 :
1298 1446 : paramid = -1;
1299 1920 : while ((paramid = bms_next_member(params, paramid)) >= 0)
1300 : {
1301 474 : ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1302 :
1303 474 : if (prm->execPlan != NULL)
1304 : {
1305 : /* Parameter not evaluated yet, so go do it */
1306 34 : ExecSetParamPlan(prm->execPlan, econtext);
1307 : /* ExecSetParamPlan should have processed this param... */
1308 : Assert(prm->execPlan == NULL);
1309 : }
1310 : }
1311 1446 : }
1312 :
1313 : /*
1314 : * Mark an initplan as needing recalculation
1315 : */
1316 : void
1317 1382 : ExecReScanSetParamPlan(SubPlanState *node, PlanState *parent)
1318 : {
1319 1382 : PlanState *planstate = node->planstate;
1320 1382 : SubPlan *subplan = node->subplan;
1321 1382 : EState *estate = parent->state;
1322 : ListCell *l;
1323 :
1324 : /* sanity checks */
1325 1382 : if (subplan->parParam != NIL)
1326 0 : elog(ERROR, "direct correlated subquery unsupported as initplan");
1327 1382 : if (subplan->setParam == NIL)
1328 0 : elog(ERROR, "setParam list of initplan is empty");
1329 1382 : if (bms_is_empty(planstate->plan->extParam))
1330 0 : elog(ERROR, "extParam set of initplan is empty");
1331 :
1332 : /*
1333 : * Don't actually re-scan: it'll happen inside ExecSetParamPlan if needed.
1334 : */
1335 :
1336 : /*
1337 : * Mark this subplan's output parameters as needing recalculation.
1338 : *
1339 : * CTE subplans are never executed via parameter recalculation; instead
1340 : * they get run when called by nodeCtescan.c. So don't mark the output
1341 : * parameter of a CTE subplan as dirty, but do set the chgParam bit for it
1342 : * so that dependent plan nodes will get told to rescan.
1343 : */
1344 2764 : foreach(l, subplan->setParam)
1345 : {
1346 1382 : int paramid = lfirst_int(l);
1347 1382 : ParamExecData *prm = &(estate->es_param_exec_vals[paramid]);
1348 :
1349 1382 : if (subplan->subLinkType != CTE_SUBLINK)
1350 826 : prm->execPlan = node;
1351 :
1352 1382 : parent->chgParam = bms_add_member(parent->chgParam, paramid);
1353 : }
1354 1382 : }
|
