Debian Codegraph @

src/backend/executor/execExpr.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * execExpr.c
4 * Expression evaluation infrastructure.
5 *
6 * During executor startup, we compile each expression tree (which has
7 * previously been processed by the parser and planner) into an ExprState,
8 * using ExecInitExpr() et al. This converts the tree into a flat array
9 * of ExprEvalSteps, which may be thought of as instructions in a program.
10 * At runtime, we'll execute steps, starting with the first, until we reach
11 * an EEOP_DONE_{RETURN|NO_RETURN} opcode.
12 *
13 * This file contains the "compilation" logic. It is independent of the
14 * specific execution technology we use (switch statement, computed goto,
15 * JIT compilation, etc).
16 *
17 * See src/backend/executor/README for some background, specifically the
18 * "Expression Trees and ExprState nodes", "Expression Initialization",
19 * and "Expression Evaluation" sections.
20 *
21 *
22 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
23 * Portions Copyright (c) 1994, Regents of the University of California
24 *
25 *
26 * IDENTIFICATION
27 * src/backend/executor/execExpr.c
28 *
29 *-------------------------------------------------------------------------
30 */
31 #include "postgres.h"
32
33 #include "access/nbtree.h"
34 #include "catalog/objectaccess.h"
35 #include "catalog/pg_proc.h"
36 #include "catalog/pg_type.h"
37 #include "executor/execExpr.h"
38 #include "executor/nodeSubplan.h"
39 #include "funcapi.h"
40 #include "jit/jit.h"
41 #include "miscadmin.h"
42 #include "nodes/makefuncs.h"
43 #include "nodes/nodeFuncs.h"
44 #include "nodes/subscripting.h"
45 #include "optimizer/optimizer.h"
46 #include "pgstat.h"
47 #include "utils/acl.h"
48 #include "utils/array.h"
49 #include "utils/builtins.h"
50 #include "utils/jsonfuncs.h"
51 #include "utils/jsonpath.h"
52 #include "utils/lsyscache.h"
53 #include "utils/typcache.h"
54
55
56 typedef struct ExprSetupInfo
57 {
58 /*
59 * Highest attribute numbers fetched from inner/outer/scan/old/new tuple
60 * slots:
61 */
62 AttrNumber last_inner;
63 AttrNumber last_outer;
64 AttrNumber last_scan;
65 AttrNumber last_old;
66 AttrNumber last_new;
67 /* MULTIEXPR SubPlan nodes appearing in the expression: */
68 List *multiexpr_subplans;
69 } ExprSetupInfo;
70
71 static void ExecReadyExpr(ExprState *state);
72 static void ExecInitExprRec(Expr *node, ExprState *state,
73 Datum *resv, bool *resnull);
74 static void ExecInitFunc(ExprEvalStep *scratch, Expr *node, List *args,
75 Oid funcid, Oid inputcollid,
76 ExprState *state);
77 static void ExecInitSubPlanExpr(SubPlan *subplan,
78 ExprState *state,
79 Datum *resv, bool *resnull);
80 static void ExecCreateExprSetupSteps(ExprState *state, Node *node);
81 static void ExecPushExprSetupSteps(ExprState *state, ExprSetupInfo *info);
82 static bool expr_setup_walker(Node *node, ExprSetupInfo *info);
83 static bool ExecComputeSlotInfo(ExprState *state, ExprEvalStep *op);
84 static void ExecInitWholeRowVar(ExprEvalStep *scratch, Var *variable,
85 ExprState *state);
86 static void ExecInitSubscriptingRef(ExprEvalStep *scratch,
87 SubscriptingRef *sbsref,
88 ExprState *state,
89 Datum *resv, bool *resnull);
90 static bool isAssignmentIndirectionExpr(Expr *expr);
91 static void ExecInitCoerceToDomain(ExprEvalStep *scratch, CoerceToDomain *ctest,
92 ExprState *state,
93 Datum *resv, bool *resnull);
94 static void ExecBuildAggTransCall(ExprState *state, AggState *aggstate,
95 ExprEvalStep *scratch,
96 FunctionCallInfo fcinfo, AggStatePerTrans pertrans,
97 int transno, int setno, int setoff, bool ishash,
98 bool nullcheck);
99 static void ExecInitJsonExpr(JsonExpr *jsexpr, ExprState *state,
100 Datum *resv, bool *resnull,
101 ExprEvalStep *scratch);
102 static void ExecInitJsonCoercion(ExprState *state, JsonReturning *returning,
103 ErrorSaveContext *escontext, bool omit_quotes,
104 bool exists_coerce,
105 Datum *resv, bool *resnull);
106
107
108 /*
109 * ExecInitExpr: prepare an expression tree for execution
110 *
111 * This function builds and returns an ExprState implementing the given
112 * Expr node tree. The return ExprState can then be handed to ExecEvalExpr
113 * for execution. Because the Expr tree itself is read-only as far as
114 * ExecInitExpr and ExecEvalExpr are concerned, several different executions
115 * of the same plan tree can occur concurrently. (But note that an ExprState
116 * does mutate at runtime, so it can't be re-used concurrently.)
117 *
118 * This must be called in a memory context that will last as long as repeated
119 * executions of the expression are needed. Typically the context will be
120 * the same as the per-query context of the associated ExprContext.
121 *
122 * Any Aggref, WindowFunc, or SubPlan nodes found in the tree are added to
123 * the lists of such nodes held by the parent PlanState.
124 *
125 * Note: there is no ExecEndExpr function; we assume that any resource
126 * cleanup needed will be handled by just releasing the memory context
127 * in which the state tree is built. Functions that require additional
128 * cleanup work can register a shutdown callback in the ExprContext.
129 *
130 * 'node' is the root of the expression tree to compile.
131 * 'parent' is the PlanState node that owns the expression.
132 *
133 * 'parent' may be NULL if we are preparing an expression that is not
134 * associated with a plan tree. (If so, it can't have aggs or subplans.)
135 * Such cases should usually come through ExecPrepareExpr, not directly here.
136 *
137 * Also, if 'node' is NULL, we just return NULL. This is convenient for some
138 * callers that may or may not have an expression that needs to be compiled.
139 * Note that a NULL ExprState pointer *cannot* be handed to ExecEvalExpr,
140 * although ExecQual and ExecCheck will accept one (and treat it as "true").
141 */
142 ExprState *
143 ExecInitExpr(Expr *node, PlanState *parent)
144 {
145 ExprState *state;
146 ExprEvalStep scratch = {0};
147
148 /* Special case: NULL expression produces a NULL ExprState pointer */
149 if (node == NULL)
150 return NULL;
151
152 /* Initialize ExprState with empty step list */
153 state = makeNode(ExprState);
154 state->expr = node;
155 state->parent = parent;
156 state->ext_params = NULL;
157
158 /* Insert setup steps as needed */
159 ExecCreateExprSetupSteps(state, (Node *) node);
160
161 /* Compile the expression proper */
162 ExecInitExprRec(node, state, &state->resvalue, &state->resnull);
163
164 /* Finally, append a DONE step */
165 scratch.opcode = EEOP_DONE_RETURN;
166 ExprEvalPushStep(state, &scratch);
167
168 ExecReadyExpr(state);
169
170 return state;
171 }
172
173 /*
174 * ExecInitExprWithParams: prepare a standalone expression tree for execution
175 *
176 * This is the same as ExecInitExpr, except that there is no parent PlanState,
177 * and instead we may have a ParamListInfo describing PARAM_EXTERN Params.
178 */
179 ExprState *
180 ExecInitExprWithParams(Expr *node, ParamListInfo ext_params)
181 {
182 ExprState *state;
183 ExprEvalStep scratch = {0};
184
185 /* Special case: NULL expression produces a NULL ExprState pointer */
186 if (node == NULL)
187 return NULL;
188
189 /* Initialize ExprState with empty step list */
190 state = makeNode(ExprState);
191 state->expr = node;
192 state->parent = NULL;
193 state->ext_params = ext_params;
194
195 /* Insert setup steps as needed */
196 ExecCreateExprSetupSteps(state, (Node *) node);
197
198 /* Compile the expression proper */
199 ExecInitExprRec(node, state, &state->resvalue, &state->resnull);
200
201 /* Finally, append a DONE step */
202 scratch.opcode = EEOP_DONE_RETURN;
203 ExprEvalPushStep(state, &scratch);
204
205 ExecReadyExpr(state);
206
207 return state;
208 }
209
210 /*
211 * ExecInitQual: prepare a qual for execution by ExecQual
212 *
213 * Prepares for the evaluation of a conjunctive boolean expression (qual list
214 * with implicit AND semantics) that returns true if none of the
215 * subexpressions are false.
216 *
217 * We must return true if the list is empty. Since that's a very common case,
218 * we optimize it a bit further by translating to a NULL ExprState pointer
219 * rather than setting up an ExprState that computes constant TRUE. (Some
220 * especially hot-spot callers of ExecQual detect this and avoid calling
221 * ExecQual at all.)
222 *
223 * If any of the subexpressions yield NULL, then the result of the conjunction
224 * is false. This makes ExecQual primarily useful for evaluating WHERE
225 * clauses, since SQL specifies that tuples with null WHERE results do not
226 * get selected.
227 */
228 ExprState *
229 ExecInitQual(List *qual, PlanState *parent)
230 {
231 ExprState *state;
232 ExprEvalStep scratch = {0};
233 List *adjust_jumps = NIL;
234
235 /* short-circuit (here and in ExecQual) for empty restriction list */
236 if (qual == NIL)
237 return NULL;
238
239 Assert(IsA(qual, List));
240
241 state = makeNode(ExprState);
242 state->expr = (Expr *) qual;
243 state->parent = parent;
244 state->ext_params = NULL;
245
246 /* mark expression as to be used with ExecQual() */
247 state->flags = EEO_FLAG_IS_QUAL;
248
249 /* Insert setup steps as needed */
250 ExecCreateExprSetupSteps(state, (Node *) qual);
251
252 /*
253 * ExecQual() needs to return false for an expression returning NULL. That
254 * allows us to short-circuit the evaluation the first time a NULL is
255 * encountered. As qual evaluation is a hot-path this warrants using a
256 * special opcode for qual evaluation that's simpler than BOOL_AND (which
257 * has more complex NULL handling).
258 */
259 scratch.opcode = EEOP_QUAL;
260
261 /*
262 * We can use ExprState's resvalue/resnull as target for each qual expr.
263 */
264 scratch.resvalue = &state->resvalue;
265 scratch.resnull = &state->resnull;
266
267 foreach_ptr(Expr, node, qual)
268 {
269 /* first evaluate expression */
270 ExecInitExprRec(node, state, &state->resvalue, &state->resnull);
271
272 /* then emit EEOP_QUAL to detect if it's false (or null) */
273 scratch.d.qualexpr.jumpdone = -1;
274 ExprEvalPushStep(state, &scratch);
275 adjust_jumps = lappend_int(adjust_jumps,
276 state->steps_len - 1);
277 }
278
279 /* adjust jump targets */
280 foreach_int(jump, adjust_jumps)
281 {
282 ExprEvalStep *as = &state->steps[jump];
283
284 Assert(as->opcode == EEOP_QUAL);
285 Assert(as->d.qualexpr.jumpdone == -1);
286 as->d.qualexpr.jumpdone = state->steps_len;
287 }
288
289 /*
290 * At the end, we don't need to do anything more. The last qual expr must
291 * have yielded TRUE, and since its result is stored in the desired output
292 * location, we're done.
293 */
294 scratch.opcode = EEOP_DONE_RETURN;
295 ExprEvalPushStep(state, &scratch);
296
297 ExecReadyExpr(state);
298
299 return state;
300 }
301
302 /*
303 * ExecInitCheck: prepare a check constraint for execution by ExecCheck
304 *
305 * This is much like ExecInitQual/ExecQual, except that a null result from
306 * the conjunction is treated as TRUE. This behavior is appropriate for
307 * evaluating CHECK constraints, since SQL specifies that NULL constraint
308 * conditions are not failures.
309 *
310 * Note that like ExecInitQual, this expects input in implicit-AND format.
311 * Users of ExecCheck that have expressions in normal explicit-AND format
312 * can just apply ExecInitExpr to produce suitable input for ExecCheck.
313 */
314 ExprState *
315 ExecInitCheck(List *qual, PlanState *parent)
316 {
317 /* short-circuit (here and in ExecCheck) for empty restriction list */
318 if (qual == NIL)
319 return NULL;
320
321 Assert(IsA(qual, List));
322
323 /*
324 * Just convert the implicit-AND list to an explicit AND (if there's more
325 * than one entry), and compile normally. Unlike ExecQual, we can't
326 * short-circuit on NULL results, so the regular AND behavior is needed.
327 */
328 return ExecInitExpr(make_ands_explicit(qual), parent);
329 }
330
331 /*
332 * Call ExecInitExpr() on a list of expressions, return a list of ExprStates.
333 */
334 List *
335 ExecInitExprList(List *nodes, PlanState *parent)
336 {
337 List *result = NIL;
338 ListCell *lc;
339
340 foreach(lc, nodes)
341 {
342 Expr *e = lfirst(lc);
343
344 result = lappend(result, ExecInitExpr(e, parent));
345 }
346
347 return result;
348 }
349
350 /*
351 * ExecBuildProjectionInfo
352 *
353 * Build a ProjectionInfo node for evaluating the given tlist in the given
354 * econtext, and storing the result into the tuple slot. (Caller must have
355 * ensured that tuple slot has a descriptor matching the tlist!)
356 *
357 * inputDesc can be NULL, but if it is not, we check to see whether simple
358 * Vars in the tlist match the descriptor. It is important to provide
359 * inputDesc for relation-scan plan nodes, as a cross check that the relation
360 * hasn't been changed since the plan was made. At higher levels of a plan,
361 * there is no need to recheck.
362 *
363 * This is implemented by internally building an ExprState that performs the
364 * whole projection in one go.
365 *
366 * Caution: before PG v10, the targetList was a list of ExprStates; now it
367 * should be the planner-created targetlist, since we do the compilation here.
368 */
369 ProjectionInfo *
370 ExecBuildProjectionInfo(List *targetList,
371 ExprContext *econtext,
372 TupleTableSlot *slot,
373 PlanState *parent,
374 TupleDesc inputDesc)
375 {
376 ProjectionInfo *projInfo = makeNode(ProjectionInfo);
377 ExprState *state;
378 ExprEvalStep scratch = {0};
379 ListCell *lc;
380
381 projInfo->pi_exprContext = econtext;
382 /* We embed ExprState into ProjectionInfo instead of doing extra palloc */
383 projInfo->pi_state.type = T_ExprState;
384 state = &projInfo->pi_state;
385 state->expr = (Expr *) targetList;
386 state->parent = parent;
387 state->ext_params = NULL;
388
389 state->resultslot = slot;
390
391 /* Insert setup steps as needed */
392 ExecCreateExprSetupSteps(state, (Node *) targetList);
393
394 /* Now compile each tlist column */
395 foreach(lc, targetList)
396 {
397 TargetEntry *tle = lfirst_node(TargetEntry, lc);
398 Var *variable = NULL;
399 AttrNumber attnum = 0;
400 bool isSafeVar = false;
401
402 /*
403 * If tlist expression is a safe non-system Var, use the fast-path
404 * ASSIGN_*_VAR opcodes. "Safe" means that we don't need to apply
405 * CheckVarSlotCompatibility() during plan startup. If a source slot
406 * was provided, we make the equivalent tests here; if a slot was not
407 * provided, we assume that no check is needed because we're dealing
408 * with a non-relation-scan-level expression.
409 */
410 if (tle->expr != NULL &&
411 IsA(tle->expr, Var) &&
412 ((Var *) tle->expr)->varattno > 0)
413 {
414 /* Non-system Var, but how safe is it? */
415 variable = (Var *) tle->expr;
416 attnum = variable->varattno;
417
418 if (inputDesc == NULL)
419 isSafeVar = true; /* can't check, just assume OK */
420 else if (attnum <= inputDesc->natts)
421 {
422 Form_pg_attribute attr = TupleDescAttr(inputDesc, attnum - 1);
423
424 /*
425 * If user attribute is dropped or has a type mismatch, don't
426 * use ASSIGN_*_VAR. Instead let the normal expression
427 * machinery handle it (which'll possibly error out).
428 */
429 if (!attr->attisdropped && variable->vartype == attr->atttypid)
430 {
431 isSafeVar = true;
432 }
433 }
434 }
435
436 if (isSafeVar)
437 {
438 /* Fast-path: just generate an EEOP_ASSIGN_*_VAR step */
439 switch (variable->varno)
440 {
441 case INNER_VAR:
442 /* get the tuple from the inner node */
443 scratch.opcode = EEOP_ASSIGN_INNER_VAR;
444 break;
445
446 case OUTER_VAR:
447 /* get the tuple from the outer node */
448 scratch.opcode = EEOP_ASSIGN_OUTER_VAR;
449 break;
450
451 /* INDEX_VAR is handled by default case */
452
453 default:
454
455 /*
456 * Get the tuple from the relation being scanned, or the
457 * old/new tuple slot, if old/new values were requested.
458 */
459 switch (variable->varreturningtype)
460 {
461 case VAR_RETURNING_DEFAULT:
462 scratch.opcode = EEOP_ASSIGN_SCAN_VAR;
463 break;
464 case VAR_RETURNING_OLD:
465 scratch.opcode = EEOP_ASSIGN_OLD_VAR;
466 state->flags |= EEO_FLAG_HAS_OLD;
467 break;
468 case VAR_RETURNING_NEW:
469 scratch.opcode = EEOP_ASSIGN_NEW_VAR;
470 state->flags |= EEO_FLAG_HAS_NEW;
471 break;
472 }
473 break;
474 }
475
476 scratch.d.assign_var.attnum = attnum - 1;
477 scratch.d.assign_var.resultnum = tle->resno - 1;
478 ExprEvalPushStep(state, &scratch);
479 }
480 else
481 {
482 /*
483 * Otherwise, compile the column expression normally.
484 *
485 * We can't tell the expression to evaluate directly into the
486 * result slot, as the result slot (and the exprstate for that
487 * matter) can change between executions. We instead evaluate
488 * into the ExprState's resvalue/resnull and then move.
489 */
490 ExecInitExprRec(tle->expr, state,
491 &state->resvalue, &state->resnull);
492
493 /*
494 * Column might be referenced multiple times in upper nodes, so
495 * force value to R/O - but only if it could be an expanded datum.
496 */
497 if (get_typlen(exprType((Node *) tle->expr)) == -1)
498 scratch.opcode = EEOP_ASSIGN_TMP_MAKE_RO;
499 else
500 scratch.opcode = EEOP_ASSIGN_TMP;
501 scratch.d.assign_tmp.resultnum = tle->resno - 1;
502 ExprEvalPushStep(state, &scratch);
503 }
504 }
505
506 scratch.opcode = EEOP_DONE_NO_RETURN;
507 ExprEvalPushStep(state, &scratch);
508
509 ExecReadyExpr(state);
510
511 return projInfo;
512 }
513
514 /*
515 * ExecBuildUpdateProjection
516 *
517 * Build a ProjectionInfo node for constructing a new tuple during UPDATE.
518 * The projection will be executed in the given econtext and the result will
519 * be stored into the given tuple slot. (Caller must have ensured that tuple
520 * slot has a descriptor matching the target rel!)
521 *
522 * When evalTargetList is false, targetList contains the UPDATE ... SET
523 * expressions that have already been computed by a subplan node; the values
524 * from this tlist are assumed to be available in the "outer" tuple slot.
525 * When evalTargetList is true, targetList contains the UPDATE ... SET
526 * expressions that must be computed (which could contain references to
527 * the outer, inner, or scan tuple slots).
528 *
529 * In either case, targetColnos contains a list of the target column numbers
530 * corresponding to the non-resjunk entries of targetList. The tlist values
531 * are assigned into these columns of the result tuple slot. Target columns
532 * not listed in targetColnos are filled from the UPDATE's old tuple, which
533 * is assumed to be available in the "scan" tuple slot.
534 *
535 * targetList can also contain resjunk columns. These must be evaluated
536 * if evalTargetList is true, but their values are discarded.
537 *
538 * relDesc must describe the relation we intend to update.
539 *
540 * This is basically a specialized variant of ExecBuildProjectionInfo.
541 * However, it also performs sanity checks equivalent to ExecCheckPlanOutput.
542 * Since we never make a normal tlist equivalent to the whole
543 * tuple-to-be-assigned, there is no convenient way to apply
544 * ExecCheckPlanOutput, so we must do our safety checks here.
545 */
546 ProjectionInfo *
547 ExecBuildUpdateProjection(List *targetList,
548 bool evalTargetList,
549 List *targetColnos,
550 TupleDesc relDesc,
551 ExprContext *econtext,
552 TupleTableSlot *slot,
553 PlanState *parent)
554 {
555 ProjectionInfo *projInfo = makeNode(ProjectionInfo);
556 ExprState *state;
557 int nAssignableCols;
558 bool sawJunk;
559 Bitmapset *assignedCols;
560 ExprSetupInfo deform = {0, 0, 0, 0, 0, NIL};
561 ExprEvalStep scratch = {0};
562 int outerattnum;
563 ListCell *lc,
564 *lc2;
565
566 projInfo->pi_exprContext = econtext;
567 /* We embed ExprState into ProjectionInfo instead of doing extra palloc */
568 projInfo->pi_state.type = T_ExprState;
569 state = &projInfo->pi_state;
570 if (evalTargetList)
571 state->expr = (Expr *) targetList;
572 else
573 state->expr = NULL; /* not used */
574 state->parent = parent;
575 state->ext_params = NULL;
576
577 state->resultslot = slot;
578
579 /*
580 * Examine the targetList to see how many non-junk columns there are, and
581 * to verify that the non-junk columns come before the junk ones.
582 */
583 nAssignableCols = 0;
584 sawJunk = false;
585 foreach(lc, targetList)
586 {
587 TargetEntry *tle = lfirst_node(TargetEntry, lc);
588
589 if (tle->resjunk)
590 sawJunk = true;
591 else
592 {
593 if (sawJunk)
594 elog(ERROR, "subplan target list is out of order");
595 nAssignableCols++;
596 }
597 }
598
599 /* We should have one targetColnos entry per non-junk column */
600 if (nAssignableCols != list_length(targetColnos))
601 elog(ERROR, "targetColnos does not match subplan target list");
602
603 /*
604 * Build a bitmapset of the columns in targetColnos. (We could just use
605 * list_member_int() tests, but that risks O(N^2) behavior with many
606 * columns.)
607 */
608 assignedCols = NULL;
609 foreach(lc, targetColnos)
610 {
611 AttrNumber targetattnum = lfirst_int(lc);
612
613 assignedCols = bms_add_member(assignedCols, targetattnum);
614 }
615
616 /*
617 * We need to insert EEOP_*_FETCHSOME steps to ensure the input tuples are
618 * sufficiently deconstructed. The scan tuple must be deconstructed at
619 * least as far as the last old column we need.
620 */
621 for (int attnum = relDesc->natts; attnum > 0; attnum--)
622 {
623 CompactAttribute *attr = TupleDescCompactAttr(relDesc, attnum - 1);
624
625 if (attr->attisdropped)
626 continue;
627 if (bms_is_member(attnum, assignedCols))
628 continue;
629 deform.last_scan = attnum;
630 break;
631 }
632
633 /*
634 * If we're actually evaluating the tlist, incorporate its input
635 * requirements too; otherwise, we'll just need to fetch the appropriate
636 * number of columns of the "outer" tuple.
637 */
638 if (evalTargetList)
639 expr_setup_walker((Node *) targetList, &deform);
640 else
641 deform.last_outer = nAssignableCols;
642
643 ExecPushExprSetupSteps(state, &deform);
644
645 /*
646 * Now generate code to evaluate the tlist's assignable expressions or
647 * fetch them from the outer tuple, incidentally validating that they'll
648 * be of the right data type. The checks above ensure that the forboth()
649 * will iterate over exactly the non-junk columns. Note that we don't
650 * bother evaluating any remaining resjunk columns.
651 */
652 outerattnum = 0;
653 forboth(lc, targetList, lc2, targetColnos)
654 {
655 TargetEntry *tle = lfirst_node(TargetEntry, lc);
656 AttrNumber targetattnum = lfirst_int(lc2);
657 Form_pg_attribute attr;
658
659 Assert(!tle->resjunk);
660
661 /*
662 * Apply sanity checks comparable to ExecCheckPlanOutput().
663 */
664 if (targetattnum <= 0 || targetattnum > relDesc->natts)
665 ereport(ERROR,
666 (errcode(ERRCODE_DATATYPE_MISMATCH),
667 errmsg("table row type and query-specified row type do not match"),
668 errdetail("Query has too many columns.")));
669 attr = TupleDescAttr(relDesc, targetattnum - 1);
670
671 if (attr->attisdropped)
672 ereport(ERROR,
673 (errcode(ERRCODE_DATATYPE_MISMATCH),
674 errmsg("table row type and query-specified row type do not match"),
675 errdetail("Query provides a value for a dropped column at ordinal position %d.",
676 targetattnum)));
677 if (exprType((Node *) tle->expr) != attr->atttypid)
678 ereport(ERROR,
679 (errcode(ERRCODE_DATATYPE_MISMATCH),
680 errmsg("table row type and query-specified row type do not match"),
681 errdetail("Table has type %s at ordinal position %d, but query expects %s.",
682 format_type_be(attr->atttypid),
683 targetattnum,
684 format_type_be(exprType((Node *) tle->expr)))));
685
686 /* OK, generate code to perform the assignment. */
687 if (evalTargetList)
688 {
689 /*
690 * We must evaluate the TLE's expression and assign it. We do not
691 * bother jumping through hoops for "safe" Vars like
692 * ExecBuildProjectionInfo does; this is a relatively less-used
693 * path and it doesn't seem worth expending code for that.
694 */
695 ExecInitExprRec(tle->expr, state,
696 &state->resvalue, &state->resnull);
697 /* Needn't worry about read-only-ness here, either. */
698 scratch.opcode = EEOP_ASSIGN_TMP;
699 scratch.d.assign_tmp.resultnum = targetattnum - 1;
700 ExprEvalPushStep(state, &scratch);
701 }
702 else
703 {
704 /* Just assign from the outer tuple. */
705 scratch.opcode = EEOP_ASSIGN_OUTER_VAR;
706 scratch.d.assign_var.attnum = outerattnum;
707 scratch.d.assign_var.resultnum = targetattnum - 1;
708 ExprEvalPushStep(state, &scratch);
709 }
710 outerattnum++;
711 }
712
713 /*
714 * Now generate code to copy over any old columns that were not assigned
715 * to, and to ensure that dropped columns are set to NULL.
716 */
717 for (int attnum = 1; attnum <= relDesc->natts; attnum++)
718 {
719 CompactAttribute *attr = TupleDescCompactAttr(relDesc, attnum - 1);
720
721 if (attr->attisdropped)
722 {
723 /* Put a null into the ExprState's resvalue/resnull ... */
724 scratch.opcode = EEOP_CONST;
725 scratch.resvalue = &state->resvalue;
726 scratch.resnull = &state->resnull;
727 scratch.d.constval.value = (Datum) 0;
728 scratch.d.constval.isnull = true;
729 ExprEvalPushStep(state, &scratch);
730 /* ... then assign it to the result slot */
731 scratch.opcode = EEOP_ASSIGN_TMP;
732 scratch.d.assign_tmp.resultnum = attnum - 1;
733 ExprEvalPushStep(state, &scratch);
734 }
735 else if (!bms_is_member(attnum, assignedCols))
736 {
737 /* Certainly the right type, so needn't check */
738 scratch.opcode = EEOP_ASSIGN_SCAN_VAR;
739 scratch.d.assign_var.attnum = attnum - 1;
740 scratch.d.assign_var.resultnum = attnum - 1;
741 ExprEvalPushStep(state, &scratch);
742 }
743 }
744
745 scratch.opcode = EEOP_DONE_NO_RETURN;
746 ExprEvalPushStep(state, &scratch);
747
748 ExecReadyExpr(state);
749
750 return projInfo;
751 }
752
753 /*
754 * ExecPrepareExpr --- initialize for expression execution outside a normal
755 * Plan tree context.
756 *
757 * This differs from ExecInitExpr in that we don't assume the caller is
758 * already running in the EState's per-query context. Also, we run the
759 * passed expression tree through expression_planner() to prepare it for
760 * execution. (In ordinary Plan trees the regular planning process will have
761 * made the appropriate transformations on expressions, but for standalone
762 * expressions this won't have happened.)
763 */
764 ExprState *
765 ExecPrepareExpr(Expr *node, EState *estate)
766 {
767 ExprState *result;
768 MemoryContext oldcontext;
769
770 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
771
772 node = expression_planner(node);
773
774 result = ExecInitExpr(node, NULL);
775
776 MemoryContextSwitchTo(oldcontext);
777
778 return result;
779 }
780
781 /*
782 * ExecPrepareQual --- initialize for qual execution outside a normal
783 * Plan tree context.
784 *
785 * This differs from ExecInitQual in that we don't assume the caller is
786 * already running in the EState's per-query context. Also, we run the
787 * passed expression tree through expression_planner() to prepare it for
788 * execution. (In ordinary Plan trees the regular planning process will have
789 * made the appropriate transformations on expressions, but for standalone
790 * expressions this won't have happened.)
791 */
792 ExprState *
793 ExecPrepareQual(List *qual, EState *estate)
794 {
795 ExprState *result;
796 MemoryContext oldcontext;
797
798 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
799
800 qual = (List *) expression_planner((Expr *) qual);
801
802 result = ExecInitQual(qual, NULL);
803
804 MemoryContextSwitchTo(oldcontext);
805
806 return result;
807 }
808
809 /*
810 * ExecPrepareCheck -- initialize check constraint for execution outside a
811 * normal Plan tree context.
812 *
813 * See ExecPrepareExpr() and ExecInitCheck() for details.
814 */
815 ExprState *
816 ExecPrepareCheck(List *qual, EState *estate)
817 {
818 ExprState *result;
819 MemoryContext oldcontext;
820
821 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
822
823 qual = (List *) expression_planner((Expr *) qual);
824
825 result = ExecInitCheck(qual, NULL);
826
827 MemoryContextSwitchTo(oldcontext);
828
829 return result;
830 }
831
832 /*
833 * Call ExecPrepareExpr() on each member of a list of Exprs, and return
834 * a list of ExprStates.
835 *
836 * See ExecPrepareExpr() for details.
837 */
838 List *
839 ExecPrepareExprList(List *nodes, EState *estate)
840 {
841 List *result = NIL;
842 MemoryContext oldcontext;
843 ListCell *lc;
844
845 /* Ensure that the list cell nodes are in the right context too */
846 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
847
848 foreach(lc, nodes)
849 {
850 Expr *e = (Expr *) lfirst(lc);
851
852 result = lappend(result, ExecPrepareExpr(e, estate));
853 }
854
855 MemoryContextSwitchTo(oldcontext);
856
857 return result;
858 }
859
860 /*
861 * ExecCheck - evaluate a check constraint
862 *
863 * For check constraints, a null result is taken as TRUE, ie the constraint
864 * passes.
865 *
866 * The check constraint may have been prepared with ExecInitCheck
867 * (possibly via ExecPrepareCheck) if the caller had it in implicit-AND
868 * format, but a regular boolean expression prepared with ExecInitExpr or
869 * ExecPrepareExpr works too.
870 */
871 bool
872 ExecCheck(ExprState *state, ExprContext *econtext)
873 {
874 Datum ret;
875 bool isnull;
876
877 /* short-circuit (here and in ExecInitCheck) for empty restriction list */
878 if (state == NULL)
879 return true;
880
881 /* verify that expression was not compiled using ExecInitQual */
882 Assert(!(state->flags & EEO_FLAG_IS_QUAL));
883
884 ret = ExecEvalExprSwitchContext(state, econtext, &isnull);
885
886 if (isnull)
887 return true;
888
889 return DatumGetBool(ret);
890 }
891
892 /*
893 * Prepare a compiled expression for execution. This has to be called for
894 * every ExprState before it can be executed.
895 *
896 * NB: While this currently only calls ExecReadyInterpretedExpr(),
897 * this will likely get extended to further expression evaluation methods.
898 * Therefore this should be used instead of directly calling
899 * ExecReadyInterpretedExpr().
900 */
901 static void
902 ExecReadyExpr(ExprState *state)
903 {
904 if (jit_compile_expr(state))
905 return;
906
907 ExecReadyInterpretedExpr(state);
908 }
909
910 /*
911 * Append the steps necessary for the evaluation of node to ExprState->steps,
912 * possibly recursing into sub-expressions of node.
913 *
914 * node - expression to evaluate
915 * state - ExprState to whose ->steps to append the necessary operations
916 * resv / resnull - where to store the result of the node into
917 */
918 static void
919 ExecInitExprRec(Expr *node, ExprState *state,
920 Datum *resv, bool *resnull)
921 {
922 ExprEvalStep scratch = {0};
923
924 /* Guard against stack overflow due to overly complex expressions */
925 check_stack_depth();
926
927 /* Step's output location is always what the caller gave us */
928 Assert(resv != NULL && resnull != NULL);
929 scratch.resvalue = resv;
930 scratch.resnull = resnull;
931
932 /* cases should be ordered as they are in enum NodeTag */
933 switch (nodeTag(node))
934 {
935 case T_Var:
936 {
937 Var *variable = (Var *) node;
938
939 if (variable->varattno == InvalidAttrNumber)
940 {
941 /* whole-row Var */
942 ExecInitWholeRowVar(&scratch, variable, state);
943 }
944 else if (variable->varattno <= 0)
945 {
946 /* system column */
947 scratch.d.var.attnum = variable->varattno;
948 scratch.d.var.vartype = variable->vartype;
949 scratch.d.var.varreturningtype = variable->varreturningtype;
950 switch (variable->varno)
951 {
952 case INNER_VAR:
953 scratch.opcode = EEOP_INNER_SYSVAR;
954 break;
955 case OUTER_VAR:
956 scratch.opcode = EEOP_OUTER_SYSVAR;
957 break;
958
959 /* INDEX_VAR is handled by default case */
960
961 default:
962 switch (variable->varreturningtype)
963 {
964 case VAR_RETURNING_DEFAULT:
965 scratch.opcode = EEOP_SCAN_SYSVAR;
966 break;
967 case VAR_RETURNING_OLD:
968 scratch.opcode = EEOP_OLD_SYSVAR;
969 state->flags |= EEO_FLAG_HAS_OLD;
970 break;
971 case VAR_RETURNING_NEW:
972 scratch.opcode = EEOP_NEW_SYSVAR;
973 state->flags |= EEO_FLAG_HAS_NEW;
974 break;
975 }
976 break;
977 }
978 }
979 else
980 {
981 /* regular user column */
982 scratch.d.var.attnum = variable->varattno - 1;
983 scratch.d.var.vartype = variable->vartype;
984 scratch.d.var.varreturningtype = variable->varreturningtype;
985 switch (variable->varno)
986 {
987 case INNER_VAR:
988 scratch.opcode = EEOP_INNER_VAR;
989 break;
990 case OUTER_VAR:
991 scratch.opcode = EEOP_OUTER_VAR;
992 break;
993
994 /* INDEX_VAR is handled by default case */
995
996 default:
997 switch (variable->varreturningtype)
998 {
999 case VAR_RETURNING_DEFAULT:
1000 scratch.opcode = EEOP_SCAN_VAR;
1001 break;
1002 case VAR_RETURNING_OLD:
1003 scratch.opcode = EEOP_OLD_VAR;
1004 state->flags |= EEO_FLAG_HAS_OLD;
1005 break;
1006 case VAR_RETURNING_NEW:
1007 scratch.opcode = EEOP_NEW_VAR;
1008 state->flags |= EEO_FLAG_HAS_NEW;
1009 break;
1010 }
1011 break;
1012 }
1013 }
1014
1015 ExprEvalPushStep(state, &scratch);
1016 break;
1017 }
1018
1019 case T_Const:
1020 {
1021 Const *con = (Const *) node;
1022
1023 scratch.opcode = EEOP_CONST;
1024 scratch.d.constval.value = con->constvalue;
1025 scratch.d.constval.isnull = con->constisnull;
1026
1027 ExprEvalPushStep(state, &scratch);
1028 break;
1029 }
1030
1031 case T_Param:
1032 {
1033 Param *param = (Param *) node;
1034 ParamListInfo params;
1035
1036 switch (param->paramkind)
1037 {
1038 case PARAM_EXEC:
1039 scratch.opcode = EEOP_PARAM_EXEC;
1040 scratch.d.param.paramid = param->paramid;
1041 scratch.d.param.paramtype = param->paramtype;
1042 ExprEvalPushStep(state, &scratch);
1043 break;
1044 case PARAM_EXTERN:
1045
1046 /*
1047 * If we have a relevant ParamCompileHook, use it;
1048 * otherwise compile a standard EEOP_PARAM_EXTERN
1049 * step. ext_params, if supplied, takes precedence
1050 * over info from the parent node's EState (if any).
1051 */
1052 if (state->ext_params)
1053 params = state->ext_params;
1054 else if (state->parent &&
1055 state->parent->state)
1056 params = state->parent->state->es_param_list_info;
1057 else
1058 params = NULL;
1059 if (params && params->paramCompile)
1060 {
1061 params->paramCompile(params, param, state,
1062 resv, resnull);
1063 }
1064 else
1065 {
1066 scratch.opcode = EEOP_PARAM_EXTERN;
1067 scratch.d.param.paramid = param->paramid;
1068 scratch.d.param.paramtype = param->paramtype;
1069 ExprEvalPushStep(state, &scratch);
1070 }
1071 break;
1072 default:
1073 elog(ERROR, "unrecognized paramkind: %d",
1074 (int) param->paramkind);
1075 break;
1076 }
1077 break;
1078 }
1079
1080 case T_Aggref:
1081 {
1082 Aggref *aggref = (Aggref *) node;
1083
1084 scratch.opcode = EEOP_AGGREF;
1085 scratch.d.aggref.aggno = aggref->aggno;
1086
1087 if (state->parent && IsA(state->parent, AggState))
1088 {
1089 AggState *aggstate = (AggState *) state->parent;
1090
1091 aggstate->aggs = lappend(aggstate->aggs, aggref);
1092 }
1093 else
1094 {
1095 /* planner messed up */
1096 elog(ERROR, "Aggref found in non-Agg plan node");
1097 }
1098
1099 ExprEvalPushStep(state, &scratch);
1100 break;
1101 }
1102
1103 case T_GroupingFunc:
1104 {
1105 GroupingFunc *grp_node = (GroupingFunc *) node;
1106 Agg *agg;
1107
1108 if (!state->parent || !IsA(state->parent, AggState) ||
1109 !IsA(state->parent->plan, Agg))
1110 elog(ERROR, "GroupingFunc found in non-Agg plan node");
1111
1112 scratch.opcode = EEOP_GROUPING_FUNC;
1113
1114 agg = (Agg *) (state->parent->plan);
1115
1116 if (agg->groupingSets)
1117 scratch.d.grouping_func.clauses = grp_node->cols;
1118 else
1119 scratch.d.grouping_func.clauses = NIL;
1120
1121 ExprEvalPushStep(state, &scratch);
1122 break;
1123 }
1124
1125 case T_WindowFunc:
1126 {
1127 WindowFunc *wfunc = (WindowFunc *) node;
1128 WindowFuncExprState *wfstate = makeNode(WindowFuncExprState);
1129
1130 wfstate->wfunc = wfunc;
1131
1132 if (state->parent && IsA(state->parent, WindowAggState))
1133 {
1134 WindowAggState *winstate = (WindowAggState *) state->parent;
1135 int nfuncs;
1136
1137 winstate->funcs = lappend(winstate->funcs, wfstate);
1138 nfuncs = ++winstate->numfuncs;
1139 if (wfunc->winagg)
1140 winstate->numaggs++;
1141
1142 /* for now initialize agg using old style expressions */
1143 wfstate->args = ExecInitExprList(wfunc->args,
1144 state->parent);
1145 wfstate->aggfilter = ExecInitExpr(wfunc->aggfilter,
1146 state->parent);
1147
1148 /*
1149 * Complain if the windowfunc's arguments contain any
1150 * windowfuncs; nested window functions are semantically
1151 * nonsensical. (This should have been caught earlier,
1152 * but we defend against it here anyway.)
1153 */
1154 if (nfuncs != winstate->numfuncs)
1155 ereport(ERROR,
1156 (errcode(ERRCODE_WINDOWING_ERROR),
1157 errmsg("window function calls cannot be nested")));
1158 }
1159 else
1160 {
1161 /* planner messed up */
1162 elog(ERROR, "WindowFunc found in non-WindowAgg plan node");
1163 }
1164
1165 scratch.opcode = EEOP_WINDOW_FUNC;
1166 scratch.d.window_func.wfstate = wfstate;
1167 ExprEvalPushStep(state, &scratch);
1168 break;
1169 }
1170
1171 case T_MergeSupportFunc:
1172 {
1173 /* must be in a MERGE, else something messed up */
1174 if (!state->parent ||
1175 !IsA(state->parent, ModifyTableState) ||
1176 ((ModifyTableState *) state->parent)->operation != CMD_MERGE)
1177 elog(ERROR, "MergeSupportFunc found in non-merge plan node");
1178
1179 scratch.opcode = EEOP_MERGE_SUPPORT_FUNC;
1180 ExprEvalPushStep(state, &scratch);
1181 break;
1182 }
1183
1184 case T_SubscriptingRef:
1185 {
1186 SubscriptingRef *sbsref = (SubscriptingRef *) node;
1187
1188 ExecInitSubscriptingRef(&scratch, sbsref, state, resv, resnull);
1189 break;
1190 }
1191
1192 case T_FuncExpr:
1193 {
1194 FuncExpr *func = (FuncExpr *) node;
1195
1196 ExecInitFunc(&scratch, node,
1197 func->args, func->funcid, func->inputcollid,
1198 state);
1199 ExprEvalPushStep(state, &scratch);
1200 break;
1201 }
1202
1203 case T_OpExpr:
1204 {
1205 OpExpr *op = (OpExpr *) node;
1206
1207 ExecInitFunc(&scratch, node,
1208 op->args, op->opfuncid, op->inputcollid,
1209 state);
1210 ExprEvalPushStep(state, &scratch);
1211 break;
1212 }
1213
1214 case T_DistinctExpr:
1215 {
1216 DistinctExpr *op = (DistinctExpr *) node;
1217
1218 ExecInitFunc(&scratch, node,
1219 op->args, op->opfuncid, op->inputcollid,
1220 state);
1221
1222 /*
1223 * Change opcode of call instruction to EEOP_DISTINCT.
1224 *
1225 * XXX: historically we've not called the function usage
1226 * pgstat infrastructure - that seems inconsistent given that
1227 * we do so for normal function *and* operator evaluation. If
1228 * we decided to do that here, we'd probably want separate
1229 * opcodes for FUSAGE or not.
1230 */
1231 scratch.opcode = EEOP_DISTINCT;
1232 ExprEvalPushStep(state, &scratch);
1233 break;
1234 }
1235
1236 case T_NullIfExpr:
1237 {
1238 NullIfExpr *op = (NullIfExpr *) node;
1239
1240 ExecInitFunc(&scratch, node,
1241 op->args, op->opfuncid, op->inputcollid,
1242 state);
1243
1244 /*
1245 * If first argument is of varlena type, we'll need to ensure
1246 * that the value passed to the comparison function is a
1247 * read-only pointer.
1248 */
1249 scratch.d.func.make_ro =
1250 (get_typlen(exprType((Node *) linitial(op->args))) == -1);
1251
1252 /*
1253 * Change opcode of call instruction to EEOP_NULLIF.
1254 *
1255 * XXX: historically we've not called the function usage
1256 * pgstat infrastructure - that seems inconsistent given that
1257 * we do so for normal function *and* operator evaluation. If
1258 * we decided to do that here, we'd probably want separate
1259 * opcodes for FUSAGE or not.
1260 */
1261 scratch.opcode = EEOP_NULLIF;
1262 ExprEvalPushStep(state, &scratch);
1263 break;
1264 }
1265
1266 case T_ScalarArrayOpExpr:
1267 {
1268 ScalarArrayOpExpr *opexpr = (ScalarArrayOpExpr *) node;
1269 Expr *scalararg;
1270 Expr *arrayarg;
1271 FmgrInfo *finfo;
1272 FunctionCallInfo fcinfo;
1273 AclResult aclresult;
1274 Oid cmpfuncid;
1275
1276 /*
1277 * Select the correct comparison function. When we do hashed
1278 * NOT IN clauses, the opfuncid will be the inequality
1279 * comparison function and negfuncid will be set to equality.
1280 * We need to use the equality function for hash probes.
1281 */
1282 if (OidIsValid(opexpr->negfuncid))
1283 {
1284 Assert(OidIsValid(opexpr->hashfuncid));
1285 cmpfuncid = opexpr->negfuncid;
1286 }
1287 else
1288 cmpfuncid = opexpr->opfuncid;
1289
1290 Assert(list_length(opexpr->args) == 2);
1291 scalararg = (Expr *) linitial(opexpr->args);
1292 arrayarg = (Expr *) lsecond(opexpr->args);
1293
1294 /* Check permission to call function */
1295 aclresult = object_aclcheck(ProcedureRelationId, cmpfuncid,
1296 GetUserId(),
1297 ACL_EXECUTE);
1298 if (aclresult != ACLCHECK_OK)
1299 aclcheck_error(aclresult, OBJECT_FUNCTION,
1300 get_func_name(cmpfuncid));
1301 InvokeFunctionExecuteHook(cmpfuncid);
1302
1303 if (OidIsValid(opexpr->hashfuncid))
1304 {
1305 aclresult = object_aclcheck(ProcedureRelationId, opexpr->hashfuncid,
1306 GetUserId(),
1307 ACL_EXECUTE);
1308 if (aclresult != ACLCHECK_OK)
1309 aclcheck_error(aclresult, OBJECT_FUNCTION,
1310 get_func_name(opexpr->hashfuncid));
1311 InvokeFunctionExecuteHook(opexpr->hashfuncid);
1312 }
1313
1314 /* Set up the primary fmgr lookup information */
1315 finfo = palloc0(sizeof(FmgrInfo));
1316 fcinfo = palloc0(SizeForFunctionCallInfo(2));
1317 fmgr_info(cmpfuncid, finfo);
1318 fmgr_info_set_expr((Node *) node, finfo);
1319 InitFunctionCallInfoData(*fcinfo, finfo, 2,
1320 opexpr->inputcollid, NULL, NULL);
1321
1322 /*
1323 * If hashfuncid is set, we create a EEOP_HASHED_SCALARARRAYOP
1324 * step instead of a EEOP_SCALARARRAYOP. This provides much
1325 * faster lookup performance than the normal linear search
1326 * when the number of items in the array is anything but very
1327 * small.
1328 */
1329 if (OidIsValid(opexpr->hashfuncid))
1330 {
1331 /* Evaluate scalar directly into left function argument */
1332 ExecInitExprRec(scalararg, state,
1333 &fcinfo->args[0].value, &fcinfo->args[0].isnull);
1334
1335 /*
1336 * Evaluate array argument into our return value. There's
1337 * no danger in that, because the return value is
1338 * guaranteed to be overwritten by
1339 * EEOP_HASHED_SCALARARRAYOP, and will not be passed to
1340 * any other expression.
1341 */
1342 ExecInitExprRec(arrayarg, state, resv, resnull);
1343
1344 /* And perform the operation */
1345 scratch.opcode = EEOP_HASHED_SCALARARRAYOP;
1346 scratch.d.hashedscalararrayop.inclause = opexpr->useOr;
1347 scratch.d.hashedscalararrayop.finfo = finfo;
1348 scratch.d.hashedscalararrayop.fcinfo_data = fcinfo;
1349 scratch.d.hashedscalararrayop.saop = opexpr;
1350
1351
1352 ExprEvalPushStep(state, &scratch);
1353 }
1354 else
1355 {
1356 /* Evaluate scalar directly into left function argument */
1357 ExecInitExprRec(scalararg, state,
1358 &fcinfo->args[0].value,
1359 &fcinfo->args[0].isnull);
1360
1361 /*
1362 * Evaluate array argument into our return value. There's
1363 * no danger in that, because the return value is
1364 * guaranteed to be overwritten by EEOP_SCALARARRAYOP, and
1365 * will not be passed to any other expression.
1366 */
1367 ExecInitExprRec(arrayarg, state, resv, resnull);
1368
1369 /* And perform the operation */
1370 scratch.opcode = EEOP_SCALARARRAYOP;
1371 scratch.d.scalararrayop.element_type = InvalidOid;
1372 scratch.d.scalararrayop.useOr = opexpr->useOr;
1373 scratch.d.scalararrayop.finfo = finfo;
1374 scratch.d.scalararrayop.fcinfo_data = fcinfo;
1375 scratch.d.scalararrayop.fn_addr = finfo->fn_addr;
1376 ExprEvalPushStep(state, &scratch);
1377 }
1378 break;
1379 }
1380
1381 case T_BoolExpr:
1382 {
1383 BoolExpr *boolexpr = (BoolExpr *) node;
1384 int nargs = list_length(boolexpr->args);
1385 List *adjust_jumps = NIL;
1386 int off;
1387 ListCell *lc;
1388
1389 /* allocate scratch memory used by all steps of AND/OR */
1390 if (boolexpr->boolop != NOT_EXPR)
1391 scratch.d.boolexpr.anynull = (bool *) palloc(sizeof(bool));
1392
1393 /*
1394 * For each argument evaluate the argument itself, then
1395 * perform the bool operation's appropriate handling.
1396 *
1397 * We can evaluate each argument into our result area, since
1398 * the short-circuiting logic means we only need to remember
1399 * previous NULL values.
1400 *
1401 * AND/OR is split into separate STEP_FIRST (one) / STEP (zero
1402 * or more) / STEP_LAST (one) steps, as each of those has to
1403 * perform different work. The FIRST/LAST split is valid
1404 * because AND/OR have at least two arguments.
1405 */
1406 off = 0;
1407 foreach(lc, boolexpr->args)
1408 {
1409 Expr *arg = (Expr *) lfirst(lc);
1410
1411 /* Evaluate argument into our output variable */
1412 ExecInitExprRec(arg, state, resv, resnull);
1413
1414 /* Perform the appropriate step type */
1415 switch (boolexpr->boolop)
1416 {
1417 case AND_EXPR:
1418 Assert(nargs >= 2);
1419
1420 if (off == 0)
1421 scratch.opcode = EEOP_BOOL_AND_STEP_FIRST;
1422 else if (off + 1 == nargs)
1423 scratch.opcode = EEOP_BOOL_AND_STEP_LAST;
1424 else
1425 scratch.opcode = EEOP_BOOL_AND_STEP;
1426 break;
1427 case OR_EXPR:
1428 Assert(nargs >= 2);
1429
1430 if (off == 0)
1431 scratch.opcode = EEOP_BOOL_OR_STEP_FIRST;
1432 else if (off + 1 == nargs)
1433 scratch.opcode = EEOP_BOOL_OR_STEP_LAST;
1434 else
1435 scratch.opcode = EEOP_BOOL_OR_STEP;
1436 break;
1437 case NOT_EXPR:
1438 Assert(nargs == 1);
1439
1440 scratch.opcode = EEOP_BOOL_NOT_STEP;
1441 break;
1442 default:
1443 elog(ERROR, "unrecognized boolop: %d",
1444 (int) boolexpr->boolop);
1445 break;
1446 }
1447
1448 scratch.d.boolexpr.jumpdone = -1;
1449 ExprEvalPushStep(state, &scratch);
1450 adjust_jumps = lappend_int(adjust_jumps,
1451 state->steps_len - 1);
1452 off++;
1453 }
1454
1455 /* adjust jump targets */
1456 foreach(lc, adjust_jumps)
1457 {
1458 ExprEvalStep *as = &state->steps[lfirst_int(lc)];
1459
1460 Assert(as->d.boolexpr.jumpdone == -1);
1461 as->d.boolexpr.jumpdone = state->steps_len;
1462 }
1463
1464 break;
1465 }
1466
1467 case T_SubPlan:
1468 {
1469 SubPlan *subplan = (SubPlan *) node;
1470
1471 /*
1472 * Real execution of a MULTIEXPR SubPlan has already been
1473 * done. What we have to do here is return a dummy NULL record
1474 * value in case this targetlist element is assigned
1475 * someplace.
1476 */
1477 if (subplan->subLinkType == MULTIEXPR_SUBLINK)
1478 {
1479 scratch.opcode = EEOP_CONST;
1480 scratch.d.constval.value = (Datum) 0;
1481 scratch.d.constval.isnull = true;
1482 ExprEvalPushStep(state, &scratch);
1483 break;
1484 }
1485
1486 ExecInitSubPlanExpr(subplan, state, resv, resnull);
1487 break;
1488 }
1489
1490 case T_FieldSelect:
1491 {
1492 FieldSelect *fselect = (FieldSelect *) node;
1493
1494 /* evaluate row/record argument into result area */
1495 ExecInitExprRec(fselect->arg, state, resv, resnull);
1496
1497 /* and extract field */
1498 scratch.opcode = EEOP_FIELDSELECT;
1499 scratch.d.fieldselect.fieldnum = fselect->fieldnum;
1500 scratch.d.fieldselect.resulttype = fselect->resulttype;
1501 scratch.d.fieldselect.rowcache.cacheptr = NULL;
1502
1503 ExprEvalPushStep(state, &scratch);
1504 break;
1505 }
1506
1507 case T_FieldStore:
1508 {
1509 FieldStore *fstore = (FieldStore *) node;
1510 TupleDesc tupDesc;
1511 ExprEvalRowtypeCache *rowcachep;
1512 Datum *values;
1513 bool *nulls;
1514 int ncolumns;
1515 ListCell *l1,
1516 *l2;
1517
1518 /* find out the number of columns in the composite type */
1519 tupDesc = lookup_rowtype_tupdesc(fstore->resulttype, -1);
1520 ncolumns = tupDesc->natts;
1521 ReleaseTupleDesc(tupDesc);
1522
1523 /* create workspace for column values */
1524 values = (Datum *) palloc(sizeof(Datum) * ncolumns);
1525 nulls = (bool *) palloc(sizeof(bool) * ncolumns);
1526
1527 /* create shared composite-type-lookup cache struct */
1528 rowcachep = palloc(sizeof(ExprEvalRowtypeCache));
1529 rowcachep->cacheptr = NULL;
1530
1531 /* emit code to evaluate the composite input value */
1532 ExecInitExprRec(fstore->arg, state, resv, resnull);
1533
1534 /* next, deform the input tuple into our workspace */
1535 scratch.opcode = EEOP_FIELDSTORE_DEFORM;
1536 scratch.d.fieldstore.fstore = fstore;
1537 scratch.d.fieldstore.rowcache = rowcachep;
1538 scratch.d.fieldstore.values = values;
1539 scratch.d.fieldstore.nulls = nulls;
1540 scratch.d.fieldstore.ncolumns = ncolumns;
1541 ExprEvalPushStep(state, &scratch);
1542
1543 /* evaluate new field values, store in workspace columns */
1544 forboth(l1, fstore->newvals, l2, fstore->fieldnums)
1545 {
1546 Expr *e = (Expr *) lfirst(l1);
1547 AttrNumber fieldnum = lfirst_int(l2);
1548 Datum *save_innermost_caseval;
1549 bool *save_innermost_casenull;
1550
1551 if (fieldnum <= 0 || fieldnum > ncolumns)
1552 elog(ERROR, "field number %d is out of range in FieldStore",
1553 fieldnum);
1554
1555 /*
1556 * Use the CaseTestExpr mechanism to pass down the old
1557 * value of the field being replaced; this is needed in
1558 * case the newval is itself a FieldStore or
1559 * SubscriptingRef that has to obtain and modify the old
1560 * value. It's safe to reuse the CASE mechanism because
1561 * there cannot be a CASE between here and where the value
1562 * would be needed, and a field assignment can't be within
1563 * a CASE either. (So saving and restoring
1564 * innermost_caseval is just paranoia, but let's do it
1565 * anyway.)
1566 *
1567 * Another non-obvious point is that it's safe to use the
1568 * field's values[]/nulls[] entries as both the caseval
1569 * source and the result address for this subexpression.
1570 * That's okay only because (1) both FieldStore and
1571 * SubscriptingRef evaluate their arg or refexpr inputs
1572 * first, and (2) any such CaseTestExpr is directly the
1573 * arg or refexpr input. So any read of the caseval will
1574 * occur before there's a chance to overwrite it. Also,
1575 * if multiple entries in the newvals/fieldnums lists
1576 * target the same field, they'll effectively be applied
1577 * left-to-right which is what we want.
1578 */
1579 save_innermost_caseval = state->innermost_caseval;
1580 save_innermost_casenull = state->innermost_casenull;
1581 state->innermost_caseval = &values[fieldnum - 1];
1582 state->innermost_casenull = &nulls[fieldnum - 1];
1583
1584 ExecInitExprRec(e, state,
1585 &values[fieldnum - 1],
1586 &nulls[fieldnum - 1]);
1587
1588 state->innermost_caseval = save_innermost_caseval;
1589 state->innermost_casenull = save_innermost_casenull;
1590 }
1591
1592 /* finally, form result tuple */
1593 scratch.opcode = EEOP_FIELDSTORE_FORM;
1594 scratch.d.fieldstore.fstore = fstore;
1595 scratch.d.fieldstore.rowcache = rowcachep;
1596 scratch.d.fieldstore.values = values;
1597 scratch.d.fieldstore.nulls = nulls;
1598 scratch.d.fieldstore.ncolumns = ncolumns;
1599 ExprEvalPushStep(state, &scratch);
1600 break;
1601 }
1602
1603 case T_RelabelType:
1604 {
1605 /* relabel doesn't need to do anything at runtime */
1606 RelabelType *relabel = (RelabelType *) node;
1607
1608 ExecInitExprRec(relabel->arg, state, resv, resnull);
1609 break;
1610 }
1611
1612 case T_CoerceViaIO:
1613 {
1614 CoerceViaIO *iocoerce = (CoerceViaIO *) node;
1615 Oid iofunc;
1616 bool typisvarlena;
1617 Oid typioparam;
1618 FunctionCallInfo fcinfo_in;
1619
1620 /* evaluate argument into step's result area */
1621 ExecInitExprRec(iocoerce->arg, state, resv, resnull);
1622
1623 /*
1624 * Prepare both output and input function calls, to be
1625 * evaluated inside a single evaluation step for speed - this
1626 * can be a very common operation.
1627 *
1628 * We don't check permissions here as a type's input/output
1629 * function are assumed to be executable by everyone.
1630 */
1631 if (state->escontext == NULL)
1632 scratch.opcode = EEOP_IOCOERCE;
1633 else
1634 scratch.opcode = EEOP_IOCOERCE_SAFE;
1635
1636 /* lookup the source type's output function */
1637 scratch.d.iocoerce.finfo_out = palloc0(sizeof(FmgrInfo));
1638 scratch.d.iocoerce.fcinfo_data_out = palloc0(SizeForFunctionCallInfo(1));
1639
1640 getTypeOutputInfo(exprType((Node *) iocoerce->arg),
1641 &iofunc, &typisvarlena);
1642 fmgr_info(iofunc, scratch.d.iocoerce.finfo_out);
1643 fmgr_info_set_expr((Node *) node, scratch.d.iocoerce.finfo_out);
1644 InitFunctionCallInfoData(*scratch.d.iocoerce.fcinfo_data_out,
1645 scratch.d.iocoerce.finfo_out,
1646 1, InvalidOid, NULL, NULL);
1647
1648 /* lookup the result type's input function */
1649 scratch.d.iocoerce.finfo_in = palloc0(sizeof(FmgrInfo));
1650 scratch.d.iocoerce.fcinfo_data_in = palloc0(SizeForFunctionCallInfo(3));
1651
1652 getTypeInputInfo(iocoerce->resulttype,
1653 &iofunc, &typioparam);
1654 fmgr_info(iofunc, scratch.d.iocoerce.finfo_in);
1655 fmgr_info_set_expr((Node *) node, scratch.d.iocoerce.finfo_in);
1656 InitFunctionCallInfoData(*scratch.d.iocoerce.fcinfo_data_in,
1657 scratch.d.iocoerce.finfo_in,
1658 3, InvalidOid, NULL, NULL);
1659
1660 /*
1661 * We can preload the second and third arguments for the input
1662 * function, since they're constants.
1663 */
1664 fcinfo_in = scratch.d.iocoerce.fcinfo_data_in;
1665 fcinfo_in->args[1].value = ObjectIdGetDatum(typioparam);
1666 fcinfo_in->args[1].isnull = false;
1667 fcinfo_in->args[2].value = Int32GetDatum(-1);
1668 fcinfo_in->args[2].isnull = false;
1669
1670 fcinfo_in->context = (Node *) state->escontext;
1671
1672 ExprEvalPushStep(state, &scratch);
1673 break;
1674 }
1675
1676 case T_ArrayCoerceExpr:
1677 {
1678 ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
1679 Oid resultelemtype;
1680 ExprState *elemstate;
1681
1682 /* evaluate argument into step's result area */
1683 ExecInitExprRec(acoerce->arg, state, resv, resnull);
1684
1685 resultelemtype = get_element_type(acoerce->resulttype);
1686 if (!OidIsValid(resultelemtype))
1687 ereport(ERROR,
1688 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1689 errmsg("target type is not an array")));
1690
1691 /*
1692 * Construct a sub-expression for the per-element expression;
1693 * but don't ready it until after we check it for triviality.
1694 * We assume it hasn't any Var references, but does have a
1695 * CaseTestExpr representing the source array element values.
1696 */
1697 elemstate = makeNode(ExprState);
1698 elemstate->expr = acoerce->elemexpr;
1699 elemstate->parent = state->parent;
1700 elemstate->ext_params = state->ext_params;
1701
1702 elemstate->innermost_caseval = (Datum *) palloc(sizeof(Datum));
1703 elemstate->innermost_casenull = (bool *) palloc(sizeof(bool));
1704
1705 ExecInitExprRec(acoerce->elemexpr, elemstate,
1706 &elemstate->resvalue, &elemstate->resnull);
1707
1708 if (elemstate->steps_len == 1 &&
1709 elemstate->steps[0].opcode == EEOP_CASE_TESTVAL)
1710 {
1711 /* Trivial, so we need no per-element work at runtime */
1712 elemstate = NULL;
1713 }
1714 else
1715 {
1716 /* Not trivial, so append a DONE step */
1717 scratch.opcode = EEOP_DONE_RETURN;
1718 ExprEvalPushStep(elemstate, &scratch);
1719 /* and ready the subexpression */
1720 ExecReadyExpr(elemstate);
1721 }
1722
1723 scratch.opcode = EEOP_ARRAYCOERCE;
1724 scratch.d.arraycoerce.elemexprstate = elemstate;
1725 scratch.d.arraycoerce.resultelemtype = resultelemtype;
1726
1727 if (elemstate)
1728 {
1729 /* Set up workspace for array_map */
1730 scratch.d.arraycoerce.amstate =
1731 (ArrayMapState *) palloc0(sizeof(ArrayMapState));
1732 }
1733 else
1734 {
1735 /* Don't need workspace if there's no subexpression */
1736 scratch.d.arraycoerce.amstate = NULL;
1737 }
1738
1739 ExprEvalPushStep(state, &scratch);
1740 break;
1741 }
1742
1743 case T_ConvertRowtypeExpr:
1744 {
1745 ConvertRowtypeExpr *convert = (ConvertRowtypeExpr *) node;
1746 ExprEvalRowtypeCache *rowcachep;
1747
1748 /* cache structs must be out-of-line for space reasons */
1749 rowcachep = palloc(2 * sizeof(ExprEvalRowtypeCache));
1750 rowcachep[0].cacheptr = NULL;
1751 rowcachep[1].cacheptr = NULL;
1752
1753 /* evaluate argument into step's result area */
1754 ExecInitExprRec(convert->arg, state, resv, resnull);
1755
1756 /* and push conversion step */
1757 scratch.opcode = EEOP_CONVERT_ROWTYPE;
1758 scratch.d.convert_rowtype.inputtype =
1759 exprType((Node *) convert->arg);
1760 scratch.d.convert_rowtype.outputtype = convert->resulttype;
1761 scratch.d.convert_rowtype.incache = &rowcachep[0];
1762 scratch.d.convert_rowtype.outcache = &rowcachep[1];
1763 scratch.d.convert_rowtype.map = NULL;
1764
1765 ExprEvalPushStep(state, &scratch);
1766 break;
1767 }
1768
1769 /* note that CaseWhen expressions are handled within this block */
1770 case T_CaseExpr:
1771 {
1772 CaseExpr *caseExpr = (CaseExpr *) node;
1773 List *adjust_jumps = NIL;
1774 Datum *caseval = NULL;
1775 bool *casenull = NULL;
1776 ListCell *lc;
1777
1778 /*
1779 * If there's a test expression, we have to evaluate it and
1780 * save the value where the CaseTestExpr placeholders can find
1781 * it.
1782 */
1783 if (caseExpr->arg != NULL)
1784 {
1785 /* Evaluate testexpr into caseval/casenull workspace */
1786 caseval = palloc(sizeof(Datum));
1787 casenull = palloc(sizeof(bool));
1788
1789 ExecInitExprRec(caseExpr->arg, state,
1790 caseval, casenull);
1791
1792 /*
1793 * Since value might be read multiple times, force to R/O
1794 * - but only if it could be an expanded datum.
1795 */
1796 if (get_typlen(exprType((Node *) caseExpr->arg)) == -1)
1797 {
1798 /* change caseval in-place */
1799 scratch.opcode = EEOP_MAKE_READONLY;
1800 scratch.resvalue = caseval;
1801 scratch.resnull = casenull;
1802 scratch.d.make_readonly.value = caseval;
1803 scratch.d.make_readonly.isnull = casenull;
1804 ExprEvalPushStep(state, &scratch);
1805 /* restore normal settings of scratch fields */
1806 scratch.resvalue = resv;
1807 scratch.resnull = resnull;
1808 }
1809 }
1810
1811 /*
1812 * Prepare to evaluate each of the WHEN clauses in turn; as
1813 * soon as one is true we return the value of the
1814 * corresponding THEN clause. If none are true then we return
1815 * the value of the ELSE clause, or NULL if there is none.
1816 */
1817 foreach(lc, caseExpr->args)
1818 {
1819 CaseWhen *when = (CaseWhen *) lfirst(lc);
1820 Datum *save_innermost_caseval;
1821 bool *save_innermost_casenull;
1822 int whenstep;
1823
1824 /*
1825 * Make testexpr result available to CaseTestExpr nodes
1826 * within the condition. We must save and restore prior
1827 * setting of innermost_caseval fields, in case this node
1828 * is itself within a larger CASE.
1829 *
1830 * If there's no test expression, we don't actually need
1831 * to save and restore these fields; but it's less code to
1832 * just do so unconditionally.
1833 */
1834 save_innermost_caseval = state->innermost_caseval;
1835 save_innermost_casenull = state->innermost_casenull;
1836 state->innermost_caseval = caseval;
1837 state->innermost_casenull = casenull;
1838
1839 /* evaluate condition into CASE's result variables */
1840 ExecInitExprRec(when->expr, state, resv, resnull);
1841
1842 state->innermost_caseval = save_innermost_caseval;
1843 state->innermost_casenull = save_innermost_casenull;
1844
1845 /* If WHEN result isn't true, jump to next CASE arm */
1846 scratch.opcode = EEOP_JUMP_IF_NOT_TRUE;
1847 scratch.d.jump.jumpdone = -1; /* computed later */
1848 ExprEvalPushStep(state, &scratch);
1849 whenstep = state->steps_len - 1;
1850
1851 /*
1852 * If WHEN result is true, evaluate THEN result, storing
1853 * it into the CASE's result variables.
1854 */
1855 ExecInitExprRec(when->result, state, resv, resnull);
1856
1857 /* Emit JUMP step to jump to end of CASE's code */
1858 scratch.opcode = EEOP_JUMP;
1859 scratch.d.jump.jumpdone = -1; /* computed later */
1860 ExprEvalPushStep(state, &scratch);
1861
1862 /*
1863 * Don't know address for that jump yet, compute once the
1864 * whole CASE expression is built.
1865 */
1866 adjust_jumps = lappend_int(adjust_jumps,
1867 state->steps_len - 1);
1868
1869 /*
1870 * But we can set WHEN test's jump target now, to make it
1871 * jump to the next WHEN subexpression or the ELSE.
1872 */
1873 state->steps[whenstep].d.jump.jumpdone = state->steps_len;
1874 }
1875
1876 /* transformCaseExpr always adds a default */
1877 Assert(caseExpr->defresult);
1878
1879 /* evaluate ELSE expr into CASE's result variables */
1880 ExecInitExprRec(caseExpr->defresult, state,
1881 resv, resnull);
1882
1883 /* adjust jump targets */
1884 foreach(lc, adjust_jumps)
1885 {
1886 ExprEvalStep *as = &state->steps[lfirst_int(lc)];
1887
1888 Assert(as->opcode == EEOP_JUMP);
1889 Assert(as->d.jump.jumpdone == -1);
1890 as->d.jump.jumpdone = state->steps_len;
1891 }
1892
1893 break;
1894 }
1895
1896 case T_CaseTestExpr:
1897 {
1898 /*
1899 * Read from location identified by innermost_caseval. Note
1900 * that innermost_caseval could be NULL, if this node isn't
1901 * actually within a CaseExpr, ArrayCoerceExpr, etc structure.
1902 * That can happen because some parts of the system abuse
1903 * CaseTestExpr to cause a read of a value externally supplied
1904 * in econtext->caseValue_datum. We'll take care of that by
1905 * generating a specialized operation.
1906 */
1907 if (state->innermost_caseval == NULL)
1908 scratch.opcode = EEOP_CASE_TESTVAL_EXT;
1909 else
1910 {
1911 scratch.opcode = EEOP_CASE_TESTVAL;
1912 scratch.d.casetest.value = state->innermost_caseval;
1913 scratch.d.casetest.isnull = state->innermost_casenull;
1914 }
1915 ExprEvalPushStep(state, &scratch);
1916 break;
1917 }
1918
1919 case T_ArrayExpr:
1920 {
1921 ArrayExpr *arrayexpr = (ArrayExpr *) node;
1922 int nelems = list_length(arrayexpr->elements);
1923 ListCell *lc;
1924 int elemoff;
1925
1926 /*
1927 * Evaluate by computing each element, and then forming the
1928 * array. Elements are computed into scratch arrays
1929 * associated with the ARRAYEXPR step.
1930 */
1931 scratch.opcode = EEOP_ARRAYEXPR;
1932 scratch.d.arrayexpr.elemvalues =
1933 (Datum *) palloc(sizeof(Datum) * nelems);
1934 scratch.d.arrayexpr.elemnulls =
1935 (bool *) palloc(sizeof(bool) * nelems);
1936 scratch.d.arrayexpr.nelems = nelems;
1937
1938 /* fill remaining fields of step */
1939 scratch.d.arrayexpr.multidims = arrayexpr->multidims;
1940 scratch.d.arrayexpr.elemtype = arrayexpr->element_typeid;
1941
1942 /* do one-time catalog lookup for type info */
1943 get_typlenbyvalalign(arrayexpr->element_typeid,
1944 &scratch.d.arrayexpr.elemlength,
1945 &scratch.d.arrayexpr.elembyval,
1946 &scratch.d.arrayexpr.elemalign);
1947
1948 /* prepare to evaluate all arguments */
1949 elemoff = 0;
1950 foreach(lc, arrayexpr->elements)
1951 {
1952 Expr *e = (Expr *) lfirst(lc);
1953
1954 ExecInitExprRec(e, state,
1955 &scratch.d.arrayexpr.elemvalues[elemoff],
1956 &scratch.d.arrayexpr.elemnulls[elemoff]);
1957 elemoff++;
1958 }
1959
1960 /* and then collect all into an array */
1961 ExprEvalPushStep(state, &scratch);
1962 break;
1963 }
1964
1965 case T_RowExpr:
1966 {
1967 RowExpr *rowexpr = (RowExpr *) node;
1968 int nelems = list_length(rowexpr->args);
1969 TupleDesc tupdesc;
1970 int i;
1971 ListCell *l;
1972
1973 /* Build tupdesc to describe result tuples */
1974 if (rowexpr->row_typeid == RECORDOID)
1975 {
1976 /* generic record, use types of given expressions */
1977 tupdesc = ExecTypeFromExprList(rowexpr->args);
1978 /* ... but adopt RowExpr's column aliases */
1979 ExecTypeSetColNames(tupdesc, rowexpr->colnames);
1980 /* Bless the tupdesc so it can be looked up later */
1981 BlessTupleDesc(tupdesc);
1982 }
1983 else
1984 {
1985 /* it's been cast to a named type, use that */
1986 tupdesc = lookup_rowtype_tupdesc_copy(rowexpr->row_typeid, -1);
1987 }
1988
1989 /*
1990 * In the named-type case, the tupdesc could have more columns
1991 * than are in the args list, since the type might have had
1992 * columns added since the ROW() was parsed. We want those
1993 * extra columns to go to nulls, so we make sure that the
1994 * workspace arrays are large enough and then initialize any
1995 * extra columns to read as NULLs.
1996 */
1997 Assert(nelems <= tupdesc->natts);
1998 nelems = Max(nelems, tupdesc->natts);
1999
2000 /*
2001 * Evaluate by first building datums for each field, and then
2002 * a final step forming the composite datum.
2003 */
2004 scratch.opcode = EEOP_ROW;
2005 scratch.d.row.tupdesc = tupdesc;
2006
2007 /* space for the individual field datums */
2008 scratch.d.row.elemvalues =
2009 (Datum *) palloc(sizeof(Datum) * nelems);
2010 scratch.d.row.elemnulls =
2011 (bool *) palloc(sizeof(bool) * nelems);
2012 /* as explained above, make sure any extra columns are null */
2013 memset(scratch.d.row.elemnulls, true, sizeof(bool) * nelems);
2014
2015 /* Set up evaluation, skipping any deleted columns */
2016 i = 0;
2017 foreach(l, rowexpr->args)
2018 {
2019 Form_pg_attribute att = TupleDescAttr(tupdesc, i);
2020 Expr *e = (Expr *) lfirst(l);
2021
2022 if (!att->attisdropped)
2023 {
2024 /*
2025 * Guard against ALTER COLUMN TYPE on rowtype since
2026 * the RowExpr was created. XXX should we check
2027 * typmod too? Not sure we can be sure it'll be the
2028 * same.
2029 */
2030 if (exprType((Node *) e) != att->atttypid)
2031 ereport(ERROR,
2032 (errcode(ERRCODE_DATATYPE_MISMATCH),
2033 errmsg("ROW() column has type %s instead of type %s",
2034 format_type_be(exprType((Node *) e)),
2035 format_type_be(att->atttypid))));
2036 }
2037 else
2038 {
2039 /*
2040 * Ignore original expression and insert a NULL. We
2041 * don't really care what type of NULL it is, so
2042 * always make an int4 NULL.
2043 */
2044 e = (Expr *) makeNullConst(INT4OID, -1, InvalidOid);
2045 }
2046
2047 /* Evaluate column expr into appropriate workspace slot */
2048 ExecInitExprRec(e, state,
2049 &scratch.d.row.elemvalues[i],
2050 &scratch.d.row.elemnulls[i]);
2051 i++;
2052 }
2053
2054 /* And finally build the row value */
2055 ExprEvalPushStep(state, &scratch);
2056 break;
2057 }
2058
2059 case T_RowCompareExpr:
2060 {
2061 RowCompareExpr *rcexpr = (RowCompareExpr *) node;
2062 int nopers = list_length(rcexpr->opnos);
2063 List *adjust_jumps = NIL;
2064 ListCell *l_left_expr,
2065 *l_right_expr,
2066 *l_opno,
2067 *l_opfamily,
2068 *l_inputcollid;
2069 ListCell *lc;
2070
2071 /*
2072 * Iterate over each field, prepare comparisons. To handle
2073 * NULL results, prepare jumps to after the expression. If a
2074 * comparison yields a != 0 result, jump to the final step.
2075 */
2076 Assert(list_length(rcexpr->largs) == nopers);
2077 Assert(list_length(rcexpr->rargs) == nopers);
2078 Assert(list_length(rcexpr->opfamilies) == nopers);
2079 Assert(list_length(rcexpr->inputcollids) == nopers);
2080
2081 forfive(l_left_expr, rcexpr->largs,
2082 l_right_expr, rcexpr->rargs,
2083 l_opno, rcexpr->opnos,
2084 l_opfamily, rcexpr->opfamilies,
2085 l_inputcollid, rcexpr->inputcollids)
2086 {
2087 Expr *left_expr = (Expr *) lfirst(l_left_expr);
2088 Expr *right_expr = (Expr *) lfirst(l_right_expr);
2089 Oid opno = lfirst_oid(l_opno);
2090 Oid opfamily = lfirst_oid(l_opfamily);
2091 Oid inputcollid = lfirst_oid(l_inputcollid);
2092 int strategy;
2093 Oid lefttype;
2094 Oid righttype;
2095 Oid proc;
2096 FmgrInfo *finfo;
2097 FunctionCallInfo fcinfo;
2098
2099 get_op_opfamily_properties(opno, opfamily, false,
2100 &strategy,
2101 &lefttype,
2102 &righttype);
2103 proc = get_opfamily_proc(opfamily,
2104 lefttype,
2105 righttype,
2106 BTORDER_PROC);
2107 if (!OidIsValid(proc))
2108 elog(ERROR, "missing support function %d(%u,%u) in opfamily %u",
2109 BTORDER_PROC, lefttype, righttype, opfamily);
2110
2111 /* Set up the primary fmgr lookup information */
2112 finfo = palloc0(sizeof(FmgrInfo));
2113 fcinfo = palloc0(SizeForFunctionCallInfo(2));
2114 fmgr_info(proc, finfo);
2115 fmgr_info_set_expr((Node *) node, finfo);
2116 InitFunctionCallInfoData(*fcinfo, finfo, 2,
2117 inputcollid, NULL, NULL);
2118
2119 /*
2120 * If we enforced permissions checks on index support
2121 * functions, we'd need to make a check here. But the
2122 * index support machinery doesn't do that, and thus
2123 * neither does this code.
2124 */
2125
2126 /* evaluate left and right args directly into fcinfo */
2127 ExecInitExprRec(left_expr, state,
2128 &fcinfo->args[0].value, &fcinfo->args[0].isnull);
2129 ExecInitExprRec(right_expr, state,
2130 &fcinfo->args[1].value, &fcinfo->args[1].isnull);
2131
2132 scratch.opcode = EEOP_ROWCOMPARE_STEP;
2133 scratch.d.rowcompare_step.finfo = finfo;
2134 scratch.d.rowcompare_step.fcinfo_data = fcinfo;
2135 scratch.d.rowcompare_step.fn_addr = finfo->fn_addr;
2136 /* jump targets filled below */
2137 scratch.d.rowcompare_step.jumpnull = -1;
2138 scratch.d.rowcompare_step.jumpdone = -1;
2139
2140 ExprEvalPushStep(state, &scratch);
2141 adjust_jumps = lappend_int(adjust_jumps,
2142 state->steps_len - 1);
2143 }
2144
2145 /*
2146 * We could have a zero-column rowtype, in which case the rows
2147 * necessarily compare equal.
2148 */
2149 if (nopers == 0)
2150 {
2151 scratch.opcode = EEOP_CONST;
2152 scratch.d.constval.value = Int32GetDatum(0);
2153 scratch.d.constval.isnull = false;
2154 ExprEvalPushStep(state, &scratch);
2155 }
2156
2157 /* Finally, examine the last comparison result */
2158 scratch.opcode = EEOP_ROWCOMPARE_FINAL;
2159 scratch.d.rowcompare_final.cmptype = rcexpr->cmptype;
2160 ExprEvalPushStep(state, &scratch);
2161
2162 /* adjust jump targets */
2163 foreach(lc, adjust_jumps)
2164 {
2165 ExprEvalStep *as = &state->steps[lfirst_int(lc)];
2166
2167 Assert(as->opcode == EEOP_ROWCOMPARE_STEP);
2168 Assert(as->d.rowcompare_step.jumpdone == -1);
2169 Assert(as->d.rowcompare_step.jumpnull == -1);
2170
2171 /* jump to comparison evaluation */
2172 as->d.rowcompare_step.jumpdone = state->steps_len - 1;
2173 /* jump to the following expression */
2174 as->d.rowcompare_step.jumpnull = state->steps_len;
2175 }
2176
2177 break;
2178 }
2179
2180 case T_CoalesceExpr:
2181 {
2182 CoalesceExpr *coalesce = (CoalesceExpr *) node;
2183 List *adjust_jumps = NIL;
2184 ListCell *lc;
2185
2186 /* We assume there's at least one arg */
2187 Assert(coalesce->args != NIL);
2188
2189 /*
2190 * Prepare evaluation of all coalesced arguments, after each
2191 * one push a step that short-circuits if not null.
2192 */
2193 foreach(lc, coalesce->args)
2194 {
2195 Expr *e = (Expr *) lfirst(lc);
2196
2197 /* evaluate argument, directly into result datum */
2198 ExecInitExprRec(e, state, resv, resnull);
2199
2200 /* if it's not null, skip to end of COALESCE expr */
2201 scratch.opcode = EEOP_JUMP_IF_NOT_NULL;
2202 scratch.d.jump.jumpdone = -1; /* adjust later */
2203 ExprEvalPushStep(state, &scratch);
2204
2205 adjust_jumps = lappend_int(adjust_jumps,
2206 state->steps_len - 1);
2207 }
2208
2209 /*
2210 * No need to add a constant NULL return - we only can get to
2211 * the end of the expression if a NULL already is being
2212 * returned.
2213 */
2214
2215 /* adjust jump targets */
2216 foreach(lc, adjust_jumps)
2217 {
2218 ExprEvalStep *as = &state->steps[lfirst_int(lc)];
2219
2220 Assert(as->opcode == EEOP_JUMP_IF_NOT_NULL);
2221 Assert(as->d.jump.jumpdone == -1);
2222 as->d.jump.jumpdone = state->steps_len;
2223 }
2224
2225 break;
2226 }
2227
2228 case T_MinMaxExpr:
2229 {
2230 MinMaxExpr *minmaxexpr = (MinMaxExpr *) node;
2231 int nelems = list_length(minmaxexpr->args);
2232 TypeCacheEntry *typentry;
2233 FmgrInfo *finfo;
2234 FunctionCallInfo fcinfo;
2235 ListCell *lc;
2236 int off;
2237
2238 /* Look up the btree comparison function for the datatype */
2239 typentry = lookup_type_cache(minmaxexpr->minmaxtype,
2240 TYPECACHE_CMP_PROC);
2241 if (!OidIsValid(typentry->cmp_proc))
2242 ereport(ERROR,
2243 (errcode(ERRCODE_UNDEFINED_FUNCTION),
2244 errmsg("could not identify a comparison function for type %s",
2245 format_type_be(minmaxexpr->minmaxtype))));
2246
2247 /*
2248 * If we enforced permissions checks on index support
2249 * functions, we'd need to make a check here. But the index
2250 * support machinery doesn't do that, and thus neither does
2251 * this code.
2252 */
2253
2254 /* Perform function lookup */
2255 finfo = palloc0(sizeof(FmgrInfo));
2256 fcinfo = palloc0(SizeForFunctionCallInfo(2));
2257 fmgr_info(typentry->cmp_proc, finfo);
2258 fmgr_info_set_expr((Node *) node, finfo);
2259 InitFunctionCallInfoData(*fcinfo, finfo, 2,
2260 minmaxexpr->inputcollid, NULL, NULL);
2261
2262 scratch.opcode = EEOP_MINMAX;
2263 /* allocate space to store arguments */
2264 scratch.d.minmax.values =
2265 (Datum *) palloc(sizeof(Datum) * nelems);
2266 scratch.d.minmax.nulls =
2267 (bool *) palloc(sizeof(bool) * nelems);
2268 scratch.d.minmax.nelems = nelems;
2269
2270 scratch.d.minmax.op = minmaxexpr->op;
2271 scratch.d.minmax.finfo = finfo;
2272 scratch.d.minmax.fcinfo_data = fcinfo;
2273
2274 /* evaluate expressions into minmax->values/nulls */
2275 off = 0;
2276 foreach(lc, minmaxexpr->args)
2277 {
2278 Expr *e = (Expr *) lfirst(lc);
2279
2280 ExecInitExprRec(e, state,
2281 &scratch.d.minmax.values[off],
2282 &scratch.d.minmax.nulls[off]);
2283 off++;
2284 }
2285
2286 /* and push the final comparison */
2287 ExprEvalPushStep(state, &scratch);
2288 break;
2289 }
2290
2291 case T_SQLValueFunction:
2292 {
2293 SQLValueFunction *svf = (SQLValueFunction *) node;
2294
2295 scratch.opcode = EEOP_SQLVALUEFUNCTION;
2296 scratch.d.sqlvaluefunction.svf = svf;
2297
2298 ExprEvalPushStep(state, &scratch);
2299 break;
2300 }
2301
2302 case T_XmlExpr:
2303 {
2304 XmlExpr *xexpr = (XmlExpr *) node;
2305 int nnamed = list_length(xexpr->named_args);
2306 int nargs = list_length(xexpr->args);
2307 int off;
2308 ListCell *arg;
2309
2310 scratch.opcode = EEOP_XMLEXPR;
2311 scratch.d.xmlexpr.xexpr = xexpr;
2312
2313 /* allocate space for storing all the arguments */
2314 if (nnamed)
2315 {
2316 scratch.d.xmlexpr.named_argvalue =
2317 (Datum *) palloc(sizeof(Datum) * nnamed);
2318 scratch.d.xmlexpr.named_argnull =
2319 (bool *) palloc(sizeof(bool) * nnamed);
2320 }
2321 else
2322 {
2323 scratch.d.xmlexpr.named_argvalue = NULL;
2324 scratch.d.xmlexpr.named_argnull = NULL;
2325 }
2326
2327 if (nargs)
2328 {
2329 scratch.d.xmlexpr.argvalue =
2330 (Datum *) palloc(sizeof(Datum) * nargs);
2331 scratch.d.xmlexpr.argnull =
2332 (bool *) palloc(sizeof(bool) * nargs);
2333 }
2334 else
2335 {
2336 scratch.d.xmlexpr.argvalue = NULL;
2337 scratch.d.xmlexpr.argnull = NULL;
2338 }
2339
2340 /* prepare argument execution */
2341 off = 0;
2342 foreach(arg, xexpr->named_args)
2343 {
2344 Expr *e = (Expr *) lfirst(arg);
2345
2346 ExecInitExprRec(e, state,
2347 &scratch.d.xmlexpr.named_argvalue[off],
2348 &scratch.d.xmlexpr.named_argnull[off]);
2349 off++;
2350 }
2351
2352 off = 0;
2353 foreach(arg, xexpr->args)
2354 {
2355 Expr *e = (Expr *) lfirst(arg);
2356
2357 ExecInitExprRec(e, state,
2358 &scratch.d.xmlexpr.argvalue[off],
2359 &scratch.d.xmlexpr.argnull[off]);
2360 off++;
2361 }
2362
2363 /* and evaluate the actual XML expression */
2364 ExprEvalPushStep(state, &scratch);
2365 break;
2366 }
2367
2368 case T_JsonValueExpr:
2369 {
2370 JsonValueExpr *jve = (JsonValueExpr *) node;
2371
2372 Assert(jve->raw_expr != NULL);
2373 ExecInitExprRec(jve->raw_expr, state, resv, resnull);
2374 Assert(jve->formatted_expr != NULL);
2375 ExecInitExprRec(jve->formatted_expr, state, resv, resnull);
2376 break;
2377 }
2378
2379 case T_JsonConstructorExpr:
2380 {
2381 JsonConstructorExpr *ctor = (JsonConstructorExpr *) node;
2382 List *args = ctor->args;
2383 ListCell *lc;
2384 int nargs = list_length(args);
2385 int argno = 0;
2386
2387 if (ctor->func)
2388 {
2389 ExecInitExprRec(ctor->func, state, resv, resnull);
2390 }
2391 else if ((ctor->type == JSCTOR_JSON_PARSE && !ctor->unique) ||
2392 ctor->type == JSCTOR_JSON_SERIALIZE)
2393 {
2394 /* Use the value of the first argument as result */
2395 ExecInitExprRec(linitial(args), state, resv, resnull);
2396 }
2397 else
2398 {
2399 JsonConstructorExprState *jcstate;
2400
2401 jcstate = palloc0(sizeof(JsonConstructorExprState));
2402
2403 scratch.opcode = EEOP_JSON_CONSTRUCTOR;
2404 scratch.d.json_constructor.jcstate = jcstate;
2405
2406 jcstate->constructor = ctor;
2407 jcstate->arg_values = (Datum *) palloc(sizeof(Datum) * nargs);
2408 jcstate->arg_nulls = (bool *) palloc(sizeof(bool) * nargs);
2409 jcstate->arg_types = (Oid *) palloc(sizeof(Oid) * nargs);
2410 jcstate->nargs = nargs;
2411
2412 foreach(lc, args)
2413 {
2414 Expr *arg = (Expr *) lfirst(lc);
2415
2416 jcstate->arg_types[argno] = exprType((Node *) arg);
2417
2418 if (IsA(arg, Const))
2419 {
2420 /* Don't evaluate const arguments every round */
2421 Const *con = (Const *) arg;
2422
2423 jcstate->arg_values[argno] = con->constvalue;
2424 jcstate->arg_nulls[argno] = con->constisnull;
2425 }
2426 else
2427 {
2428 ExecInitExprRec(arg, state,
2429 &jcstate->arg_values[argno],
2430 &jcstate->arg_nulls[argno]);
2431 }
2432 argno++;
2433 }
2434
2435 /* prepare type cache for datum_to_json[b]() */
2436 if (ctor->type == JSCTOR_JSON_SCALAR)
2437 {
2438 bool is_jsonb =
2439 ctor->returning->format->format_type == JS_FORMAT_JSONB;
2440
2441 jcstate->arg_type_cache =
2442 palloc(sizeof(*jcstate->arg_type_cache) * nargs);
2443
2444 for (int i = 0; i < nargs; i++)
2445 {
2446 JsonTypeCategory category;
2447 Oid outfuncid;
2448 Oid typid = jcstate->arg_types[i];
2449
2450 json_categorize_type(typid, is_jsonb,
2451 &category, &outfuncid);
2452
2453 jcstate->arg_type_cache[i].outfuncid = outfuncid;
2454 jcstate->arg_type_cache[i].category = (int) category;
2455 }
2456 }
2457
2458 ExprEvalPushStep(state, &scratch);
2459 }
2460
2461 if (ctor->coercion)
2462 {
2463 Datum *innermost_caseval = state->innermost_caseval;
2464 bool *innermost_isnull = state->innermost_casenull;
2465
2466 state->innermost_caseval = resv;
2467 state->innermost_casenull = resnull;
2468
2469 ExecInitExprRec(ctor->coercion, state, resv, resnull);
2470
2471 state->innermost_caseval = innermost_caseval;
2472 state->innermost_casenull = innermost_isnull;
2473 }
2474 }
2475 break;
2476
2477 case T_JsonIsPredicate:
2478 {
2479 JsonIsPredicate *pred = (JsonIsPredicate *) node;
2480
2481 ExecInitExprRec((Expr *) pred->expr, state, resv, resnull);
2482
2483 scratch.opcode = EEOP_IS_JSON;
2484 scratch.d.is_json.pred = pred;
2485
2486 ExprEvalPushStep(state, &scratch);
2487 break;
2488 }
2489
2490 case T_JsonExpr:
2491 {
2492 JsonExpr *jsexpr = castNode(JsonExpr, node);
2493
2494 /*
2495 * No need to initialize a full JsonExprState For
2496 * JSON_TABLE(), because the upstream caller tfuncFetchRows()
2497 * is only interested in the value of formatted_expr.
2498 */
2499 if (jsexpr->op == JSON_TABLE_OP)
2500 ExecInitExprRec((Expr *) jsexpr->formatted_expr, state,
2501 resv, resnull);
2502 else
2503 ExecInitJsonExpr(jsexpr, state, resv, resnull, &scratch);
2504 break;
2505 }
2506
2507 case T_NullTest:
2508 {
2509 NullTest *ntest = (NullTest *) node;
2510
2511 if (ntest->nulltesttype == IS_NULL)
2512 {
2513 if (ntest->argisrow)
2514 scratch.opcode = EEOP_NULLTEST_ROWISNULL;
2515 else
2516 scratch.opcode = EEOP_NULLTEST_ISNULL;
2517 }
2518 else if (ntest->nulltesttype == IS_NOT_NULL)
2519 {
2520 if (ntest->argisrow)
2521 scratch.opcode = EEOP_NULLTEST_ROWISNOTNULL;
2522 else
2523 scratch.opcode = EEOP_NULLTEST_ISNOTNULL;
2524 }
2525 else
2526 {
2527 elog(ERROR, "unrecognized nulltesttype: %d",
2528 (int) ntest->nulltesttype);
2529 }
2530 /* initialize cache in case it's a row test */
2531 scratch.d.nulltest_row.rowcache.cacheptr = NULL;
2532
2533 /* first evaluate argument into result variable */
2534 ExecInitExprRec(ntest->arg, state,
2535 resv, resnull);
2536
2537 /* then push the test of that argument */
2538 ExprEvalPushStep(state, &scratch);
2539 break;
2540 }
2541
2542 case T_BooleanTest:
2543 {
2544 BooleanTest *btest = (BooleanTest *) node;
2545
2546 /*
2547 * Evaluate argument, directly into result datum. That's ok,
2548 * because resv/resnull is definitely not used anywhere else,
2549 * and will get overwritten by the below EEOP_BOOLTEST_IS_*
2550 * step.
2551 */
2552 ExecInitExprRec(btest->arg, state, resv, resnull);
2553
2554 switch (btest->booltesttype)
2555 {
2556 case IS_TRUE:
2557 scratch.opcode = EEOP_BOOLTEST_IS_TRUE;
2558 break;
2559 case IS_NOT_TRUE:
2560 scratch.opcode = EEOP_BOOLTEST_IS_NOT_TRUE;
2561 break;
2562 case IS_FALSE:
2563 scratch.opcode = EEOP_BOOLTEST_IS_FALSE;
2564 break;
2565 case IS_NOT_FALSE:
2566 scratch.opcode = EEOP_BOOLTEST_IS_NOT_FALSE;
2567 break;
2568 case IS_UNKNOWN:
2569 /* Same as scalar IS NULL test */
2570 scratch.opcode = EEOP_NULLTEST_ISNULL;
2571 break;
2572 case IS_NOT_UNKNOWN:
2573 /* Same as scalar IS NOT NULL test */
2574 scratch.opcode = EEOP_NULLTEST_ISNOTNULL;
2575 break;
2576 default:
2577 elog(ERROR, "unrecognized booltesttype: %d",
2578 (int) btest->booltesttype);
2579 }
2580
2581 ExprEvalPushStep(state, &scratch);
2582 break;
2583 }
2584
2585 case T_CoerceToDomain:
2586 {
2587 CoerceToDomain *ctest = (CoerceToDomain *) node;
2588
2589 ExecInitCoerceToDomain(&scratch, ctest, state,
2590 resv, resnull);
2591 break;
2592 }
2593
2594 case T_CoerceToDomainValue:
2595 {
2596 /*
2597 * Read from location identified by innermost_domainval. Note
2598 * that innermost_domainval could be NULL, if we're compiling
2599 * a standalone domain check rather than one embedded in a
2600 * larger expression. In that case we must read from
2601 * econtext->domainValue_datum. We'll take care of that by
2602 * generating a specialized operation.
2603 */
2604 if (state->innermost_domainval == NULL)
2605 scratch.opcode = EEOP_DOMAIN_TESTVAL_EXT;
2606 else
2607 {
2608 scratch.opcode = EEOP_DOMAIN_TESTVAL;
2609 /* we share instruction union variant with case testval */
2610 scratch.d.casetest.value = state->innermost_domainval;
2611 scratch.d.casetest.isnull = state->innermost_domainnull;
2612 }
2613 ExprEvalPushStep(state, &scratch);
2614 break;
2615 }
2616
2617 case T_CurrentOfExpr:
2618 {
2619 scratch.opcode = EEOP_CURRENTOFEXPR;
2620 ExprEvalPushStep(state, &scratch);
2621 break;
2622 }
2623
2624 case T_NextValueExpr:
2625 {
2626 NextValueExpr *nve = (NextValueExpr *) node;
2627
2628 scratch.opcode = EEOP_NEXTVALUEEXPR;
2629 scratch.d.nextvalueexpr.seqid = nve->seqid;
2630 scratch.d.nextvalueexpr.seqtypid = nve->typeId;
2631
2632 ExprEvalPushStep(state, &scratch);
2633 break;
2634 }
2635
2636 case T_ReturningExpr:
2637 {
2638 ReturningExpr *rexpr = (ReturningExpr *) node;
2639 int retstep;
2640
2641 /* Skip expression evaluation if OLD/NEW row doesn't exist */
2642 scratch.opcode = EEOP_RETURNINGEXPR;
2643 scratch.d.returningexpr.nullflag = rexpr->retold ?
2644 EEO_FLAG_OLD_IS_NULL : EEO_FLAG_NEW_IS_NULL;
2645 scratch.d.returningexpr.jumpdone = -1; /* set below */
2646 ExprEvalPushStep(state, &scratch);
2647 retstep = state->steps_len - 1;
2648
2649 /* Steps to evaluate expression to return */
2650 ExecInitExprRec(rexpr->retexpr, state, resv, resnull);
2651
2652 /* Jump target used if OLD/NEW row doesn't exist */
2653 state->steps[retstep].d.returningexpr.jumpdone = state->steps_len;
2654
2655 /* Update ExprState flags */
2656 if (rexpr->retold)
2657 state->flags |= EEO_FLAG_HAS_OLD;
2658 else
2659 state->flags |= EEO_FLAG_HAS_NEW;
2660
2661 break;
2662 }
2663
2664 default:
2665 elog(ERROR, "unrecognized node type: %d",
2666 (int) nodeTag(node));
2667 break;
2668 }
2669 }
2670
2671 /*
2672 * Add another expression evaluation step to ExprState->steps.
2673 *
2674 * Note that this potentially re-allocates es->steps, therefore no pointer
2675 * into that array may be used while the expression is still being built.
2676 */
2677 void
2678 ExprEvalPushStep(ExprState *es, const ExprEvalStep *s)
2679 {
2680 if (es->steps_alloc == 0)
2681 {
2682 es->steps_alloc = 16;
2683 es->steps = palloc(sizeof(ExprEvalStep) * es->steps_alloc);
2684 }
2685 else if (es->steps_alloc == es->steps_len)
2686 {
2687 es->steps_alloc *= 2;
2688 es->steps = repalloc(es->steps,
2689 sizeof(ExprEvalStep) * es->steps_alloc);
2690 }
2691
2692 memcpy(&es->steps[es->steps_len++], s, sizeof(ExprEvalStep));
2693 }
2694
2695 /*
2696 * Perform setup necessary for the evaluation of a function-like expression,
2697 * appending argument evaluation steps to the steps list in *state, and
2698 * setting up *scratch so it is ready to be pushed.
2699 *
2700 * *scratch is not pushed here, so that callers may override the opcode,
2701 * which is useful for function-like cases like DISTINCT.
2702 */
2703 static void
2704 ExecInitFunc(ExprEvalStep *scratch, Expr *node, List *args, Oid funcid,
2705 Oid inputcollid, ExprState *state)
2706 {
2707 int nargs = list_length(args);
2708 AclResult aclresult;
2709 FmgrInfo *flinfo;
2710 FunctionCallInfo fcinfo;
2711 int argno;
2712 ListCell *lc;
2713
2714 /* Check permission to call function */
2715 aclresult = object_aclcheck(ProcedureRelationId, funcid, GetUserId(), ACL_EXECUTE);
2716 if (aclresult != ACLCHECK_OK)
2717 aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(funcid));
2718 InvokeFunctionExecuteHook(funcid);
2719
2720 /*
2721 * Safety check on nargs. Under normal circumstances this should never
2722 * fail, as parser should check sooner. But possibly it might fail if
2723 * server has been compiled with FUNC_MAX_ARGS smaller than some functions
2724 * declared in pg_proc?
2725 */
2726 if (nargs > FUNC_MAX_ARGS)
2727 ereport(ERROR,
2728 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
2729 errmsg_plural("cannot pass more than %d argument to a function",
2730 "cannot pass more than %d arguments to a function",
2731 FUNC_MAX_ARGS,
2732 FUNC_MAX_ARGS)));
2733
2734 /* Allocate function lookup data and parameter workspace for this call */
2735 scratch->d.func.finfo = palloc0(sizeof(FmgrInfo));
2736 scratch->d.func.fcinfo_data = palloc0(SizeForFunctionCallInfo(nargs));
2737 flinfo = scratch->d.func.finfo;
2738 fcinfo = scratch->d.func.fcinfo_data;
2739
2740 /* Set up the primary fmgr lookup information */
2741 fmgr_info(funcid, flinfo);
2742 fmgr_info_set_expr((Node *) node, flinfo);
2743
2744 /* Initialize function call parameter structure too */
2745 InitFunctionCallInfoData(*fcinfo, flinfo,
2746 nargs, inputcollid, NULL, NULL);
2747
2748 /* Keep extra copies of this info to save an indirection at runtime */
2749 scratch->d.func.fn_addr = flinfo->fn_addr;
2750 scratch->d.func.nargs = nargs;
2751
2752 /* We only support non-set functions here */
2753 if (flinfo->fn_retset)
2754 ereport(ERROR,
2755 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2756 errmsg("set-valued function called in context that cannot accept a set"),
2757 state->parent ?
2758 executor_errposition(state->parent->state,
2759 exprLocation((Node *) node)) : 0));
2760
2761 /* Build code to evaluate arguments directly into the fcinfo struct */
2762 argno = 0;
2763 foreach(lc, args)
2764 {
2765 Expr *arg = (Expr *) lfirst(lc);
2766
2767 if (IsA(arg, Const))
2768 {
2769 /*
2770 * Don't evaluate const arguments every round; especially
2771 * interesting for constants in comparisons.
2772 */
2773 Const *con = (Const *) arg;
2774
2775 fcinfo->args[argno].value = con->constvalue;
2776 fcinfo->args[argno].isnull = con->constisnull;
2777 }
2778 else
2779 {
2780 ExecInitExprRec(arg, state,
2781 &fcinfo->args[argno].value,
2782 &fcinfo->args[argno].isnull);
2783 }
2784 argno++;
2785 }
2786
2787 /* Insert appropriate opcode depending on strictness and stats level */
2788 if (pgstat_track_functions <= flinfo->fn_stats)
2789 {
2790 if (flinfo->fn_strict && nargs > 0)
2791 {
2792 /* Choose nargs optimized implementation if available. */
2793 if (nargs == 1)
2794 scratch->opcode = EEOP_FUNCEXPR_STRICT_1;
2795 else if (nargs == 2)
2796 scratch->opcode = EEOP_FUNCEXPR_STRICT_2;
2797 else
2798 scratch->opcode = EEOP_FUNCEXPR_STRICT;
2799 }
2800 else
2801 scratch->opcode = EEOP_FUNCEXPR;
2802 }
2803 else
2804 {
2805 if (flinfo->fn_strict && nargs > 0)
2806 scratch->opcode = EEOP_FUNCEXPR_STRICT_FUSAGE;
2807 else
2808 scratch->opcode = EEOP_FUNCEXPR_FUSAGE;
2809 }
2810 }
2811
2812 /*
2813 * Append the steps necessary for the evaluation of a SubPlan node to
2814 * ExprState->steps.
2815 *
2816 * subplan - SubPlan expression to evaluate
2817 * state - ExprState to whose ->steps to append the necessary operations
2818 * resv / resnull - where to store the result of the node into
2819 */
2820 static void
2821 ExecInitSubPlanExpr(SubPlan *subplan,
2822 ExprState *state,
2823 Datum *resv, bool *resnull)
2824 {
2825 ExprEvalStep scratch = {0};
2826 SubPlanState *sstate;
2827 ListCell *pvar;
2828 ListCell *l;
2829
2830 if (!state->parent)
2831 elog(ERROR, "SubPlan found with no parent plan");
2832
2833 /*
2834 * Generate steps to evaluate input arguments for the subplan.
2835 *
2836 * We evaluate the argument expressions into resv/resnull, and then use
2837 * PARAM_SET to update the parameter. We do that, instead of evaluating
2838 * directly into the param, to avoid depending on the pointer value
2839 * remaining stable / being included in the generated expression. It's ok
2840 * to use resv/resnull for multiple params, as each parameter evaluation
2841 * is immediately followed by an EEOP_PARAM_SET (and thus are saved before
2842 * they could be overwritten again).
2843 *
2844 * Any calculation we have to do can be done in the parent econtext, since
2845 * the Param values don't need to have per-query lifetime.
2846 */
2847 Assert(list_length(subplan->parParam) == list_length(subplan->args));
2848 forboth(l, subplan->parParam, pvar, subplan->args)
2849 {
2850 int paramid = lfirst_int(l);
2851 Expr *arg = (Expr *) lfirst(pvar);
2852
2853 ExecInitExprRec(arg, state, resv, resnull);
2854
2855 scratch.opcode = EEOP_PARAM_SET;
2856 scratch.resvalue = resv;
2857 scratch.resnull = resnull;
2858 scratch.d.param.paramid = paramid;
2859 /* paramtype's not actually used, but we might as well fill it */
2860 scratch.d.param.paramtype = exprType((Node *) arg);
2861 ExprEvalPushStep(state, &scratch);
2862 }
2863
2864 sstate = ExecInitSubPlan(subplan, state->parent);
2865
2866 /* add SubPlanState nodes to state->parent->subPlan */
2867 state->parent->subPlan = lappend(state->parent->subPlan,
2868 sstate);
2869
2870 scratch.opcode = EEOP_SUBPLAN;
2871 scratch.resvalue = resv;
2872 scratch.resnull = resnull;
2873 scratch.d.subplan.sstate = sstate;
2874
2875 ExprEvalPushStep(state, &scratch);
2876 }
2877
2878 /*
2879 * Add expression steps performing setup that's needed before any of the
2880 * main execution of the expression.
2881 */
2882 static void
2883 ExecCreateExprSetupSteps(ExprState *state, Node *node)
2884 {
2885 ExprSetupInfo info = {0, 0, 0, 0, 0, NIL};
2886
2887 /* Prescan to find out what we need. */
2888 expr_setup_walker(node, &info);
2889
2890 /* And generate those steps. */
2891 ExecPushExprSetupSteps(state, &info);
2892 }
2893
2894 /*
2895 * Add steps performing expression setup as indicated by "info".
2896 * This is useful when building an ExprState covering more than one expression.
2897 */
2898 static void
2899 ExecPushExprSetupSteps(ExprState *state, ExprSetupInfo *info)
2900 {
2901 ExprEvalStep scratch = {0};
2902 ListCell *lc;
2903
2904 scratch.resvalue = NULL;
2905 scratch.resnull = NULL;
2906
2907 /*
2908 * Add steps deforming the ExprState's inner/outer/scan/old/new slots as
2909 * much as required by any Vars appearing in the expression.
2910 */
2911 if (info->last_inner > 0)
2912 {
2913 scratch.opcode = EEOP_INNER_FETCHSOME;
2914 scratch.d.fetch.last_var = info->last_inner;
2915 scratch.d.fetch.fixed = false;
2916 scratch.d.fetch.kind = NULL;
2917 scratch.d.fetch.known_desc = NULL;
2918 if (ExecComputeSlotInfo(state, &scratch))
2919 ExprEvalPushStep(state, &scratch);
2920 }
2921 if (info->last_outer > 0)
2922 {
2923 scratch.opcode = EEOP_OUTER_FETCHSOME;
2924 scratch.d.fetch.last_var = info->last_outer;
2925 scratch.d.fetch.fixed = false;
2926 scratch.d.fetch.kind = NULL;
2927 scratch.d.fetch.known_desc = NULL;
2928 if (ExecComputeSlotInfo(state, &scratch))
2929 ExprEvalPushStep(state, &scratch);
2930 }
2931 if (info->last_scan > 0)
2932 {
2933 scratch.opcode = EEOP_SCAN_FETCHSOME;
2934 scratch.d.fetch.last_var = info->last_scan;
2935 scratch.d.fetch.fixed = false;
2936 scratch.d.fetch.kind = NULL;
2937 scratch.d.fetch.known_desc = NULL;
2938 if (ExecComputeSlotInfo(state, &scratch))
2939 ExprEvalPushStep(state, &scratch);
2940 }
2941 if (info->last_old > 0)
2942 {
2943 scratch.opcode = EEOP_OLD_FETCHSOME;
2944 scratch.d.fetch.last_var = info->last_old;
2945 scratch.d.fetch.fixed = false;
2946 scratch.d.fetch.kind = NULL;
2947 scratch.d.fetch.known_desc = NULL;
2948 if (ExecComputeSlotInfo(state, &scratch))
2949 ExprEvalPushStep(state, &scratch);
2950 }
2951 if (info->last_new > 0)
2952 {
2953 scratch.opcode = EEOP_NEW_FETCHSOME;
2954 scratch.d.fetch.last_var = info->last_new;
2955 scratch.d.fetch.fixed = false;
2956 scratch.d.fetch.kind = NULL;
2957 scratch.d.fetch.known_desc = NULL;
2958 if (ExecComputeSlotInfo(state, &scratch))
2959 ExprEvalPushStep(state, &scratch);
2960 }
2961
2962 /*
2963 * Add steps to execute any MULTIEXPR SubPlans appearing in the
2964 * expression. We need to evaluate these before any of the Params
2965 * referencing their outputs are used, but after we've prepared for any
2966 * Var references they may contain. (There cannot be cross-references
2967 * between MULTIEXPR SubPlans, so we needn't worry about their order.)
2968 */
2969 foreach(lc, info->multiexpr_subplans)
2970 {
2971 SubPlan *subplan = (SubPlan *) lfirst(lc);
2972
2973 Assert(subplan->subLinkType == MULTIEXPR_SUBLINK);
2974
2975 /* The result can be ignored, but we better put it somewhere */
2976 ExecInitSubPlanExpr(subplan, state,
2977 &state->resvalue, &state->resnull);
2978 }
2979 }
2980
2981 /*
2982 * expr_setup_walker: expression walker for ExecCreateExprSetupSteps
2983 */
2984 static bool
2985 expr_setup_walker(Node *node, ExprSetupInfo *info)
2986 {
2987 if (node == NULL)
2988 return false;
2989 if (IsA(node, Var))
2990 {
2991 Var *variable = (Var *) node;
2992 AttrNumber attnum = variable->varattno;
2993
2994 switch (variable->varno)
2995 {
2996 case INNER_VAR:
2997 info->last_inner = Max(info->last_inner, attnum);
2998 break;
2999
3000 case OUTER_VAR:
3001 info->last_outer = Max(info->last_outer, attnum);
3002 break;
3003
3004 /* INDEX_VAR is handled by default case */
3005
3006 default:
3007 switch (variable->varreturningtype)
3008 {
3009 case VAR_RETURNING_DEFAULT:
3010 info->last_scan = Max(info->last_scan, attnum);
3011 break;
3012 case VAR_RETURNING_OLD:
3013 info->last_old = Max(info->last_old, attnum);
3014 break;
3015 case VAR_RETURNING_NEW:
3016 info->last_new = Max(info->last_new, attnum);
3017 break;
3018 }
3019 break;
3020 }
3021 return false;
3022 }
3023
3024 /* Collect all MULTIEXPR SubPlans, too */
3025 if (IsA(node, SubPlan))
3026 {
3027 SubPlan *subplan = (SubPlan *) node;
3028
3029 if (subplan->subLinkType == MULTIEXPR_SUBLINK)
3030 info->multiexpr_subplans = lappend(info->multiexpr_subplans,
3031 subplan);
3032 }
3033
3034 /*
3035 * Don't examine the arguments or filters of Aggrefs or WindowFuncs,
3036 * because those do not represent expressions to be evaluated within the
3037 * calling expression's econtext. GroupingFunc arguments are never
3038 * evaluated at all.
3039 */
3040 if (IsA(node, Aggref))
3041 return false;
3042 if (IsA(node, WindowFunc))
3043 return false;
3044 if (IsA(node, GroupingFunc))
3045 return false;
3046 return expression_tree_walker(node, expr_setup_walker, info);
3047 }
3048
3049 /*
3050 * Compute additional information for EEOP_*_FETCHSOME ops.
3051 *
3052 * The goal is to determine whether a slot is 'fixed', that is, every
3053 * evaluation of the expression will have the same type of slot, with an
3054 * equivalent descriptor.
3055 *
3056 * EEOP_OLD_FETCHSOME and EEOP_NEW_FETCHSOME are used to process RETURNING, if
3057 * OLD/NEW columns are referred to explicitly. In both cases, the tuple
3058 * descriptor comes from the parent scan node, so we treat them the same as
3059 * EEOP_SCAN_FETCHSOME.
3060 *
3061 * Returns true if the deforming step is required, false otherwise.
3062 */
3063 static bool
3064 ExecComputeSlotInfo(ExprState *state, ExprEvalStep *op)
3065 {
3066 PlanState *parent = state->parent;
3067 TupleDesc desc = NULL;
3068 const TupleTableSlotOps *tts_ops = NULL;
3069 bool isfixed = false;
3070 ExprEvalOp opcode = op->opcode;
3071
3072 Assert(opcode == EEOP_INNER_FETCHSOME ||
3073 opcode == EEOP_OUTER_FETCHSOME ||
3074 opcode == EEOP_SCAN_FETCHSOME ||
3075 opcode == EEOP_OLD_FETCHSOME ||
3076 opcode == EEOP_NEW_FETCHSOME);
3077
3078 if (op->d.fetch.known_desc != NULL)
3079 {
3080 desc = op->d.fetch.known_desc;
3081 tts_ops = op->d.fetch.kind;
3082 isfixed = op->d.fetch.kind != NULL;
3083 }
3084 else if (!parent)
3085 {
3086 isfixed = false;
3087 }
3088 else if (opcode == EEOP_INNER_FETCHSOME)
3089 {
3090 PlanState *is = innerPlanState(parent);
3091
3092 if (parent->inneropsset && !parent->inneropsfixed)
3093 {
3094 isfixed = false;
3095 }
3096 else if (parent->inneropsset && parent->innerops)
3097 {
3098 isfixed = true;
3099 tts_ops = parent->innerops;
3100 desc = ExecGetResultType(is);
3101 }
3102 else if (is)
3103 {
3104 tts_ops = ExecGetResultSlotOps(is, &isfixed);
3105 desc = ExecGetResultType(is);
3106 }
3107 }
3108 else if (opcode == EEOP_OUTER_FETCHSOME)
3109 {
3110 PlanState *os = outerPlanState(parent);
3111
3112 if (parent->outeropsset && !parent->outeropsfixed)
3113 {
3114 isfixed = false;
3115 }
3116 else if (parent->outeropsset && parent->outerops)
3117 {
3118 isfixed = true;
3119 tts_ops = parent->outerops;
3120 desc = ExecGetResultType(os);
3121 }
3122 else if (os)
3123 {
3124 tts_ops = ExecGetResultSlotOps(os, &isfixed);
3125 desc = ExecGetResultType(os);
3126 }
3127 }
3128 else if (opcode == EEOP_SCAN_FETCHSOME ||
3129 opcode == EEOP_OLD_FETCHSOME ||
3130 opcode == EEOP_NEW_FETCHSOME)
3131 {
3132 desc = parent->scandesc;
3133
3134 if (parent->scanops)
3135 tts_ops = parent->scanops;
3136
3137 if (parent->scanopsset)
3138 isfixed = parent->scanopsfixed;
3139 }
3140
3141 if (isfixed && desc != NULL && tts_ops != NULL)
3142 {
3143 op->d.fetch.fixed = true;
3144 op->d.fetch.kind = tts_ops;
3145 op->d.fetch.known_desc = desc;
3146 }
3147 else
3148 {
3149 op->d.fetch.fixed = false;
3150 op->d.fetch.kind = NULL;
3151 op->d.fetch.known_desc = NULL;
3152 }
3153
3154 /* if the slot is known to always virtual we never need to deform */
3155 if (op->d.fetch.fixed && op->d.fetch.kind == &TTSOpsVirtual)
3156 return false;
3157
3158 return true;
3159 }
3160
3161 /*
3162 * Prepare step for the evaluation of a whole-row variable.
3163 * The caller still has to push the step.
3164 */
3165 static void
3166 ExecInitWholeRowVar(ExprEvalStep *scratch, Var *variable, ExprState *state)
3167 {
3168 PlanState *parent = state->parent;
3169
3170 /* fill in all but the target */
3171 scratch->opcode = EEOP_WHOLEROW;
3172 scratch->d.wholerow.var = variable;
3173 scratch->d.wholerow.first = true;
3174 scratch->d.wholerow.slow = false;
3175 scratch->d.wholerow.tupdesc = NULL; /* filled at runtime */
3176 scratch->d.wholerow.junkFilter = NULL;
3177
3178 /* update ExprState flags if Var refers to OLD/NEW */
3179 if (variable->varreturningtype == VAR_RETURNING_OLD)
3180 state->flags |= EEO_FLAG_HAS_OLD;
3181 else if (variable->varreturningtype == VAR_RETURNING_NEW)
3182 state->flags |= EEO_FLAG_HAS_NEW;
3183
3184 /*
3185 * If the input tuple came from a subquery, it might contain "resjunk"
3186 * columns (such as GROUP BY or ORDER BY columns), which we don't want to
3187 * keep in the whole-row result. We can get rid of such columns by
3188 * passing the tuple through a JunkFilter --- but to make one, we have to
3189 * lay our hands on the subquery's targetlist. Fortunately, there are not
3190 * very many cases where this can happen, and we can identify all of them
3191 * by examining our parent PlanState. We assume this is not an issue in
3192 * standalone expressions that don't have parent plans. (Whole-row Vars
3193 * can occur in such expressions, but they will always be referencing
3194 * table rows.)
3195 */
3196 if (parent)
3197 {
3198 PlanState *subplan = NULL;
3199
3200 switch (nodeTag(parent))
3201 {
3202 case T_SubqueryScanState:
3203 subplan = ((SubqueryScanState *) parent)->subplan;
3204 break;
3205 case T_CteScanState:
3206 subplan = ((CteScanState *) parent)->cteplanstate;
3207 break;
3208 default:
3209 break;
3210 }
3211
3212 if (subplan)
3213 {
3214 bool junk_filter_needed = false;
3215 ListCell *tlist;
3216
3217 /* Detect whether subplan tlist actually has any junk columns */
3218 foreach(tlist, subplan->plan->targetlist)
3219 {
3220 TargetEntry *tle = (TargetEntry *) lfirst(tlist);
3221
3222 if (tle->resjunk)
3223 {
3224 junk_filter_needed = true;
3225 break;
3226 }
3227 }
3228
3229 /* If so, build the junkfilter now */
3230 if (junk_filter_needed)
3231 {
3232 scratch->d.wholerow.junkFilter =
3233 ExecInitJunkFilter(subplan->plan->targetlist,
3234 ExecInitExtraTupleSlot(parent->state, NULL,
3235 &TTSOpsVirtual));
3236 }
3237 }
3238 }
3239 }
3240
3241 /*
3242 * Prepare evaluation of a SubscriptingRef expression.
3243 */
3244 static void
3245 ExecInitSubscriptingRef(ExprEvalStep *scratch, SubscriptingRef *sbsref,
3246 ExprState *state, Datum *resv, bool *resnull)
3247 {
3248 bool isAssignment = (sbsref->refassgnexpr != NULL);
3249 int nupper = list_length(sbsref->refupperindexpr);
3250 int nlower = list_length(sbsref->reflowerindexpr);
3251 const SubscriptRoutines *sbsroutines;
3252 SubscriptingRefState *sbsrefstate;
3253 SubscriptExecSteps methods;
3254 char *ptr;
3255 List *adjust_jumps = NIL;
3256 ListCell *lc;
3257 int i;
3258
3259 /* Look up the subscripting support methods */
3260 sbsroutines = getSubscriptingRoutines(sbsref->refcontainertype, NULL);
3261 if (!sbsroutines)
3262 ereport(ERROR,
3263 (errcode(ERRCODE_DATATYPE_MISMATCH),
3264 errmsg("cannot subscript type %s because it does not support subscripting",
3265 format_type_be(sbsref->refcontainertype)),
3266 state->parent ?
3267 executor_errposition(state->parent->state,
3268 exprLocation((Node *) sbsref)) : 0));
3269
3270 /* Allocate sbsrefstate, with enough space for per-subscript arrays too */
3271 sbsrefstate = palloc0(MAXALIGN(sizeof(SubscriptingRefState)) +
3272 (nupper + nlower) * (sizeof(Datum) +
3273 2 * sizeof(bool)));
3274
3275 /* Fill constant fields of SubscriptingRefState */
3276 sbsrefstate->isassignment = isAssignment;
3277 sbsrefstate->numupper = nupper;
3278 sbsrefstate->numlower = nlower;
3279 /* Set up per-subscript arrays */
3280 ptr = ((char *) sbsrefstate) + MAXALIGN(sizeof(SubscriptingRefState));
3281 sbsrefstate->upperindex = (Datum *) ptr;
3282 ptr += nupper * sizeof(Datum);
3283 sbsrefstate->lowerindex = (Datum *) ptr;
3284 ptr += nlower * sizeof(Datum);
3285 sbsrefstate->upperprovided = (bool *) ptr;
3286 ptr += nupper * sizeof(bool);
3287 sbsrefstate->lowerprovided = (bool *) ptr;
3288 ptr += nlower * sizeof(bool);
3289 sbsrefstate->upperindexnull = (bool *) ptr;
3290 ptr += nupper * sizeof(bool);
3291 sbsrefstate->lowerindexnull = (bool *) ptr;
3292 /* ptr += nlower * sizeof(bool); */
3293
3294 /*
3295 * Let the container-type-specific code have a chance. It must fill the
3296 * "methods" struct with function pointers for us to possibly use in
3297 * execution steps below; and it can optionally set up some data pointed
3298 * to by the workspace field.
3299 */
3300 memset(&methods, 0, sizeof(methods));
3301 sbsroutines->exec_setup(sbsref, sbsrefstate, &methods);
3302
3303 /*
3304 * Evaluate array input. It's safe to do so into resv/resnull, because we
3305 * won't use that as target for any of the other subexpressions, and it'll
3306 * be overwritten by the final EEOP_SBSREF_FETCH/ASSIGN step, which is
3307 * pushed last.
3308 */
3309 ExecInitExprRec(sbsref->refexpr, state, resv, resnull);
3310
3311 /*
3312 * If refexpr yields NULL, and the operation should be strict, then result
3313 * is NULL. We can implement this with just JUMP_IF_NULL, since we
3314 * evaluated the array into the desired target location.
3315 */
3316 if (!isAssignment && sbsroutines->fetch_strict)
3317 {
3318 scratch->opcode = EEOP_JUMP_IF_NULL;
3319 scratch->d.jump.jumpdone = -1; /* adjust later */
3320 ExprEvalPushStep(state, scratch);
3321 adjust_jumps = lappend_int(adjust_jumps,
3322 state->steps_len - 1);
3323 }
3324
3325 /* Evaluate upper subscripts */
3326 i = 0;
3327 foreach(lc, sbsref->refupperindexpr)
3328 {
3329 Expr *e = (Expr *) lfirst(lc);
3330
3331 /* When slicing, individual subscript bounds can be omitted */
3332 if (!e)
3333 {
3334 sbsrefstate->upperprovided[i] = false;
3335 sbsrefstate->upperindexnull[i] = true;
3336 }
3337 else
3338 {
3339 sbsrefstate->upperprovided[i] = true;
3340 /* Each subscript is evaluated into appropriate array entry */
3341 ExecInitExprRec(e, state,
3342 &sbsrefstate->upperindex[i],
3343 &sbsrefstate->upperindexnull[i]);
3344 }
3345 i++;
3346 }
3347
3348 /* Evaluate lower subscripts similarly */
3349 i = 0;
3350 foreach(lc, sbsref->reflowerindexpr)
3351 {
3352 Expr *e = (Expr *) lfirst(lc);
3353
3354 /* When slicing, individual subscript bounds can be omitted */
3355 if (!e)
3356 {
3357 sbsrefstate->lowerprovided[i] = false;
3358 sbsrefstate->lowerindexnull[i] = true;
3359 }
3360 else
3361 {
3362 sbsrefstate->lowerprovided[i] = true;
3363 /* Each subscript is evaluated into appropriate array entry */
3364 ExecInitExprRec(e, state,
3365 &sbsrefstate->lowerindex[i],
3366 &sbsrefstate->lowerindexnull[i]);
3367 }
3368 i++;
3369 }
3370
3371 /* SBSREF_SUBSCRIPTS checks and converts all the subscripts at once */
3372 if (methods.sbs_check_subscripts)
3373 {
3374 scratch->opcode = EEOP_SBSREF_SUBSCRIPTS;
3375 scratch->d.sbsref_subscript.subscriptfunc = methods.sbs_check_subscripts;
3376 scratch->d.sbsref_subscript.state = sbsrefstate;
3377 scratch->d.sbsref_subscript.jumpdone = -1; /* adjust later */
3378 ExprEvalPushStep(state, scratch);
3379 adjust_jumps = lappend_int(adjust_jumps,
3380 state->steps_len - 1);
3381 }
3382
3383 if (isAssignment)
3384 {
3385 Datum *save_innermost_caseval;
3386 bool *save_innermost_casenull;
3387
3388 /* Check for unimplemented methods */
3389 if (!methods.sbs_assign)
3390 ereport(ERROR,
3391 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3392 errmsg("type %s does not support subscripted assignment",
3393 format_type_be(sbsref->refcontainertype))));
3394
3395 /*
3396 * We might have a nested-assignment situation, in which the
3397 * refassgnexpr is itself a FieldStore or SubscriptingRef that needs
3398 * to obtain and modify the previous value of the array element or
3399 * slice being replaced. If so, we have to extract that value from
3400 * the array and pass it down via the CaseTestExpr mechanism. It's
3401 * safe to reuse the CASE mechanism because there cannot be a CASE
3402 * between here and where the value would be needed, and an array
3403 * assignment can't be within a CASE either. (So saving and restoring
3404 * innermost_caseval is just paranoia, but let's do it anyway.)
3405 *
3406 * Since fetching the old element might be a nontrivial expense, do it
3407 * only if the argument actually needs it.
3408 */
3409 if (isAssignmentIndirectionExpr(sbsref->refassgnexpr))
3410 {
3411 if (!methods.sbs_fetch_old)
3412 ereport(ERROR,
3413 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3414 errmsg("type %s does not support subscripted assignment",
3415 format_type_be(sbsref->refcontainertype))));
3416 scratch->opcode = EEOP_SBSREF_OLD;
3417 scratch->d.sbsref.subscriptfunc = methods.sbs_fetch_old;
3418 scratch->d.sbsref.state = sbsrefstate;
3419 ExprEvalPushStep(state, scratch);
3420 }
3421
3422 /* SBSREF_OLD puts extracted value into prevvalue/prevnull */
3423 save_innermost_caseval = state->innermost_caseval;
3424 save_innermost_casenull = state->innermost_casenull;
3425 state->innermost_caseval = &sbsrefstate->prevvalue;
3426 state->innermost_casenull = &sbsrefstate->prevnull;
3427
3428 /* evaluate replacement value into replacevalue/replacenull */
3429 ExecInitExprRec(sbsref->refassgnexpr, state,
3430 &sbsrefstate->replacevalue, &sbsrefstate->replacenull);
3431
3432 state->innermost_caseval = save_innermost_caseval;
3433 state->innermost_casenull = save_innermost_casenull;
3434
3435 /* and perform the assignment */
3436 scratch->opcode = EEOP_SBSREF_ASSIGN;
3437 scratch->d.sbsref.subscriptfunc = methods.sbs_assign;
3438 scratch->d.sbsref.state = sbsrefstate;
3439 ExprEvalPushStep(state, scratch);
3440 }
3441 else
3442 {
3443 /* array fetch is much simpler */
3444 scratch->opcode = EEOP_SBSREF_FETCH;
3445 scratch->d.sbsref.subscriptfunc = methods.sbs_fetch;
3446 scratch->d.sbsref.state = sbsrefstate;
3447 ExprEvalPushStep(state, scratch);
3448 }
3449
3450 /* adjust jump targets */
3451 foreach(lc, adjust_jumps)
3452 {
3453 ExprEvalStep *as = &state->steps[lfirst_int(lc)];
3454
3455 if (as->opcode == EEOP_SBSREF_SUBSCRIPTS)
3456 {
3457 Assert(as->d.sbsref_subscript.jumpdone == -1);
3458 as->d.sbsref_subscript.jumpdone = state->steps_len;
3459 }
3460 else
3461 {
3462 Assert(as->opcode == EEOP_JUMP_IF_NULL);
3463 Assert(as->d.jump.jumpdone == -1);
3464 as->d.jump.jumpdone = state->steps_len;
3465 }
3466 }
3467 }
3468
3469 /*
3470 * Helper for preparing SubscriptingRef expressions for evaluation: is expr
3471 * a nested FieldStore or SubscriptingRef that needs the old element value
3472 * passed down?
3473 *
3474 * (We could use this in FieldStore too, but in that case passing the old
3475 * value is so cheap there's no need.)
3476 *
3477 * Note: it might seem that this needs to recurse, but in most cases it does
3478 * not; the CaseTestExpr, if any, will be directly the arg or refexpr of the
3479 * top-level node. Nested-assignment situations give rise to expression
3480 * trees in which each level of assignment has its own CaseTestExpr, and the
3481 * recursive structure appears within the newvals or refassgnexpr field.
3482 * There is an exception, though: if the array is an array-of-domain, we will
3483 * have a CoerceToDomain or RelabelType as the refassgnexpr, and we need to
3484 * be able to look through that.
3485 */
3486 static bool
3487 isAssignmentIndirectionExpr(Expr *expr)
3488 {
3489 if (expr == NULL)
3490 return false; /* just paranoia */
3491 if (IsA(expr, FieldStore))
3492 {
3493 FieldStore *fstore = (FieldStore *) expr;
3494
3495 if (fstore->arg && IsA(fstore->arg, CaseTestExpr))
3496 return true;
3497 }
3498 else if (IsA(expr, SubscriptingRef))
3499 {
3500 SubscriptingRef *sbsRef = (SubscriptingRef *) expr;
3501
3502 if (sbsRef->refexpr && IsA(sbsRef->refexpr, CaseTestExpr))
3503 return true;
3504 }
3505 else if (IsA(expr, CoerceToDomain))
3506 {
3507 CoerceToDomain *cd = (CoerceToDomain *) expr;
3508
3509 return isAssignmentIndirectionExpr(cd->arg);
3510 }
3511 else if (IsA(expr, RelabelType))
3512 {
3513 RelabelType *r = (RelabelType *) expr;
3514
3515 return isAssignmentIndirectionExpr(r->arg);
3516 }
3517 return false;
3518 }
3519
3520 /*
3521 * Prepare evaluation of a CoerceToDomain expression.
3522 */
3523 static void
3524 ExecInitCoerceToDomain(ExprEvalStep *scratch, CoerceToDomain *ctest,
3525 ExprState *state, Datum *resv, bool *resnull)
3526 {
3527 DomainConstraintRef *constraint_ref;
3528 Datum *domainval = NULL;
3529 bool *domainnull = NULL;
3530 ListCell *l;
3531
3532 scratch->d.domaincheck.resulttype = ctest->resulttype;
3533 /* we'll allocate workspace only if needed */
3534 scratch->d.domaincheck.checkvalue = NULL;
3535 scratch->d.domaincheck.checknull = NULL;
3536 scratch->d.domaincheck.escontext = state->escontext;
3537
3538 /*
3539 * Evaluate argument - it's fine to directly store it into resv/resnull,
3540 * if there's constraint failures there'll be errors, otherwise it's what
3541 * needs to be returned.
3542 */
3543 ExecInitExprRec(ctest->arg, state, resv, resnull);
3544
3545 /*
3546 * Note: if the argument is of varlena type, it could be a R/W expanded
3547 * object. We want to return the R/W pointer as the final result, but we
3548 * have to pass a R/O pointer as the value to be tested by any functions
3549 * in check expressions. We don't bother to emit a MAKE_READONLY step
3550 * unless there's actually at least one check expression, though. Until
3551 * we've tested that, domainval/domainnull are NULL.
3552 */
3553
3554 /*
3555 * Collect the constraints associated with the domain.
3556 *
3557 * Note: before PG v10 we'd recheck the set of constraints during each
3558 * evaluation of the expression. Now we bake them into the ExprState
3559 * during executor initialization. That means we don't need typcache.c to
3560 * provide compiled exprs.
3561 */
3562 constraint_ref = (DomainConstraintRef *)
3563 palloc(sizeof(DomainConstraintRef));
3564 InitDomainConstraintRef(ctest->resulttype,
3565 constraint_ref,
3566 CurrentMemoryContext,
3567 false);
3568
3569 /*
3570 * Compile code to check each domain constraint. NOTNULL constraints can
3571 * just be applied on the resv/resnull value, but for CHECK constraints we
3572 * need more pushups.
3573 */
3574 foreach(l, constraint_ref->constraints)
3575 {
3576 DomainConstraintState *con = (DomainConstraintState *) lfirst(l);
3577 Datum *save_innermost_domainval;
3578 bool *save_innermost_domainnull;
3579
3580 scratch->d.domaincheck.constraintname = con->name;
3581
3582 switch (con->constrainttype)
3583 {
3584 case DOM_CONSTRAINT_NOTNULL:
3585 scratch->opcode = EEOP_DOMAIN_NOTNULL;
3586 ExprEvalPushStep(state, scratch);
3587 break;
3588 case DOM_CONSTRAINT_CHECK:
3589 /* Allocate workspace for CHECK output if we didn't yet */
3590 if (scratch->d.domaincheck.checkvalue == NULL)
3591 {
3592 scratch->d.domaincheck.checkvalue =
3593 (Datum *) palloc(sizeof(Datum));
3594 scratch->d.domaincheck.checknull =
3595 (bool *) palloc(sizeof(bool));
3596 }
3597
3598 /*
3599 * If first time through, determine where CoerceToDomainValue
3600 * nodes should read from.
3601 */
3602 if (domainval == NULL)
3603 {
3604 /*
3605 * Since value might be read multiple times, force to R/O
3606 * - but only if it could be an expanded datum.
3607 */
3608 if (get_typlen(ctest->resulttype) == -1)
3609 {
3610 ExprEvalStep scratch2 = {0};
3611
3612 /* Yes, so make output workspace for MAKE_READONLY */
3613 domainval = (Datum *) palloc(sizeof(Datum));
3614 domainnull = (bool *) palloc(sizeof(bool));
3615
3616 /* Emit MAKE_READONLY */
3617 scratch2.opcode = EEOP_MAKE_READONLY;
3618 scratch2.resvalue = domainval;
3619 scratch2.resnull = domainnull;
3620 scratch2.d.make_readonly.value = resv;
3621 scratch2.d.make_readonly.isnull = resnull;
3622 ExprEvalPushStep(state, &scratch2);
3623 }
3624 else
3625 {
3626 /* No, so it's fine to read from resv/resnull */
3627 domainval = resv;
3628 domainnull = resnull;
3629 }
3630 }
3631
3632 /*
3633 * Set up value to be returned by CoerceToDomainValue nodes.
3634 * We must save and restore innermost_domainval/null fields,
3635 * in case this node is itself within a check expression for
3636 * another domain.
3637 */
3638 save_innermost_domainval = state->innermost_domainval;
3639 save_innermost_domainnull = state->innermost_domainnull;
3640 state->innermost_domainval = domainval;
3641 state->innermost_domainnull = domainnull;
3642
3643 /* evaluate check expression value */
3644 ExecInitExprRec(con->check_expr, state,
3645 scratch->d.domaincheck.checkvalue,
3646 scratch->d.domaincheck.checknull);
3647
3648 state->innermost_domainval = save_innermost_domainval;
3649 state->innermost_domainnull = save_innermost_domainnull;
3650
3651 /* now test result */
3652 scratch->opcode = EEOP_DOMAIN_CHECK;
3653 ExprEvalPushStep(state, scratch);
3654
3655 break;
3656 default:
3657 elog(ERROR, "unrecognized constraint type: %d",
3658 (int) con->constrainttype);
3659 break;
3660 }
3661 }
3662 }
3663
3664 /*
3665 * Build transition/combine function invocations for all aggregate transition
3666 * / combination function invocations in a grouping sets phase. This has to
3667 * invoke all sort based transitions in a phase (if doSort is true), all hash
3668 * based transitions (if doHash is true), or both (both true).
3669 *
3670 * The resulting expression will, for each set of transition values, first
3671 * check for filters, evaluate aggregate input, check that that input is not
3672 * NULL for a strict transition function, and then finally invoke the
3673 * transition for each of the concurrently computed grouping sets.
3674 *
3675 * If nullcheck is true, the generated code will check for a NULL pointer to
3676 * the array of AggStatePerGroup, and skip evaluation if so.
3677 */
3678 ExprState *
3679 ExecBuildAggTrans(AggState *aggstate, AggStatePerPhase phase,
3680 bool doSort, bool doHash, bool nullcheck)
3681 {
3682 ExprState *state = makeNode(ExprState);
3683 PlanState *parent = &aggstate->ss.ps;
3684 ExprEvalStep scratch = {0};
3685 bool isCombine = DO_AGGSPLIT_COMBINE(aggstate->aggsplit);
3686 ExprSetupInfo deform = {0, 0, 0, 0, 0, NIL};
3687
3688 state->expr = (Expr *) aggstate;
3689 state->parent = parent;
3690
3691 scratch.resvalue = &state->resvalue;
3692 scratch.resnull = &state->resnull;
3693
3694 /*
3695 * First figure out which slots, and how many columns from each, we're
3696 * going to need.
3697 */
3698 for (int transno = 0; transno < aggstate->numtrans; transno++)
3699 {
3700 AggStatePerTrans pertrans = &aggstate->pertrans[transno];
3701
3702 expr_setup_walker((Node *) pertrans->aggref->aggdirectargs,
3703 &deform);
3704 expr_setup_walker((Node *) pertrans->aggref->args,
3705 &deform);
3706 expr_setup_walker((Node *) pertrans->aggref->aggorder,
3707 &deform);
3708 expr_setup_walker((Node *) pertrans->aggref->aggdistinct,
3709 &deform);
3710 expr_setup_walker((Node *) pertrans->aggref->aggfilter,
3711 &deform);
3712 }
3713 ExecPushExprSetupSteps(state, &deform);
3714
3715 /*
3716 * Emit instructions for each transition value / grouping set combination.
3717 */
3718 for (int transno = 0; transno < aggstate->numtrans; transno++)
3719 {
3720 AggStatePerTrans pertrans = &aggstate->pertrans[transno];
3721 FunctionCallInfo trans_fcinfo = pertrans->transfn_fcinfo;
3722 List *adjust_bailout = NIL;
3723 NullableDatum *strictargs = NULL;
3724 bool *strictnulls = NULL;
3725 int argno;
3726 ListCell *bail;
3727
3728 /*
3729 * If filter present, emit. Do so before evaluating the input, to
3730 * avoid potentially unneeded computations, or even worse, unintended
3731 * side-effects. When combining, all the necessary filtering has
3732 * already been done.
3733 */
3734 if (pertrans->aggref->aggfilter && !isCombine)
3735 {
3736 /* evaluate filter expression */
3737 ExecInitExprRec(pertrans->aggref->aggfilter, state,
3738 &state->resvalue, &state->resnull);
3739 /* and jump out if false */
3740 scratch.opcode = EEOP_JUMP_IF_NOT_TRUE;
3741 scratch.d.jump.jumpdone = -1; /* adjust later */
3742 ExprEvalPushStep(state, &scratch);
3743 adjust_bailout = lappend_int(adjust_bailout,
3744 state->steps_len - 1);
3745 }
3746
3747 /*
3748 * Evaluate arguments to aggregate/combine function.
3749 */
3750 argno = 0;
3751 if (isCombine)
3752 {
3753 /*
3754 * Combining two aggregate transition values. Instead of directly
3755 * coming from a tuple the input is a, potentially deserialized,
3756 * transition value.
3757 */
3758 TargetEntry *source_tle;
3759
3760 Assert(pertrans->numSortCols == 0);
3761 Assert(list_length(pertrans->aggref->args) == 1);
3762
3763 strictargs = trans_fcinfo->args + 1;
3764 source_tle = (TargetEntry *) linitial(pertrans->aggref->args);
3765
3766 /*
3767 * deserialfn_oid will be set if we must deserialize the input
3768 * state before calling the combine function.
3769 */
3770 if (!OidIsValid(pertrans->deserialfn_oid))
3771 {
3772 /*
3773 * Start from 1, since the 0th arg will be the transition
3774 * value
3775 */
3776 ExecInitExprRec(source_tle->expr, state,
3777 &trans_fcinfo->args[argno + 1].value,
3778 &trans_fcinfo->args[argno + 1].isnull);
3779 }
3780 else
3781 {
3782 FunctionCallInfo ds_fcinfo = pertrans->deserialfn_fcinfo;
3783
3784 /* evaluate argument */
3785 ExecInitExprRec(source_tle->expr, state,
3786 &ds_fcinfo->args[0].value,
3787 &ds_fcinfo->args[0].isnull);
3788
3789 /* Dummy second argument for type-safety reasons */
3790 ds_fcinfo->args[1].value = PointerGetDatum(NULL);
3791 ds_fcinfo->args[1].isnull = false;
3792
3793 /*
3794 * Don't call a strict deserialization function with NULL
3795 * input
3796 */
3797 if (pertrans->deserialfn.fn_strict)
3798 scratch.opcode = EEOP_AGG_STRICT_DESERIALIZE;
3799 else
3800 scratch.opcode = EEOP_AGG_DESERIALIZE;
3801
3802 scratch.d.agg_deserialize.fcinfo_data = ds_fcinfo;
3803 scratch.d.agg_deserialize.jumpnull = -1; /* adjust later */
3804 scratch.resvalue = &trans_fcinfo->args[argno + 1].value;
3805 scratch.resnull = &trans_fcinfo->args[argno + 1].isnull;
3806
3807 ExprEvalPushStep(state, &scratch);
3808 /* don't add an adjustment unless the function is strict */
3809 if (pertrans->deserialfn.fn_strict)
3810 adjust_bailout = lappend_int(adjust_bailout,
3811 state->steps_len - 1);
3812
3813 /* restore normal settings of scratch fields */
3814 scratch.resvalue = &state->resvalue;
3815 scratch.resnull = &state->resnull;
3816 }
3817 argno++;
3818
3819 Assert(pertrans->numInputs == argno);
3820 }
3821 else if (!pertrans->aggsortrequired)
3822 {
3823 ListCell *arg;
3824
3825 /*
3826 * Normal transition function without ORDER BY / DISTINCT or with
3827 * ORDER BY / DISTINCT but the planner has given us pre-sorted
3828 * input.
3829 */
3830 strictargs = trans_fcinfo->args + 1;
3831
3832 foreach(arg, pertrans->aggref->args)
3833 {
3834 TargetEntry *source_tle = (TargetEntry *) lfirst(arg);
3835
3836 /*
3837 * Don't initialize args for any ORDER BY clause that might
3838 * exist in a presorted aggregate.
3839 */
3840 if (argno == pertrans->numTransInputs)
3841 break;
3842
3843 /*
3844 * Start from 1, since the 0th arg will be the transition
3845 * value
3846 */
3847 ExecInitExprRec(source_tle->expr, state,
3848 &trans_fcinfo->args[argno + 1].value,
3849 &trans_fcinfo->args[argno + 1].isnull);
3850 argno++;
3851 }
3852 Assert(pertrans->numTransInputs == argno);
3853 }
3854 else if (pertrans->numInputs == 1)
3855 {
3856 /*
3857 * Non-presorted DISTINCT and/or ORDER BY case, with a single
3858 * column sorted on.
3859 */
3860 TargetEntry *source_tle =
3861 (TargetEntry *) linitial(pertrans->aggref->args);
3862
3863 Assert(list_length(pertrans->aggref->args) == 1);
3864
3865 ExecInitExprRec(source_tle->expr, state,
3866 &state->resvalue,
3867 &state->resnull);
3868 strictnulls = &state->resnull;
3869 argno++;
3870
3871 Assert(pertrans->numInputs == argno);
3872 }
3873 else
3874 {
3875 /*
3876 * Non-presorted DISTINCT and/or ORDER BY case, with multiple
3877 * columns sorted on.
3878 */
3879 Datum *values = pertrans->sortslot->tts_values;
3880 bool *nulls = pertrans->sortslot->tts_isnull;
3881 ListCell *arg;
3882
3883 strictnulls = nulls;
3884
3885 foreach(arg, pertrans->aggref->args)
3886 {
3887 TargetEntry *source_tle = (TargetEntry *) lfirst(arg);
3888
3889 ExecInitExprRec(source_tle->expr, state,
3890 &values[argno], &nulls[argno]);
3891 argno++;
3892 }
3893 Assert(pertrans->numInputs == argno);
3894 }
3895
3896 /*
3897 * For a strict transfn, nothing happens when there's a NULL input; we
3898 * just keep the prior transValue. This is true for both plain and
3899 * sorted/distinct aggregates.
3900 */
3901 if (trans_fcinfo->flinfo->fn_strict && pertrans->numTransInputs > 0)
3902 {
3903 if (strictnulls)
3904 scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_NULLS;
3905 else if (strictargs && pertrans->numTransInputs == 1)
3906 scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1;
3907 else
3908 scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_ARGS;
3909 scratch.d.agg_strict_input_check.nulls = strictnulls;
3910 scratch.d.agg_strict_input_check.args = strictargs;
3911 scratch.d.agg_strict_input_check.jumpnull = -1; /* adjust later */
3912 scratch.d.agg_strict_input_check.nargs = pertrans->numTransInputs;
3913 ExprEvalPushStep(state, &scratch);
3914 adjust_bailout = lappend_int(adjust_bailout,
3915 state->steps_len - 1);
3916 }
3917
3918 /* Handle DISTINCT aggregates which have pre-sorted input */
3919 if (pertrans->numDistinctCols > 0 && !pertrans->aggsortrequired)
3920 {
3921 if (pertrans->numDistinctCols > 1)
3922 scratch.opcode = EEOP_AGG_PRESORTED_DISTINCT_MULTI;
3923 else
3924 scratch.opcode = EEOP_AGG_PRESORTED_DISTINCT_SINGLE;
3925
3926 scratch.d.agg_presorted_distinctcheck.pertrans = pertrans;
3927 scratch.d.agg_presorted_distinctcheck.jumpdistinct = -1; /* adjust later */
3928 ExprEvalPushStep(state, &scratch);
3929 adjust_bailout = lappend_int(adjust_bailout,
3930 state->steps_len - 1);
3931 }
3932
3933 /*
3934 * Call transition function (once for each concurrently evaluated
3935 * grouping set). Do so for both sort and hash based computations, as
3936 * applicable.
3937 */
3938 if (doSort)
3939 {
3940 int processGroupingSets = Max(phase->numsets, 1);
3941 int setoff = 0;
3942
3943 for (int setno = 0; setno < processGroupingSets; setno++)
3944 {
3945 ExecBuildAggTransCall(state, aggstate, &scratch, trans_fcinfo,
3946 pertrans, transno, setno, setoff, false,
3947 nullcheck);
3948 setoff++;
3949 }
3950 }
3951
3952 if (doHash)
3953 {
3954 int numHashes = aggstate->num_hashes;
3955 int setoff;
3956
3957 /* in MIXED mode, there'll be preceding transition values */
3958 if (aggstate->aggstrategy != AGG_HASHED)
3959 setoff = aggstate->maxsets;
3960 else
3961 setoff = 0;
3962
3963 for (int setno = 0; setno < numHashes; setno++)
3964 {
3965 ExecBuildAggTransCall(state, aggstate, &scratch, trans_fcinfo,
3966 pertrans, transno, setno, setoff, true,
3967 nullcheck);
3968 setoff++;
3969 }
3970 }
3971
3972 /* adjust early bail out jump target(s) */
3973 foreach(bail, adjust_bailout)
3974 {
3975 ExprEvalStep *as = &state->steps[lfirst_int(bail)];
3976
3977 if (as->opcode == EEOP_JUMP_IF_NOT_TRUE)
3978 {
3979 Assert(as->d.jump.jumpdone == -1);
3980 as->d.jump.jumpdone = state->steps_len;
3981 }
3982 else if (as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_ARGS ||
3983 as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1 ||
3984 as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_NULLS)
3985 {
3986 Assert(as->d.agg_strict_input_check.jumpnull == -1);
3987 as->d.agg_strict_input_check.jumpnull = state->steps_len;
3988 }
3989 else if (as->opcode == EEOP_AGG_STRICT_DESERIALIZE)
3990 {
3991 Assert(as->d.agg_deserialize.jumpnull == -1);
3992 as->d.agg_deserialize.jumpnull = state->steps_len;
3993 }
3994 else if (as->opcode == EEOP_AGG_PRESORTED_DISTINCT_SINGLE ||
3995 as->opcode == EEOP_AGG_PRESORTED_DISTINCT_MULTI)
3996 {
3997 Assert(as->d.agg_presorted_distinctcheck.jumpdistinct == -1);
3998 as->d.agg_presorted_distinctcheck.jumpdistinct = state->steps_len;
3999 }
4000 else
4001 Assert(false);
4002 }
4003 }
4004
4005 scratch.resvalue = NULL;
4006 scratch.resnull = NULL;
4007 scratch.opcode = EEOP_DONE_NO_RETURN;
4008 ExprEvalPushStep(state, &scratch);
4009
4010 ExecReadyExpr(state);
4011
4012 return state;
4013 }
4014
4015 /*
4016 * Build transition/combine function invocation for a single transition
4017 * value. This is separated from ExecBuildAggTrans() because there are
4018 * multiple callsites (hash and sort in some grouping set cases).
4019 */
4020 static void
4021 ExecBuildAggTransCall(ExprState *state, AggState *aggstate,
4022 ExprEvalStep *scratch,
4023 FunctionCallInfo fcinfo, AggStatePerTrans pertrans,
4024 int transno, int setno, int setoff, bool ishash,
4025 bool nullcheck)
4026 {
4027 ExprContext *aggcontext;
4028 int adjust_jumpnull = -1;
4029
4030 if (ishash)
4031 aggcontext = aggstate->hashcontext;
4032 else
4033 aggcontext = aggstate->aggcontexts[setno];
4034
4035 /* add check for NULL pointer? */
4036 if (nullcheck)
4037 {
4038 scratch->opcode = EEOP_AGG_PLAIN_PERGROUP_NULLCHECK;
4039 scratch->d.agg_plain_pergroup_nullcheck.setoff = setoff;
4040 /* adjust later */
4041 scratch->d.agg_plain_pergroup_nullcheck.jumpnull = -1;
4042 ExprEvalPushStep(state, scratch);
4043 adjust_jumpnull = state->steps_len - 1;
4044 }
4045
4046 /*
4047 * Determine appropriate transition implementation.
4048 *
4049 * For non-ordered aggregates and ORDER BY / DISTINCT aggregates with
4050 * presorted input:
4051 *
4052 * If the initial value for the transition state doesn't exist in the
4053 * pg_aggregate table then we will let the first non-NULL value returned
4054 * from the outer procNode become the initial value. (This is useful for
4055 * aggregates like max() and min().) The noTransValue flag signals that we
4056 * need to do so. If true, generate a
4057 * EEOP_AGG_INIT_STRICT_PLAIN_TRANS{,_BYVAL} step. This step also needs to
4058 * do the work described next:
4059 *
4060 * If the function is strict, but does have an initial value, choose
4061 * EEOP_AGG_STRICT_PLAIN_TRANS{,_BYVAL}, which skips the transition
4062 * function if the transition value has become NULL (because a previous
4063 * transition function returned NULL). This step also needs to do the work
4064 * described next:
4065 *
4066 * Otherwise we call EEOP_AGG_PLAIN_TRANS{,_BYVAL}, which does not have to
4067 * perform either of the above checks.
4068 *
4069 * Having steps with overlapping responsibilities is not nice, but
4070 * aggregations are very performance sensitive, making this worthwhile.
4071 *
4072 * For ordered aggregates:
4073 *
4074 * Only need to choose between the faster path for a single ordered
4075 * column, and the one between multiple columns. Checking strictness etc
4076 * is done when finalizing the aggregate. See
4077 * process_ordered_aggregate_{single, multi} and
4078 * advance_transition_function.
4079 */
4080 if (!pertrans->aggsortrequired)
4081 {
4082 if (pertrans->transtypeByVal)
4083 {
4084 if (fcinfo->flinfo->fn_strict &&
4085 pertrans->initValueIsNull)
4086 scratch->opcode = EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL;
4087 else if (fcinfo->flinfo->fn_strict)
4088 scratch->opcode = EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL;
4089 else
4090 scratch->opcode = EEOP_AGG_PLAIN_TRANS_BYVAL;
4091 }
4092 else
4093 {
4094 if (fcinfo->flinfo->fn_strict &&
4095 pertrans->initValueIsNull)
4096 scratch->opcode = EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF;
4097 else if (fcinfo->flinfo->fn_strict)
4098 scratch->opcode = EEOP_AGG_PLAIN_TRANS_STRICT_BYREF;
4099 else
4100 scratch->opcode = EEOP_AGG_PLAIN_TRANS_BYREF;
4101 }
4102 }
4103 else if (pertrans->numInputs == 1)
4104 scratch->opcode = EEOP_AGG_ORDERED_TRANS_DATUM;
4105 else
4106 scratch->opcode = EEOP_AGG_ORDERED_TRANS_TUPLE;
4107
4108 scratch->d.agg_trans.pertrans = pertrans;
4109 scratch->d.agg_trans.setno = setno;
4110 scratch->d.agg_trans.setoff = setoff;
4111 scratch->d.agg_trans.transno = transno;
4112 scratch->d.agg_trans.aggcontext = aggcontext;
4113 ExprEvalPushStep(state, scratch);
4114
4115 /* fix up jumpnull */
4116 if (adjust_jumpnull != -1)
4117 {
4118 ExprEvalStep *as = &state->steps[adjust_jumpnull];
4119
4120 Assert(as->opcode == EEOP_AGG_PLAIN_PERGROUP_NULLCHECK);
4121 Assert(as->d.agg_plain_pergroup_nullcheck.jumpnull == -1);
4122 as->d.agg_plain_pergroup_nullcheck.jumpnull = state->steps_len;
4123 }
4124 }
4125
4126 /*
4127 * Build an ExprState that calls the given hash function(s) on the attnums
4128 * given by 'keyColIdx' . When numCols > 1, the hash values returned by each
4129 * hash function are combined to produce a single hash value.
4130 *
4131 * desc: tuple descriptor for the to-be-hashed columns
4132 * ops: TupleTableSlotOps to use for the give TupleDesc
4133 * hashfunctions: FmgrInfos for each hash function to call, one per numCols.
4134 * These are used directly in the returned ExprState so must remain allocated.
4135 * collations: collation to use when calling the hash function.
4136 * numCols: array length of hashfunctions, collations and keyColIdx.
4137 * parent: PlanState node that the resulting ExprState will be evaluated at
4138 * init_value: Normally 0, but can be set to other values to seed the hash
4139 * with. Non-zero is marginally slower, so best to only use if it's provably
4140 * worthwhile.
4141 */
4142 ExprState *
4143 ExecBuildHash32FromAttrs(TupleDesc desc, const TupleTableSlotOps *ops,
4144 FmgrInfo *hashfunctions, Oid *collations,
4145 int numCols, AttrNumber *keyColIdx,
4146 PlanState *parent, uint32 init_value)
4147 {
4148 ExprState *state = makeNode(ExprState);
4149 ExprEvalStep scratch = {0};
4150 NullableDatum *iresult = NULL;
4151 intptr_t opcode;
4152 AttrNumber last_attnum = 0;
4153
4154 Assert(numCols >= 0);
4155
4156 state->parent = parent;
4157
4158 /*
4159 * Make a place to store intermediate hash values between subsequent
4160 * hashing of individual columns. We only need this if there is more than
4161 * one column to hash or an initial value plus one column.
4162 */
4163 if ((int64) numCols + (init_value != 0) > 1)
4164 iresult = palloc(sizeof(NullableDatum));
4165
4166 /* find the highest attnum so we deform the tuple to that point */
4167 for (int i = 0; i < numCols; i++)
4168 last_attnum = Max(last_attnum, keyColIdx[i]);
4169
4170 scratch.opcode = EEOP_INNER_FETCHSOME;
4171 scratch.d.fetch.last_var = last_attnum;
4172 scratch.d.fetch.fixed = false;
4173 scratch.d.fetch.kind = ops;
4174 scratch.d.fetch.known_desc = desc;
4175 if (ExecComputeSlotInfo(state, &scratch))
4176 ExprEvalPushStep(state, &scratch);
4177
4178 if (init_value == 0)
4179 {
4180 /*
4181 * No initial value, so we can assign the result of the hash function
4182 * for the first attribute without having to concern ourselves with
4183 * combining the result with any initial value.
4184 */
4185 opcode = EEOP_HASHDATUM_FIRST;
4186 }
4187 else
4188 {
4189 /*
4190 * Set up operation to set the initial value. Normally we store this
4191 * in the intermediate hash value location, but if there are no
4192 * columns to hash, store it in the ExprState's result field.
4193 */
4194 scratch.opcode = EEOP_HASHDATUM_SET_INITVAL;
4195 scratch.d.hashdatum_initvalue.init_value = UInt32GetDatum(init_value);
4196 scratch.resvalue = numCols > 0 ? &iresult->value : &state->resvalue;
4197 scratch.resnull = numCols > 0 ? &iresult->isnull : &state->resnull;
4198
4199 ExprEvalPushStep(state, &scratch);
4200
4201 /*
4202 * When using an initial value use the NEXT32 ops as the FIRST ops
4203 * would overwrite the stored initial value.
4204 */
4205 opcode = EEOP_HASHDATUM_NEXT32;
4206 }
4207
4208 for (int i = 0; i < numCols; i++)
4209 {
4210 FmgrInfo *finfo;
4211 FunctionCallInfo fcinfo;
4212 Oid inputcollid = collations[i];
4213 AttrNumber attnum = keyColIdx[i] - 1;
4214
4215 finfo = &hashfunctions[i];
4216 fcinfo = palloc0(SizeForFunctionCallInfo(1));
4217
4218 /* Initialize function call parameter structure too */
4219 InitFunctionCallInfoData(*fcinfo, finfo, 1, inputcollid, NULL, NULL);
4220
4221 /*
4222 * Fetch inner Var for this attnum and store it in the 1st arg of the
4223 * hash func.
4224 */
4225 scratch.opcode = EEOP_INNER_VAR;
4226 scratch.resvalue = &fcinfo->args[0].value;
4227 scratch.resnull = &fcinfo->args[0].isnull;
4228 scratch.d.var.attnum = attnum;
4229 scratch.d.var.vartype = TupleDescAttr(desc, attnum)->atttypid;
4230 scratch.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
4231
4232 ExprEvalPushStep(state, &scratch);
4233
4234 /* Call the hash function */
4235 scratch.opcode = opcode;
4236
4237 if (i == numCols - 1)
4238 {
4239 /*
4240 * The result for hashing the final column is stored in the
4241 * ExprState.
4242 */
4243 scratch.resvalue = &state->resvalue;
4244 scratch.resnull = &state->resnull;
4245 }
4246 else
4247 {
4248 Assert(iresult != NULL);
4249
4250 /* intermediate values are stored in an intermediate result */
4251 scratch.resvalue = &iresult->value;
4252 scratch.resnull = &iresult->isnull;
4253 }
4254
4255 /*
4256 * NEXT32 opcodes need to look at the intermediate result. We might
4257 * as well just set this for all ops. FIRSTs won't look at it.
4258 */
4259 scratch.d.hashdatum.iresult = iresult;
4260
4261 scratch.d.hashdatum.finfo = finfo;
4262 scratch.d.hashdatum.fcinfo_data = fcinfo;
4263 scratch.d.hashdatum.fn_addr = finfo->fn_addr;
4264 scratch.d.hashdatum.jumpdone = -1;
4265
4266 ExprEvalPushStep(state, &scratch);
4267
4268 /* subsequent attnums must be combined with the previous */
4269 opcode = EEOP_HASHDATUM_NEXT32;
4270 }
4271
4272 scratch.resvalue = NULL;
4273 scratch.resnull = NULL;
4274 scratch.opcode = EEOP_DONE_RETURN;
4275 ExprEvalPushStep(state, &scratch);
4276
4277 ExecReadyExpr(state);
4278
4279 return state;
4280 }
4281
4282 /*
4283 * Build an ExprState that calls the given hash function(s) on the given
4284 * 'hash_exprs'. When multiple expressions are present, the hash values
4285 * returned by each hash function are combined to produce a single hash value.
4286 *
4287 * desc: tuple descriptor for the to-be-hashed expressions
4288 * ops: TupleTableSlotOps for the TupleDesc
4289 * hashfunc_oids: Oid for each hash function to call, one for each 'hash_expr'
4290 * collations: collation to use when calling the hash function.
4291 * hash_expr: list of expressions to hash the value of
4292 * opstrict: array corresponding to the 'hashfunc_oids' to store op_strict()
4293 * parent: PlanState node that the 'hash_exprs' will be evaluated at
4294 * init_value: Normally 0, but can be set to other values to seed the hash
4295 * with some other value. Using non-zero is slightly less efficient but can
4296 * be useful.
4297 * keep_nulls: if true, evaluation of the returned ExprState will abort early
4298 * returning NULL if the given hash function is strict and the Datum to hash
4299 * is null. When set to false, any NULL input Datums are skipped.
4300 */
4301 ExprState *
4302 ExecBuildHash32Expr(TupleDesc desc, const TupleTableSlotOps *ops,
4303 const Oid *hashfunc_oids, const List *collations,
4304 const List *hash_exprs, const bool *opstrict,
4305 PlanState *parent, uint32 init_value, bool keep_nulls)
4306 {
4307 ExprState *state = makeNode(ExprState);
4308 ExprEvalStep scratch = {0};
4309 NullableDatum *iresult = NULL;
4310 List *adjust_jumps = NIL;
4311 ListCell *lc;
4312 ListCell *lc2;
4313 intptr_t strict_opcode;
4314 intptr_t opcode;
4315 int num_exprs = list_length(hash_exprs);
4316
4317 Assert(num_exprs == list_length(collations));
4318
4319 state->parent = parent;
4320
4321 /* Insert setup steps as needed. */
4322 ExecCreateExprSetupSteps(state, (Node *) hash_exprs);
4323
4324 /*
4325 * Make a place to store intermediate hash values between subsequent
4326 * hashing of individual expressions. We only need this if there is more
4327 * than one expression to hash or an initial value plus one expression.
4328 */
4329 if ((int64) num_exprs + (init_value != 0) > 1)
4330 iresult = palloc(sizeof(NullableDatum));
4331
4332 if (init_value == 0)
4333 {
4334 /*
4335 * No initial value, so we can assign the result of the hash function
4336 * for the first hash_expr without having to concern ourselves with
4337 * combining the result with any initial value.
4338 */
4339 strict_opcode = EEOP_HASHDATUM_FIRST_STRICT;
4340 opcode = EEOP_HASHDATUM_FIRST;
4341 }
4342 else
4343 {
4344 /*
4345 * Set up operation to set the initial value. Normally we store this
4346 * in the intermediate hash value location, but if there are no exprs
4347 * to hash, store it in the ExprState's result field.
4348 */
4349 scratch.opcode = EEOP_HASHDATUM_SET_INITVAL;
4350 scratch.d.hashdatum_initvalue.init_value = UInt32GetDatum(init_value);
4351 scratch.resvalue = num_exprs > 0 ? &iresult->value : &state->resvalue;
4352 scratch.resnull = num_exprs > 0 ? &iresult->isnull : &state->resnull;
4353
4354 ExprEvalPushStep(state, &scratch);
4355
4356 /*
4357 * When using an initial value use the NEXT32/NEXT32_STRICT ops as the
4358 * FIRST/FIRST_STRICT ops would overwrite the stored initial value.
4359 */
4360 strict_opcode = EEOP_HASHDATUM_NEXT32_STRICT;
4361 opcode = EEOP_HASHDATUM_NEXT32;
4362 }
4363
4364 forboth(lc, hash_exprs, lc2, collations)
4365 {
4366 Expr *expr = (Expr *) lfirst(lc);
4367 FmgrInfo *finfo;
4368 FunctionCallInfo fcinfo;
4369 int i = foreach_current_index(lc);
4370 Oid funcid;
4371 Oid inputcollid = lfirst_oid(lc2);
4372
4373 funcid = hashfunc_oids[i];
4374
4375 /* Allocate hash function lookup data. */
4376 finfo = palloc0(sizeof(FmgrInfo));
4377 fcinfo = palloc0(SizeForFunctionCallInfo(1));
4378
4379 fmgr_info(funcid, finfo);
4380
4381 /*
4382 * Build the steps to evaluate the hash function's argument have it so
4383 * the value of that is stored in the 0th argument of the hash func.
4384 */
4385 ExecInitExprRec(expr,
4386 state,
4387 &fcinfo->args[0].value,
4388 &fcinfo->args[0].isnull);
4389
4390 if (i == num_exprs - 1)
4391 {
4392 /* the result for hashing the final expr is stored in the state */
4393 scratch.resvalue = &state->resvalue;
4394 scratch.resnull = &state->resnull;
4395 }
4396 else
4397 {
4398 Assert(iresult != NULL);
4399
4400 /* intermediate values are stored in an intermediate result */
4401 scratch.resvalue = &iresult->value;
4402 scratch.resnull = &iresult->isnull;
4403 }
4404
4405 /*
4406 * NEXT32 opcodes need to look at the intermediate result. We might
4407 * as well just set this for all ops. FIRSTs won't look at it.
4408 */
4409 scratch.d.hashdatum.iresult = iresult;
4410
4411 /* Initialize function call parameter structure too */
4412 InitFunctionCallInfoData(*fcinfo, finfo, 1, inputcollid, NULL, NULL);
4413
4414 scratch.d.hashdatum.finfo = finfo;
4415 scratch.d.hashdatum.fcinfo_data = fcinfo;
4416 scratch.d.hashdatum.fn_addr = finfo->fn_addr;
4417
4418 scratch.opcode = opstrict[i] && !keep_nulls ? strict_opcode : opcode;
4419 scratch.d.hashdatum.jumpdone = -1;
4420
4421 ExprEvalPushStep(state, &scratch);
4422 adjust_jumps = lappend_int(adjust_jumps, state->steps_len - 1);
4423
4424 /*
4425 * For subsequent keys we must combine the hash value with the
4426 * previous hashes.
4427 */
4428 strict_opcode = EEOP_HASHDATUM_NEXT32_STRICT;
4429 opcode = EEOP_HASHDATUM_NEXT32;
4430 }
4431
4432 /* adjust jump targets */
4433 foreach(lc, adjust_jumps)
4434 {
4435 ExprEvalStep *as = &state->steps[lfirst_int(lc)];
4436
4437 Assert(as->opcode == EEOP_HASHDATUM_FIRST ||
4438 as->opcode == EEOP_HASHDATUM_FIRST_STRICT ||
4439 as->opcode == EEOP_HASHDATUM_NEXT32 ||
4440 as->opcode == EEOP_HASHDATUM_NEXT32_STRICT);
4441 Assert(as->d.hashdatum.jumpdone == -1);
4442 as->d.hashdatum.jumpdone = state->steps_len;
4443 }
4444
4445 scratch.resvalue = NULL;
4446 scratch.resnull = NULL;
4447 scratch.opcode = EEOP_DONE_RETURN;
4448 ExprEvalPushStep(state, &scratch);
4449
4450 ExecReadyExpr(state);
4451
4452 return state;
4453 }
4454
4455 /*
4456 * Build equality expression that can be evaluated using ExecQual(), returning
4457 * true if the expression context's inner/outer tuple are NOT DISTINCT. I.e
4458 * two nulls match, a null and a not-null don't match.
4459 *
4460 * desc: tuple descriptor of the to-be-compared tuples
4461 * numCols: the number of attributes to be examined
4462 * keyColIdx: array of attribute column numbers
4463 * eqFunctions: array of function oids of the equality functions to use
4464 * parent: parent executor node
4465 */
4466 ExprState *
4467 ExecBuildGroupingEqual(TupleDesc ldesc, TupleDesc rdesc,
4468 const TupleTableSlotOps *lops, const TupleTableSlotOps *rops,
4469 int numCols,
4470 const AttrNumber *keyColIdx,
4471 const Oid *eqfunctions,
4472 const Oid *collations,
4473 PlanState *parent)
4474 {
4475 ExprState *state = makeNode(ExprState);
4476 ExprEvalStep scratch = {0};
4477 int maxatt = -1;
4478 List *adjust_jumps = NIL;
4479 ListCell *lc;
4480
4481 /*
4482 * When no columns are actually compared, the result's always true. See
4483 * special case in ExecQual().
4484 */
4485 if (numCols == 0)
4486 return NULL;
4487
4488 state->expr = NULL;
4489 state->flags = EEO_FLAG_IS_QUAL;
4490 state->parent = parent;
4491
4492 scratch.resvalue = &state->resvalue;
4493 scratch.resnull = &state->resnull;
4494
4495 /* compute max needed attribute */
4496 for (int natt = 0; natt < numCols; natt++)
4497 {
4498 int attno = keyColIdx[natt];
4499
4500 if (attno > maxatt)
4501 maxatt = attno;
4502 }
4503 Assert(maxatt >= 0);
4504
4505 /* push deform steps */
4506 scratch.opcode = EEOP_INNER_FETCHSOME;
4507 scratch.d.fetch.last_var = maxatt;
4508 scratch.d.fetch.fixed = false;
4509 scratch.d.fetch.known_desc = ldesc;
4510 scratch.d.fetch.kind = lops;
4511 if (ExecComputeSlotInfo(state, &scratch))
4512 ExprEvalPushStep(state, &scratch);
4513
4514 scratch.opcode = EEOP_OUTER_FETCHSOME;
4515 scratch.d.fetch.last_var = maxatt;
4516 scratch.d.fetch.fixed = false;
4517 scratch.d.fetch.known_desc = rdesc;
4518 scratch.d.fetch.kind = rops;
4519 if (ExecComputeSlotInfo(state, &scratch))
4520 ExprEvalPushStep(state, &scratch);
4521
4522 /*
4523 * Start comparing at the last field (least significant sort key). That's
4524 * the most likely to be different if we are dealing with sorted input.
4525 */
4526 for (int natt = numCols; --natt >= 0;)
4527 {
4528 int attno = keyColIdx[natt];
4529 Form_pg_attribute latt = TupleDescAttr(ldesc, attno - 1);
4530 Form_pg_attribute ratt = TupleDescAttr(rdesc, attno - 1);
4531 Oid foid = eqfunctions[natt];
4532 Oid collid = collations[natt];
4533 FmgrInfo *finfo;
4534 FunctionCallInfo fcinfo;
4535 AclResult aclresult;
4536
4537 /* Check permission to call function */
4538 aclresult = object_aclcheck(ProcedureRelationId, foid, GetUserId(), ACL_EXECUTE);
4539 if (aclresult != ACLCHECK_OK)
4540 aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(foid));
4541
4542 InvokeFunctionExecuteHook(foid);
4543
4544 /* Set up the primary fmgr lookup information */
4545 finfo = palloc0(sizeof(FmgrInfo));
4546 fcinfo = palloc0(SizeForFunctionCallInfo(2));
4547 fmgr_info(foid, finfo);
4548 fmgr_info_set_expr(NULL, finfo);
4549 InitFunctionCallInfoData(*fcinfo, finfo, 2,
4550 collid, NULL, NULL);
4551
4552 /* left arg */
4553 scratch.opcode = EEOP_INNER_VAR;
4554 scratch.d.var.attnum = attno - 1;
4555 scratch.d.var.vartype = latt->atttypid;
4556 scratch.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
4557 scratch.resvalue = &fcinfo->args[0].value;
4558 scratch.resnull = &fcinfo->args[0].isnull;
4559 ExprEvalPushStep(state, &scratch);
4560
4561 /* right arg */
4562 scratch.opcode = EEOP_OUTER_VAR;
4563 scratch.d.var.attnum = attno - 1;
4564 scratch.d.var.vartype = ratt->atttypid;
4565 scratch.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
4566 scratch.resvalue = &fcinfo->args[1].value;
4567 scratch.resnull = &fcinfo->args[1].isnull;
4568 ExprEvalPushStep(state, &scratch);
4569
4570 /* evaluate distinctness */
4571 scratch.opcode = EEOP_NOT_DISTINCT;
4572 scratch.d.func.finfo = finfo;
4573 scratch.d.func.fcinfo_data = fcinfo;
4574 scratch.d.func.fn_addr = finfo->fn_addr;
4575 scratch.d.func.nargs = 2;
4576 scratch.resvalue = &state->resvalue;
4577 scratch.resnull = &state->resnull;
4578 ExprEvalPushStep(state, &scratch);
4579
4580 /* then emit EEOP_QUAL to detect if result is false (or null) */
4581 scratch.opcode = EEOP_QUAL;
4582 scratch.d.qualexpr.jumpdone = -1;
4583 scratch.resvalue = &state->resvalue;
4584 scratch.resnull = &state->resnull;
4585 ExprEvalPushStep(state, &scratch);
4586 adjust_jumps = lappend_int(adjust_jumps,
4587 state->steps_len - 1);
4588 }
4589
4590 /* adjust jump targets */
4591 foreach(lc, adjust_jumps)
4592 {
4593 ExprEvalStep *as = &state->steps[lfirst_int(lc)];
4594
4595 Assert(as->opcode == EEOP_QUAL);
4596 Assert(as->d.qualexpr.jumpdone == -1);
4597 as->d.qualexpr.jumpdone = state->steps_len;
4598 }
4599
4600 scratch.resvalue = NULL;
4601 scratch.resnull = NULL;
4602 scratch.opcode = EEOP_DONE_RETURN;
4603 ExprEvalPushStep(state, &scratch);
4604
4605 ExecReadyExpr(state);
4606
4607 return state;
4608 }
4609
4610 /*
4611 * Build equality expression that can be evaluated using ExecQual(), returning
4612 * true if the expression context's inner/outer tuples are equal. Datums in
4613 * the inner/outer slots are assumed to be in the same order and quantity as
4614 * the 'eqfunctions' parameter. NULLs are treated as equal.
4615 *
4616 * desc: tuple descriptor of the to-be-compared tuples
4617 * lops: the slot ops for the inner tuple slots
4618 * rops: the slot ops for the outer tuple slots
4619 * eqFunctions: array of function oids of the equality functions to use
4620 * this must be the same length as the 'param_exprs' list.
4621 * collations: collation Oids to use for equality comparison. Must be the
4622 * same length as the 'param_exprs' list.
4623 * parent: parent executor node
4624 */
4625 ExprState *
4626 ExecBuildParamSetEqual(TupleDesc desc,
4627 const TupleTableSlotOps *lops,
4628 const TupleTableSlotOps *rops,
4629 const Oid *eqfunctions,
4630 const Oid *collations,
4631 const List *param_exprs,
4632 PlanState *parent)
4633 {
4634 ExprState *state = makeNode(ExprState);
4635 ExprEvalStep scratch = {0};
4636 int maxatt = list_length(param_exprs);
4637 List *adjust_jumps = NIL;
4638 ListCell *lc;
4639
4640 state->expr = NULL;
4641 state->flags = EEO_FLAG_IS_QUAL;
4642 state->parent = parent;
4643
4644 scratch.resvalue = &state->resvalue;
4645 scratch.resnull = &state->resnull;
4646
4647 /* push deform steps */
4648 scratch.opcode = EEOP_INNER_FETCHSOME;
4649 scratch.d.fetch.last_var = maxatt;
4650 scratch.d.fetch.fixed = false;
4651 scratch.d.fetch.known_desc = desc;
4652 scratch.d.fetch.kind = lops;
4653 if (ExecComputeSlotInfo(state, &scratch))
4654 ExprEvalPushStep(state, &scratch);
4655
4656 scratch.opcode = EEOP_OUTER_FETCHSOME;
4657 scratch.d.fetch.last_var = maxatt;
4658 scratch.d.fetch.fixed = false;
4659 scratch.d.fetch.known_desc = desc;
4660 scratch.d.fetch.kind = rops;
4661 if (ExecComputeSlotInfo(state, &scratch))
4662 ExprEvalPushStep(state, &scratch);
4663
4664 for (int attno = 0; attno < maxatt; attno++)
4665 {
4666 Form_pg_attribute att = TupleDescAttr(desc, attno);
4667 Oid foid = eqfunctions[attno];
4668 Oid collid = collations[attno];
4669 FmgrInfo *finfo;
4670 FunctionCallInfo fcinfo;
4671 AclResult aclresult;
4672
4673 /* Check permission to call function */
4674 aclresult = object_aclcheck(ProcedureRelationId, foid, GetUserId(), ACL_EXECUTE);
4675 if (aclresult != ACLCHECK_OK)
4676 aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(foid));
4677
4678 InvokeFunctionExecuteHook(foid);
4679
4680 /* Set up the primary fmgr lookup information */
4681 finfo = palloc0(sizeof(FmgrInfo));
4682 fcinfo = palloc0(SizeForFunctionCallInfo(2));
4683 fmgr_info(foid, finfo);
4684 fmgr_info_set_expr(NULL, finfo);
4685 InitFunctionCallInfoData(*fcinfo, finfo, 2,
4686 collid, NULL, NULL);
4687
4688 /* left arg */
4689 scratch.opcode = EEOP_INNER_VAR;
4690 scratch.d.var.attnum = attno;
4691 scratch.d.var.vartype = att->atttypid;
4692 scratch.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
4693 scratch.resvalue = &fcinfo->args[0].value;
4694 scratch.resnull = &fcinfo->args[0].isnull;
4695 ExprEvalPushStep(state, &scratch);
4696
4697 /* right arg */
4698 scratch.opcode = EEOP_OUTER_VAR;
4699 scratch.d.var.attnum = attno;
4700 scratch.d.var.vartype = att->atttypid;
4701 scratch.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
4702 scratch.resvalue = &fcinfo->args[1].value;
4703 scratch.resnull = &fcinfo->args[1].isnull;
4704 ExprEvalPushStep(state, &scratch);
4705
4706 /* evaluate distinctness */
4707 scratch.opcode = EEOP_NOT_DISTINCT;
4708 scratch.d.func.finfo = finfo;
4709 scratch.d.func.fcinfo_data = fcinfo;
4710 scratch.d.func.fn_addr = finfo->fn_addr;
4711 scratch.d.func.nargs = 2;
4712 scratch.resvalue = &state->resvalue;
4713 scratch.resnull = &state->resnull;
4714 ExprEvalPushStep(state, &scratch);
4715
4716 /* then emit EEOP_QUAL to detect if result is false (or null) */
4717 scratch.opcode = EEOP_QUAL;
4718 scratch.d.qualexpr.jumpdone = -1;
4719 scratch.resvalue = &state->resvalue;
4720 scratch.resnull = &state->resnull;
4721 ExprEvalPushStep(state, &scratch);
4722 adjust_jumps = lappend_int(adjust_jumps,
4723 state->steps_len - 1);
4724 }
4725
4726 /* adjust jump targets */
4727 foreach(lc, adjust_jumps)
4728 {
4729 ExprEvalStep *as = &state->steps[lfirst_int(lc)];
4730
4731 Assert(as->opcode == EEOP_QUAL);
4732 Assert(as->d.qualexpr.jumpdone == -1);
4733 as->d.qualexpr.jumpdone = state->steps_len;
4734 }
4735
4736 scratch.resvalue = NULL;
4737 scratch.resnull = NULL;
4738 scratch.opcode = EEOP_DONE_RETURN;
4739 ExprEvalPushStep(state, &scratch);
4740
4741 ExecReadyExpr(state);
4742
4743 return state;
4744 }
4745
4746 /*
4747 * Push steps to evaluate a JsonExpr and its various subsidiary expressions.
4748 */
4749 static void
4750 ExecInitJsonExpr(JsonExpr *jsexpr, ExprState *state,
4751 Datum *resv, bool *resnull,
4752 ExprEvalStep *scratch)
4753 {
4754 JsonExprState *jsestate = palloc0(sizeof(JsonExprState));
4755 ListCell *argexprlc;
4756 ListCell *argnamelc;
4757 List *jumps_return_null = NIL;
4758 List *jumps_to_end = NIL;
4759 ListCell *lc;
4760 ErrorSaveContext *escontext;
4761 bool returning_domain =
4762 get_typtype(jsexpr->returning->typid) == TYPTYPE_DOMAIN;
4763
4764 Assert(jsexpr->on_error != NULL);
4765
4766 jsestate->jsexpr = jsexpr;
4767
4768 /*
4769 * Evaluate formatted_expr storing the result into
4770 * jsestate->formatted_expr.
4771 */
4772 ExecInitExprRec((Expr *) jsexpr->formatted_expr, state,
4773 &jsestate->formatted_expr.value,
4774 &jsestate->formatted_expr.isnull);
4775
4776 /* JUMP to return NULL if formatted_expr evaluates to NULL */
4777 jumps_return_null = lappend_int(jumps_return_null, state->steps_len);
4778 scratch->opcode = EEOP_JUMP_IF_NULL;
4779 scratch->resnull = &jsestate->formatted_expr.isnull;
4780 scratch->d.jump.jumpdone = -1; /* set below */
4781 ExprEvalPushStep(state, scratch);
4782
4783 /*
4784 * Evaluate pathspec expression storing the result into
4785 * jsestate->pathspec.
4786 */
4787 ExecInitExprRec((Expr *) jsexpr->path_spec, state,
4788 &jsestate->pathspec.value,
4789 &jsestate->pathspec.isnull);
4790
4791 /* JUMP to return NULL if path_spec evaluates to NULL */
4792 jumps_return_null = lappend_int(jumps_return_null, state->steps_len);
4793 scratch->opcode = EEOP_JUMP_IF_NULL;
4794 scratch->resnull = &jsestate->pathspec.isnull;
4795 scratch->d.jump.jumpdone = -1; /* set below */
4796 ExprEvalPushStep(state, scratch);
4797
4798 /* Steps to compute PASSING args. */
4799 jsestate->args = NIL;
4800 forboth(argexprlc, jsexpr->passing_values,
4801 argnamelc, jsexpr->passing_names)
4802 {
4803 Expr *argexpr = (Expr *) lfirst(argexprlc);
4804 String *argname = lfirst_node(String, argnamelc);
4805 JsonPathVariable *var = palloc(sizeof(*var));
4806
4807 var->name = argname->sval;
4808 var->namelen = strlen(var->name);
4809 var->typid = exprType((Node *) argexpr);
4810 var->typmod = exprTypmod((Node *) argexpr);
4811
4812 ExecInitExprRec((Expr *) argexpr, state, &var->value, &var->isnull);
4813
4814 jsestate->args = lappend(jsestate->args, var);
4815 }
4816
4817 /* Step for jsonpath evaluation; see ExecEvalJsonExprPath(). */
4818 scratch->opcode = EEOP_JSONEXPR_PATH;
4819 scratch->resvalue = resv;
4820 scratch->resnull = resnull;
4821 scratch->d.jsonexpr.jsestate = jsestate;
4822 ExprEvalPushStep(state, scratch);
4823
4824 /*
4825 * Step to return NULL after jumping to skip the EEOP_JSONEXPR_PATH step
4826 * when either formatted_expr or pathspec is NULL. Adjust jump target
4827 * addresses of JUMPs that we added above.
4828 */
4829 foreach(lc, jumps_return_null)
4830 {
4831 ExprEvalStep *as = &state->steps[lfirst_int(lc)];
4832
4833 as->d.jump.jumpdone = state->steps_len;
4834 }
4835 scratch->opcode = EEOP_CONST;
4836 scratch->resvalue = resv;
4837 scratch->resnull = resnull;
4838 scratch->d.constval.value = (Datum) 0;
4839 scratch->d.constval.isnull = true;
4840 ExprEvalPushStep(state, scratch);
4841
4842 escontext = jsexpr->on_error->btype != JSON_BEHAVIOR_ERROR ?
4843 &jsestate->escontext : NULL;
4844
4845 /*
4846 * To handle coercion errors softly, use the following ErrorSaveContext to
4847 * pass to ExecInitExprRec() when initializing the coercion expressions
4848 * and in the EEOP_JSONEXPR_COERCION step.
4849 */
4850 jsestate->escontext.type = T_ErrorSaveContext;
4851
4852 /*
4853 * Steps to coerce the result value computed by EEOP_JSONEXPR_PATH or the
4854 * NULL returned on NULL input as described above.
4855 */
4856 jsestate->jump_eval_coercion = -1;
4857 if (jsexpr->use_json_coercion)
4858 {
4859 jsestate->jump_eval_coercion = state->steps_len;
4860
4861 ExecInitJsonCoercion(state, jsexpr->returning, escontext,
4862 jsexpr->omit_quotes,
4863 jsexpr->op == JSON_EXISTS_OP,
4864 resv, resnull);
4865 }
4866 else if (jsexpr->use_io_coercion)
4867 {
4868 /*
4869 * Here we only need to initialize the FunctionCallInfo for the target
4870 * type's input function, which is called by ExecEvalJsonExprPath()
4871 * itself, so no additional step is necessary.
4872 */
4873 Oid typinput;
4874 Oid typioparam;
4875 FmgrInfo *finfo;
4876 FunctionCallInfo fcinfo;
4877
4878 getTypeInputInfo(jsexpr->returning->typid, &typinput, &typioparam);
4879 finfo = palloc0(sizeof(FmgrInfo));
4880 fcinfo = palloc0(SizeForFunctionCallInfo(3));
4881 fmgr_info(typinput, finfo);
4882 fmgr_info_set_expr((Node *) jsexpr->returning, finfo);
4883 InitFunctionCallInfoData(*fcinfo, finfo, 3, InvalidOid, NULL, NULL);
4884
4885 /*
4886 * We can preload the second and third arguments for the input
4887 * function, since they're constants.
4888 */
4889 fcinfo->args[1].value = ObjectIdGetDatum(typioparam);
4890 fcinfo->args[1].isnull = false;
4891 fcinfo->args[2].value = Int32GetDatum(jsexpr->returning->typmod);
4892 fcinfo->args[2].isnull = false;
4893 fcinfo->context = (Node *) escontext;
4894
4895 jsestate->input_fcinfo = fcinfo;
4896 }
4897
4898 /*
4899 * Add a special step, if needed, to check if the coercion evaluation ran
4900 * into an error but was not thrown because the ON ERROR behavior is not
4901 * ERROR. It will set jsestate->error if an error did occur.
4902 */
4903 if (jsestate->jump_eval_coercion >= 0 && escontext != NULL)
4904 {
4905 scratch->opcode = EEOP_JSONEXPR_COERCION_FINISH;
4906 scratch->d.jsonexpr.jsestate = jsestate;
4907 ExprEvalPushStep(state, scratch);
4908 }
4909
4910 jsestate->jump_empty = jsestate->jump_error = -1;
4911
4912 /*
4913 * Step to check jsestate->error and return the ON ERROR expression if
4914 * there is one. This handles both the errors that occur during jsonpath
4915 * evaluation in EEOP_JSONEXPR_PATH and subsequent coercion evaluation.
4916 *
4917 * Speed up common cases by avoiding extra steps for a NULL-valued ON
4918 * ERROR expression unless RETURNING a domain type, where constraints must
4919 * be checked. ExecEvalJsonExprPath() already returns NULL on error,
4920 * making additional steps unnecessary in typical scenarios. Note that the
4921 * default ON ERROR behavior for JSON_VALUE() and JSON_QUERY() is to
4922 * return NULL.
4923 */
4924 if (jsexpr->on_error->btype != JSON_BEHAVIOR_ERROR &&
4925 (!(IsA(jsexpr->on_error->expr, Const) &&
4926 ((Const *) jsexpr->on_error->expr)->constisnull) ||
4927 returning_domain))
4928 {
4929 ErrorSaveContext *saved_escontext;
4930
4931 jsestate->jump_error = state->steps_len;
4932
4933 /* JUMP to end if false, that is, skip the ON ERROR expression. */
4934 jumps_to_end = lappend_int(jumps_to_end, state->steps_len);
4935 scratch->opcode = EEOP_JUMP_IF_NOT_TRUE;
4936 scratch->resvalue = &jsestate->error.value;
4937 scratch->resnull = &jsestate->error.isnull;
4938 scratch->d.jump.jumpdone = -1; /* set below */
4939 ExprEvalPushStep(state, scratch);
4940
4941 /*
4942 * Steps to evaluate the ON ERROR expression; handle errors softly to
4943 * rethrow them in COERCION_FINISH step that will be added later.
4944 */
4945 saved_escontext = state->escontext;
4946 state->escontext = escontext;
4947 ExecInitExprRec((Expr *) jsexpr->on_error->expr,
4948 state, resv, resnull);
4949 state->escontext = saved_escontext;
4950
4951 /* Step to coerce the ON ERROR expression if needed */
4952 if (jsexpr->on_error->coerce)
4953 ExecInitJsonCoercion(state, jsexpr->returning, escontext,
4954 jsexpr->omit_quotes, false,
4955 resv, resnull);
4956
4957 /*
4958 * Add a COERCION_FINISH step to check for errors that may occur when
4959 * coercing and rethrow them.
4960 */
4961 if (jsexpr->on_error->coerce ||
4962 IsA(jsexpr->on_error->expr, CoerceViaIO) ||
4963 IsA(jsexpr->on_error->expr, CoerceToDomain))
4964 {
4965 scratch->opcode = EEOP_JSONEXPR_COERCION_FINISH;
4966 scratch->resvalue = resv;
4967 scratch->resnull = resnull;
4968 scratch->d.jsonexpr.jsestate = jsestate;
4969 ExprEvalPushStep(state, scratch);
4970 }
4971
4972 /* JUMP to end to skip the ON EMPTY steps added below. */
4973 jumps_to_end = lappend_int(jumps_to_end, state->steps_len);
4974 scratch->opcode = EEOP_JUMP;
4975 scratch->d.jump.jumpdone = -1;
4976 ExprEvalPushStep(state, scratch);
4977 }
4978
4979 /*
4980 * Step to check jsestate->empty and return the ON EMPTY expression if
4981 * there is one.
4982 *
4983 * See the comment above for details on the optimization for NULL-valued
4984 * expressions.
4985 */
4986 if (jsexpr->on_empty != NULL &&
4987 jsexpr->on_empty->btype != JSON_BEHAVIOR_ERROR &&
4988 (!(IsA(jsexpr->on_empty->expr, Const) &&
4989 ((Const *) jsexpr->on_empty->expr)->constisnull) ||
4990 returning_domain))
4991 {
4992 ErrorSaveContext *saved_escontext;
4993
4994 jsestate->jump_empty = state->steps_len;
4995
4996 /* JUMP to end if false, that is, skip the ON EMPTY expression. */
4997 jumps_to_end = lappend_int(jumps_to_end, state->steps_len);
4998 scratch->opcode = EEOP_JUMP_IF_NOT_TRUE;
4999 scratch->resvalue = &jsestate->empty.value;
5000 scratch->resnull = &jsestate->empty.isnull;
5001 scratch->d.jump.jumpdone = -1; /* set below */
5002 ExprEvalPushStep(state, scratch);
5003
5004 /*
5005 * Steps to evaluate the ON EMPTY expression; handle errors softly to
5006 * rethrow them in COERCION_FINISH step that will be added later.
5007 */
5008 saved_escontext = state->escontext;
5009 state->escontext = escontext;
5010 ExecInitExprRec((Expr *) jsexpr->on_empty->expr,
5011 state, resv, resnull);
5012 state->escontext = saved_escontext;
5013
5014 /* Step to coerce the ON EMPTY expression if needed */
5015 if (jsexpr->on_empty->coerce)
5016 ExecInitJsonCoercion(state, jsexpr->returning, escontext,
5017 jsexpr->omit_quotes, false,
5018 resv, resnull);
5019
5020 /*
5021 * Add a COERCION_FINISH step to check for errors that may occur when
5022 * coercing and rethrow them.
5023 */
5024 if (jsexpr->on_empty->coerce ||
5025 IsA(jsexpr->on_empty->expr, CoerceViaIO) ||
5026 IsA(jsexpr->on_empty->expr, CoerceToDomain))
5027 {
5028
5029 scratch->opcode = EEOP_JSONEXPR_COERCION_FINISH;
5030 scratch->resvalue = resv;
5031 scratch->resnull = resnull;
5032 scratch->d.jsonexpr.jsestate = jsestate;
5033 ExprEvalPushStep(state, scratch);
5034 }
5035 }
5036
5037 foreach(lc, jumps_to_end)
5038 {
5039 ExprEvalStep *as = &state->steps[lfirst_int(lc)];
5040
5041 as->d.jump.jumpdone = state->steps_len;
5042 }
5043
5044 jsestate->jump_end = state->steps_len;
5045 }
5046
5047 /*
5048 * Initialize a EEOP_JSONEXPR_COERCION step to coerce the value given in resv
5049 * to the given RETURNING type.
5050 */
5051 static void
5052 ExecInitJsonCoercion(ExprState *state, JsonReturning *returning,
5053 ErrorSaveContext *escontext, bool omit_quotes,
5054 bool exists_coerce,
5055 Datum *resv, bool *resnull)
5056 {
5057 ExprEvalStep scratch = {0};
5058
5059 /* For json_populate_type() */
5060 scratch.opcode = EEOP_JSONEXPR_COERCION;
5061 scratch.resvalue = resv;
5062 scratch.resnull = resnull;
5063 scratch.d.jsonexpr_coercion.targettype = returning->typid;
5064 scratch.d.jsonexpr_coercion.targettypmod = returning->typmod;
5065 scratch.d.jsonexpr_coercion.json_coercion_cache = NULL;
5066 scratch.d.jsonexpr_coercion.escontext = escontext;
5067 scratch.d.jsonexpr_coercion.omit_quotes = omit_quotes;
5068 scratch.d.jsonexpr_coercion.exists_coerce = exists_coerce;
5069 scratch.d.jsonexpr_coercion.exists_cast_to_int = exists_coerce &&
5070 getBaseType(returning->typid) == INT4OID;
5071 scratch.d.jsonexpr_coercion.exists_check_domain = exists_coerce &&
5072 DomainHasConstraints(returning->typid);
5073 ExprEvalPushStep(state, &scratch);
5074 }