Age Owner Branch data TLA 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
8255 bruce@momjian.us 59 :CBC 2324032 : ExecSubPlan(SubPlanState *node,
60 : : ExprContext *econtext,
61 : : bool *isNull)
62 : : {
3288 andres@anarazel.de 63 : 2324032 : SubPlan *subplan = node->subplan;
2767 rhodiumtoad@postgres 64 : 2324032 : EState *estate = node->planstate->state;
65 : 2324032 : ScanDirection dir = estate->es_direction;
66 : : Datum retval;
67 : :
3155 andres@anarazel.de 68 [ + + ]: 2324032 : CHECK_FOR_INTERRUPTS();
69 : :
70 : : /* Set non-null as default */
8033 tgl@sss.pgh.pa.us 71 : 2324032 : *isNull = false;
72 : :
73 : : /* Sanity checks */
6371 74 [ - + ]: 2324032 : if (subplan->subLinkType == CTE_SUBLINK)
6371 tgl@sss.pgh.pa.us 75 [ # # ]:UBC 0 : elog(ERROR, "CTE subplans should not be executed via ExecSubPlan");
4288 tgl@sss.pgh.pa.us 76 [ + + - + ]:CBC 2324032 : if (subplan->setParam != NIL && subplan->subLinkType != MULTIEXPR_SUBLINK)
8273 tgl@sss.pgh.pa.us 77 [ # # ]:UBC 0 : elog(ERROR, "cannot set parent params from subquery");
78 : :
79 : : /* Force forward-scan mode for evaluation */
2767 rhodiumtoad@postgres 80 :CBC 2324032 : estate->es_direction = ForwardScanDirection;
81 : :
82 : : /* Select appropriate evaluation strategy */
8463 tgl@sss.pgh.pa.us 83 [ + + ]: 2324032 : if (subplan->useHashTable)
2767 rhodiumtoad@postgres 84 : 1191347 : retval = ExecHashSubPlan(node, econtext, isNull);
85 : : else
86 : 1132685 : retval = ExecScanSubPlan(node, econtext, isNull);
87 : :
88 : : /* restore scan direction */
89 : 2324029 : estate->es_direction = dir;
90 : :
91 : 2324029 : return retval;
92 : : }
93 : :
94 : : /*
95 : : * ExecHashSubPlan: store subselect result in an in-memory hash table
96 : : */
97 : : static Datum
8255 bruce@momjian.us 98 : 1191347 : ExecHashSubPlan(SubPlanState *node,
99 : : ExprContext *econtext,
100 : : bool *isNull)
101 : : {
186 tgl@sss.pgh.pa.us 102 : 1191347 : bool result = false;
3288 andres@anarazel.de 103 : 1191347 : SubPlan *subplan = node->subplan;
8463 tgl@sss.pgh.pa.us 104 : 1191347 : PlanState *planstate = node->planstate;
105 : : TupleTableSlot *slot;
106 : :
107 : : /* Shouldn't have any direct correlation Vars */
592 andres@anarazel.de 108 [ + - - + ]: 1191347 : if (subplan->parParam != NIL || subplan->args != NIL)
8273 tgl@sss.pgh.pa.us 109 [ # # ]:UBC 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 : : */
8435 tgl@sss.pgh.pa.us 115 [ + + + + ]:CBC 1191347 : if (node->hashtable == NULL || planstate->chgParam != NULL)
6956 116 : 855 : buildSubPlanHash(node, econtext);
117 : :
118 : : /*
119 : : * The result for an empty subplan is always FALSE; no need to evaluate
120 : : * lefthand side.
121 : : */
8463 122 : 1191344 : *isNull = false;
123 [ + + + + ]: 1191344 : if (!node->havehashrows && !node->havenullrows)
124 : 678846 : 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 : 512498 : node->projLeft->pi_exprContext = econtext;
3342 andres@anarazel.de 131 : 512498 : 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 : : */
7669 tgl@sss.pgh.pa.us 147 [ + + ]: 512498 : if (slotNoNulls(slot))
148 : : {
8463 149 [ + + + + ]: 1024948 : if (node->havehashrows &&
6977 150 : 512468 : FindTupleHashEntry(node->hashtable,
151 : : slot,
152 : : node->cur_eq_comp,
153 : : node->lhs_hash_expr) != NULL)
186 154 : 30938 : result = true;
155 [ + + + + ]: 481560 : else if (node->havenullrows &&
156 : 18 : findPartialMatch(node->hashnulls, slot, node->cur_eq_funcs))
8463 157 : 9 : *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 : : */
186 170 [ + - ]: 18 : else if (node->hashnulls == NULL)
171 : : /* just return FALSE */ ;
172 [ - + ]: 18 : else if (slotAllNulls(slot))
8463 tgl@sss.pgh.pa.us 173 :UBC 0 : *isNull = true;
174 : : /* Scan partly-null table first, since more likely to get a match */
186 tgl@sss.pgh.pa.us 175 [ + - + + ]:CBC 36 : else if (node->havenullrows &&
176 : 18 : findPartialMatch(node->hashnulls, slot, node->cur_eq_funcs))
8463 177 : 9 : *isNull = true;
186 178 [ + + - + ]: 12 : else if (node->havehashrows &&
179 : 3 : findPartialMatch(node->hashtable, slot, node->cur_eq_funcs))
8463 tgl@sss.pgh.pa.us 180 :UBC 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 : : */
8463 tgl@sss.pgh.pa.us 189 :CBC 512498 : ExecClearTuple(slot);
190 : :
191 : : /* Also must reset the innerecontext after each hashtable lookup. */
186 tgl@sss.pgh.pa.us 192 :GNC 512498 : ResetExprContext(node->innerecontext);
193 : :
186 tgl@sss.pgh.pa.us 194 :CBC 512498 : return BoolGetDatum(result);
195 : : }
196 : :
197 : : /*
198 : : * ExecScanSubPlan: default case where we have to rescan subplan each time
199 : : */
200 : : static Datum
8255 bruce@momjian.us 201 : 1132685 : ExecScanSubPlan(SubPlanState *node,
202 : : ExprContext *econtext,
203 : : bool *isNull)
204 : : {
3288 andres@anarazel.de 205 : 1132685 : SubPlan *subplan = node->subplan;
8501 tgl@sss.pgh.pa.us 206 : 1132685 : PlanState *planstate = node->planstate;
8492 207 : 1132685 : SubLinkType subLinkType = subplan->subLinkType;
208 : : MemoryContext oldcontext;
209 : : TupleTableSlot *slot;
210 : : Datum result;
3133 peter_e@gmx.net 211 : 1132685 : bool found = false; /* true if got at least one subplan tuple */
212 : : ListCell *l;
4128 tgl@sss.pgh.pa.us 213 : 1132685 : ArrayBuildStateAny *astate = NULL;
214 : :
215 : : /* Initialize ArrayBuildStateAny in caller's context, if needed */
216 [ + + ]: 1132685 : if (subLinkType == ARRAY_SUBLINK)
217 : 28192 : 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 : : */
6956 225 : 1132685 : 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 : : */
592 andres@anarazel.de 233 [ + + + + : 2280775 : foreach(l, subplan->parParam)
+ + ]
234 : : {
7963 neilc@samurai.com 235 : 1148090 : int paramid = lfirst_int(l);
236 : :
8435 tgl@sss.pgh.pa.us 237 : 1148090 : planstate->chgParam = bms_add_member(planstate->chgParam, paramid);
238 : : }
239 : :
240 : : /* with that done, we can reset the subplan */
5725 241 : 1132685 : 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 : : */
9377 269 : 1132685 : result = BoolGetDatum(subLinkType == ALL_SUBLINK);
9620 270 : 1132685 : *isNull = false;
271 : :
8501 272 : 1132685 : for (slot = ExecProcNode(planstate);
10244 bruce@momjian.us 273 [ + + + + ]: 1353730 : !TupIsNull(slot);
8501 tgl@sss.pgh.pa.us 274 : 221045 : slot = ExecProcNode(planstate))
275 : : {
7669 276 : 221474 : TupleDesc tdesc = slot->tts_tupleDescriptor;
277 : : Datum rowresult;
278 : : bool rownull;
279 : : int col;
280 : : ListCell *plst;
281 : :
9827 282 [ + + ]: 221474 : if (subLinkType == EXISTS_SUBLINK)
283 : : {
9377 284 : 355 : found = true;
285 : 355 : result = BoolGetDatum(true);
286 : 429 : break;
287 : : }
288 : :
9617 289 [ + + ]: 221119 : if (subLinkType == EXPR_SUBLINK)
290 : : {
291 : : /* cannot allow multiple input tuples for EXPR sublink */
292 [ - + ]: 213052 : if (found)
8273 tgl@sss.pgh.pa.us 293 [ # # ]:UBC 0 : ereport(ERROR,
294 : : (errcode(ERRCODE_CARDINALITY_VIOLATION),
295 : : errmsg("more than one row returned by a subquery used as an expression")));
9617 tgl@sss.pgh.pa.us 296 :CBC 213052 : 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 [ + + ]: 213052 : if (node->curTuple)
9586 JanWieck@Yahoo.com 307 : 209681 : heap_freetuple(node->curTuple);
2676 andres@anarazel.de 308 : 213052 : node->curTuple = ExecCopySlotHeapTuple(slot);
309 : :
7382 tgl@sss.pgh.pa.us 310 : 213052 : result = heap_getattr(node->curTuple, 1, tdesc, isNull);
311 : : /* keep scanning subplan to make sure there's only one tuple */
9617 312 : 215567 : continue;
313 : : }
314 : :
1114 315 [ + + ]: 8067 : if (subLinkType == MULTIEXPR_SUBLINK)
316 : : {
317 : : /* cannot allow multiple input tuples for MULTIEXPR sublink */
318 [ - + ]: 120 : if (found)
1114 tgl@sss.pgh.pa.us 319 [ # # ]:UBC 0 : ereport(ERROR,
320 : : (errcode(ERRCODE_CARDINALITY_VIOLATION),
321 : : errmsg("more than one row returned by a subquery used as an expression")));
1114 tgl@sss.pgh.pa.us 322 :CBC 120 : 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 [ + + ]: 120 : if (node->curTuple)
333 : 76 : heap_freetuple(node->curTuple);
334 : 120 : node->curTuple = ExecCopySlotHeapTuple(slot);
335 : :
336 : : /*
337 : : * Now set all the setParam params from the columns of the tuple
338 : : */
339 : 120 : col = 1;
340 [ + - + + : 357 : foreach(plst, subplan->setParam)
+ + ]
341 : : {
342 : 237 : int paramid = lfirst_int(plst);
343 : : ParamExecData *prmdata;
344 : :
345 : 237 : prmdata = &(econtext->ecxt_param_exec_vals[paramid]);
346 [ - + ]: 237 : Assert(prmdata->execPlan == NULL);
347 : 237 : prmdata->value = heap_getattr(node->curTuple, col, tdesc,
348 : : &(prmdata->isnull));
349 : 237 : col++;
350 : : }
351 : :
352 : : /* keep scanning subplan to make sure there's only one tuple */
353 : 120 : continue;
354 : : }
355 : :
8377 356 [ + + ]: 7947 : if (subLinkType == ARRAY_SUBLINK)
357 : 2395 : {
358 : : Datum dvalue;
359 : : bool disnull;
360 : :
361 : 2395 : found = true;
362 : : /* stash away current value */
3129 andres@anarazel.de 363 [ - + ]: 2395 : Assert(subplan->firstColType == TupleDescAttr(tdesc, 0)->atttypid);
7669 tgl@sss.pgh.pa.us 364 : 2395 : dvalue = slot_getattr(slot, 1, &disnull);
4128 365 : 2395 : astate = accumArrayResultAny(astate, dvalue, disnull,
366 : : subplan->firstColType, oldcontext);
367 : : /* keep scanning subplan to collect all values */
8377 368 : 2395 : continue;
369 : : }
370 : :
371 : : /* cannot allow multiple input tuples for ROWCOMPARE sublink either */
7382 372 [ + + - + ]: 5552 : if (subLinkType == ROWCOMPARE_SUBLINK && found)
8273 tgl@sss.pgh.pa.us 373 [ # # ]:UBC 0 : ereport(ERROR,
374 : : (errcode(ERRCODE_CARDINALITY_VIOLATION),
375 : : errmsg("more than one row returned by a subquery used as an expression")));
376 : :
10257 vadim4o@yahoo.com 377 :CBC 5552 : 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 : : */
7382 tgl@sss.pgh.pa.us 384 : 5552 : col = 1;
385 [ + - + + : 16483 : foreach(plst, subplan->paramIds)
+ + ]
386 : : {
7963 neilc@samurai.com 387 : 10931 : int paramid = lfirst_int(plst);
388 : : ParamExecData *prmdata;
389 : :
8299 bruce@momjian.us 390 : 10931 : prmdata = &(econtext->ecxt_param_exec_vals[paramid]);
391 [ - + ]: 10931 : Assert(prmdata->execPlan == NULL);
7382 tgl@sss.pgh.pa.us 392 : 10931 : prmdata->value = slot_getattr(slot, col, &(prmdata->isnull));
8299 bruce@momjian.us 393 : 10931 : col++;
394 : : }
395 : :
7382 tgl@sss.pgh.pa.us 396 : 5552 : rowresult = ExecEvalExprSwitchContext(node->testexpr, econtext,
397 : : &rownull);
398 : :
8299 bruce@momjian.us 399 [ + + ]: 5552 : if (subLinkType == ANY_SUBLINK)
400 : : {
401 : : /* combine across rows per OR semantics */
402 [ - + ]: 5483 : if (rownull)
8299 bruce@momjian.us 403 :UBC 0 : *isNull = true;
8299 bruce@momjian.us 404 [ + + ]:CBC 5483 : else if (DatumGetBool(rowresult))
405 : : {
406 : 62 : result = BoolGetDatum(true);
407 : 62 : *isNull = false;
408 : 62 : break; /* needn't look at any more rows */
409 : : }
410 : : }
411 [ + + ]: 69 : else if (subLinkType == ALL_SUBLINK)
412 : : {
413 : : /* combine across rows per AND semantics */
414 [ - + ]: 45 : if (rownull)
8299 bruce@momjian.us 415 :UBC 0 : *isNull = true;
8299 bruce@momjian.us 416 [ + + ]:CBC 45 : else if (!DatumGetBool(rowresult))
417 : : {
418 : 12 : result = BoolGetDatum(false);
419 : 12 : *isNull = false;
420 : 12 : break; /* needn't look at any more rows */
421 : : }
422 : : }
423 : : else
424 : : {
425 : : /* must be ROWCOMPARE_SUBLINK */
426 : 24 : result = rowresult;
427 : 24 : *isNull = rownull;
428 : : }
429 : : }
430 : :
6776 tgl@sss.pgh.pa.us 431 : 1132685 : MemoryContextSwitchTo(oldcontext);
432 : :
433 [ + + ]: 1132685 : if (subLinkType == ARRAY_SUBLINK)
434 : : {
435 : : /* We return the result in the caller's context */
4128 436 : 28192 : result = makeArrayResultAny(astate, oldcontext, true);
437 : : }
6776 438 [ + + ]: 1104493 : 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 : : */
8377 445 [ + + - + ]: 888155 : if (subLinkType == EXPR_SUBLINK ||
446 : : subLinkType == ROWCOMPARE_SUBLINK)
447 : : {
9377 448 : 38455 : result = (Datum) 0;
9468 bruce@momjian.us 449 : 38455 : *isNull = true;
450 : : }
1114 tgl@sss.pgh.pa.us 451 [ + + ]: 849700 : else if (subLinkType == MULTIEXPR_SUBLINK)
452 : : {
453 : : /* We don't care about function result, but set the setParams */
454 [ + - + + : 9 : foreach(l, subplan->setParam)
+ + ]
455 : : {
456 : 6 : int paramid = lfirst_int(l);
457 : : ParamExecData *prmdata;
458 : :
459 : 6 : prmdata = &(econtext->ecxt_param_exec_vals[paramid]);
460 [ - + ]: 6 : Assert(prmdata->execPlan == NULL);
461 : 6 : prmdata->value = (Datum) 0;
462 : 6 : prmdata->isnull = true;
463 : : }
464 : : }
465 : : }
466 : :
9827 467 : 1132685 : return result;
468 : : }
469 : :
470 : : /*
471 : : * buildSubPlanHash: load hash table by scanning subplan output.
472 : : */
473 : : static void
6956 474 : 855 : buildSubPlanHash(SubPlanState *node, ExprContext *econtext)
475 : : {
3288 andres@anarazel.de 476 : 855 : SubPlan *subplan = node->subplan;
8463 tgl@sss.pgh.pa.us 477 : 855 : PlanState *planstate = node->planstate;
2039 478 : 855 : int ncols = node->numCols;
8463 479 : 855 : ExprContext *innerecontext = node->innerecontext;
480 : : MemoryContext oldcontext;
481 : : double nentries;
482 : : TupleTableSlot *slot;
483 : :
484 [ - + ]: 855 : 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 : 855 : node->havehashrows = false;
507 : 855 : node->havenullrows = false;
508 : :
133 tgl@sss.pgh.pa.us 509 :GNC 855 : nentries = planstate->plan->plan_rows;
510 : :
2591 andres@anarazel.de 511 [ + + ]:CBC 855 : if (node->hashtable)
512 : 297 : ResetTupleHashTable(node->hashtable);
513 : : else
451 tgl@sss.pgh.pa.us 514 : 558 : node->hashtable = BuildTupleHashTable(node->parent,
515 : : node->descRight,
516 : : &TTSOpsVirtual,
517 : : ncols,
518 : : node->keyColIdx,
519 : 558 : node->tab_eq_funcoids,
520 : : node->tab_hash_funcs,
521 : : node->tab_collations,
522 : : nentries,
523 : : 0, /* no additional data */
524 : 558 : node->planstate->state->es_query_cxt,
525 : : node->tuplesContext,
526 : : innerecontext->ecxt_per_tuple_memory,
527 : : false);
528 : :
8463 529 [ + + ]: 855 : if (!subplan->unknownEqFalse)
530 : : {
531 [ + + ]: 391 : if (ncols == 1)
133 tgl@sss.pgh.pa.us 532 :GNC 355 : nentries = 1; /* there can only be one entry */
533 : : else
534 : : {
535 : 36 : nentries /= 16;
536 [ - + ]: 36 : if (nentries < 1)
133 tgl@sss.pgh.pa.us 537 :UNC 0 : nentries = 1;
538 : : }
539 : :
2591 andres@anarazel.de 540 [ + + ]:CBC 391 : if (node->hashnulls)
2206 tgl@sss.pgh.pa.us 541 : 297 : ResetTupleHashTable(node->hashnulls);
542 : : else
451 543 : 94 : node->hashnulls = BuildTupleHashTable(node->parent,
544 : : node->descRight,
545 : : &TTSOpsVirtual,
546 : : ncols,
547 : : node->keyColIdx,
548 : 94 : node->tab_eq_funcoids,
549 : : node->tab_hash_funcs,
550 : : node->tab_collations,
551 : : nentries,
552 : : 0, /* no additional data */
553 : 94 : node->planstate->state->es_query_cxt,
554 : : node->tuplesContext,
555 : : innerecontext->ecxt_per_tuple_memory,
556 : : false);
557 : : }
558 : : else
2206 559 : 464 : 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 : : */
6956 565 : 855 : oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
566 : :
567 : : /*
568 : : * Reset subplan to start.
569 : : */
5725 570 : 855 : 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 : : */
8463 576 : 855 : for (slot = ExecProcNode(planstate);
577 [ + + + + ]: 199559 : !TupIsNull(slot);
578 : 198704 : slot = ExecProcNode(planstate))
579 : : {
8299 bruce@momjian.us 580 : 198707 : 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 [ + - + + : 532312 : foreach(plst, subplan->paramIds)
+ + ]
589 : : {
7959 neilc@samurai.com 590 : 333605 : int paramid = lfirst_int(plst);
591 : : ParamExecData *prmdata;
592 : :
8299 bruce@momjian.us 593 : 333605 : prmdata = &(innerecontext->ecxt_param_exec_vals[paramid]);
594 [ - + ]: 333605 : Assert(prmdata->execPlan == NULL);
7669 tgl@sss.pgh.pa.us 595 : 333605 : prmdata->value = slot_getattr(slot, col,
596 : : &(prmdata->isnull));
8299 bruce@momjian.us 597 : 333605 : col++;
598 : : }
3342 andres@anarazel.de 599 : 198707 : slot = ExecProject(node->projRight);
600 : :
601 : : /*
602 : : * If result contains any nulls, store separately or not at all.
603 : : */
7669 tgl@sss.pgh.pa.us 604 [ + + ]: 198707 : if (slotNoNulls(slot))
605 : : {
2058 jdavis@postgresql.or 606 : 198695 : (void) LookupTupleHashEntry(node->hashtable, slot, &isnew, NULL);
8299 bruce@momjian.us 607 : 198692 : node->havehashrows = true;
608 : : }
609 [ + - ]: 12 : else if (node->hashnulls)
610 : : {
2058 jdavis@postgresql.or 611 : 12 : (void) LookupTupleHashEntry(node->hashnulls, slot, &isnew, NULL);
8299 bruce@momjian.us 612 : 12 : 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 : : */
8463 tgl@sss.pgh.pa.us 619 : 198704 : 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 : : */
3288 andres@anarazel.de 629 : 852 : ExecClearTuple(node->projRight->pi_state.resultslot);
630 : :
8463 tgl@sss.pgh.pa.us 631 : 852 : MemoryContextSwitchTo(oldcontext);
632 : 852 : }
633 : :
634 : : /* Planner support routine to estimate space needed for hash table(s) */
635 : : Size
133 tgl@sss.pgh.pa.us 636 :GNC 2105 : EstimateSubplanHashTableSpace(double nentries,
637 : : Size tupleWidth,
638 : : bool unknownEqFalse)
639 : : {
640 : : Size tab1space,
641 : : tab2space;
642 : :
643 : : /* Estimate size of main hashtable */
644 : 2105 : tab1space = EstimateTupleHashTableSpace(nentries,
645 : : tupleWidth,
646 : : 0 /* no additional data */ );
647 : :
648 : : /* Give up if that's already too big */
649 [ + + ]: 2105 : if (tab1space >= SIZE_MAX)
650 : 3 : return tab1space;
651 : :
652 : : /* Done if we don't need a hashnulls table */
653 [ + + ]: 2102 : if (unknownEqFalse)
654 : 1908 : 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 : 194 : nentries /= 16;
664 [ + + ]: 194 : if (nentries < 1)
665 : 58 : 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 : 194 : tab2space = EstimateTupleHashTableSpace(nentries,
673 : : tupleWidth,
674 : : 0 /* no additional data */ );
675 : :
676 : : /* Guard against overflow */
677 [ - + ]: 194 : if (tab2space >= SIZE_MAX - tab1space)
133 tgl@sss.pgh.pa.us 678 :UNC 0 : return SIZE_MAX;
679 : :
133 tgl@sss.pgh.pa.us 680 :GNC 194 : 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
2950 andres@anarazel.de 698 :CBC 39 : 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 : 39 : MemoryContextReset(evalContext);
712 : 39 : 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 : 39 : result = false;
721 : :
722 [ + + ]: 96 : for (i = numCols; --i >= 0;)
723 : : {
724 : 78 : AttrNumber att = matchColIdx[i];
725 : : Datum attr1,
726 : : attr2;
727 : : bool isNull1,
728 : : isNull2;
729 : :
730 : 78 : attr1 = slot_getattr(slot1, att, &isNull1);
731 : :
732 [ + + ]: 78 : if (isNull1)
733 : 39 : continue; /* can't prove anything here */
734 : :
735 : 57 : attr2 = slot_getattr(slot2, att, &isNull2);
736 : :
737 [ + + ]: 57 : if (isNull2)
738 : 18 : continue; /* can't prove anything here */
739 : :
740 : : /* Apply the type-specific equality function */
2550 peter@eisentraut.org 741 [ + + ]: 39 : if (!DatumGetBool(FunctionCall2Coll(&eqfunctions[i],
742 : 39 : collations[i],
743 : : attr1, attr2)))
744 : : {
2950 andres@anarazel.de 745 : 21 : result = true; /* they are unequal */
746 : 21 : break;
747 : : }
748 : : }
749 : :
750 : 39 : MemoryContextSwitchTo(oldContext);
751 : :
752 : 39 : 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
4903 tgl@sss.pgh.pa.us 767 : 39 : findPartialMatch(TupleHashTable hashtable, TupleTableSlot *slot,
768 : : FmgrInfo *eqfunctions)
769 : : {
8463 770 : 39 : int numCols = hashtable->numCols;
771 : 39 : AttrNumber *keyColIdx = hashtable->keyColIdx;
772 : : TupleHashIterator hashiter;
773 : : TupleHashEntry entry;
774 : :
6898 775 : 39 : InitTupleHashIterator(hashtable, &hashiter);
3439 andres@anarazel.de 776 [ + + ]: 60 : while ((entry = ScanTupleHashTable(hashtable, &hashiter)) != NULL)
777 : : {
3155 778 [ - + ]: 39 : CHECK_FOR_INTERRUPTS();
779 : :
356 jdavis@postgresql.or 780 : 39 : ExecStoreMinimalTuple(TupleHashEntryGetTuple(entry), hashtable->tableslot, false);
6977 tgl@sss.pgh.pa.us 781 [ + + ]: 39 : if (!execTuplesUnequal(slot, hashtable->tableslot,
782 : : numCols, keyColIdx,
783 : : eqfunctions,
2550 peter@eisentraut.org 784 : 39 : hashtable->tab_collations,
785 : : hashtable->tempcxt))
786 : : {
787 : : TermTupleHashIterator(&hashiter);
8463 tgl@sss.pgh.pa.us 788 : 18 : return true;
789 : : }
790 : : }
791 : : /* No TermTupleHashIterator call needed here */
792 : 21 : 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
7669 802 : 18 : slotAllNulls(TupleTableSlot *slot)
803 : : {
804 : 18 : int ncols = slot->tts_tupleDescriptor->natts;
805 : : int i;
806 : :
807 [ + - ]: 18 : for (i = 1; i <= ncols; i++)
808 : : {
809 [ + - ]: 18 : if (!slot_attisnull(slot, i))
810 : 18 : return false;
811 : : }
7669 tgl@sss.pgh.pa.us 812 :UBC 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
7669 tgl@sss.pgh.pa.us 822 :CBC 711205 : slotNoNulls(TupleTableSlot *slot)
823 : : {
824 : 711205 : int ncols = slot->tts_tupleDescriptor->natts;
825 : : int i;
826 : :
8463 827 [ + + ]: 1587371 : for (i = 1; i <= ncols; i++)
828 : : {
7669 829 [ + + ]: 876196 : if (slot_attisnull(slot, i))
8463 830 : 30 : return false;
831 : : }
832 : 711175 : 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 *
6956 850 : 24905 : ExecInitSubPlan(SubPlan *subplan, PlanState *parent)
851 : : {
852 : 24905 : SubPlanState *sstate = makeNode(SubPlanState);
853 : 24905 : EState *estate = parent->state;
854 : :
3288 andres@anarazel.de 855 : 24905 : sstate->subplan = subplan;
856 : :
857 : : /* Link the SubPlanState to already-initialized subplan */
6956 tgl@sss.pgh.pa.us 858 : 49810 : sstate->planstate = (PlanState *) list_nth(estate->es_subplanstates,
859 : 24905 : 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 : : */
1958 865 [ - + ]: 24905 : if (sstate->planstate == NULL)
1958 tgl@sss.pgh.pa.us 866 [ # # ]:UBC 0 : elog(ERROR, "subplan \"%s\" was not initialized",
867 : : subplan->plan_name);
868 : :
869 : : /* Link to parent's state, too */
4288 tgl@sss.pgh.pa.us 870 :CBC 24905 : sstate->parent = parent;
871 : :
872 : : /* Initialize subexpressions */
6956 873 : 24905 : sstate->testexpr = ExecInitExpr((Expr *) subplan->testexpr, parent);
874 : :
875 : : /*
876 : : * initialize my state
877 : : */
878 : 24905 : sstate->curTuple = NULL;
5015 879 : 24905 : sstate->curArray = PointerGetDatum(NULL);
6956 880 : 24905 : sstate->projLeft = NULL;
881 : 24905 : sstate->projRight = NULL;
882 : 24905 : sstate->hashtable = NULL;
883 : 24905 : sstate->hashnulls = NULL;
136 tgl@sss.pgh.pa.us 884 :GNC 24905 : sstate->tuplesContext = NULL;
6956 tgl@sss.pgh.pa.us 885 :CBC 24905 : sstate->innerecontext = NULL;
886 : 24905 : sstate->keyColIdx = NULL;
2950 andres@anarazel.de 887 : 24905 : sstate->tab_eq_funcoids = NULL;
6956 tgl@sss.pgh.pa.us 888 : 24905 : sstate->tab_hash_funcs = NULL;
2550 peter@eisentraut.org 889 : 24905 : sstate->tab_collations = NULL;
6956 tgl@sss.pgh.pa.us 890 : 24905 : 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 : : */
1114 903 [ + + + + ]: 24905 : if (subplan->setParam != NIL && subplan->parParam == NIL &&
904 [ + + ]: 8625 : subplan->subLinkType != CTE_SUBLINK)
905 : : {
906 : : ListCell *lst;
907 : :
8492 908 [ + - + + : 14392 : foreach(lst, subplan->setParam)
+ + ]
909 : : {
7959 neilc@samurai.com 910 : 7208 : int paramid = lfirst_int(lst);
8435 tgl@sss.pgh.pa.us 911 : 7208 : ParamExecData *prm = &(estate->es_param_exec_vals[paramid]);
912 : :
6956 913 : 7208 : 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 : : */
8463 921 [ + + ]: 24905 : 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 */
136 tgl@sss.pgh.pa.us 936 :GNC 671 : sstate->tuplesContext =
937 : 671 : BumpContextCreate(CurrentMemoryContext,
938 : : "SubPlan hashed tuples",
939 : : ALLOCSET_DEFAULT_SIZES);
940 : : /* and a short-lived exprcontext for function evaluation */
6956 tgl@sss.pgh.pa.us 941 :CBC 671 : 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 : : */
3288 andres@anarazel.de 956 [ + + ]: 671 : if (IsA(subplan->testexpr, OpExpr))
957 : : {
958 : : /* single combining operator */
959 : 619 : oplist = list_make1(subplan->testexpr);
960 : : }
2602 tgl@sss.pgh.pa.us 961 [ + - ]: 52 : else if (is_andclause(subplan->testexpr))
962 : : {
963 : : /* multiple combining operators */
3288 andres@anarazel.de 964 : 52 : oplist = castNode(BoolExpr, subplan->testexpr)->args;
965 : : }
966 : : else
967 : : {
968 : : /* shouldn't see anything else in a hashable subplan */
7382 tgl@sss.pgh.pa.us 969 [ # # ]:UBC 0 : elog(ERROR, "unrecognized testexpr type: %d",
970 : : (int) nodeTag(subplan->testexpr));
971 : : oplist = NIL; /* keep compiler quiet */
972 : : }
2039 tgl@sss.pgh.pa.us 973 :CBC 671 : ncols = list_length(oplist);
974 : :
8463 975 : 671 : lefttlist = righttlist = NIL;
2039 976 : 671 : sstate->numCols = ncols;
977 : 671 : sstate->keyColIdx = (AttrNumber *) palloc(ncols * sizeof(AttrNumber));
2950 andres@anarazel.de 978 : 671 : sstate->tab_eq_funcoids = (Oid *) palloc(ncols * sizeof(Oid));
2039 tgl@sss.pgh.pa.us 979 : 671 : sstate->tab_collations = (Oid *) palloc(ncols * sizeof(Oid));
6956 980 : 671 : sstate->tab_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
459 drowley@postgresql.o 981 : 671 : lhs_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
6956 tgl@sss.pgh.pa.us 982 : 671 : sstate->cur_eq_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
983 : : /* we'll need the cross-type equality fns below, but not in sstate */
2414 984 : 671 : cross_eq_funcoids = (Oid *) palloc(ncols * sizeof(Oid));
985 : :
8463 986 : 671 : i = 1;
7382 987 [ + - + + : 1394 : foreach(l, oplist)
+ + ]
988 : : {
3261 989 : 723 : 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 : :
3288 andres@anarazel.de 996 [ - + ]: 723 : Assert(list_length(opexpr->args) == 2);
997 : :
998 : : /* Process lefthand argument */
999 : 723 : expr = (Expr *) linitial(opexpr->args);
7648 tgl@sss.pgh.pa.us 1000 : 723 : tle = makeTargetEntry(expr,
1001 : : i,
1002 : : NULL,
1003 : : false);
3288 andres@anarazel.de 1004 : 723 : lefttlist = lappend(lefttlist, tle);
1005 : :
1006 : : /* Process righthand argument */
1007 : 723 : expr = (Expr *) lsecond(opexpr->args);
7648 tgl@sss.pgh.pa.us 1008 : 723 : tle = makeTargetEntry(expr,
1009 : : i,
1010 : : NULL,
1011 : : false);
3288 andres@anarazel.de 1012 : 723 : righttlist = lappend(righttlist, tle);
1013 : :
1014 : : /* Lookup the equality function (potentially cross-type) */
2414 tgl@sss.pgh.pa.us 1015 : 723 : cross_eq_funcoids[i - 1] = opexpr->opfuncid;
6956 1016 : 723 : fmgr_info(opexpr->opfuncid, &sstate->cur_eq_funcs[i - 1]);
5475 1017 : 723 : fmgr_info_set_expr((Node *) opexpr, &sstate->cur_eq_funcs[i - 1]);
1018 : :
1019 : : /* Look up the equality function for the RHS type */
6977 1020 [ - + ]: 723 : if (!get_compatible_hash_operators(opexpr->opno,
1021 : : NULL, &rhs_eq_oper))
6977 tgl@sss.pgh.pa.us 1022 [ # # ]:UBC 0 : elog(ERROR, "could not find compatible hash operator for operator %u",
1023 : : opexpr->opno);
2414 tgl@sss.pgh.pa.us 1024 :CBC 723 : sstate->tab_eq_funcoids[i - 1] = get_opcode(rhs_eq_oper);
1025 : :
1026 : : /* Lookup the associated hash functions */
6984 1027 [ - + ]: 723 : if (!get_op_hash_functions(opexpr->opno,
1028 : : &left_hashfn, &right_hashfn))
8273 tgl@sss.pgh.pa.us 1029 [ # # ]:UBC 0 : elog(ERROR, "could not find hash function for hash operator %u",
1030 : : opexpr->opno);
459 drowley@postgresql.o 1031 :CBC 723 : fmgr_info(left_hashfn, &lhs_hash_funcs[i - 1]);
6956 tgl@sss.pgh.pa.us 1032 : 723 : fmgr_info(right_hashfn, &sstate->tab_hash_funcs[i - 1]);
1033 : :
1034 : : /* Set collation */
2550 peter@eisentraut.org 1035 : 723 : sstate->tab_collations[i - 1] = opexpr->inputcollid;
1036 : :
1037 : : /* keyColIdx is just column numbers 1..n */
2039 tgl@sss.pgh.pa.us 1038 : 723 : sstate->keyColIdx[i - 1] = i;
1039 : :
8463 1040 : 723 : 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 : : */
2672 andres@anarazel.de 1051 : 671 : tupDescLeft = ExecTypeFromTL(lefttlist);
2677 1052 : 671 : slot = ExecInitExtraTupleSlot(estate, tupDescLeft, &TTSOpsVirtual);
6956 tgl@sss.pgh.pa.us 1053 : 671 : sstate->projLeft = ExecBuildProjectionInfo(lefttlist,
1054 : : NULL,
1055 : : slot,
1056 : : parent,
1057 : : NULL);
1058 : :
2672 andres@anarazel.de 1059 : 671 : sstate->descRight = tupDescRight = ExecTypeFromTL(righttlist);
2677 1060 : 671 : slot = ExecInitExtraTupleSlot(estate, tupDescRight, &TTSOpsVirtual);
6956 tgl@sss.pgh.pa.us 1061 : 671 : sstate->projRight = ExecBuildProjectionInfo(righttlist,
1062 : : sstate->innerecontext,
1063 : : slot,
3288 andres@anarazel.de 1064 :ECB (559) : sstate->planstate,
1065 : : NULL);
1066 : :
1067 : : /* Build the ExprState for generating hash values */
459 drowley@postgresql.o 1068 :CBC 671 : 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 : : */
2950 andres@anarazel.de 1081 : 671 : sstate->cur_eq_comp = ExecBuildGroupingEqual(tupDescLeft, tupDescRight,
1082 : : &TTSOpsVirtual, &TTSOpsMinimalTuple,
1083 : : ncols,
1084 : 671 : sstate->keyColIdx,
1085 : : cross_eq_funcoids,
2550 peter@eisentraut.org 1086 : 671 : sstate->tab_collations,
1087 : : parent);
1088 : : }
1089 : :
6956 tgl@sss.pgh.pa.us 1090 : 24905 : 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
8255 bruce@momjian.us 1118 : 5502 : ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
1119 : : {
3288 andres@anarazel.de 1120 : 5502 : SubPlan *subplan = node->subplan;
8501 tgl@sss.pgh.pa.us 1121 : 5502 : PlanState *planstate = node->planstate;
8259 bruce@momjian.us 1122 : 5502 : SubLinkType subLinkType = subplan->subLinkType;
2767 rhodiumtoad@postgres 1123 : 5502 : EState *estate = planstate->state;
1124 : 5502 : ScanDirection dir = estate->es_direction;
1125 : : MemoryContext oldcontext;
1126 : : TupleTableSlot *slot;
1127 : : ListCell *l;
10244 bruce@momjian.us 1128 : 5502 : bool found = false;
4128 tgl@sss.pgh.pa.us 1129 : 5502 : ArrayBuildStateAny *astate = NULL;
1130 : :
8493 1131 [ + - - + ]: 5502 : if (subLinkType == ANY_SUBLINK ||
1132 : : subLinkType == ALL_SUBLINK)
8273 tgl@sss.pgh.pa.us 1133 [ # # ]:UBC 0 : elog(ERROR, "ANY/ALL subselect unsupported as initplan");
6371 tgl@sss.pgh.pa.us 1134 [ - + ]:CBC 5502 : if (subLinkType == CTE_SUBLINK)
6371 tgl@sss.pgh.pa.us 1135 [ # # ]:UBC 0 : elog(ERROR, "CTE subplans should not be executed via ExecSetParamPlan");
592 andres@anarazel.de 1136 [ + - - + ]:CBC 5502 : if (subplan->parParam || subplan->args)
1114 tgl@sss.pgh.pa.us 1137 [ # # ]:UBC 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 : : */
2767 rhodiumtoad@postgres 1143 :CBC 5502 : estate->es_direction = ForwardScanDirection;
1144 : :
1145 : : /* Initialize ArrayBuildStateAny in caller's context, if needed */
4128 tgl@sss.pgh.pa.us 1146 [ + + ]: 5502 : if (subLinkType == ARRAY_SUBLINK)
1147 : 61 : astate = initArrayResultAny(subplan->firstColType,
1148 : : CurrentMemoryContext, true);
1149 : :
1150 : : /*
1151 : : * Must switch to per-query memory context.
1152 : : */
6371 1153 : 5502 : 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 : : */
8501 1159 : 5502 : for (slot = ExecProcNode(planstate);
10244 bruce@momjian.us 1160 [ + + + + ]: 16677 : !TupIsNull(slot);
8501 tgl@sss.pgh.pa.us 1161 : 11175 : slot = ExecProcNode(planstate))
1162 : : {
7669 1163 : 11249 : TupleDesc tdesc = slot->tts_tupleDescriptor;
10257 vadim4o@yahoo.com 1164 : 11249 : int i = 1;
1165 : :
8493 tgl@sss.pgh.pa.us 1166 [ + + ]: 11249 : if (subLinkType == EXISTS_SUBLINK)
1167 : : {
1168 : : /* There can be only one setParam... */
7963 neilc@samurai.com 1169 : 66 : int paramid = linitial_int(subplan->setParam);
8435 tgl@sss.pgh.pa.us 1170 : 66 : ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1171 : :
10257 vadim4o@yahoo.com 1172 : 66 : prm->execPlan = NULL;
9377 tgl@sss.pgh.pa.us 1173 : 66 : prm->value = BoolGetDatum(true);
10257 vadim4o@yahoo.com 1174 : 66 : prm->isnull = false;
9617 tgl@sss.pgh.pa.us 1175 : 66 : found = true;
10257 vadim4o@yahoo.com 1176 : 66 : break;
1177 : : }
1178 : :
8377 tgl@sss.pgh.pa.us 1179 [ + + ]: 11183 : if (subLinkType == ARRAY_SUBLINK)
1180 : 6167 : {
1181 : : Datum dvalue;
1182 : : bool disnull;
1183 : :
1184 : 6167 : found = true;
1185 : : /* stash away current value */
3129 andres@anarazel.de 1186 [ - + ]: 6167 : Assert(subplan->firstColType == TupleDescAttr(tdesc, 0)->atttypid);
7669 tgl@sss.pgh.pa.us 1187 : 6167 : dvalue = slot_getattr(slot, 1, &disnull);
4128 1188 : 6167 : astate = accumArrayResultAny(astate, dvalue, disnull,
1189 : : subplan->firstColType, oldcontext);
1190 : : /* keep scanning subplan to collect all values */
8377 1191 : 6167 : continue;
1192 : : }
1193 : :
9617 1194 [ + + + + ]: 5016 : if (found &&
8493 1195 [ + + ]: 6 : (subLinkType == EXPR_SUBLINK ||
4288 1196 [ + - ]: 3 : subLinkType == MULTIEXPR_SUBLINK ||
1197 : : subLinkType == ROWCOMPARE_SUBLINK))
8273 1198 [ + - ]: 8 : ereport(ERROR,
1199 : : (errcode(ERRCODE_CARDINALITY_VIOLATION),
1200 : : errmsg("more than one row returned by a subquery used as an expression")));
1201 : :
9617 1202 : 5008 : 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 [ + + ]: 5008 : if (node->curTuple)
9586 JanWieck@Yahoo.com 1211 : 260 : heap_freetuple(node->curTuple);
2676 andres@anarazel.de 1212 : 5008 : node->curTuple = ExecCopySlotHeapTuple(slot);
1213 : :
1214 : : /*
1215 : : * Now set all the setParam params from the columns of the tuple
1216 : : */
7963 neilc@samurai.com 1217 [ + - + + : 10034 : foreach(l, subplan->setParam)
+ + ]
1218 : : {
7959 1219 : 5026 : int paramid = lfirst_int(l);
8435 tgl@sss.pgh.pa.us 1220 : 5026 : ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1221 : :
10257 vadim4o@yahoo.com 1222 : 5026 : prm->execPlan = NULL;
7669 tgl@sss.pgh.pa.us 1223 : 5026 : prm->value = heap_getattr(node->curTuple, i, tdesc,
1224 : : &(prm->isnull));
10257 vadim4o@yahoo.com 1225 : 5026 : i++;
1226 : : }
1227 : : }
1228 : :
6776 tgl@sss.pgh.pa.us 1229 [ + + ]: 5494 : if (subLinkType == ARRAY_SUBLINK)
1230 : : {
1231 : : /* There can be only one setParam... */
1232 : 61 : int paramid = linitial_int(subplan->setParam);
1233 : 61 : 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 : : */
5015 1240 [ - + ]: 61 : if (node->curArray != PointerGetDatum(NULL))
5015 tgl@sss.pgh.pa.us 1241 :UBC 0 : pfree(DatumGetPointer(node->curArray));
4128 tgl@sss.pgh.pa.us 1242 :CBC 61 : node->curArray = makeArrayResultAny(astate,
1243 : : econtext->ecxt_per_query_memory,
1244 : : true);
5015 1245 : 61 : prm->execPlan = NULL;
1246 : 61 : prm->value = node->curArray;
6776 1247 : 61 : prm->isnull = false;
1248 : : }
1249 [ + + ]: 5433 : else if (!found)
1250 : : {
8493 1251 [ + + ]: 367 : if (subLinkType == EXISTS_SUBLINK)
1252 : : {
1253 : : /* There can be only one setParam... */
7963 neilc@samurai.com 1254 : 336 : int paramid = linitial_int(subplan->setParam);
8435 tgl@sss.pgh.pa.us 1255 : 336 : ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1256 : :
10257 vadim4o@yahoo.com 1257 : 336 : prm->execPlan = NULL;
9377 tgl@sss.pgh.pa.us 1258 : 336 : prm->value = BoolGetDatum(false);
10257 vadim4o@yahoo.com 1259 : 336 : prm->isnull = false;
1260 : : }
1261 : : else
1262 : : {
1263 : : /* For other sublink types, set all the output params to NULL */
7963 neilc@samurai.com 1264 [ + - + + : 65 : foreach(l, subplan->setParam)
+ + ]
1265 : : {
7959 1266 : 34 : int paramid = lfirst_int(l);
8435 tgl@sss.pgh.pa.us 1267 : 34 : ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1268 : :
10257 vadim4o@yahoo.com 1269 : 34 : prm->execPlan = NULL;
9377 tgl@sss.pgh.pa.us 1270 : 34 : prm->value = (Datum) 0;
10257 vadim4o@yahoo.com 1271 : 34 : prm->isnull = true;
1272 : : }
1273 : : }
1274 : : }
1275 : :
9292 tgl@sss.pgh.pa.us 1276 : 5494 : MemoryContextSwitchTo(oldcontext);
1277 : :
1278 : : /* restore scan direction */
2767 rhodiumtoad@postgres 1279 : 5494 : estate->es_direction = dir;
10257 vadim4o@yahoo.com 1280 : 5494 : }
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
2738 tgl@sss.pgh.pa.us 1294 : 729 : ExecSetParamPlanMulti(const Bitmapset *params, ExprContext *econtext)
1295 : : {
1296 : : int paramid;
1297 : :
1298 : 729 : paramid = -1;
1299 [ + + ]: 971 : while ((paramid = bms_next_member(params, paramid)) >= 0)
1300 : : {
1301 : 242 : ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
1302 : :
1303 [ + + ]: 242 : if (prm->execPlan != NULL)
1304 : : {
1305 : : /* Parameter not evaluated yet, so go do it */
1306 : 17 : ExecSetParamPlan(prm->execPlan, econtext);
1307 : : /* ExecSetParamPlan should have processed this param... */
1308 [ - + ]: 17 : Assert(prm->execPlan == NULL);
1309 : : }
1310 : : }
1311 : 729 : }
1312 : :
1313 : : /*
1314 : : * Mark an initplan as needing recalculation
1315 : : */
1316 : : void
8255 bruce@momjian.us 1317 : 691 : ExecReScanSetParamPlan(SubPlanState *node, PlanState *parent)
1318 : : {
8501 tgl@sss.pgh.pa.us 1319 : 691 : PlanState *planstate = node->planstate;
3288 andres@anarazel.de 1320 : 691 : SubPlan *subplan = node->subplan;
8493 tgl@sss.pgh.pa.us 1321 : 691 : EState *estate = parent->state;
1322 : : ListCell *l;
1323 : :
1324 : : /* sanity checks */
8435 1325 [ - + ]: 691 : if (subplan->parParam != NIL)
8273 tgl@sss.pgh.pa.us 1326 [ # # ]:UBC 0 : elog(ERROR, "direct correlated subquery unsupported as initplan");
8435 tgl@sss.pgh.pa.us 1327 [ - + ]:CBC 691 : if (subplan->setParam == NIL)
8273 tgl@sss.pgh.pa.us 1328 [ # # ]:UBC 0 : elog(ERROR, "setParam list of initplan is empty");
8435 tgl@sss.pgh.pa.us 1329 [ - + ]:CBC 691 : if (bms_is_empty(planstate->plan->extParam))
8273 tgl@sss.pgh.pa.us 1330 [ # # ]:UBC 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 : : */
7963 neilc@samurai.com 1344 [ + - + + :CBC 1382 : foreach(l, subplan->setParam)
+ + ]
1345 : : {
7959 1346 : 691 : int paramid = lfirst_int(l);
8435 tgl@sss.pgh.pa.us 1347 : 691 : ParamExecData *prm = &(estate->es_param_exec_vals[paramid]);
1348 : :
6371 1349 [ + + ]: 691 : if (subplan->subLinkType != CTE_SUBLINK)
1350 : 413 : prm->execPlan = node;
1351 : :
8435 1352 : 691 : parent->chgParam = bms_add_member(parent->chgParam, paramid);
1353 : : }
10257 vadim4o@yahoo.com 1354 : 691 : }
|
