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