PostgreSQL Source Code git master
Loading...
Searching...
No Matches
execExprInterp.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * execExprInterp.c
4 * Interpreted evaluation of an expression step list.
5 *
6 * This file provides either a "direct threaded" (for gcc, clang and
7 * compatible) or a "switch threaded" (for all compilers) implementation of
8 * expression evaluation. The former is amongst the fastest known methods
9 * of interpreting programs without resorting to assembly level work, or
10 * just-in-time compilation, but it requires support for computed gotos.
11 * The latter is amongst the fastest approaches doable in standard C.
12 *
13 * In either case we use ExprEvalStep->opcode to dispatch to the code block
14 * within ExecInterpExpr() that implements the specific opcode type.
15 *
16 * Switch-threading uses a plain switch() statement to perform the
17 * dispatch. This has the advantages of being plain C and allowing the
18 * compiler to warn if implementation of a specific opcode has been forgotten.
19 * The disadvantage is that dispatches will, as commonly implemented by
20 * compilers, happen from a single location, requiring more jumps and causing
21 * bad branch prediction.
22 *
23 * In direct threading, we use gcc's label-as-values extension - also adopted
24 * by some other compilers - to replace ExprEvalStep->opcode with the address
25 * of the block implementing the instruction. Dispatch to the next instruction
26 * is done by a "computed goto". This allows for better branch prediction
27 * (as the jumps are happening from different locations) and fewer jumps
28 * (as no preparatory jump to a common dispatch location is needed).
29 *
30 * When using direct threading, ExecReadyInterpretedExpr will replace
31 * each step's opcode field with the address of the relevant code block and
32 * ExprState->flags will contain EEO_FLAG_DIRECT_THREADED to remember that
33 * that's been done.
34 *
35 * For very simple instructions the overhead of the full interpreter
36 * "startup", as minimal as it is, is noticeable. Therefore
37 * ExecReadyInterpretedExpr will choose to implement certain simple
38 * opcode patterns using special fast-path routines (ExecJust*).
39 *
40 * Complex or uncommon instructions are not implemented in-line in
41 * ExecInterpExpr(), rather we call out to a helper function appearing later
42 * in this file. For one reason, there'd not be a noticeable performance
43 * benefit, but more importantly those complex routines are intended to be
44 * shared between different expression evaluation approaches. For instance
45 * a JIT compiler would generate calls to them. (This is why they are
46 * exported rather than being "static" in this file.)
47 *
48 *
49 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
50 * Portions Copyright (c) 1994, Regents of the University of California
51 *
52 * IDENTIFICATION
53 * src/backend/executor/execExprInterp.c
54 *
55 *-------------------------------------------------------------------------
56 */
57#include "postgres.h"
58
59#include "access/heaptoast.h"
60#include "catalog/pg_type.h"
61#include "commands/sequence.h"
62#include "executor/execExpr.h"
63#include "executor/nodeSubplan.h"
64#include "funcapi.h"
65#include "miscadmin.h"
66#include "nodes/miscnodes.h"
67#include "nodes/nodeFuncs.h"
68#include "pgstat.h"
69#include "utils/array.h"
70#include "utils/builtins.h"
71#include "utils/date.h"
72#include "utils/datum.h"
73#include "utils/expandedrecord.h"
74#include "utils/json.h"
75#include "utils/jsonfuncs.h"
76#include "utils/jsonpath.h"
77#include "utils/lsyscache.h"
78#include "utils/memutils.h"
79#include "utils/timestamp.h"
80#include "utils/typcache.h"
81#include "utils/xml.h"
82
83/*
84 * Use computed-goto-based opcode dispatch when computed gotos are available.
85 * But use a separate symbol so that it's easy to adjust locally in this file
86 * for development and testing.
87 */
88#ifdef HAVE_COMPUTED_GOTO
89#define EEO_USE_COMPUTED_GOTO
90#endif /* HAVE_COMPUTED_GOTO */
91
92/*
93 * Macros for opcode dispatch.
94 *
95 * EEO_SWITCH - just hides the switch if not in use.
96 * EEO_CASE - labels the implementation of named expression step type.
97 * EEO_DISPATCH - jump to the implementation of the step type for 'op'.
98 * EEO_OPCODE - compute opcode required by used expression evaluation method.
99 * EEO_NEXT - increment 'op' and jump to correct next step type.
100 * EEO_JUMP - jump to the specified step number within the current expression.
101 */
102#if defined(EEO_USE_COMPUTED_GOTO)
103
104/* struct for jump target -> opcode lookup table */
105typedef struct ExprEvalOpLookup
106{
107 const void *opcode;
108 ExprEvalOp op;
109} ExprEvalOpLookup;
110
111/* to make dispatch_table accessible outside ExecInterpExpr() */
112static const void **dispatch_table = NULL;
113
114/* jump target -> opcode lookup table */
115static ExprEvalOpLookup reverse_dispatch_table[EEOP_LAST];
116
117#define EEO_SWITCH()
118#define EEO_CASE(name) CASE_##name:
119#define EEO_DISPATCH() goto *((void *) op->opcode)
120#define EEO_OPCODE(opcode) ((intptr_t) dispatch_table[opcode])
121
122#else /* !EEO_USE_COMPUTED_GOTO */
123
124#define EEO_SWITCH() starteval: switch ((ExprEvalOp) op->opcode)
125#define EEO_CASE(name) case name:
126#define EEO_DISPATCH() goto starteval
127#define EEO_OPCODE(opcode) (opcode)
128
129#endif /* EEO_USE_COMPUTED_GOTO */
130
131#define EEO_NEXT() \
132 do { \
133 op++; \
134 EEO_DISPATCH(); \
135 } while (0)
136
137#define EEO_JUMP(stepno) \
138 do { \
139 op = &state->steps[stepno]; \
140 EEO_DISPATCH(); \
141 } while (0)
142
143
144static Datum ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull);
145static void ExecInitInterpreter(void);
146
147/* support functions */
148static void CheckVarSlotCompatibility(TupleTableSlot *slot, int attnum, Oid vartype);
149static void CheckOpSlotCompatibility(ExprEvalStep *op, TupleTableSlot *slot);
150static TupleDesc get_cached_rowtype(Oid type_id, int32 typmod,
151 ExprEvalRowtypeCache *rowcache,
152 bool *changed);
153static void ExecEvalRowNullInt(ExprState *state, ExprEvalStep *op,
154 ExprContext *econtext, bool checkisnull);
155
156/* fast-path evaluation functions */
157static Datum ExecJustInnerVar(ExprState *state, ExprContext *econtext, bool *isnull);
158static Datum ExecJustOuterVar(ExprState *state, ExprContext *econtext, bool *isnull);
159static Datum ExecJustScanVar(ExprState *state, ExprContext *econtext, bool *isnull);
160static Datum ExecJustAssignInnerVar(ExprState *state, ExprContext *econtext, bool *isnull);
161static Datum ExecJustAssignOuterVar(ExprState *state, ExprContext *econtext, bool *isnull);
162static Datum ExecJustAssignScanVar(ExprState *state, ExprContext *econtext, bool *isnull);
163static Datum ExecJustApplyFuncToCase(ExprState *state, ExprContext *econtext, bool *isnull);
164static Datum ExecJustConst(ExprState *state, ExprContext *econtext, bool *isnull);
165static Datum ExecJustInnerVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);
166static Datum ExecJustOuterVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);
167static Datum ExecJustScanVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);
168static Datum ExecJustAssignInnerVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);
169static Datum ExecJustAssignOuterVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);
170static Datum ExecJustAssignScanVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);
171static Datum ExecJustHashInnerVarWithIV(ExprState *state, ExprContext *econtext, bool *isnull);
172static Datum ExecJustHashOuterVar(ExprState *state, ExprContext *econtext, bool *isnull);
173static Datum ExecJustHashInnerVar(ExprState *state, ExprContext *econtext, bool *isnull);
174static Datum ExecJustHashOuterVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);
175static Datum ExecJustHashInnerVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);
176static Datum ExecJustHashOuterVarStrict(ExprState *state, ExprContext *econtext, bool *isnull);
177
178/* execution helper functions */
179static pg_attribute_always_inline void ExecAggPlainTransByVal(AggState *aggstate,
180 AggStatePerTrans pertrans,
181 AggStatePerGroup pergroup,
182 ExprContext *aggcontext,
183 int setno);
184static pg_attribute_always_inline void ExecAggPlainTransByRef(AggState *aggstate,
185 AggStatePerTrans pertrans,
186 AggStatePerGroup pergroup,
187 ExprContext *aggcontext,
188 int setno);
189static char *ExecGetJsonValueItemString(JsonbValue *item, bool *resnull);
190
191/*
192 * ScalarArrayOpExprHashEntry
193 * Hash table entry type used during EEOP_HASHED_SCALARARRAYOP
194 */
195typedef struct ScalarArrayOpExprHashEntry
196{
197 Datum key;
198 uint32 status; /* hash status */
199 uint32 hash; /* hash value (cached) */
200} ScalarArrayOpExprHashEntry;
201
202#define SH_PREFIX saophash
203#define SH_ELEMENT_TYPE ScalarArrayOpExprHashEntry
204#define SH_KEY_TYPE Datum
205#define SH_SCOPE static inline
206#define SH_DECLARE
207#include "lib/simplehash.h"
208
209static bool saop_hash_element_match(struct saophash_hash *tb, Datum key1,
210 Datum key2);
211static uint32 saop_element_hash(struct saophash_hash *tb, Datum key);
212
213/*
214 * ScalarArrayOpExprHashTable
215 * Hash table for EEOP_HASHED_SCALARARRAYOP
216 */
217typedef struct ScalarArrayOpExprHashTable
218{
219 saophash_hash *hashtab; /* underlying hash table */
220 struct ExprEvalStep *op;
221 FmgrInfo hash_finfo; /* function's lookup data */
222 FunctionCallInfoBaseData hash_fcinfo_data; /* arguments etc */
223} ScalarArrayOpExprHashTable;
224
225/* Define parameters for ScalarArrayOpExpr hash table code generation. */
226#define SH_PREFIX saophash
227#define SH_ELEMENT_TYPE ScalarArrayOpExprHashEntry
228#define SH_KEY_TYPE Datum
229#define SH_KEY key
230#define SH_HASH_KEY(tb, key) saop_element_hash(tb, key)
231#define SH_EQUAL(tb, a, b) saop_hash_element_match(tb, a, b)
232#define SH_SCOPE static inline
233#define SH_STORE_HASH
234#define SH_GET_HASH(tb, a) a->hash
235#define SH_DEFINE
236#include "lib/simplehash.h"
237
238/*
239 * Prepare ExprState for interpreted execution.
240 */
241void
242ExecReadyInterpretedExpr(ExprState *state)
243{
244 /* Ensure one-time interpreter setup has been done */
245 ExecInitInterpreter();
246
247 /* Simple validity checks on expression */
248 Assert(state->steps_len >= 1);
249 Assert(state->steps[state->steps_len - 1].opcode == EEOP_DONE_RETURN ||
250 state->steps[state->steps_len - 1].opcode == EEOP_DONE_NO_RETURN);
251
252 /*
253 * Don't perform redundant initialization. This is unreachable in current
254 * cases, but might be hit if there's additional expression evaluation
255 * methods that rely on interpreted execution to work.
256 */
257 if (state->flags & EEO_FLAG_INTERPRETER_INITIALIZED)
258 return;
259
260 /*
261 * First time through, check whether attribute matches Var. Might not be
262 * ok anymore, due to schema changes. We do that by setting up a callback
263 * that does checking on the first call, which then sets the evalfunc
264 * callback to the actual method of execution.
265 */
266 state->evalfunc = ExecInterpExprStillValid;
267
268 /* DIRECT_THREADED should not already be set */
269 Assert((state->flags & EEO_FLAG_DIRECT_THREADED) == 0);
270
271 /*
272 * There shouldn't be any errors before the expression is fully
273 * initialized, and even if so, it'd lead to the expression being
274 * abandoned. So we can set the flag now and save some code.
275 */
276 state->flags |= EEO_FLAG_INTERPRETER_INITIALIZED;
277
278 /*
279 * Select fast-path evalfuncs for very simple expressions. "Starting up"
280 * the full interpreter is a measurable overhead for these, and these
281 * patterns occur often enough to be worth optimizing.
282 */
283 if (state->steps_len == 5)
284 {
285 ExprEvalOp step0 = state->steps[0].opcode;
286 ExprEvalOp step1 = state->steps[1].opcode;
287 ExprEvalOp step2 = state->steps[2].opcode;
288 ExprEvalOp step3 = state->steps[3].opcode;
289
290 if (step0 == EEOP_INNER_FETCHSOME &&
291 step1 == EEOP_HASHDATUM_SET_INITVAL &&
292 step2 == EEOP_INNER_VAR &&
293 step3 == EEOP_HASHDATUM_NEXT32)
294 {
295 state->evalfunc_private = (void *) ExecJustHashInnerVarWithIV;
296 return;
297 }
298 }
299 else if (state->steps_len == 4)
300 {
301 ExprEvalOp step0 = state->steps[0].opcode;
302 ExprEvalOp step1 = state->steps[1].opcode;
303 ExprEvalOp step2 = state->steps[2].opcode;
304
305 if (step0 == EEOP_OUTER_FETCHSOME &&
306 step1 == EEOP_OUTER_VAR &&
307 step2 == EEOP_HASHDATUM_FIRST)
308 {
309 state->evalfunc_private = (void *) ExecJustHashOuterVar;
310 return;
311 }
312 else if (step0 == EEOP_INNER_FETCHSOME &&
313 step1 == EEOP_INNER_VAR &&
314 step2 == EEOP_HASHDATUM_FIRST)
315 {
316 state->evalfunc_private = (void *) ExecJustHashInnerVar;
317 return;
318 }
319 else if (step0 == EEOP_OUTER_FETCHSOME &&
320 step1 == EEOP_OUTER_VAR &&
321 step2 == EEOP_HASHDATUM_FIRST_STRICT)
322 {
323 state->evalfunc_private = (void *) ExecJustHashOuterVarStrict;
324 return;
325 }
326 }
327 else if (state->steps_len == 3)
328 {
329 ExprEvalOp step0 = state->steps[0].opcode;
330 ExprEvalOp step1 = state->steps[1].opcode;
331
332 if (step0 == EEOP_INNER_FETCHSOME &&
333 step1 == EEOP_INNER_VAR)
334 {
335 state->evalfunc_private = ExecJustInnerVar;
336 return;
337 }
338 else if (step0 == EEOP_OUTER_FETCHSOME &&
339 step1 == EEOP_OUTER_VAR)
340 {
341 state->evalfunc_private = ExecJustOuterVar;
342 return;
343 }
344 else if (step0 == EEOP_SCAN_FETCHSOME &&
345 step1 == EEOP_SCAN_VAR)
346 {
347 state->evalfunc_private = ExecJustScanVar;
348 return;
349 }
350 else if (step0 == EEOP_INNER_FETCHSOME &&
351 step1 == EEOP_ASSIGN_INNER_VAR)
352 {
353 state->evalfunc_private = ExecJustAssignInnerVar;
354 return;
355 }
356 else if (step0 == EEOP_OUTER_FETCHSOME &&
357 step1 == EEOP_ASSIGN_OUTER_VAR)
358 {
359 state->evalfunc_private = ExecJustAssignOuterVar;
360 return;
361 }
362 else if (step0 == EEOP_SCAN_FETCHSOME &&
363 step1 == EEOP_ASSIGN_SCAN_VAR)
364 {
365 state->evalfunc_private = ExecJustAssignScanVar;
366 return;
367 }
368 else if (step0 == EEOP_CASE_TESTVAL &&
369 (step1 == EEOP_FUNCEXPR_STRICT ||
370 step1 == EEOP_FUNCEXPR_STRICT_1 ||
371 step1 == EEOP_FUNCEXPR_STRICT_2))
372 {
373 state->evalfunc_private = ExecJustApplyFuncToCase;
374 return;
375 }
376 else if (step0 == EEOP_INNER_VAR &&
377 step1 == EEOP_HASHDATUM_FIRST)
378 {
379 state->evalfunc_private = (void *) ExecJustHashInnerVarVirt;
380 return;
381 }
382 else if (step0 == EEOP_OUTER_VAR &&
383 step1 == EEOP_HASHDATUM_FIRST)
384 {
385 state->evalfunc_private = (void *) ExecJustHashOuterVarVirt;
386 return;
387 }
388 }
389 else if (state->steps_len == 2)
390 {
391 ExprEvalOp step0 = state->steps[0].opcode;
392
393 if (step0 == EEOP_CONST)
394 {
395 state->evalfunc_private = ExecJustConst;
396 return;
397 }
398 else if (step0 == EEOP_INNER_VAR)
399 {
400 state->evalfunc_private = ExecJustInnerVarVirt;
401 return;
402 }
403 else if (step0 == EEOP_OUTER_VAR)
404 {
405 state->evalfunc_private = ExecJustOuterVarVirt;
406 return;
407 }
408 else if (step0 == EEOP_SCAN_VAR)
409 {
410 state->evalfunc_private = ExecJustScanVarVirt;
411 return;
412 }
413 else if (step0 == EEOP_ASSIGN_INNER_VAR)
414 {
415 state->evalfunc_private = ExecJustAssignInnerVarVirt;
416 return;
417 }
418 else if (step0 == EEOP_ASSIGN_OUTER_VAR)
419 {
420 state->evalfunc_private = ExecJustAssignOuterVarVirt;
421 return;
422 }
423 else if (step0 == EEOP_ASSIGN_SCAN_VAR)
424 {
425 state->evalfunc_private = ExecJustAssignScanVarVirt;
426 return;
427 }
428 }
429
430#if defined(EEO_USE_COMPUTED_GOTO)
431
432 /*
433 * In the direct-threaded implementation, replace each opcode with the
434 * address to jump to. (Use ExecEvalStepOp() to get back the opcode.)
435 */
436 for (int off = 0; off < state->steps_len; off++)
437 {
438 ExprEvalStep *op = &state->steps[off];
439
440 op->opcode = EEO_OPCODE(op->opcode);
441 }
442
443 state->flags |= EEO_FLAG_DIRECT_THREADED;
444#endif /* EEO_USE_COMPUTED_GOTO */
445
446 state->evalfunc_private = ExecInterpExpr;
447}
448
449
450/*
451 * Evaluate expression identified by "state" in the execution context
452 * given by "econtext". *isnull is set to the is-null flag for the result,
453 * and the Datum value is the function result.
454 *
455 * As a special case, return the dispatch table's address if state is NULL.
456 * This is used by ExecInitInterpreter to set up the dispatch_table global.
457 * (Only applies when EEO_USE_COMPUTED_GOTO is defined.)
458 */
459static Datum
460ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
461{
462 ExprEvalStep *op;
463 TupleTableSlot *resultslot;
464 TupleTableSlot *innerslot;
465 TupleTableSlot *outerslot;
466 TupleTableSlot *scanslot;
467 TupleTableSlot *oldslot;
468 TupleTableSlot *newslot;
469
470 /*
471 * This array has to be in the same order as enum ExprEvalOp.
472 */
473#if defined(EEO_USE_COMPUTED_GOTO)
474 static const void *const dispatch_table[] = {
475 &&CASE_EEOP_DONE_RETURN,
476 &&CASE_EEOP_DONE_NO_RETURN,
477 &&CASE_EEOP_INNER_FETCHSOME,
478 &&CASE_EEOP_OUTER_FETCHSOME,
479 &&CASE_EEOP_SCAN_FETCHSOME,
480 &&CASE_EEOP_OLD_FETCHSOME,
481 &&CASE_EEOP_NEW_FETCHSOME,
482 &&CASE_EEOP_INNER_VAR,
483 &&CASE_EEOP_OUTER_VAR,
484 &&CASE_EEOP_SCAN_VAR,
485 &&CASE_EEOP_OLD_VAR,
486 &&CASE_EEOP_NEW_VAR,
487 &&CASE_EEOP_INNER_SYSVAR,
488 &&CASE_EEOP_OUTER_SYSVAR,
489 &&CASE_EEOP_SCAN_SYSVAR,
490 &&CASE_EEOP_OLD_SYSVAR,
491 &&CASE_EEOP_NEW_SYSVAR,
492 &&CASE_EEOP_WHOLEROW,
493 &&CASE_EEOP_ASSIGN_INNER_VAR,
494 &&CASE_EEOP_ASSIGN_OUTER_VAR,
495 &&CASE_EEOP_ASSIGN_SCAN_VAR,
496 &&CASE_EEOP_ASSIGN_OLD_VAR,
497 &&CASE_EEOP_ASSIGN_NEW_VAR,
498 &&CASE_EEOP_ASSIGN_TMP,
499 &&CASE_EEOP_ASSIGN_TMP_MAKE_RO,
500 &&CASE_EEOP_CONST,
501 &&CASE_EEOP_FUNCEXPR,
502 &&CASE_EEOP_FUNCEXPR_STRICT,
503 &&CASE_EEOP_FUNCEXPR_STRICT_1,
504 &&CASE_EEOP_FUNCEXPR_STRICT_2,
505 &&CASE_EEOP_FUNCEXPR_FUSAGE,
506 &&CASE_EEOP_FUNCEXPR_STRICT_FUSAGE,
507 &&CASE_EEOP_BOOL_AND_STEP_FIRST,
508 &&CASE_EEOP_BOOL_AND_STEP,
509 &&CASE_EEOP_BOOL_AND_STEP_LAST,
510 &&CASE_EEOP_BOOL_OR_STEP_FIRST,
511 &&CASE_EEOP_BOOL_OR_STEP,
512 &&CASE_EEOP_BOOL_OR_STEP_LAST,
513 &&CASE_EEOP_BOOL_NOT_STEP,
514 &&CASE_EEOP_QUAL,
515 &&CASE_EEOP_JUMP,
516 &&CASE_EEOP_JUMP_IF_NULL,
517 &&CASE_EEOP_JUMP_IF_NOT_NULL,
518 &&CASE_EEOP_JUMP_IF_NOT_TRUE,
519 &&CASE_EEOP_NULLTEST_ISNULL,
520 &&CASE_EEOP_NULLTEST_ISNOTNULL,
521 &&CASE_EEOP_NULLTEST_ROWISNULL,
522 &&CASE_EEOP_NULLTEST_ROWISNOTNULL,
523 &&CASE_EEOP_BOOLTEST_IS_TRUE,
524 &&CASE_EEOP_BOOLTEST_IS_NOT_TRUE,
525 &&CASE_EEOP_BOOLTEST_IS_FALSE,
526 &&CASE_EEOP_BOOLTEST_IS_NOT_FALSE,
527 &&CASE_EEOP_PARAM_EXEC,
528 &&CASE_EEOP_PARAM_EXTERN,
529 &&CASE_EEOP_PARAM_CALLBACK,
530 &&CASE_EEOP_PARAM_SET,
531 &&CASE_EEOP_CASE_TESTVAL,
532 &&CASE_EEOP_CASE_TESTVAL_EXT,
533 &&CASE_EEOP_MAKE_READONLY,
534 &&CASE_EEOP_IOCOERCE,
535 &&CASE_EEOP_IOCOERCE_SAFE,
536 &&CASE_EEOP_DISTINCT,
537 &&CASE_EEOP_NOT_DISTINCT,
538 &&CASE_EEOP_NULLIF,
539 &&CASE_EEOP_SQLVALUEFUNCTION,
540 &&CASE_EEOP_CURRENTOFEXPR,
541 &&CASE_EEOP_NEXTVALUEEXPR,
542 &&CASE_EEOP_RETURNINGEXPR,
543 &&CASE_EEOP_ARRAYEXPR,
544 &&CASE_EEOP_ARRAYCOERCE,
545 &&CASE_EEOP_ROW,
546 &&CASE_EEOP_ROWCOMPARE_STEP,
547 &&CASE_EEOP_ROWCOMPARE_FINAL,
548 &&CASE_EEOP_MINMAX,
549 &&CASE_EEOP_FIELDSELECT,
550 &&CASE_EEOP_FIELDSTORE_DEFORM,
551 &&CASE_EEOP_FIELDSTORE_FORM,
552 &&CASE_EEOP_SBSREF_SUBSCRIPTS,
553 &&CASE_EEOP_SBSREF_OLD,
554 &&CASE_EEOP_SBSREF_ASSIGN,
555 &&CASE_EEOP_SBSREF_FETCH,
556 &&CASE_EEOP_DOMAIN_TESTVAL,
557 &&CASE_EEOP_DOMAIN_TESTVAL_EXT,
558 &&CASE_EEOP_DOMAIN_NOTNULL,
559 &&CASE_EEOP_DOMAIN_CHECK,
560 &&CASE_EEOP_HASHDATUM_SET_INITVAL,
561 &&CASE_EEOP_HASHDATUM_FIRST,
562 &&CASE_EEOP_HASHDATUM_FIRST_STRICT,
563 &&CASE_EEOP_HASHDATUM_NEXT32,
564 &&CASE_EEOP_HASHDATUM_NEXT32_STRICT,
565 &&CASE_EEOP_CONVERT_ROWTYPE,
566 &&CASE_EEOP_SCALARARRAYOP,
567 &&CASE_EEOP_HASHED_SCALARARRAYOP,
568 &&CASE_EEOP_XMLEXPR,
569 &&CASE_EEOP_JSON_CONSTRUCTOR,
570 &&CASE_EEOP_IS_JSON,
571 &&CASE_EEOP_JSONEXPR_PATH,
572 &&CASE_EEOP_JSONEXPR_COERCION,
573 &&CASE_EEOP_JSONEXPR_COERCION_FINISH,
574 &&CASE_EEOP_AGGREF,
575 &&CASE_EEOP_GROUPING_FUNC,
576 &&CASE_EEOP_WINDOW_FUNC,
577 &&CASE_EEOP_MERGE_SUPPORT_FUNC,
578 &&CASE_EEOP_SUBPLAN,
579 &&CASE_EEOP_AGG_STRICT_DESERIALIZE,
580 &&CASE_EEOP_AGG_DESERIALIZE,
581 &&CASE_EEOP_AGG_STRICT_INPUT_CHECK_ARGS,
582 &&CASE_EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1,
583 &&CASE_EEOP_AGG_STRICT_INPUT_CHECK_NULLS,
584 &&CASE_EEOP_AGG_PLAIN_PERGROUP_NULLCHECK,
585 &&CASE_EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL,
586 &&CASE_EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL,
587 &&CASE_EEOP_AGG_PLAIN_TRANS_BYVAL,
588 &&CASE_EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF,
589 &&CASE_EEOP_AGG_PLAIN_TRANS_STRICT_BYREF,
590 &&CASE_EEOP_AGG_PLAIN_TRANS_BYREF,
591 &&CASE_EEOP_AGG_PRESORTED_DISTINCT_SINGLE,
592 &&CASE_EEOP_AGG_PRESORTED_DISTINCT_MULTI,
593 &&CASE_EEOP_AGG_ORDERED_TRANS_DATUM,
594 &&CASE_EEOP_AGG_ORDERED_TRANS_TUPLE,
595 &&CASE_EEOP_LAST
596 };
597
598 StaticAssertDecl(lengthof(dispatch_table) == EEOP_LAST + 1,
599 "dispatch_table out of whack with ExprEvalOp");
600
601 if (unlikely(state == NULL))
602 return PointerGetDatum(dispatch_table);
603#else
604 Assert(state != NULL);
605#endif /* EEO_USE_COMPUTED_GOTO */
606
607 /* setup state */
608 op = state->steps;
609 resultslot = state->resultslot;
610 innerslot = econtext->ecxt_innertuple;
611 outerslot = econtext->ecxt_outertuple;
612 scanslot = econtext->ecxt_scantuple;
613 oldslot = econtext->ecxt_oldtuple;
614 newslot = econtext->ecxt_newtuple;
615
616#if defined(EEO_USE_COMPUTED_GOTO)
617 EEO_DISPATCH();
618#endif
619
620 EEO_SWITCH()
621 {
622 EEO_CASE(EEOP_DONE_RETURN)
623 {
624 *isnull = state->resnull;
625 return state->resvalue;
626 }
627
628 EEO_CASE(EEOP_DONE_NO_RETURN)
629 {
630 Assert(isnull == NULL);
631 return (Datum) 0;
632 }
633
634 EEO_CASE(EEOP_INNER_FETCHSOME)
635 {
636 CheckOpSlotCompatibility(op, innerslot);
637
638 slot_getsomeattrs(innerslot, op->d.fetch.last_var);
639
640 EEO_NEXT();
641 }
642
643 EEO_CASE(EEOP_OUTER_FETCHSOME)
644 {
645 CheckOpSlotCompatibility(op, outerslot);
646
647 slot_getsomeattrs(outerslot, op->d.fetch.last_var);
648
649 EEO_NEXT();
650 }
651
652 EEO_CASE(EEOP_SCAN_FETCHSOME)
653 {
654 CheckOpSlotCompatibility(op, scanslot);
655
656 slot_getsomeattrs(scanslot, op->d.fetch.last_var);
657
658 EEO_NEXT();
659 }
660
661 EEO_CASE(EEOP_OLD_FETCHSOME)
662 {
663 CheckOpSlotCompatibility(op, oldslot);
664
665 slot_getsomeattrs(oldslot, op->d.fetch.last_var);
666
667 EEO_NEXT();
668 }
669
670 EEO_CASE(EEOP_NEW_FETCHSOME)
671 {
672 CheckOpSlotCompatibility(op, newslot);
673
674 slot_getsomeattrs(newslot, op->d.fetch.last_var);
675
676 EEO_NEXT();
677 }
678
679 EEO_CASE(EEOP_INNER_VAR)
680 {
681 int attnum = op->d.var.attnum;
682
683 /*
684 * Since we already extracted all referenced columns from the
685 * tuple with a FETCHSOME step, we can just grab the value
686 * directly out of the slot's decomposed-data arrays. But let's
687 * have an Assert to check that that did happen.
688 */
689 Assert(attnum >= 0 && attnum < innerslot->tts_nvalid);
690 *op->resvalue = innerslot->tts_values[attnum];
691 *op->resnull = innerslot->tts_isnull[attnum];
692
693 EEO_NEXT();
694 }
695
696 EEO_CASE(EEOP_OUTER_VAR)
697 {
698 int attnum = op->d.var.attnum;
699
700 /* See EEOP_INNER_VAR comments */
701
702 Assert(attnum >= 0 && attnum < outerslot->tts_nvalid);
703 *op->resvalue = outerslot->tts_values[attnum];
704 *op->resnull = outerslot->tts_isnull[attnum];
705
706 EEO_NEXT();
707 }
708
709 EEO_CASE(EEOP_SCAN_VAR)
710 {
711 int attnum = op->d.var.attnum;
712
713 /* See EEOP_INNER_VAR comments */
714
715 Assert(attnum >= 0 && attnum < scanslot->tts_nvalid);
716 *op->resvalue = scanslot->tts_values[attnum];
717 *op->resnull = scanslot->tts_isnull[attnum];
718
719 EEO_NEXT();
720 }
721
722 EEO_CASE(EEOP_OLD_VAR)
723 {
724 int attnum = op->d.var.attnum;
725
726 /* See EEOP_INNER_VAR comments */
727
728 Assert(attnum >= 0 && attnum < oldslot->tts_nvalid);
729 *op->resvalue = oldslot->tts_values[attnum];
730 *op->resnull = oldslot->tts_isnull[attnum];
731
732 EEO_NEXT();
733 }
734
735 EEO_CASE(EEOP_NEW_VAR)
736 {
737 int attnum = op->d.var.attnum;
738
739 /* See EEOP_INNER_VAR comments */
740
741 Assert(attnum >= 0 && attnum < newslot->tts_nvalid);
742 *op->resvalue = newslot->tts_values[attnum];
743 *op->resnull = newslot->tts_isnull[attnum];
744
745 EEO_NEXT();
746 }
747
748 EEO_CASE(EEOP_INNER_SYSVAR)
749 {
750 ExecEvalSysVar(state, op, econtext, innerslot);
751 EEO_NEXT();
752 }
753
754 EEO_CASE(EEOP_OUTER_SYSVAR)
755 {
756 ExecEvalSysVar(state, op, econtext, outerslot);
757 EEO_NEXT();
758 }
759
760 EEO_CASE(EEOP_SCAN_SYSVAR)
761 {
762 ExecEvalSysVar(state, op, econtext, scanslot);
763 EEO_NEXT();
764 }
765
766 EEO_CASE(EEOP_OLD_SYSVAR)
767 {
768 ExecEvalSysVar(state, op, econtext, oldslot);
769 EEO_NEXT();
770 }
771
772 EEO_CASE(EEOP_NEW_SYSVAR)
773 {
774 ExecEvalSysVar(state, op, econtext, newslot);
775 EEO_NEXT();
776 }
777
778 EEO_CASE(EEOP_WHOLEROW)
779 {
780 /* too complex for an inline implementation */
781 ExecEvalWholeRowVar(state, op, econtext);
782
783 EEO_NEXT();
784 }
785
786 EEO_CASE(EEOP_ASSIGN_INNER_VAR)
787 {
788 int resultnum = op->d.assign_var.resultnum;
789 int attnum = op->d.assign_var.attnum;
790
791 /*
792 * We do not need CheckVarSlotCompatibility here; that was taken
793 * care of at compilation time. But see EEOP_INNER_VAR comments.
794 */
795 Assert(attnum >= 0 && attnum < innerslot->tts_nvalid);
796 Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
797 resultslot->tts_values[resultnum] = innerslot->tts_values[attnum];
798 resultslot->tts_isnull[resultnum] = innerslot->tts_isnull[attnum];
799
800 EEO_NEXT();
801 }
802
803 EEO_CASE(EEOP_ASSIGN_OUTER_VAR)
804 {
805 int resultnum = op->d.assign_var.resultnum;
806 int attnum = op->d.assign_var.attnum;
807
808 /*
809 * We do not need CheckVarSlotCompatibility here; that was taken
810 * care of at compilation time. But see EEOP_INNER_VAR comments.
811 */
812 Assert(attnum >= 0 && attnum < outerslot->tts_nvalid);
813 Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
814 resultslot->tts_values[resultnum] = outerslot->tts_values[attnum];
815 resultslot->tts_isnull[resultnum] = outerslot->tts_isnull[attnum];
816
817 EEO_NEXT();
818 }
819
820 EEO_CASE(EEOP_ASSIGN_SCAN_VAR)
821 {
822 int resultnum = op->d.assign_var.resultnum;
823 int attnum = op->d.assign_var.attnum;
824
825 /*
826 * We do not need CheckVarSlotCompatibility here; that was taken
827 * care of at compilation time. But see EEOP_INNER_VAR comments.
828 */
829 Assert(attnum >= 0 && attnum < scanslot->tts_nvalid);
830 Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
831 resultslot->tts_values[resultnum] = scanslot->tts_values[attnum];
832 resultslot->tts_isnull[resultnum] = scanslot->tts_isnull[attnum];
833
834 EEO_NEXT();
835 }
836
837 EEO_CASE(EEOP_ASSIGN_OLD_VAR)
838 {
839 int resultnum = op->d.assign_var.resultnum;
840 int attnum = op->d.assign_var.attnum;
841
842 /*
843 * We do not need CheckVarSlotCompatibility here; that was taken
844 * care of at compilation time. But see EEOP_INNER_VAR comments.
845 */
846 Assert(attnum >= 0 && attnum < oldslot->tts_nvalid);
847 Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
848 resultslot->tts_values[resultnum] = oldslot->tts_values[attnum];
849 resultslot->tts_isnull[resultnum] = oldslot->tts_isnull[attnum];
850
851 EEO_NEXT();
852 }
853
854 EEO_CASE(EEOP_ASSIGN_NEW_VAR)
855 {
856 int resultnum = op->d.assign_var.resultnum;
857 int attnum = op->d.assign_var.attnum;
858
859 /*
860 * We do not need CheckVarSlotCompatibility here; that was taken
861 * care of at compilation time. But see EEOP_INNER_VAR comments.
862 */
863 Assert(attnum >= 0 && attnum < newslot->tts_nvalid);
864 Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
865 resultslot->tts_values[resultnum] = newslot->tts_values[attnum];
866 resultslot->tts_isnull[resultnum] = newslot->tts_isnull[attnum];
867
868 EEO_NEXT();
869 }
870
871 EEO_CASE(EEOP_ASSIGN_TMP)
872 {
873 int resultnum = op->d.assign_tmp.resultnum;
874
875 Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
876 resultslot->tts_values[resultnum] = state->resvalue;
877 resultslot->tts_isnull[resultnum] = state->resnull;
878
879 EEO_NEXT();
880 }
881
882 EEO_CASE(EEOP_ASSIGN_TMP_MAKE_RO)
883 {
884 int resultnum = op->d.assign_tmp.resultnum;
885
886 Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
887 resultslot->tts_isnull[resultnum] = state->resnull;
888 if (!resultslot->tts_isnull[resultnum])
889 resultslot->tts_values[resultnum] =
890 MakeExpandedObjectReadOnlyInternal(state->resvalue);
891 else
892 resultslot->tts_values[resultnum] = state->resvalue;
893
894 EEO_NEXT();
895 }
896
897 EEO_CASE(EEOP_CONST)
898 {
899 *op->resnull = op->d.constval.isnull;
900 *op->resvalue = op->d.constval.value;
901
902 EEO_NEXT();
903 }
904
905 /*
906 * Function-call implementations. Arguments have previously been
907 * evaluated directly into fcinfo->args.
908 *
909 * As both STRICT checks and function-usage are noticeable performance
910 * wise, and function calls are a very hot-path (they also back
911 * operators!), it's worth having so many separate opcodes.
912 *
913 * Note: the reason for using a temporary variable "d", here and in
914 * other places, is that some compilers think "*op->resvalue = f();"
915 * requires them to evaluate op->resvalue into a register before
916 * calling f(), just in case f() is able to modify op->resvalue
917 * somehow. The extra line of code can save a useless register spill
918 * and reload across the function call.
919 */
920 EEO_CASE(EEOP_FUNCEXPR)
921 {
922 FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
923 Datum d;
924
925 fcinfo->isnull = false;
926 d = op->d.func.fn_addr(fcinfo);
927 *op->resvalue = d;
928 *op->resnull = fcinfo->isnull;
929
930 EEO_NEXT();
931 }
932
933 /* strict function call with more than two arguments */
934 EEO_CASE(EEOP_FUNCEXPR_STRICT)
935 {
936 FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
937 NullableDatum *args = fcinfo->args;
938 int nargs = op->d.func.nargs;
939 Datum d;
940
941 Assert(nargs > 2);
942
943 /* strict function, so check for NULL args */
944 for (int argno = 0; argno < nargs; argno++)
945 {
946 if (args[argno].isnull)
947 {
948 *op->resnull = true;
949 goto strictfail;
950 }
951 }
952 fcinfo->isnull = false;
953 d = op->d.func.fn_addr(fcinfo);
954 *op->resvalue = d;
955 *op->resnull = fcinfo->isnull;
956
957 strictfail:
958 EEO_NEXT();
959 }
960
961 /* strict function call with one argument */
962 EEO_CASE(EEOP_FUNCEXPR_STRICT_1)
963 {
964 FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
965 NullableDatum *args = fcinfo->args;
966
967 Assert(op->d.func.nargs == 1);
968
969 /* strict function, so check for NULL args */
970 if (args[0].isnull)
971 *op->resnull = true;
972 else
973 {
974 Datum d;
975
976 fcinfo->isnull = false;
977 d = op->d.func.fn_addr(fcinfo);
978 *op->resvalue = d;
979 *op->resnull = fcinfo->isnull;
980 }
981
982 EEO_NEXT();
983 }
984
985 /* strict function call with two arguments */
986 EEO_CASE(EEOP_FUNCEXPR_STRICT_2)
987 {
988 FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
989 NullableDatum *args = fcinfo->args;
990
991 Assert(op->d.func.nargs == 2);
992
993 /* strict function, so check for NULL args */
994 if (args[0].isnull || args[1].isnull)
995 *op->resnull = true;
996 else
997 {
998 Datum d;
999
1000 fcinfo->isnull = false;
1001 d = op->d.func.fn_addr(fcinfo);
1002 *op->resvalue = d;
1003 *op->resnull = fcinfo->isnull;
1004 }
1005
1006 EEO_NEXT();
1007 }
1008
1009 EEO_CASE(EEOP_FUNCEXPR_FUSAGE)
1010 {
1011 /* not common enough to inline */
1012 ExecEvalFuncExprFusage(state, op, econtext);
1013
1014 EEO_NEXT();
1015 }
1016
1017 EEO_CASE(EEOP_FUNCEXPR_STRICT_FUSAGE)
1018 {
1019 /* not common enough to inline */
1020 ExecEvalFuncExprStrictFusage(state, op, econtext);
1021
1022 EEO_NEXT();
1023 }
1024
1025 /*
1026 * If any of its clauses is FALSE, an AND's result is FALSE regardless
1027 * of the states of the rest of the clauses, so we can stop evaluating
1028 * and return FALSE immediately. If none are FALSE and one or more is
1029 * NULL, we return NULL; otherwise we return TRUE. This makes sense
1030 * when you interpret NULL as "don't know": perhaps one of the "don't
1031 * knows" would have been FALSE if we'd known its value. Only when
1032 * all the inputs are known to be TRUE can we state confidently that
1033 * the AND's result is TRUE.
1034 */
1035 EEO_CASE(EEOP_BOOL_AND_STEP_FIRST)
1036 {
1037 *op->d.boolexpr.anynull = false;
1038
1039 /*
1040 * EEOP_BOOL_AND_STEP_FIRST resets anynull, otherwise it's the
1041 * same as EEOP_BOOL_AND_STEP - so fall through to that.
1042 */
1043
1044 /* FALL THROUGH */
1045 }
1046
1047 EEO_CASE(EEOP_BOOL_AND_STEP)
1048 {
1049 if (*op->resnull)
1050 {
1051 *op->d.boolexpr.anynull = true;
1052 }
1053 else if (!DatumGetBool(*op->resvalue))
1054 {
1055 /* result is already set to FALSE, need not change it */
1056 /* bail out early */
1057 EEO_JUMP(op->d.boolexpr.jumpdone);
1058 }
1059
1060 EEO_NEXT();
1061 }
1062
1063 EEO_CASE(EEOP_BOOL_AND_STEP_LAST)
1064 {
1065 if (*op->resnull)
1066 {
1067 /* result is already set to NULL, need not change it */
1068 }
1069 else if (!DatumGetBool(*op->resvalue))
1070 {
1071 /* result is already set to FALSE, need not change it */
1072
1073 /*
1074 * No point jumping early to jumpdone - would be same target
1075 * (as this is the last argument to the AND expression),
1076 * except more expensive.
1077 */
1078 }
1079 else if (*op->d.boolexpr.anynull)
1080 {
1081 *op->resvalue = (Datum) 0;
1082 *op->resnull = true;
1083 }
1084 else
1085 {
1086 /* result is already set to TRUE, need not change it */
1087 }
1088
1089 EEO_NEXT();
1090 }
1091
1092 /*
1093 * If any of its clauses is TRUE, an OR's result is TRUE regardless of
1094 * the states of the rest of the clauses, so we can stop evaluating
1095 * and return TRUE immediately. If none are TRUE and one or more is
1096 * NULL, we return NULL; otherwise we return FALSE. This makes sense
1097 * when you interpret NULL as "don't know": perhaps one of the "don't
1098 * knows" would have been TRUE if we'd known its value. Only when all
1099 * the inputs are known to be FALSE can we state confidently that the
1100 * OR's result is FALSE.
1101 */
1102 EEO_CASE(EEOP_BOOL_OR_STEP_FIRST)
1103 {
1104 *op->d.boolexpr.anynull = false;
1105
1106 /*
1107 * EEOP_BOOL_OR_STEP_FIRST resets anynull, otherwise it's the same
1108 * as EEOP_BOOL_OR_STEP - so fall through to that.
1109 */
1110
1111 /* FALL THROUGH */
1112 }
1113
1114 EEO_CASE(EEOP_BOOL_OR_STEP)
1115 {
1116 if (*op->resnull)
1117 {
1118 *op->d.boolexpr.anynull = true;
1119 }
1120 else if (DatumGetBool(*op->resvalue))
1121 {
1122 /* result is already set to TRUE, need not change it */
1123 /* bail out early */
1124 EEO_JUMP(op->d.boolexpr.jumpdone);
1125 }
1126
1127 EEO_NEXT();
1128 }
1129
1130 EEO_CASE(EEOP_BOOL_OR_STEP_LAST)
1131 {
1132 if (*op->resnull)
1133 {
1134 /* result is already set to NULL, need not change it */
1135 }
1136 else if (DatumGetBool(*op->resvalue))
1137 {
1138 /* result is already set to TRUE, need not change it */
1139
1140 /*
1141 * No point jumping to jumpdone - would be same target (as
1142 * this is the last argument to the AND expression), except
1143 * more expensive.
1144 */
1145 }
1146 else if (*op->d.boolexpr.anynull)
1147 {
1148 *op->resvalue = (Datum) 0;
1149 *op->resnull = true;
1150 }
1151 else
1152 {
1153 /* result is already set to FALSE, need not change it */
1154 }
1155
1156 EEO_NEXT();
1157 }
1158
1159 EEO_CASE(EEOP_BOOL_NOT_STEP)
1160 {
1161 /*
1162 * Evaluation of 'not' is simple... if expr is false, then return
1163 * 'true' and vice versa. It's safe to do this even on a
1164 * nominally null value, so we ignore resnull; that means that
1165 * NULL in produces NULL out, which is what we want.
1166 */
1167 *op->resvalue = BoolGetDatum(!DatumGetBool(*op->resvalue));
1168
1169 EEO_NEXT();
1170 }
1171
1172 EEO_CASE(EEOP_QUAL)
1173 {
1174 /* simplified version of BOOL_AND_STEP for use by ExecQual() */
1175
1176 /* If argument (also result) is false or null ... */
1177 if (*op->resnull ||
1178 !DatumGetBool(*op->resvalue))
1179 {
1180 /* ... bail out early, returning FALSE */
1181 *op->resnull = false;
1182 *op->resvalue = BoolGetDatum(false);
1183 EEO_JUMP(op->d.qualexpr.jumpdone);
1184 }
1185
1186 /*
1187 * Otherwise, leave the TRUE value in place, in case this is the
1188 * last qual. Then, TRUE is the correct answer.
1189 */
1190
1191 EEO_NEXT();
1192 }
1193
1194 EEO_CASE(EEOP_JUMP)
1195 {
1196 /* Unconditionally jump to target step */
1197 EEO_JUMP(op->d.jump.jumpdone);
1198 }
1199
1200 EEO_CASE(EEOP_JUMP_IF_NULL)
1201 {
1202 /* Transfer control if current result is null */
1203 if (*op->resnull)
1204 EEO_JUMP(op->d.jump.jumpdone);
1205
1206 EEO_NEXT();
1207 }
1208
1209 EEO_CASE(EEOP_JUMP_IF_NOT_NULL)
1210 {
1211 /* Transfer control if current result is non-null */
1212 if (!*op->resnull)
1213 EEO_JUMP(op->d.jump.jumpdone);
1214
1215 EEO_NEXT();
1216 }
1217
1218 EEO_CASE(EEOP_JUMP_IF_NOT_TRUE)
1219 {
1220 /* Transfer control if current result is null or false */
1221 if (*op->resnull || !DatumGetBool(*op->resvalue))
1222 EEO_JUMP(op->d.jump.jumpdone);
1223
1224 EEO_NEXT();
1225 }
1226
1227 EEO_CASE(EEOP_NULLTEST_ISNULL)
1228 {
1229 *op->resvalue = BoolGetDatum(*op->resnull);
1230 *op->resnull = false;
1231
1232 EEO_NEXT();
1233 }
1234
1235 EEO_CASE(EEOP_NULLTEST_ISNOTNULL)
1236 {
1237 *op->resvalue = BoolGetDatum(!*op->resnull);
1238 *op->resnull = false;
1239
1240 EEO_NEXT();
1241 }
1242
1243 EEO_CASE(EEOP_NULLTEST_ROWISNULL)
1244 {
1245 /* out of line implementation: too large */
1246 ExecEvalRowNull(state, op, econtext);
1247
1248 EEO_NEXT();
1249 }
1250
1251 EEO_CASE(EEOP_NULLTEST_ROWISNOTNULL)
1252 {
1253 /* out of line implementation: too large */
1254 ExecEvalRowNotNull(state, op, econtext);
1255
1256 EEO_NEXT();
1257 }
1258
1259 /* BooleanTest implementations for all booltesttypes */
1260
1261 EEO_CASE(EEOP_BOOLTEST_IS_TRUE)
1262 {
1263 if (*op->resnull)
1264 {
1265 *op->resvalue = BoolGetDatum(false);
1266 *op->resnull = false;
1267 }
1268 /* else, input value is the correct output as well */
1269
1270 EEO_NEXT();
1271 }
1272
1273 EEO_CASE(EEOP_BOOLTEST_IS_NOT_TRUE)
1274 {
1275 if (*op->resnull)
1276 {
1277 *op->resvalue = BoolGetDatum(true);
1278 *op->resnull = false;
1279 }
1280 else
1281 *op->resvalue = BoolGetDatum(!DatumGetBool(*op->resvalue));
1282
1283 EEO_NEXT();
1284 }
1285
1286 EEO_CASE(EEOP_BOOLTEST_IS_FALSE)
1287 {
1288 if (*op->resnull)
1289 {
1290 *op->resvalue = BoolGetDatum(false);
1291 *op->resnull = false;
1292 }
1293 else
1294 *op->resvalue = BoolGetDatum(!DatumGetBool(*op->resvalue));
1295
1296 EEO_NEXT();
1297 }
1298
1299 EEO_CASE(EEOP_BOOLTEST_IS_NOT_FALSE)
1300 {
1301 if (*op->resnull)
1302 {
1303 *op->resvalue = BoolGetDatum(true);
1304 *op->resnull = false;
1305 }
1306 /* else, input value is the correct output as well */
1307
1308 EEO_NEXT();
1309 }
1310
1311 EEO_CASE(EEOP_PARAM_EXEC)
1312 {
1313 /* out of line implementation: too large */
1314 ExecEvalParamExec(state, op, econtext);
1315
1316 EEO_NEXT();
1317 }
1318
1319 EEO_CASE(EEOP_PARAM_EXTERN)
1320 {
1321 /* out of line implementation: too large */
1322 ExecEvalParamExtern(state, op, econtext);
1323 EEO_NEXT();
1324 }
1325
1326 EEO_CASE(EEOP_PARAM_CALLBACK)
1327 {
1328 /* allow an extension module to supply a PARAM_EXTERN value */
1329 op->d.cparam.paramfunc(state, op, econtext);
1330 EEO_NEXT();
1331 }
1332
1333 EEO_CASE(EEOP_PARAM_SET)
1334 {
1335 /* out of line, unlikely to matter performance-wise */
1336 ExecEvalParamSet(state, op, econtext);
1337 EEO_NEXT();
1338 }
1339
1340 EEO_CASE(EEOP_CASE_TESTVAL)
1341 {
1342 *op->resvalue = *op->d.casetest.value;
1343 *op->resnull = *op->d.casetest.isnull;
1344
1345 EEO_NEXT();
1346 }
1347
1348 EEO_CASE(EEOP_CASE_TESTVAL_EXT)
1349 {
1350 *op->resvalue = econtext->caseValue_datum;
1351 *op->resnull = econtext->caseValue_isNull;
1352
1353 EEO_NEXT();
1354 }
1355
1356 EEO_CASE(EEOP_MAKE_READONLY)
1357 {
1358 /*
1359 * Force a varlena value that might be read multiple times to R/O
1360 */
1361 if (!*op->d.make_readonly.isnull)
1362 *op->resvalue =
1363 MakeExpandedObjectReadOnlyInternal(*op->d.make_readonly.value);
1364 *op->resnull = *op->d.make_readonly.isnull;
1365
1366 EEO_NEXT();
1367 }
1368
1369 EEO_CASE(EEOP_IOCOERCE)
1370 {
1371 /*
1372 * Evaluate a CoerceViaIO node. This can be quite a hot path, so
1373 * inline as much work as possible. The source value is in our
1374 * result variable.
1375 *
1376 * Also look at ExecEvalCoerceViaIOSafe() if you change anything
1377 * here.
1378 */
1379 char *str;
1380
1381 /* call output function (similar to OutputFunctionCall) */
1382 if (*op->resnull)
1383 {
1384 /* output functions are not called on nulls */
1385 str = NULL;
1386 }
1387 else
1388 {
1389 FunctionCallInfo fcinfo_out;
1390
1391 fcinfo_out = op->d.iocoerce.fcinfo_data_out;
1392 fcinfo_out->args[0].value = *op->resvalue;
1393 fcinfo_out->args[0].isnull = false;
1394
1395 fcinfo_out->isnull = false;
1396 str = DatumGetCString(FunctionCallInvoke(fcinfo_out));
1397
1398 /* OutputFunctionCall assumes result isn't null */
1399 Assert(!fcinfo_out->isnull);
1400 }
1401
1402 /* call input function (similar to InputFunctionCall) */
1403 if (!op->d.iocoerce.finfo_in->fn_strict || str != NULL)
1404 {
1405 FunctionCallInfo fcinfo_in;
1406 Datum d;
1407
1408 fcinfo_in = op->d.iocoerce.fcinfo_data_in;
1409 fcinfo_in->args[0].value = PointerGetDatum(str);
1410 fcinfo_in->args[0].isnull = *op->resnull;
1411 /* second and third arguments are already set up */
1412
1413 fcinfo_in->isnull = false;
1414 d = FunctionCallInvoke(fcinfo_in);
1415 *op->resvalue = d;
1416
1417 /* Should get null result if and only if str is NULL */
1418 if (str == NULL)
1419 {
1420 Assert(*op->resnull);
1421 Assert(fcinfo_in->isnull);
1422 }
1423 else
1424 {
1425 Assert(!*op->resnull);
1426 Assert(!fcinfo_in->isnull);
1427 }
1428 }
1429
1430 EEO_NEXT();
1431 }
1432
1433 EEO_CASE(EEOP_IOCOERCE_SAFE)
1434 {
1435 ExecEvalCoerceViaIOSafe(state, op);
1436 EEO_NEXT();
1437 }
1438
1439 EEO_CASE(EEOP_DISTINCT)
1440 {
1441 /*
1442 * IS DISTINCT FROM must evaluate arguments (already done into
1443 * fcinfo->args) to determine whether they are NULL; if either is
1444 * NULL then the result is determined. If neither is NULL, then
1445 * proceed to evaluate the comparison function, which is just the
1446 * type's standard equality operator. We need not care whether
1447 * that function is strict. Because the handling of nulls is
1448 * different, we can't just reuse EEOP_FUNCEXPR.
1449 */
1450 FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
1451
1452 /* check function arguments for NULLness */
1453 if (fcinfo->args[0].isnull && fcinfo->args[1].isnull)
1454 {
1455 /* Both NULL? Then is not distinct... */
1456 *op->resvalue = BoolGetDatum(false);
1457 *op->resnull = false;
1458 }
1459 else if (fcinfo->args[0].isnull || fcinfo->args[1].isnull)
1460 {
1461 /* Only one is NULL? Then is distinct... */
1462 *op->resvalue = BoolGetDatum(true);
1463 *op->resnull = false;
1464 }
1465 else
1466 {
1467 /* Neither null, so apply the equality function */
1468 Datum eqresult;
1469
1470 fcinfo->isnull = false;
1471 eqresult = op->d.func.fn_addr(fcinfo);
1472 /* Must invert result of "="; safe to do even if null */
1473 *op->resvalue = BoolGetDatum(!DatumGetBool(eqresult));
1474 *op->resnull = fcinfo->isnull;
1475 }
1476
1477 EEO_NEXT();
1478 }
1479
1480 /* see EEOP_DISTINCT for comments, this is just inverted */
1481 EEO_CASE(EEOP_NOT_DISTINCT)
1482 {
1483 FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
1484
1485 if (fcinfo->args[0].isnull && fcinfo->args[1].isnull)
1486 {
1487 *op->resvalue = BoolGetDatum(true);
1488 *op->resnull = false;
1489 }
1490 else if (fcinfo->args[0].isnull || fcinfo->args[1].isnull)
1491 {
1492 *op->resvalue = BoolGetDatum(false);
1493 *op->resnull = false;
1494 }
1495 else
1496 {
1497 Datum eqresult;
1498
1499 fcinfo->isnull = false;
1500 eqresult = op->d.func.fn_addr(fcinfo);
1501 *op->resvalue = eqresult;
1502 *op->resnull = fcinfo->isnull;
1503 }
1504
1505 EEO_NEXT();
1506 }
1507
1508 EEO_CASE(EEOP_NULLIF)
1509 {
1510 /*
1511 * The arguments are already evaluated into fcinfo->args.
1512 */
1513 FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
1514 Datum save_arg0 = fcinfo->args[0].value;
1515
1516 /* if either argument is NULL they can't be equal */
1517 if (!fcinfo->args[0].isnull && !fcinfo->args[1].isnull)
1518 {
1519 Datum result;
1520
1521 /*
1522 * If first argument is of varlena type, it might be an
1523 * expanded datum. We need to ensure that the value passed to
1524 * the comparison function is a read-only pointer. However,
1525 * if we end by returning the first argument, that will be the
1526 * original read-write pointer if it was read-write.
1527 */
1528 if (op->d.func.make_ro)
1529 fcinfo->args[0].value =
1530 MakeExpandedObjectReadOnlyInternal(save_arg0);
1531
1532 fcinfo->isnull = false;
1533 result = op->d.func.fn_addr(fcinfo);
1534
1535 /* if the arguments are equal return null */
1536 if (!fcinfo->isnull && DatumGetBool(result))
1537 {
1538 *op->resvalue = (Datum) 0;
1539 *op->resnull = true;
1540
1541 EEO_NEXT();
1542 }
1543 }
1544
1545 /* Arguments aren't equal, so return the first one */
1546 *op->resvalue = save_arg0;
1547 *op->resnull = fcinfo->args[0].isnull;
1548
1549 EEO_NEXT();
1550 }
1551
1552 EEO_CASE(EEOP_SQLVALUEFUNCTION)
1553 {
1554 /*
1555 * Doesn't seem worthwhile to have an inline implementation
1556 * efficiency-wise.
1557 */
1558 ExecEvalSQLValueFunction(state, op);
1559
1560 EEO_NEXT();
1561 }
1562
1563 EEO_CASE(EEOP_CURRENTOFEXPR)
1564 {
1565 /* error invocation uses space, and shouldn't ever occur */
1566 ExecEvalCurrentOfExpr(state, op);
1567
1568 EEO_NEXT();
1569 }
1570
1571 EEO_CASE(EEOP_NEXTVALUEEXPR)
1572 {
1573 /*
1574 * Doesn't seem worthwhile to have an inline implementation
1575 * efficiency-wise.
1576 */
1577 ExecEvalNextValueExpr(state, op);
1578
1579 EEO_NEXT();
1580 }
1581
1582 EEO_CASE(EEOP_RETURNINGEXPR)
1583 {
1584 /*
1585 * The next op actually evaluates the expression. If the OLD/NEW
1586 * row doesn't exist, skip that and return NULL.
1587 */
1588 if (state->flags & op->d.returningexpr.nullflag)
1589 {
1590 *op->resvalue = (Datum) 0;
1591 *op->resnull = true;
1592
1593 EEO_JUMP(op->d.returningexpr.jumpdone);
1594 }
1595
1596 EEO_NEXT();
1597 }
1598
1599 EEO_CASE(EEOP_ARRAYEXPR)
1600 {
1601 /* too complex for an inline implementation */
1602 ExecEvalArrayExpr(state, op);
1603
1604 EEO_NEXT();
1605 }
1606
1607 EEO_CASE(EEOP_ARRAYCOERCE)
1608 {
1609 /* too complex for an inline implementation */
1610 ExecEvalArrayCoerce(state, op, econtext);
1611
1612 EEO_NEXT();
1613 }
1614
1615 EEO_CASE(EEOP_ROW)
1616 {
1617 /* too complex for an inline implementation */
1618 ExecEvalRow(state, op);
1619
1620 EEO_NEXT();
1621 }
1622
1623 EEO_CASE(EEOP_ROWCOMPARE_STEP)
1624 {
1625 FunctionCallInfo fcinfo = op->d.rowcompare_step.fcinfo_data;
1626 Datum d;
1627
1628 /* force NULL result if strict fn and NULL input */
1629 if (op->d.rowcompare_step.finfo->fn_strict &&
1630 (fcinfo->args[0].isnull || fcinfo->args[1].isnull))
1631 {
1632 *op->resnull = true;
1633 EEO_JUMP(op->d.rowcompare_step.jumpnull);
1634 }
1635
1636 /* Apply comparison function */
1637 fcinfo->isnull = false;
1638 d = op->d.rowcompare_step.fn_addr(fcinfo);
1639 *op->resvalue = d;
1640
1641 /* force NULL result if NULL function result */
1642 if (fcinfo->isnull)
1643 {
1644 *op->resnull = true;
1645 EEO_JUMP(op->d.rowcompare_step.jumpnull);
1646 }
1647 *op->resnull = false;
1648
1649 /* If unequal, no need to compare remaining columns */
1650 if (DatumGetInt32(*op->resvalue) != 0)
1651 {
1652 EEO_JUMP(op->d.rowcompare_step.jumpdone);
1653 }
1654
1655 EEO_NEXT();
1656 }
1657
1658 EEO_CASE(EEOP_ROWCOMPARE_FINAL)
1659 {
1660 int32 cmpresult = DatumGetInt32(*op->resvalue);
1661 CompareType cmptype = op->d.rowcompare_final.cmptype;
1662
1663 *op->resnull = false;
1664 switch (cmptype)
1665 {
1666 /* EQ and NE cases aren't allowed here */
1667 case COMPARE_LT:
1668 *op->resvalue = BoolGetDatum(cmpresult < 0);
1669 break;
1670 case COMPARE_LE:
1671 *op->resvalue = BoolGetDatum(cmpresult <= 0);
1672 break;
1673 case COMPARE_GE:
1674 *op->resvalue = BoolGetDatum(cmpresult >= 0);
1675 break;
1676 case COMPARE_GT:
1677 *op->resvalue = BoolGetDatum(cmpresult > 0);
1678 break;
1679 default:
1680 Assert(false);
1681 break;
1682 }
1683
1684 EEO_NEXT();
1685 }
1686
1687 EEO_CASE(EEOP_MINMAX)
1688 {
1689 /* too complex for an inline implementation */
1690 ExecEvalMinMax(state, op);
1691
1692 EEO_NEXT();
1693 }
1694
1695 EEO_CASE(EEOP_FIELDSELECT)
1696 {
1697 /* too complex for an inline implementation */
1698 ExecEvalFieldSelect(state, op, econtext);
1699
1700 EEO_NEXT();
1701 }
1702
1703 EEO_CASE(EEOP_FIELDSTORE_DEFORM)
1704 {
1705 /* too complex for an inline implementation */
1706 ExecEvalFieldStoreDeForm(state, op, econtext);
1707
1708 EEO_NEXT();
1709 }
1710
1711 EEO_CASE(EEOP_FIELDSTORE_FORM)
1712 {
1713 /* too complex for an inline implementation */
1714 ExecEvalFieldStoreForm(state, op, econtext);
1715
1716 EEO_NEXT();
1717 }
1718
1719 EEO_CASE(EEOP_SBSREF_SUBSCRIPTS)
1720 {
1721 /* Precheck SubscriptingRef subscript(s) */
1722 if (op->d.sbsref_subscript.subscriptfunc(state, op, econtext))
1723 {
1724 EEO_NEXT();
1725 }
1726 else
1727 {
1728 /* Subscript is null, short-circuit SubscriptingRef to NULL */
1729 EEO_JUMP(op->d.sbsref_subscript.jumpdone);
1730 }
1731 }
1732
1733 EEO_CASE(EEOP_SBSREF_OLD)
1734 EEO_CASE(EEOP_SBSREF_ASSIGN)
1735 EEO_CASE(EEOP_SBSREF_FETCH)
1736 {
1737 /* Perform a SubscriptingRef fetch or assignment */
1738 op->d.sbsref.subscriptfunc(state, op, econtext);
1739
1740 EEO_NEXT();
1741 }
1742
1743 EEO_CASE(EEOP_CONVERT_ROWTYPE)
1744 {
1745 /* too complex for an inline implementation */
1746 ExecEvalConvertRowtype(state, op, econtext);
1747
1748 EEO_NEXT();
1749 }
1750
1751 EEO_CASE(EEOP_SCALARARRAYOP)
1752 {
1753 /* too complex for an inline implementation */
1754 ExecEvalScalarArrayOp(state, op);
1755
1756 EEO_NEXT();
1757 }
1758
1759 EEO_CASE(EEOP_HASHED_SCALARARRAYOP)
1760 {
1761 /* too complex for an inline implementation */
1762 ExecEvalHashedScalarArrayOp(state, op, econtext);
1763
1764 EEO_NEXT();
1765 }
1766
1767 EEO_CASE(EEOP_DOMAIN_TESTVAL)
1768 {
1769 *op->resvalue = *op->d.casetest.value;
1770 *op->resnull = *op->d.casetest.isnull;
1771
1772 EEO_NEXT();
1773 }
1774
1775 EEO_CASE(EEOP_DOMAIN_TESTVAL_EXT)
1776 {
1777 *op->resvalue = econtext->domainValue_datum;
1778 *op->resnull = econtext->domainValue_isNull;
1779
1780 EEO_NEXT();
1781 }
1782
1783 EEO_CASE(EEOP_DOMAIN_NOTNULL)
1784 {
1785 /* too complex for an inline implementation */
1786 ExecEvalConstraintNotNull(state, op);
1787
1788 EEO_NEXT();
1789 }
1790
1791 EEO_CASE(EEOP_DOMAIN_CHECK)
1792 {
1793 /* too complex for an inline implementation */
1794 ExecEvalConstraintCheck(state, op);
1795
1796 EEO_NEXT();
1797 }
1798
1799 EEO_CASE(EEOP_HASHDATUM_SET_INITVAL)
1800 {
1801 *op->resvalue = op->d.hashdatum_initvalue.init_value;
1802 *op->resnull = false;
1803
1804 EEO_NEXT();
1805 }
1806
1807 EEO_CASE(EEOP_HASHDATUM_FIRST)
1808 {
1809 FunctionCallInfo fcinfo = op->d.hashdatum.fcinfo_data;
1810
1811 /*
1812 * Save the Datum on non-null inputs, otherwise store 0 so that
1813 * subsequent NEXT32 operations combine with an initialized value.
1814 */
1815 if (!fcinfo->args[0].isnull)
1816 *op->resvalue = op->d.hashdatum.fn_addr(fcinfo);
1817 else
1818 *op->resvalue = (Datum) 0;
1819
1820 *op->resnull = false;
1821
1822 EEO_NEXT();
1823 }
1824
1825 EEO_CASE(EEOP_HASHDATUM_FIRST_STRICT)
1826 {
1827 FunctionCallInfo fcinfo = op->d.hashdatum.fcinfo_data;
1828
1829 if (fcinfo->args[0].isnull)
1830 {
1831 /*
1832 * With strict we have the expression return NULL instead of
1833 * ignoring NULL input values. We've nothing more to do after
1834 * finding a NULL.
1835 */
1836 *op->resnull = true;
1837 *op->resvalue = (Datum) 0;
1838 EEO_JUMP(op->d.hashdatum.jumpdone);
1839 }
1840
1841 /* execute the hash function and save the resulting value */
1842 *op->resvalue = op->d.hashdatum.fn_addr(fcinfo);
1843 *op->resnull = false;
1844
1845 EEO_NEXT();
1846 }
1847
1848 EEO_CASE(EEOP_HASHDATUM_NEXT32)
1849 {
1850 FunctionCallInfo fcinfo = op->d.hashdatum.fcinfo_data;
1851 uint32 existinghash;
1852
1853 existinghash = DatumGetUInt32(op->d.hashdatum.iresult->value);
1854 /* combine successive hash values by rotating */
1855 existinghash = pg_rotate_left32(existinghash, 1);
1856
1857 /* leave the hash value alone on NULL inputs */
1858 if (!fcinfo->args[0].isnull)
1859 {
1860 uint32 hashvalue;
1861
1862 /* execute hash func and combine with previous hash value */
1863 hashvalue = DatumGetUInt32(op->d.hashdatum.fn_addr(fcinfo));
1864 existinghash = existinghash ^ hashvalue;
1865 }
1866
1867 *op->resvalue = UInt32GetDatum(existinghash);
1868 *op->resnull = false;
1869
1870 EEO_NEXT();
1871 }
1872
1873 EEO_CASE(EEOP_HASHDATUM_NEXT32_STRICT)
1874 {
1875 FunctionCallInfo fcinfo = op->d.hashdatum.fcinfo_data;
1876
1877 if (fcinfo->args[0].isnull)
1878 {
1879 /*
1880 * With strict we have the expression return NULL instead of
1881 * ignoring NULL input values. We've nothing more to do after
1882 * finding a NULL.
1883 */
1884 *op->resnull = true;
1885 *op->resvalue = (Datum) 0;
1886 EEO_JUMP(op->d.hashdatum.jumpdone);
1887 }
1888 else
1889 {
1890 uint32 existinghash;
1891 uint32 hashvalue;
1892
1893 existinghash = DatumGetUInt32(op->d.hashdatum.iresult->value);
1894 /* combine successive hash values by rotating */
1895 existinghash = pg_rotate_left32(existinghash, 1);
1896
1897 /* execute hash func and combine with previous hash value */
1898 hashvalue = DatumGetUInt32(op->d.hashdatum.fn_addr(fcinfo));
1899 *op->resvalue = UInt32GetDatum(existinghash ^ hashvalue);
1900 *op->resnull = false;
1901 }
1902
1903 EEO_NEXT();
1904 }
1905
1906 EEO_CASE(EEOP_XMLEXPR)
1907 {
1908 /* too complex for an inline implementation */
1909 ExecEvalXmlExpr(state, op);
1910
1911 EEO_NEXT();
1912 }
1913
1914 EEO_CASE(EEOP_JSON_CONSTRUCTOR)
1915 {
1916 /* too complex for an inline implementation */
1917 ExecEvalJsonConstructor(state, op, econtext);
1918 EEO_NEXT();
1919 }
1920
1921 EEO_CASE(EEOP_IS_JSON)
1922 {
1923 /* too complex for an inline implementation */
1924 ExecEvalJsonIsPredicate(state, op);
1925
1926 EEO_NEXT();
1927 }
1928
1929 EEO_CASE(EEOP_JSONEXPR_PATH)
1930 {
1931 /* too complex for an inline implementation */
1932 EEO_JUMP(ExecEvalJsonExprPath(state, op, econtext));
1933 }
1934
1935 EEO_CASE(EEOP_JSONEXPR_COERCION)
1936 {
1937 /* too complex for an inline implementation */
1938 ExecEvalJsonCoercion(state, op, econtext);
1939
1940 EEO_NEXT();
1941 }
1942
1943 EEO_CASE(EEOP_JSONEXPR_COERCION_FINISH)
1944 {
1945 /* too complex for an inline implementation */
1946 ExecEvalJsonCoercionFinish(state, op);
1947
1948 EEO_NEXT();
1949 }
1950
1951 EEO_CASE(EEOP_AGGREF)
1952 {
1953 /*
1954 * Returns a Datum whose value is the precomputed aggregate value
1955 * found in the given expression context.
1956 */
1957 int aggno = op->d.aggref.aggno;
1958
1959 Assert(econtext->ecxt_aggvalues != NULL);
1960
1961 *op->resvalue = econtext->ecxt_aggvalues[aggno];
1962 *op->resnull = econtext->ecxt_aggnulls[aggno];
1963
1964 EEO_NEXT();
1965 }
1966
1967 EEO_CASE(EEOP_GROUPING_FUNC)
1968 {
1969 /* too complex/uncommon for an inline implementation */
1970 ExecEvalGroupingFunc(state, op);
1971
1972 EEO_NEXT();
1973 }
1974
1975 EEO_CASE(EEOP_WINDOW_FUNC)
1976 {
1977 /*
1978 * Like Aggref, just return a precomputed value from the econtext.
1979 */
1980 WindowFuncExprState *wfunc = op->d.window_func.wfstate;
1981
1982 Assert(econtext->ecxt_aggvalues != NULL);
1983
1984 *op->resvalue = econtext->ecxt_aggvalues[wfunc->wfuncno];
1985 *op->resnull = econtext->ecxt_aggnulls[wfunc->wfuncno];
1986
1987 EEO_NEXT();
1988 }
1989
1990 EEO_CASE(EEOP_MERGE_SUPPORT_FUNC)
1991 {
1992 /* too complex/uncommon for an inline implementation */
1993 ExecEvalMergeSupportFunc(state, op, econtext);
1994
1995 EEO_NEXT();
1996 }
1997
1998 EEO_CASE(EEOP_SUBPLAN)
1999 {
2000 /* too complex for an inline implementation */
2001 ExecEvalSubPlan(state, op, econtext);
2002
2003 EEO_NEXT();
2004 }
2005
2006 /* evaluate a strict aggregate deserialization function */
2007 EEO_CASE(EEOP_AGG_STRICT_DESERIALIZE)
2008 {
2009 /* Don't call a strict deserialization function with NULL input */
2010 if (op->d.agg_deserialize.fcinfo_data->args[0].isnull)
2011 EEO_JUMP(op->d.agg_deserialize.jumpnull);
2012
2013 /* fallthrough */
2014 }
2015
2016 /* evaluate aggregate deserialization function (non-strict portion) */
2017 EEO_CASE(EEOP_AGG_DESERIALIZE)
2018 {
2019 FunctionCallInfo fcinfo = op->d.agg_deserialize.fcinfo_data;
2020 AggState *aggstate = castNode(AggState, state->parent);
2021 MemoryContext oldContext;
2022
2023 /*
2024 * We run the deserialization functions in per-input-tuple memory
2025 * context.
2026 */
2027 oldContext = MemoryContextSwitchTo(aggstate->tmpcontext->ecxt_per_tuple_memory);
2028 fcinfo->isnull = false;
2029 *op->resvalue = FunctionCallInvoke(fcinfo);
2030 *op->resnull = fcinfo->isnull;
2031 MemoryContextSwitchTo(oldContext);
2032
2033 EEO_NEXT();
2034 }
2035
2036 /*
2037 * Check that a strict aggregate transition / combination function's
2038 * input is not NULL.
2039 */
2040
2041 /* when checking more than one argument */
2042 EEO_CASE(EEOP_AGG_STRICT_INPUT_CHECK_ARGS)
2043 {
2044 NullableDatum *args = op->d.agg_strict_input_check.args;
2045 int nargs = op->d.agg_strict_input_check.nargs;
2046
2047 Assert(nargs > 1);
2048
2049 for (int argno = 0; argno < nargs; argno++)
2050 {
2051 if (args[argno].isnull)
2052 EEO_JUMP(op->d.agg_strict_input_check.jumpnull);
2053 }
2054 EEO_NEXT();
2055 }
2056
2057 /* special case for just one argument */
2058 EEO_CASE(EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1)
2059 {
2060 NullableDatum *args = op->d.agg_strict_input_check.args;
2061 PG_USED_FOR_ASSERTS_ONLY int nargs = op->d.agg_strict_input_check.nargs;
2062
2063 Assert(nargs == 1);
2064
2065 if (args[0].isnull)
2066 EEO_JUMP(op->d.agg_strict_input_check.jumpnull);
2067 EEO_NEXT();
2068 }
2069
2070 EEO_CASE(EEOP_AGG_STRICT_INPUT_CHECK_NULLS)
2071 {
2072 bool *nulls = op->d.agg_strict_input_check.nulls;
2073 int nargs = op->d.agg_strict_input_check.nargs;
2074
2075 for (int argno = 0; argno < nargs; argno++)
2076 {
2077 if (nulls[argno])
2078 EEO_JUMP(op->d.agg_strict_input_check.jumpnull);
2079 }
2080 EEO_NEXT();
2081 }
2082
2083 /*
2084 * Check for a NULL pointer to the per-group states.
2085 */
2086
2087 EEO_CASE(EEOP_AGG_PLAIN_PERGROUP_NULLCHECK)
2088 {
2089 AggState *aggstate = castNode(AggState, state->parent);
2090 AggStatePerGroup pergroup_allaggs =
2091 aggstate->all_pergroups[op->d.agg_plain_pergroup_nullcheck.setoff];
2092
2093 if (pergroup_allaggs == NULL)
2094 EEO_JUMP(op->d.agg_plain_pergroup_nullcheck.jumpnull);
2095
2096 EEO_NEXT();
2097 }
2098
2099 /*
2100 * Different types of aggregate transition functions are implemented
2101 * as different types of steps, to avoid incurring unnecessary
2102 * overhead. There's a step type for each valid combination of having
2103 * a by value / by reference transition type, [not] needing to the
2104 * initialize the transition value for the first row in a group from
2105 * input, and [not] strict transition function.
2106 *
2107 * Could optimize further by splitting off by-reference for
2108 * fixed-length types, but currently that doesn't seem worth it.
2109 */
2110
2111 EEO_CASE(EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL)
2112 {
2113 AggState *aggstate = castNode(AggState, state->parent);
2114 AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
2115 AggStatePerGroup pergroup =
2116 &aggstate->all_pergroups[op->d.agg_trans.setoff][op->d.agg_trans.transno];
2117
2118 Assert(pertrans->transtypeByVal);
2119
2120 if (pergroup->noTransValue)
2121 {
2122 /* If transValue has not yet been initialized, do so now. */
2123 ExecAggInitGroup(aggstate, pertrans, pergroup,
2124 op->d.agg_trans.aggcontext);
2125 /* copied trans value from input, done this round */
2126 }
2127 else if (likely(!pergroup->transValueIsNull))
2128 {
2129 /* invoke transition function, unless prevented by strictness */
2130 ExecAggPlainTransByVal(aggstate, pertrans, pergroup,
2131 op->d.agg_trans.aggcontext,
2132 op->d.agg_trans.setno);
2133 }
2134
2135 EEO_NEXT();
2136 }
2137
2138 /* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */
2139 EEO_CASE(EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL)
2140 {
2141 AggState *aggstate = castNode(AggState, state->parent);
2142 AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
2143 AggStatePerGroup pergroup =
2144 &aggstate->all_pergroups[op->d.agg_trans.setoff][op->d.agg_trans.transno];
2145
2146 Assert(pertrans->transtypeByVal);
2147
2148 if (likely(!pergroup->transValueIsNull))
2149 ExecAggPlainTransByVal(aggstate, pertrans, pergroup,
2150 op->d.agg_trans.aggcontext,
2151 op->d.agg_trans.setno);
2152
2153 EEO_NEXT();
2154 }
2155
2156 /* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */
2157 EEO_CASE(EEOP_AGG_PLAIN_TRANS_BYVAL)
2158 {
2159 AggState *aggstate = castNode(AggState, state->parent);
2160 AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
2161 AggStatePerGroup pergroup =
2162 &aggstate->all_pergroups[op->d.agg_trans.setoff][op->d.agg_trans.transno];
2163
2164 Assert(pertrans->transtypeByVal);
2165
2166 ExecAggPlainTransByVal(aggstate, pertrans, pergroup,
2167 op->d.agg_trans.aggcontext,
2168 op->d.agg_trans.setno);
2169
2170 EEO_NEXT();
2171 }
2172
2173 /* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */
2174 EEO_CASE(EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF)
2175 {
2176 AggState *aggstate = castNode(AggState, state->parent);
2177 AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
2178 AggStatePerGroup pergroup =
2179 &aggstate->all_pergroups[op->d.agg_trans.setoff][op->d.agg_trans.transno];
2180
2181 Assert(!pertrans->transtypeByVal);
2182
2183 if (pergroup->noTransValue)
2184 ExecAggInitGroup(aggstate, pertrans, pergroup,
2185 op->d.agg_trans.aggcontext);
2186 else if (likely(!pergroup->transValueIsNull))
2187 ExecAggPlainTransByRef(aggstate, pertrans, pergroup,
2188 op->d.agg_trans.aggcontext,
2189 op->d.agg_trans.setno);
2190
2191 EEO_NEXT();
2192 }
2193
2194 /* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */
2195 EEO_CASE(EEOP_AGG_PLAIN_TRANS_STRICT_BYREF)
2196 {
2197 AggState *aggstate = castNode(AggState, state->parent);
2198 AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
2199 AggStatePerGroup pergroup =
2200 &aggstate->all_pergroups[op->d.agg_trans.setoff][op->d.agg_trans.transno];
2201
2202 Assert(!pertrans->transtypeByVal);
2203
2204 if (likely(!pergroup->transValueIsNull))
2205 ExecAggPlainTransByRef(aggstate, pertrans, pergroup,
2206 op->d.agg_trans.aggcontext,
2207 op->d.agg_trans.setno);
2208 EEO_NEXT();
2209 }
2210
2211 /* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */
2212 EEO_CASE(EEOP_AGG_PLAIN_TRANS_BYREF)
2213 {
2214 AggState *aggstate = castNode(AggState, state->parent);
2215 AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
2216 AggStatePerGroup pergroup =
2217 &aggstate->all_pergroups[op->d.agg_trans.setoff][op->d.agg_trans.transno];
2218
2219 Assert(!pertrans->transtypeByVal);
2220
2221 ExecAggPlainTransByRef(aggstate, pertrans, pergroup,
2222 op->d.agg_trans.aggcontext,
2223 op->d.agg_trans.setno);
2224
2225 EEO_NEXT();
2226 }
2227
2228 EEO_CASE(EEOP_AGG_PRESORTED_DISTINCT_SINGLE)
2229 {
2230 AggStatePerTrans pertrans = op->d.agg_presorted_distinctcheck.pertrans;
2231 AggState *aggstate = castNode(AggState, state->parent);
2232
2233 if (ExecEvalPreOrderedDistinctSingle(aggstate, pertrans))
2234 EEO_NEXT();
2235 else
2236 EEO_JUMP(op->d.agg_presorted_distinctcheck.jumpdistinct);
2237 }
2238
2239 EEO_CASE(EEOP_AGG_PRESORTED_DISTINCT_MULTI)
2240 {
2241 AggState *aggstate = castNode(AggState, state->parent);
2242 AggStatePerTrans pertrans = op->d.agg_presorted_distinctcheck.pertrans;
2243
2244 if (ExecEvalPreOrderedDistinctMulti(aggstate, pertrans))
2245 EEO_NEXT();
2246 else
2247 EEO_JUMP(op->d.agg_presorted_distinctcheck.jumpdistinct);
2248 }
2249
2250 /* process single-column ordered aggregate datum */
2251 EEO_CASE(EEOP_AGG_ORDERED_TRANS_DATUM)
2252 {
2253 /* too complex for an inline implementation */
2254 ExecEvalAggOrderedTransDatum(state, op, econtext);
2255
2256 EEO_NEXT();
2257 }
2258
2259 /* process multi-column ordered aggregate tuple */
2260 EEO_CASE(EEOP_AGG_ORDERED_TRANS_TUPLE)
2261 {
2262 /* too complex for an inline implementation */
2263 ExecEvalAggOrderedTransTuple(state, op, econtext);
2264
2265 EEO_NEXT();
2266 }
2267
2268 EEO_CASE(EEOP_LAST)
2269 {
2270 /* unreachable */
2271 Assert(false);
2272 goto out_error;
2273 }
2274 }
2275
2276out_error:
2277 pg_unreachable();
2278 return (Datum) 0;
2279}
2280
2281/*
2282 * Expression evaluation callback that performs extra checks before executing
2283 * the expression. Declared extern so other methods of execution can use it
2284 * too.
2285 */
2286Datum
2287ExecInterpExprStillValid(ExprState *state, ExprContext *econtext, bool *isNull)
2288{
2289 /*
2290 * First time through, check whether attribute matches Var. Might not be
2291 * ok anymore, due to schema changes.
2292 */
2293 CheckExprStillValid(state, econtext);
2294
2295 /* skip the check during further executions */
2296 state->evalfunc = (ExprStateEvalFunc) state->evalfunc_private;
2297
2298 /* and actually execute */
2299 return state->evalfunc(state, econtext, isNull);
2300}
2301
2302/*
2303 * Check that an expression is still valid in the face of potential schema
2304 * changes since the plan has been created.
2305 */
2306void
2307CheckExprStillValid(ExprState *state, ExprContext *econtext)
2308{
2309 TupleTableSlot *innerslot;
2310 TupleTableSlot *outerslot;
2311 TupleTableSlot *scanslot;
2312 TupleTableSlot *oldslot;
2313 TupleTableSlot *newslot;
2314
2315 innerslot = econtext->ecxt_innertuple;
2316 outerslot = econtext->ecxt_outertuple;
2317 scanslot = econtext->ecxt_scantuple;
2318 oldslot = econtext->ecxt_oldtuple;
2319 newslot = econtext->ecxt_newtuple;
2320
2321 for (int i = 0; i < state->steps_len; i++)
2322 {
2323 ExprEvalStep *op = &state->steps[i];
2324
2325 switch (ExecEvalStepOp(state, op))
2326 {
2327 case EEOP_INNER_VAR:
2328 {
2329 int attnum = op->d.var.attnum;
2330
2331 CheckVarSlotCompatibility(innerslot, attnum + 1, op->d.var.vartype);
2332 break;
2333 }
2334
2335 case EEOP_OUTER_VAR:
2336 {
2337 int attnum = op->d.var.attnum;
2338
2339 CheckVarSlotCompatibility(outerslot, attnum + 1, op->d.var.vartype);
2340 break;
2341 }
2342
2343 case EEOP_SCAN_VAR:
2344 {
2345 int attnum = op->d.var.attnum;
2346
2347 CheckVarSlotCompatibility(scanslot, attnum + 1, op->d.var.vartype);
2348 break;
2349 }
2350
2351 case EEOP_OLD_VAR:
2352 {
2353 int attnum = op->d.var.attnum;
2354
2355 CheckVarSlotCompatibility(oldslot, attnum + 1, op->d.var.vartype);
2356 break;
2357 }
2358
2359 case EEOP_NEW_VAR:
2360 {
2361 int attnum = op->d.var.attnum;
2362
2363 CheckVarSlotCompatibility(newslot, attnum + 1, op->d.var.vartype);
2364 break;
2365 }
2366 default:
2367 break;
2368 }
2369 }
2370}
2371
2372/*
2373 * Check whether a user attribute in a slot can be referenced by a Var
2374 * expression. This should succeed unless there have been schema changes
2375 * since the expression tree has been created.
2376 */
2377static void
2378CheckVarSlotCompatibility(TupleTableSlot *slot, int attnum, Oid vartype)
2379{
2380 /*
2381 * What we have to check for here is the possibility of an attribute
2382 * having been dropped or changed in type since the plan tree was created.
2383 * Ideally the plan will get invalidated and not re-used, but just in
2384 * case, we keep these defenses. Fortunately it's sufficient to check
2385 * once on the first time through.
2386 *
2387 * Note: ideally we'd check typmod as well as typid, but that seems
2388 * impractical at the moment: in many cases the tupdesc will have been
2389 * generated by ExecTypeFromTL(), and that can't guarantee to generate an
2390 * accurate typmod in all cases, because some expression node types don't
2391 * carry typmod. Fortunately, for precisely that reason, there should be
2392 * no places with a critical dependency on the typmod of a value.
2393 *
2394 * System attributes don't require checking since their types never
2395 * change.
2396 */
2397 if (attnum > 0)
2398 {
2399 TupleDesc slot_tupdesc = slot->tts_tupleDescriptor;
2400 Form_pg_attribute attr;
2401
2402 if (attnum > slot_tupdesc->natts) /* should never happen */
2403 elog(ERROR, "attribute number %d exceeds number of columns %d",
2404 attnum, slot_tupdesc->natts);
2405
2406 attr = TupleDescAttr(slot_tupdesc, attnum - 1);
2407
2408 /* Internal error: somebody forgot to expand it. */
2409 if (attr->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
2410 elog(ERROR, "unexpected virtual generated column reference");
2411
2412 if (attr->attisdropped)
2413 ereport(ERROR,
2414 (errcode(ERRCODE_UNDEFINED_COLUMN),
2415 errmsg("attribute %d of type %s has been dropped",
2416 attnum, format_type_be(slot_tupdesc->tdtypeid))));
2417
2418 if (vartype != attr->atttypid)
2419 ereport(ERROR,
2420 (errcode(ERRCODE_DATATYPE_MISMATCH),
2421 errmsg("attribute %d of type %s has wrong type",
2422 attnum, format_type_be(slot_tupdesc->tdtypeid)),
2423 errdetail("Table has type %s, but query expects %s.",
2424 format_type_be(attr->atttypid),
2425 format_type_be(vartype))));
2426 }
2427}
2428
2429/*
2430 * Verify that the slot is compatible with a EEOP_*_FETCHSOME operation.
2431 */
2432static void
2433CheckOpSlotCompatibility(ExprEvalStep *op, TupleTableSlot *slot)
2434{
2435#ifdef USE_ASSERT_CHECKING
2436 /* there's nothing to check */
2437 if (!op->d.fetch.fixed)
2438 return;
2439
2440 /*
2441 * Should probably fixed at some point, but for now it's easier to allow
2442 * buffer and heap tuples to be used interchangeably.
2443 */
2444 if (slot->tts_ops == &TTSOpsBufferHeapTuple &&
2445 op->d.fetch.kind == &TTSOpsHeapTuple)
2446 return;
2447 if (slot->tts_ops == &TTSOpsHeapTuple &&
2448 op->d.fetch.kind == &TTSOpsBufferHeapTuple)
2449 return;
2450
2451 /*
2452 * At the moment we consider it OK if a virtual slot is used instead of a
2453 * specific type of slot, as a virtual slot never needs to be deformed.
2454 */
2455 if (slot->tts_ops == &TTSOpsVirtual)
2456 return;
2457
2458 Assert(op->d.fetch.kind == slot->tts_ops);
2459#endif
2460}
2461
2462/*
2463 * get_cached_rowtype: utility function to lookup a rowtype tupdesc
2464 *
2465 * type_id, typmod: identity of the rowtype
2466 * rowcache: space for caching identity info
2467 * (rowcache->cacheptr must be initialized to NULL)
2468 * changed: if not NULL, *changed is set to true on any update
2469 *
2470 * The returned TupleDesc is not guaranteed pinned; caller must pin it
2471 * to use it across any operation that might incur cache invalidation,
2472 * including for example detoasting of input tuples.
2473 * (The TupleDesc is always refcounted, so just use IncrTupleDescRefCount.)
2474 *
2475 * NOTE: because composite types can change contents, we must be prepared
2476 * to re-do this during any node execution; cannot call just once during
2477 * expression initialization.
2478 */
2479static TupleDesc
2480get_cached_rowtype(Oid type_id, int32 typmod,
2481 ExprEvalRowtypeCache *rowcache,
2482 bool *changed)
2483{
2484 if (type_id != RECORDOID)
2485 {
2486 /*
2487 * It's a named composite type, so use the regular typcache. Do a
2488 * lookup first time through, or if the composite type changed. Note:
2489 * "tupdesc_id == 0" may look redundant, but it protects against the
2490 * admittedly-theoretical possibility that type_id was RECORDOID the
2491 * last time through, so that the cacheptr isn't TypeCacheEntry *.
2492 */
2493 TypeCacheEntry *typentry = (TypeCacheEntry *) rowcache->cacheptr;
2494
2495 if (unlikely(typentry == NULL ||
2496 rowcache->tupdesc_id == 0 ||
2497 typentry->tupDesc_identifier != rowcache->tupdesc_id))
2498 {
2499 typentry = lookup_type_cache(type_id, TYPECACHE_TUPDESC);
2500 if (typentry->tupDesc == NULL)
2501 ereport(ERROR,
2502 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
2503 errmsg("type %s is not composite",
2504 format_type_be(type_id))));
2505 rowcache->cacheptr = typentry;
2506 rowcache->tupdesc_id = typentry->tupDesc_identifier;
2507 if (changed)
2508 *changed = true;
2509 }
2510 return typentry->tupDesc;
2511 }
2512 else
2513 {
2514 /*
2515 * A RECORD type, once registered, doesn't change for the life of the
2516 * backend. So we don't need a typcache entry as such, which is good
2517 * because there isn't one. It's possible that the caller is asking
2518 * about a different type than before, though.
2519 */
2520 TupleDesc tupDesc = (TupleDesc) rowcache->cacheptr;
2521
2522 if (unlikely(tupDesc == NULL ||
2523 rowcache->tupdesc_id != 0 ||
2524 type_id != tupDesc->tdtypeid ||
2525 typmod != tupDesc->tdtypmod))
2526 {
2527 tupDesc = lookup_rowtype_tupdesc(type_id, typmod);
2528 /* Drop pin acquired by lookup_rowtype_tupdesc */
2529 ReleaseTupleDesc(tupDesc);
2530 rowcache->cacheptr = tupDesc;
2531 rowcache->tupdesc_id = 0; /* not a valid value for non-RECORD */
2532 if (changed)
2533 *changed = true;
2534 }
2535 return tupDesc;
2536 }
2537}
2538
2539
2540/*
2541 * Fast-path functions, for very simple expressions
2542 */
2543
2544/* implementation of ExecJust(Inner|Outer|Scan)Var */
2545static pg_attribute_always_inline Datum
2546ExecJustVarImpl(ExprState *state, TupleTableSlot *slot, bool *isnull)
2547{
2548 ExprEvalStep *op = &state->steps[1];
2549 int attnum = op->d.var.attnum + 1;
2550
2551 CheckOpSlotCompatibility(&state->steps[0], slot);
2552
2553 /*
2554 * Since we use slot_getattr(), we don't need to implement the FETCHSOME
2555 * step explicitly, and we also needn't Assert that the attnum is in range
2556 * --- slot_getattr() will take care of any problems.
2557 */
2558 return slot_getattr(slot, attnum, isnull);
2559}
2560
2561/* Simple reference to inner Var */
2562static Datum
2563ExecJustInnerVar(ExprState *state, ExprContext *econtext, bool *isnull)
2564{
2565 return ExecJustVarImpl(state, econtext->ecxt_innertuple, isnull);
2566}
2567
2568/* Simple reference to outer Var */
2569static Datum
2570ExecJustOuterVar(ExprState *state, ExprContext *econtext, bool *isnull)
2571{
2572 return ExecJustVarImpl(state, econtext->ecxt_outertuple, isnull);
2573}
2574
2575/* Simple reference to scan Var */
2576static Datum
2577ExecJustScanVar(ExprState *state, ExprContext *econtext, bool *isnull)
2578{
2579 return ExecJustVarImpl(state, econtext->ecxt_scantuple, isnull);
2580}
2581
2582/* implementation of ExecJustAssign(Inner|Outer|Scan)Var */
2583static pg_attribute_always_inline Datum
2584ExecJustAssignVarImpl(ExprState *state, TupleTableSlot *inslot, bool *isnull)
2585{
2586 ExprEvalStep *op = &state->steps[1];
2587 int attnum = op->d.assign_var.attnum + 1;
2588 int resultnum = op->d.assign_var.resultnum;
2589 TupleTableSlot *outslot = state->resultslot;
2590
2591 CheckOpSlotCompatibility(&state->steps[0], inslot);
2592
2593 /*
2594 * We do not need CheckVarSlotCompatibility here; that was taken care of
2595 * at compilation time.
2596 *
2597 * Since we use slot_getattr(), we don't need to implement the FETCHSOME
2598 * step explicitly, and we also needn't Assert that the attnum is in range
2599 * --- slot_getattr() will take care of any problems. Nonetheless, check
2600 * that resultnum is in range.
2601 */
2602 Assert(resultnum >= 0 && resultnum < outslot->tts_tupleDescriptor->natts);
2603 outslot->tts_values[resultnum] =
2604 slot_getattr(inslot, attnum, &outslot->tts_isnull[resultnum]);
2605 return 0;
2606}
2607
2608/* Evaluate inner Var and assign to appropriate column of result tuple */
2609static Datum
2614
2615/* Evaluate outer Var and assign to appropriate column of result tuple */
2616static Datum
2621
2622/* Evaluate scan Var and assign to appropriate column of result tuple */
2623static Datum
2628
2629/* Evaluate CASE_TESTVAL and apply a strict function to it */
2630static Datum
2631ExecJustApplyFuncToCase(ExprState *state, ExprContext *econtext, bool *isnull)
2632{
2633 ExprEvalStep *op = &state->steps[0];
2634 FunctionCallInfo fcinfo;
2635 NullableDatum *args;
2636 int nargs;
2637 Datum d;
2638
2639 /*
2640 * XXX with some redesign of the CaseTestExpr mechanism, maybe we could
2641 * get rid of this data shuffling?
2642 */
2643 *op->resvalue = *op->d.casetest.value;
2644 *op->resnull = *op->d.casetest.isnull;
2645
2646 op++;
2647
2648 nargs = op->d.func.nargs;
2649 fcinfo = op->d.func.fcinfo_data;
2650 args = fcinfo->args;
2651
2652 /* strict function, so check for NULL args */
2653 for (int argno = 0; argno < nargs; argno++)
2654 {
2655 if (args[argno].isnull)
2656 {
2657 *isnull = true;
2658 return (Datum) 0;
2659 }
2660 }
2661 fcinfo->isnull = false;
2662 d = op->d.func.fn_addr(fcinfo);
2663 *isnull = fcinfo->isnull;
2664 return d;
2665}
2666
2667/* Simple Const expression */
2668static Datum
2669ExecJustConst(ExprState *state, ExprContext *econtext, bool *isnull)
2670{
2671 ExprEvalStep *op = &state->steps[0];
2672
2673 *isnull = op->d.constval.isnull;
2674 return op->d.constval.value;
2675}
2676
2677/* implementation of ExecJust(Inner|Outer|Scan)VarVirt */
2678static pg_attribute_always_inline Datum
2679ExecJustVarVirtImpl(ExprState *state, TupleTableSlot *slot, bool *isnull)
2680{
2681 ExprEvalStep *op = &state->steps[0];
2682 int attnum = op->d.var.attnum;
2683
2684 /*
2685 * As it is guaranteed that a virtual slot is used, there never is a need
2686 * to perform tuple deforming (nor would it be possible). Therefore
2687 * execExpr.c has not emitted an EEOP_*_FETCHSOME step. Verify, as much as
2688 * possible, that that determination was accurate.
2689 */
2690 Assert(TTS_IS_VIRTUAL(slot));
2691 Assert(TTS_FIXED(slot));
2692 Assert(attnum >= 0 && attnum < slot->tts_nvalid);
2693
2694 *isnull = slot->tts_isnull[attnum];
2695
2696 return slot->tts_values[attnum];
2697}
2698
2699/* Like ExecJustInnerVar, optimized for virtual slots */
2700static Datum
2705
2706/* Like ExecJustOuterVar, optimized for virtual slots */
2707static Datum
2712
2713/* Like ExecJustScanVar, optimized for virtual slots */
2714static Datum
2715ExecJustScanVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
2716{
2717 return ExecJustVarVirtImpl(state, econtext->ecxt_scantuple, isnull);
2718}
2719
2720/* implementation of ExecJustAssign(Inner|Outer|Scan)VarVirt */
2721static pg_attribute_always_inline Datum
2722ExecJustAssignVarVirtImpl(ExprState *state, TupleTableSlot *inslot, bool *isnull)
2723{
2724 ExprEvalStep *op = &state->steps[0];
2725 int attnum = op->d.assign_var.attnum;
2726 int resultnum = op->d.assign_var.resultnum;
2727 TupleTableSlot *outslot = state->resultslot;
2728
2729 /* see ExecJustVarVirtImpl for comments */
2730
2731 Assert(TTS_IS_VIRTUAL(inslot));
2732 Assert(TTS_FIXED(inslot));
2733 Assert(attnum >= 0 && attnum < inslot->tts_nvalid);
2734 Assert(resultnum >= 0 && resultnum < outslot->tts_tupleDescriptor->natts);
2735
2736 outslot->tts_values[resultnum] = inslot->tts_values[attnum];
2737 outslot->tts_isnull[resultnum] = inslot->tts_isnull[attnum];
2738
2739 return 0;
2740}
2741
2742/* Like ExecJustAssignInnerVar, optimized for virtual slots */
2743static Datum
2748
2749/* Like ExecJustAssignOuterVar, optimized for virtual slots */
2750static Datum
2755
2756/* Like ExecJustAssignScanVar, optimized for virtual slots */
2757static Datum
2762
2763/*
2764 * implementation for hashing an inner Var, seeding with an initial value.
2765 */
2766static Datum
2767ExecJustHashInnerVarWithIV(ExprState *state, ExprContext *econtext,
2768 bool *isnull)
2769{
2770 ExprEvalStep *fetchop = &state->steps[0];
2771 ExprEvalStep *setivop = &state->steps[1];
2772 ExprEvalStep *innervar = &state->steps[2];
2773 ExprEvalStep *hashop = &state->steps[3];
2774 FunctionCallInfo fcinfo = hashop->d.hashdatum.fcinfo_data;
2775 int attnum = innervar->d.var.attnum;
2776 uint32 hashkey;
2777
2778 CheckOpSlotCompatibility(fetchop, econtext->ecxt_innertuple);
2779 slot_getsomeattrs(econtext->ecxt_innertuple, fetchop->d.fetch.last_var);
2780
2781 fcinfo->args[0].value = econtext->ecxt_innertuple->tts_values[attnum];
2782 fcinfo->args[0].isnull = econtext->ecxt_innertuple->tts_isnull[attnum];
2783
2784 hashkey = DatumGetUInt32(setivop->d.hashdatum_initvalue.init_value);
2785 hashkey = pg_rotate_left32(hashkey, 1);
2786
2787 if (!fcinfo->args[0].isnull)
2788 {
2789 uint32 hashvalue;
2790
2791 hashvalue = DatumGetUInt32(hashop->d.hashdatum.fn_addr(fcinfo));
2792 hashkey = hashkey ^ hashvalue;
2793 }
2794
2795 *isnull = false;
2796 return UInt32GetDatum(hashkey);
2797}
2798
2799/* implementation of ExecJustHash(Inner|Outer)Var */
2800static pg_attribute_always_inline Datum
2801ExecJustHashVarImpl(ExprState *state, TupleTableSlot *slot, bool *isnull)
2802{
2803 ExprEvalStep *fetchop = &state->steps[0];
2804 ExprEvalStep *var = &state->steps[1];
2805 ExprEvalStep *hashop = &state->steps[2];
2806 FunctionCallInfo fcinfo = hashop->d.hashdatum.fcinfo_data;
2807 int attnum = var->d.var.attnum;
2808
2809 CheckOpSlotCompatibility(fetchop, slot);
2810 slot_getsomeattrs(slot, fetchop->d.fetch.last_var);
2811
2812 fcinfo->args[0].value = slot->tts_values[attnum];
2813 fcinfo->args[0].isnull = slot->tts_isnull[attnum];
2814
2815 *isnull = false;
2816
2817 if (!fcinfo->args[0].isnull)
2818 return hashop->d.hashdatum.fn_addr(fcinfo);
2819 else
2820 return (Datum) 0;
2821}
2822
2823/* implementation for hashing an outer Var */
2824static Datum
2829
2830/* implementation for hashing an inner Var */
2831static Datum
2836
2837/* implementation of ExecJustHash(Inner|Outer)VarVirt */
2838static pg_attribute_always_inline Datum
2839ExecJustHashVarVirtImpl(ExprState *state, TupleTableSlot *slot, bool *isnull)
2840{
2841 ExprEvalStep *var = &state->steps[0];
2842 ExprEvalStep *hashop = &state->steps[1];
2843 FunctionCallInfo fcinfo = hashop->d.hashdatum.fcinfo_data;
2844 int attnum = var->d.var.attnum;
2845
2846 fcinfo->args[0].value = slot->tts_values[attnum];
2847 fcinfo->args[0].isnull = slot->tts_isnull[attnum];
2848
2849 *isnull = false;
2850
2851 if (!fcinfo->args[0].isnull)
2852 return hashop->d.hashdatum.fn_addr(fcinfo);
2853 else
2854 return (Datum) 0;
2855}
2856
2857/* Like ExecJustHashInnerVar, optimized for virtual slots */
2858static Datum
2864
2865/* Like ExecJustHashOuterVar, optimized for virtual slots */
2866static Datum
2872
2873/*
2874 * implementation for hashing an outer Var. Returns NULL on NULL input.
2875 */
2876static Datum
2877ExecJustHashOuterVarStrict(ExprState *state, ExprContext *econtext,
2878 bool *isnull)
2879{
2880 ExprEvalStep *fetchop = &state->steps[0];
2881 ExprEvalStep *var = &state->steps[1];
2882 ExprEvalStep *hashop = &state->steps[2];
2883 FunctionCallInfo fcinfo = hashop->d.hashdatum.fcinfo_data;
2884 int attnum = var->d.var.attnum;
2885
2886 CheckOpSlotCompatibility(fetchop, econtext->ecxt_outertuple);
2887 slot_getsomeattrs(econtext->ecxt_outertuple, fetchop->d.fetch.last_var);
2888
2889 fcinfo->args[0].value = econtext->ecxt_outertuple->tts_values[attnum];
2890 fcinfo->args[0].isnull = econtext->ecxt_outertuple->tts_isnull[attnum];
2891
2892 if (!fcinfo->args[0].isnull)
2893 {
2894 *isnull = false;
2895 return hashop->d.hashdatum.fn_addr(fcinfo);
2896 }
2897 else
2898 {
2899 /* return NULL on NULL input */
2900 *isnull = true;
2901 return (Datum) 0;
2902 }
2903}
2904
2905#if defined(EEO_USE_COMPUTED_GOTO)
2906/*
2907 * Comparator used when building address->opcode lookup table for
2908 * ExecEvalStepOp() in the threaded dispatch case.
2909 */
2910static int
2911dispatch_compare_ptr(const void *a, const void *b)
2912{
2913 const ExprEvalOpLookup *la = (const ExprEvalOpLookup *) a;
2914 const ExprEvalOpLookup *lb = (const ExprEvalOpLookup *) b;
2915
2916 if (la->opcode < lb->opcode)
2917 return -1;
2918 else if (la->opcode > lb->opcode)
2919 return 1;
2920 return 0;
2921}
2922#endif
2923
2924/*
2925 * Do one-time initialization of interpretation machinery.
2926 */
2927static void
2928ExecInitInterpreter(void)
2929{
2930#if defined(EEO_USE_COMPUTED_GOTO)
2931 /* Set up externally-visible pointer to dispatch table */
2932 if (dispatch_table == NULL)
2933 {
2934 dispatch_table = (const void **)
2935 DatumGetPointer(ExecInterpExpr(NULL, NULL, NULL));
2936
2937 /* build reverse lookup table */
2938 for (int i = 0; i < EEOP_LAST; i++)
2939 {
2940 reverse_dispatch_table[i].opcode = dispatch_table[i];
2941 reverse_dispatch_table[i].op = (ExprEvalOp) i;
2942 }
2943
2944 /* make it bsearch()able */
2945 qsort(reverse_dispatch_table,
2946 EEOP_LAST /* nmembers */ ,
2947 sizeof(ExprEvalOpLookup),
2948 dispatch_compare_ptr);
2949 }
2950#endif
2951}
2952
2953/*
2954 * Function to return the opcode of an expression step.
2955 *
2956 * When direct-threading is in use, ExprState->opcode isn't easily
2957 * decipherable. This function returns the appropriate enum member.
2958 */
2959ExprEvalOp
2960ExecEvalStepOp(ExprState *state, ExprEvalStep *op)
2961{
2962#if defined(EEO_USE_COMPUTED_GOTO)
2963 if (state->flags & EEO_FLAG_DIRECT_THREADED)
2964 {
2965 ExprEvalOpLookup key;
2966 ExprEvalOpLookup *res;
2967
2968 key.opcode = (void *) op->opcode;
2969 res = bsearch(&key,
2970 reverse_dispatch_table,
2971 EEOP_LAST /* nmembers */ ,
2972 sizeof(ExprEvalOpLookup),
2973 dispatch_compare_ptr);
2974 Assert(res); /* unknown ops shouldn't get looked up */
2975 return res->op;
2976 }
2977#endif
2978 return (ExprEvalOp) op->opcode;
2979}
2980
2981
2982/*
2983 * Out-of-line helper functions for complex instructions.
2984 */
2985
2986/*
2987 * Evaluate EEOP_FUNCEXPR_FUSAGE
2988 */
2989void
2990ExecEvalFuncExprFusage(ExprState *state, ExprEvalStep *op,
2991 ExprContext *econtext)
2992{
2993 FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
2994 PgStat_FunctionCallUsage fcusage;
2995 Datum d;
2996
2997 pgstat_init_function_usage(fcinfo, &fcusage);
2998
2999 fcinfo->isnull = false;
3000 d = op->d.func.fn_addr(fcinfo);
3001 *op->resvalue = d;
3002 *op->resnull = fcinfo->isnull;
3003
3004 pgstat_end_function_usage(&fcusage, true);
3005}
3006
3007/*
3008 * Evaluate EEOP_FUNCEXPR_STRICT_FUSAGE
3009 */
3010void
3011ExecEvalFuncExprStrictFusage(ExprState *state, ExprEvalStep *op,
3012 ExprContext *econtext)
3013{
3014
3015 FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
3016 PgStat_FunctionCallUsage fcusage;
3017 NullableDatum *args = fcinfo->args;
3018 int nargs = op->d.func.nargs;
3019 Datum d;
3020
3021 /* strict function, so check for NULL args */
3022 for (int argno = 0; argno < nargs; argno++)
3023 {
3024 if (args[argno].isnull)
3025 {
3026 *op->resnull = true;
3027 return;
3028 }
3029 }
3030
3031 pgstat_init_function_usage(fcinfo, &fcusage);
3032
3033 fcinfo->isnull = false;
3034 d = op->d.func.fn_addr(fcinfo);
3035 *op->resvalue = d;
3036 *op->resnull = fcinfo->isnull;
3037
3038 pgstat_end_function_usage(&fcusage, true);
3039}
3040
3041/*
3042 * Evaluate a PARAM_EXEC parameter.
3043 *
3044 * PARAM_EXEC params (internal executor parameters) are stored in the
3045 * ecxt_param_exec_vals array, and can be accessed by array index.
3046 */
3047void
3048ExecEvalParamExec(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
3049{
3050 ParamExecData *prm;
3051
3052 prm = &(econtext->ecxt_param_exec_vals[op->d.param.paramid]);
3053 if (unlikely(prm->execPlan != NULL))
3054 {
3055 /* Parameter not evaluated yet, so go do it */
3056 ExecSetParamPlan(prm->execPlan, econtext);
3057 /* ExecSetParamPlan should have processed this param... */
3058 Assert(prm->execPlan == NULL);
3059 }
3060 *op->resvalue = prm->value;
3061 *op->resnull = prm->isnull;
3062}
3063
3064/*
3065 * Evaluate a PARAM_EXTERN parameter.
3066 *
3067 * PARAM_EXTERN parameters must be sought in ecxt_param_list_info.
3068 */
3069void
3070ExecEvalParamExtern(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
3071{
3072 ParamListInfo paramInfo = econtext->ecxt_param_list_info;
3073 int paramId = op->d.param.paramid;
3074
3075 if (likely(paramInfo &&
3076 paramId > 0 && paramId <= paramInfo->numParams))
3077 {
3078 ParamExternData *prm;
3079 ParamExternData prmdata;
3080
3081 /* give hook a chance in case parameter is dynamic */
3082 if (paramInfo->paramFetch != NULL)
3083 prm = paramInfo->paramFetch(paramInfo, paramId, false, &prmdata);
3084 else
3085 prm = &paramInfo->params[paramId - 1];
3086
3087 if (likely(OidIsValid(prm->ptype)))
3088 {
3089 /* safety check in case hook did something unexpected */
3090 if (unlikely(prm->ptype != op->d.param.paramtype))
3091 ereport(ERROR,
3092 (errcode(ERRCODE_DATATYPE_MISMATCH),
3093 errmsg("type of parameter %d (%s) does not match that when preparing the plan (%s)",
3094 paramId,
3095 format_type_be(prm->ptype),
3096 format_type_be(op->d.param.paramtype))));
3097 *op->resvalue = prm->value;
3098 *op->resnull = prm->isnull;
3099 return;
3100 }
3101 }
3102
3103 ereport(ERROR,
3104 (errcode(ERRCODE_UNDEFINED_OBJECT),
3105 errmsg("no value found for parameter %d", paramId)));
3106}
3107
3108/*
3109 * Set value of a param (currently always PARAM_EXEC) from
3110 * op->res{value,null}.
3111 */
3112void
3113ExecEvalParamSet(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
3114{
3115 ParamExecData *prm;
3116
3117 prm = &(econtext->ecxt_param_exec_vals[op->d.param.paramid]);
3118
3119 /* Shouldn't have a pending evaluation anymore */
3120 Assert(prm->execPlan == NULL);
3121
3122 prm->value = *op->resvalue;
3123 prm->isnull = *op->resnull;
3124}
3125
3126/*
3127 * Evaluate a CoerceViaIO node in soft-error mode.
3128 *
3129 * The source value is in op's result variable.
3130 *
3131 * Note: This implements EEOP_IOCOERCE_SAFE. If you change anything here,
3132 * also look at the inline code for EEOP_IOCOERCE.
3133 */
3134void
3135ExecEvalCoerceViaIOSafe(ExprState *state, ExprEvalStep *op)
3136{
3137 char *str;
3138
3139 /* call output function (similar to OutputFunctionCall) */
3140 if (*op->resnull)
3141 {
3142 /* output functions are not called on nulls */
3143 str = NULL;
3144 }
3145 else
3146 {
3147 FunctionCallInfo fcinfo_out;
3148
3149 fcinfo_out = op->d.iocoerce.fcinfo_data_out;
3150 fcinfo_out->args[0].value = *op->resvalue;
3151 fcinfo_out->args[0].isnull = false;
3152
3153 fcinfo_out->isnull = false;
3154 str = DatumGetCString(FunctionCallInvoke(fcinfo_out));
3155
3156 /* OutputFunctionCall assumes result isn't null */
3157 Assert(!fcinfo_out->isnull);
3158 }
3159
3160 /* call input function (similar to InputFunctionCallSafe) */
3161 if (!op->d.iocoerce.finfo_in->fn_strict || str != NULL)
3162 {
3163 FunctionCallInfo fcinfo_in;
3164
3165 fcinfo_in = op->d.iocoerce.fcinfo_data_in;
3166 fcinfo_in->args[0].value = PointerGetDatum(str);
3167 fcinfo_in->args[0].isnull = *op->resnull;
3168 /* second and third arguments are already set up */
3169
3170 /* ErrorSaveContext must be present. */
3171 Assert(IsA(fcinfo_in->context, ErrorSaveContext));
3172
3173 fcinfo_in->isnull = false;
3174 *op->resvalue = FunctionCallInvoke(fcinfo_in);
3175
3176 if (SOFT_ERROR_OCCURRED(fcinfo_in->context))
3177 {
3178 *op->resnull = true;
3179 *op->resvalue = (Datum) 0;
3180 return;
3181 }
3182
3183 /* Should get null result if and only if str is NULL */
3184 if (str == NULL)
3185 Assert(*op->resnull);
3186 else
3187 Assert(!*op->resnull);
3188 }
3189}
3190
3191/*
3192 * Evaluate a SQLValueFunction expression.
3193 */
3194void
3195ExecEvalSQLValueFunction(ExprState *state, ExprEvalStep *op)
3196{
3197 LOCAL_FCINFO(fcinfo, 0);
3198 SQLValueFunction *svf = op->d.sqlvaluefunction.svf;
3199
3200 *op->resnull = false;
3201
3202 /*
3203 * Note: current_schema() can return NULL. current_user() etc currently
3204 * cannot, but might as well code those cases the same way for safety.
3205 */
3206 switch (svf->op)
3207 {
3208 case SVFOP_CURRENT_DATE:
3209 *op->resvalue = DateADTGetDatum(GetSQLCurrentDate());
3210 break;
3211 case SVFOP_CURRENT_TIME:
3212 case SVFOP_CURRENT_TIME_N:
3213 *op->resvalue = TimeTzADTPGetDatum(GetSQLCurrentTime(svf->typmod));
3214 break;
3215 case SVFOP_CURRENT_TIMESTAMP:
3216 case SVFOP_CURRENT_TIMESTAMP_N:
3217 *op->resvalue = TimestampTzGetDatum(GetSQLCurrentTimestamp(svf->typmod));
3218 break;
3219 case SVFOP_LOCALTIME:
3220 case SVFOP_LOCALTIME_N:
3221 *op->resvalue = TimeADTGetDatum(GetSQLLocalTime(svf->typmod));
3222 break;
3223 case SVFOP_LOCALTIMESTAMP:
3224 case SVFOP_LOCALTIMESTAMP_N:
3225 *op->resvalue = TimestampGetDatum(GetSQLLocalTimestamp(svf->typmod));
3226 break;
3227 case SVFOP_CURRENT_ROLE:
3228 case SVFOP_CURRENT_USER:
3229 case SVFOP_USER:
3230 InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
3231 *op->resvalue = current_user(fcinfo);
3232 *op->resnull = fcinfo->isnull;
3233 break;
3234 case SVFOP_SESSION_USER:
3235 InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
3236 *op->resvalue = session_user(fcinfo);
3237 *op->resnull = fcinfo->isnull;
3238 break;
3239 case SVFOP_CURRENT_CATALOG:
3240 InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
3241 *op->resvalue = current_database(fcinfo);
3242 *op->resnull = fcinfo->isnull;
3243 break;
3244 case SVFOP_CURRENT_SCHEMA:
3245 InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
3246 *op->resvalue = current_schema(fcinfo);
3247 *op->resnull = fcinfo->isnull;
3248 break;
3249 }
3250}
3251
3252/*
3253 * Raise error if a CURRENT OF expression is evaluated.
3254 *
3255 * The planner should convert CURRENT OF into a TidScan qualification, or some
3256 * other special handling in a ForeignScan node. So we have to be able to do
3257 * ExecInitExpr on a CurrentOfExpr, but we shouldn't ever actually execute it.
3258 * If we get here, we suppose we must be dealing with CURRENT OF on a foreign
3259 * table whose FDW doesn't handle it, and complain accordingly.
3260 */
3261void
3262ExecEvalCurrentOfExpr(ExprState *state, ExprEvalStep *op)
3263{
3264 ereport(ERROR,
3265 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3266 errmsg("WHERE CURRENT OF is not supported for this table type")));
3267}
3268
3269/*
3270 * Evaluate NextValueExpr.
3271 */
3272void
3273ExecEvalNextValueExpr(ExprState *state, ExprEvalStep *op)
3274{
3275 int64 newval = nextval_internal(op->d.nextvalueexpr.seqid, false);
3276
3277 switch (op->d.nextvalueexpr.seqtypid)
3278 {
3279 case INT2OID:
3280 *op->resvalue = Int16GetDatum((int16) newval);
3281 break;
3282 case INT4OID:
3283 *op->resvalue = Int32GetDatum((int32) newval);
3284 break;
3285 case INT8OID:
3286 *op->resvalue = Int64GetDatum(newval);
3287 break;
3288 default:
3289 elog(ERROR, "unsupported sequence type %u",
3290 op->d.nextvalueexpr.seqtypid);
3291 }
3292 *op->resnull = false;
3293}
3294
3295/*
3296 * Evaluate NullTest / IS NULL for rows.
3297 */
3298void
3299ExecEvalRowNull(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
3300{
3301 ExecEvalRowNullInt(state, op, econtext, true);
3302}
3303
3304/*
3305 * Evaluate NullTest / IS NOT NULL for rows.
3306 */
3307void
3308ExecEvalRowNotNull(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
3309{
3310 ExecEvalRowNullInt(state, op, econtext, false);
3311}
3312
3313/* Common code for IS [NOT] NULL on a row value */
3314static void
3315ExecEvalRowNullInt(ExprState *state, ExprEvalStep *op,
3316 ExprContext *econtext, bool checkisnull)
3317{
3318 Datum value = *op->resvalue;
3319 bool isnull = *op->resnull;
3320 HeapTupleHeader tuple;
3321 Oid tupType;
3322 int32 tupTypmod;
3323 TupleDesc tupDesc;
3324 HeapTupleData tmptup;
3325
3326 *op->resnull = false;
3327
3328 /* NULL row variables are treated just as NULL scalar columns */
3329 if (isnull)
3330 {
3331 *op->resvalue = BoolGetDatum(checkisnull);
3332 return;
3333 }
3334
3335 /*
3336 * The SQL standard defines IS [NOT] NULL for a non-null rowtype argument
3337 * as:
3338 *
3339 * "R IS NULL" is true if every field is the null value.
3340 *
3341 * "R IS NOT NULL" is true if no field is the null value.
3342 *
3343 * This definition is (apparently intentionally) not recursive; so our
3344 * tests on the fields are primitive attisnull tests, not recursive checks
3345 * to see if they are all-nulls or no-nulls rowtypes.
3346 *
3347 * The standard does not consider the possibility of zero-field rows, but
3348 * here we consider them to vacuously satisfy both predicates.
3349 */
3350
3351 tuple = DatumGetHeapTupleHeader(value);
3352
3353 tupType = HeapTupleHeaderGetTypeId(tuple);
3354 tupTypmod = HeapTupleHeaderGetTypMod(tuple);
3355
3356 /* Lookup tupdesc if first time through or if type changes */
3357 tupDesc = get_cached_rowtype(tupType, tupTypmod,
3358 &op->d.nulltest_row.rowcache, NULL);
3359
3360 /*
3361 * heap_attisnull needs a HeapTuple not a bare HeapTupleHeader.
3362 */
3363 tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
3364 tmptup.t_data = tuple;
3365
3366 for (int att = 1; att <= tupDesc->natts; att++)
3367 {
3368 /* ignore dropped columns */
3369 if (TupleDescCompactAttr(tupDesc, att - 1)->attisdropped)
3370 continue;
3371 if (heap_attisnull(&tmptup, att, tupDesc))
3372 {
3373 /* null field disproves IS NOT NULL */
3374 if (!checkisnull)
3375 {
3376 *op->resvalue = BoolGetDatum(false);
3377 return;
3378 }
3379 }
3380 else
3381 {
3382 /* non-null field disproves IS NULL */
3383 if (checkisnull)
3384 {
3385 *op->resvalue = BoolGetDatum(false);
3386 return;
3387 }
3388 }
3389 }
3390
3391 *op->resvalue = BoolGetDatum(true);
3392}
3393
3394/*
3395 * Evaluate an ARRAY[] expression.
3396 *
3397 * The individual array elements (or subarrays) have already been evaluated
3398 * into op->d.arrayexpr.elemvalues[]/elemnulls[].
3399 */
3400void
3401ExecEvalArrayExpr(ExprState *state, ExprEvalStep *op)
3402{
3403 ArrayType *result;
3404 Oid element_type = op->d.arrayexpr.elemtype;
3405 int nelems = op->d.arrayexpr.nelems;
3406 int ndims = 0;
3407 int dims[MAXDIM];
3408 int lbs[MAXDIM];
3409
3410 /* Set non-null as default */
3411 *op->resnull = false;
3412
3413 if (!op->d.arrayexpr.multidims)
3414 {
3415 /* Elements are presumably of scalar type */
3416 Datum *dvalues = op->d.arrayexpr.elemvalues;
3417 bool *dnulls = op->d.arrayexpr.elemnulls;
3418
3419 /* setup for 1-D array of the given length */
3420 ndims = 1;
3421 dims[0] = nelems;
3422 lbs[0] = 1;
3423
3424 result = construct_md_array(dvalues, dnulls, ndims, dims, lbs,
3425 element_type,
3426 op->d.arrayexpr.elemlength,
3427 op->d.arrayexpr.elembyval,
3428 op->d.arrayexpr.elemalign);
3429 }
3430 else
3431 {
3432 /* Must be nested array expressions */
3433 int nbytes = 0;
3434 int nitems;
3435 int outer_nelems = 0;
3436 int elem_ndims = 0;
3437 int *elem_dims = NULL;
3438 int *elem_lbs = NULL;
3439 bool firstone = true;
3440 bool havenulls = false;
3441 bool haveempty = false;
3442 char **subdata;
3443 bits8 **subbitmaps;
3444 int *subbytes;
3445 int *subnitems;
3446 int32 dataoffset;
3447 char *dat;
3448 int iitem;
3449
3450 subdata = (char **) palloc(nelems * sizeof(char *));
3451 subbitmaps = (bits8 **) palloc(nelems * sizeof(bits8 *));
3452 subbytes = (int *) palloc(nelems * sizeof(int));
3453 subnitems = (int *) palloc(nelems * sizeof(int));
3454
3455 /* loop through and get data area from each element */
3456 for (int elemoff = 0; elemoff < nelems; elemoff++)
3457 {
3458 Datum arraydatum;
3459 bool eisnull;
3460 ArrayType *array;
3461 int this_ndims;
3462
3463 arraydatum = op->d.arrayexpr.elemvalues[elemoff];
3464 eisnull = op->d.arrayexpr.elemnulls[elemoff];
3465
3466 /* temporarily ignore null subarrays */
3467 if (eisnull)
3468 {
3469 haveempty = true;
3470 continue;
3471 }
3472
3473 array = DatumGetArrayTypeP(arraydatum);
3474
3475 /* run-time double-check on element type */
3476 if (element_type != ARR_ELEMTYPE(array))
3477 ereport(ERROR,
3478 (errcode(ERRCODE_DATATYPE_MISMATCH),
3479 errmsg("cannot merge incompatible arrays"),
3480 errdetail("Array with element type %s cannot be "
3481 "included in ARRAY construct with element type %s.",
3482 format_type_be(ARR_ELEMTYPE(array)),
3483 format_type_be(element_type))));
3484
3485 this_ndims = ARR_NDIM(array);
3486 /* temporarily ignore zero-dimensional subarrays */
3487 if (this_ndims <= 0)
3488 {
3489 haveempty = true;
3490 continue;
3491 }
3492
3493 if (firstone)
3494 {
3495 /* Get sub-array details from first member */
3496 elem_ndims = this_ndims;
3497 ndims = elem_ndims + 1;
3498 if (ndims <= 0 || ndims > MAXDIM)
3499 ereport(ERROR,
3500 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
3501 errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
3502 ndims, MAXDIM)));
3503
3504 elem_dims = (int *) palloc(elem_ndims * sizeof(int));
3505 memcpy(elem_dims, ARR_DIMS(array), elem_ndims * sizeof(int));
3506 elem_lbs = (int *) palloc(elem_ndims * sizeof(int));
3507 memcpy(elem_lbs, ARR_LBOUND(array), elem_ndims * sizeof(int));
3508
3509 firstone = false;
3510 }
3511 else
3512 {
3513 /* Check other sub-arrays are compatible */
3514 if (elem_ndims != this_ndims ||
3515 memcmp(elem_dims, ARR_DIMS(array),
3516 elem_ndims * sizeof(int)) != 0 ||
3517 memcmp(elem_lbs, ARR_LBOUND(array),
3518 elem_ndims * sizeof(int)) != 0)
3519 ereport(ERROR,
3520 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3521 errmsg("multidimensional arrays must have array "
3522 "expressions with matching dimensions")));
3523 }
3524
3525 subdata[outer_nelems] = ARR_DATA_PTR(array);
3526 subbitmaps[outer_nelems] = ARR_NULLBITMAP(array);
3527 subbytes[outer_nelems] = ARR_SIZE(array) - ARR_DATA_OFFSET(array);
3528 nbytes += subbytes[outer_nelems];
3529 /* check for overflow of total request */
3530 if (!AllocSizeIsValid(nbytes))
3531 ereport(ERROR,
3532 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
3533 errmsg("array size exceeds the maximum allowed (%d)",
3534 (int) MaxAllocSize)));
3535 subnitems[outer_nelems] = ArrayGetNItems(this_ndims,
3536 ARR_DIMS(array));
3537 havenulls |= ARR_HASNULL(array);
3538 outer_nelems++;
3539 }
3540
3541 /*
3542 * If all items were null or empty arrays, return an empty array;
3543 * otherwise, if some were and some weren't, raise error. (Note: we
3544 * must special-case this somehow to avoid trying to generate a 1-D
3545 * array formed from empty arrays. It's not ideal...)
3546 */
3547 if (haveempty)
3548 {
3549 if (ndims == 0) /* didn't find any nonempty array */
3550 {
3551 *op->resvalue = PointerGetDatum(construct_empty_array(element_type));
3552 return;
3553 }
3554 ereport(ERROR,
3555 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3556 errmsg("multidimensional arrays must have array "
3557 "expressions with matching dimensions")));
3558 }
3559
3560 /* setup for multi-D array */
3561 dims[0] = outer_nelems;
3562 lbs[0] = 1;
3563 for (int i = 1; i < ndims; i++)
3564 {
3565 dims[i] = elem_dims[i - 1];
3566 lbs[i] = elem_lbs[i - 1];
3567 }
3568
3569 /* check for subscript overflow */
3570 nitems = ArrayGetNItems(ndims, dims);
3571 ArrayCheckBounds(ndims, dims, lbs);
3572
3573 if (havenulls)
3574 {
3575 dataoffset = ARR_OVERHEAD_WITHNULLS(ndims, nitems);
3576 nbytes += dataoffset;
3577 }
3578 else
3579 {
3580 dataoffset = 0; /* marker for no null bitmap */
3581 nbytes += ARR_OVERHEAD_NONULLS(ndims);
3582 }
3583
3584 result = (ArrayType *) palloc0(nbytes);
3585 SET_VARSIZE(result, nbytes);
3586 result->ndim = ndims;
3587 result->dataoffset = dataoffset;
3588 result->elemtype = element_type;
3589 memcpy(ARR_DIMS(result), dims, ndims * sizeof(int));
3590 memcpy(ARR_LBOUND(result), lbs, ndims * sizeof(int));
3591
3592 dat = ARR_DATA_PTR(result);
3593 iitem = 0;
3594 for (int i = 0; i < outer_nelems; i++)
3595 {
3596 memcpy(dat, subdata[i], subbytes[i]);
3597 dat += subbytes[i];
3598 if (havenulls)
3599 array_bitmap_copy(ARR_NULLBITMAP(result), iitem,
3600 subbitmaps[i], 0,
3601 subnitems[i]);
3602 iitem += subnitems[i];
3603 }
3604 }
3605
3606 *op->resvalue = PointerGetDatum(result);
3607}
3608
3609/*
3610 * Evaluate an ArrayCoerceExpr expression.
3611 *
3612 * Source array is in step's result variable.
3613 */
3614void
3615ExecEvalArrayCoerce(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
3616{
3617 Datum arraydatum;
3618
3619 /* NULL array -> NULL result */
3620 if (*op->resnull)
3621 return;
3622
3623 arraydatum = *op->resvalue;
3624
3625 /*
3626 * If it's binary-compatible, modify the element type in the array header,
3627 * but otherwise leave the array as we received it.
3628 */
3629 if (op->d.arraycoerce.elemexprstate == NULL)
3630 {
3631 /* Detoast input array if necessary, and copy in any case */
3632 ArrayType *array = DatumGetArrayTypePCopy(arraydatum);
3633
3634 ARR_ELEMTYPE(array) = op->d.arraycoerce.resultelemtype;
3635 *op->resvalue = PointerGetDatum(array);
3636 return;
3637 }
3638
3639 /*
3640 * Use array_map to apply the sub-expression to each array element.
3641 */
3642 *op->resvalue = array_map(arraydatum,
3643 op->d.arraycoerce.elemexprstate,
3644 econtext,
3645 op->d.arraycoerce.resultelemtype,
3646 op->d.arraycoerce.amstate);
3647}
3648
3649/*
3650 * Evaluate a ROW() expression.
3651 *
3652 * The individual columns have already been evaluated into
3653 * op->d.row.elemvalues[]/elemnulls[].
3654 */
3655void
3656ExecEvalRow(ExprState *state, ExprEvalStep *op)
3657{
3658 HeapTuple tuple;
3659
3660 /* build tuple from evaluated field values */
3661 tuple = heap_form_tuple(op->d.row.tupdesc,
3662 op->d.row.elemvalues,
3663 op->d.row.elemnulls);
3664
3665 *op->resvalue = HeapTupleGetDatum(tuple);
3666 *op->resnull = false;
3667}
3668
3669/*
3670 * Evaluate GREATEST() or LEAST() expression (note this is *not* MIN()/MAX()).
3671 *
3672 * All of the to-be-compared expressions have already been evaluated into
3673 * op->d.minmax.values[]/nulls[].
3674 */
3675void
3676ExecEvalMinMax(ExprState *state, ExprEvalStep *op)
3677{
3678 Datum *values = op->d.minmax.values;
3679 bool *nulls = op->d.minmax.nulls;
3680 FunctionCallInfo fcinfo = op->d.minmax.fcinfo_data;
3681 MinMaxOp operator = op->d.minmax.op;
3682
3683 /* set at initialization */
3684 Assert(fcinfo->args[0].isnull == false);
3685 Assert(fcinfo->args[1].isnull == false);
3686
3687 /* default to null result */
3688 *op->resnull = true;
3689
3690 for (int off = 0; off < op->d.minmax.nelems; off++)
3691 {
3692 /* ignore NULL inputs */
3693 if (nulls[off])
3694 continue;
3695
3696 if (*op->resnull)
3697 {
3698 /* first nonnull input, adopt value */
3699 *op->resvalue = values[off];
3700 *op->resnull = false;
3701 }
3702 else
3703 {
3704 int cmpresult;
3705
3706 /* apply comparison function */
3707 fcinfo->args[0].value = *op->resvalue;
3708 fcinfo->args[1].value = values[off];
3709
3710 fcinfo->isnull = false;
3711 cmpresult = DatumGetInt32(FunctionCallInvoke(fcinfo));
3712 if (fcinfo->isnull) /* probably should not happen */
3713 continue;
3714
3715 if (cmpresult > 0 && operator == IS_LEAST)
3716 *op->resvalue = values[off];
3717 else if (cmpresult < 0 && operator == IS_GREATEST)
3718 *op->resvalue = values[off];
3719 }
3720 }
3721}
3722
3723/*
3724 * Evaluate a FieldSelect node.
3725 *
3726 * Source record is in step's result variable.
3727 */
3728void
3729ExecEvalFieldSelect(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
3730{
3731 AttrNumber fieldnum = op->d.fieldselect.fieldnum;
3732 Datum tupDatum;
3733 HeapTupleHeader tuple;
3734 Oid tupType;
3735 int32 tupTypmod;
3736 TupleDesc tupDesc;
3737 Form_pg_attribute attr;
3738 HeapTupleData tmptup;
3739
3740 /* NULL record -> NULL result */
3741 if (*op->resnull)
3742 return;
3743
3744 tupDatum = *op->resvalue;
3745
3746 /* We can special-case expanded records for speed */
3747 if (VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(tupDatum)))
3748 {
3749 ExpandedRecordHeader *erh = (ExpandedRecordHeader *) DatumGetEOHP(tupDatum);
3750
3751 Assert(erh->er_magic == ER_MAGIC);
3752
3753 /* Extract record's TupleDesc */
3754 tupDesc = expanded_record_get_tupdesc(erh);
3755
3756 /*
3757 * Find field's attr record. Note we don't support system columns
3758 * here: a datum tuple doesn't have valid values for most of the
3759 * interesting system columns anyway.
3760 */
3761 if (fieldnum <= 0) /* should never happen */
3762 elog(ERROR, "unsupported reference to system column %d in FieldSelect",
3763 fieldnum);
3764 if (fieldnum > tupDesc->natts) /* should never happen */
3765 elog(ERROR, "attribute number %d exceeds number of columns %d",
3766 fieldnum, tupDesc->natts);
3767 attr = TupleDescAttr(tupDesc, fieldnum - 1);
3768
3769 /* Check for dropped column, and force a NULL result if so */
3770 if (attr->attisdropped)
3771 {
3772 *op->resnull = true;
3773 return;
3774 }
3775
3776 /* Check for type mismatch --- possible after ALTER COLUMN TYPE? */
3777 /* As in CheckVarSlotCompatibility, we should but can't check typmod */
3778 if (op->d.fieldselect.resulttype != attr->atttypid)
3779 ereport(ERROR,
3780 (errcode(ERRCODE_DATATYPE_MISMATCH),
3781 errmsg("attribute %d has wrong type", fieldnum),
3782 errdetail("Table has type %s, but query expects %s.",
3783 format_type_be(attr->atttypid),
3784 format_type_be(op->d.fieldselect.resulttype))));
3785
3786 /* extract the field */
3787 *op->resvalue = expanded_record_get_field(erh, fieldnum,
3788 op->resnull);
3789 }
3790 else
3791 {
3792 /* Get the composite datum and extract its type fields */
3793 tuple = DatumGetHeapTupleHeader(tupDatum);
3794
3795 tupType = HeapTupleHeaderGetTypeId(tuple);
3796 tupTypmod = HeapTupleHeaderGetTypMod(tuple);
3797
3798 /* Lookup tupdesc if first time through or if type changes */
3799 tupDesc = get_cached_rowtype(tupType, tupTypmod,
3800 &op->d.fieldselect.rowcache, NULL);
3801
3802 /*
3803 * Find field's attr record. Note we don't support system columns
3804 * here: a datum tuple doesn't have valid values for most of the
3805 * interesting system columns anyway.
3806 */
3807 if (fieldnum <= 0) /* should never happen */
3808 elog(ERROR, "unsupported reference to system column %d in FieldSelect",
3809 fieldnum);
3810 if (fieldnum > tupDesc->natts) /* should never happen */
3811 elog(ERROR, "attribute number %d exceeds number of columns %d",
3812 fieldnum, tupDesc->natts);
3813 attr = TupleDescAttr(tupDesc, fieldnum - 1);
3814
3815 /* Check for dropped column, and force a NULL result if so */
3816 if (attr->attisdropped)
3817 {
3818 *op->resnull = true;
3819 return;
3820 }
3821
3822 /* Check for type mismatch --- possible after ALTER COLUMN TYPE? */
3823 /* As in CheckVarSlotCompatibility, we should but can't check typmod */
3824 if (op->d.fieldselect.resulttype != attr->atttypid)
3825 ereport(ERROR,
3826 (errcode(ERRCODE_DATATYPE_MISMATCH),
3827 errmsg("attribute %d has wrong type", fieldnum),
3828 errdetail("Table has type %s, but query expects %s.",
3829 format_type_be(attr->atttypid),
3830 format_type_be(op->d.fieldselect.resulttype))));
3831
3832 /* heap_getattr needs a HeapTuple not a bare HeapTupleHeader */
3833 tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
3834 tmptup.t_data = tuple;
3835
3836 /* extract the field */
3837 *op->resvalue = heap_getattr(&tmptup,
3838 fieldnum,
3839 tupDesc,
3840 op->resnull);
3841 }
3842}
3843
3844/*
3845 * Deform source tuple, filling in the step's values/nulls arrays, before
3846 * evaluating individual new values as part of a FieldStore expression.
3847 * Subsequent steps will overwrite individual elements of the values/nulls
3848 * arrays with the new field values, and then FIELDSTORE_FORM will build the
3849 * new tuple value.
3850 *
3851 * Source record is in step's result variable.
3852 */
3853void
3854ExecEvalFieldStoreDeForm(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
3855{
3856 if (*op->resnull)
3857 {
3858 /* Convert null input tuple into an all-nulls row */
3859 memset(op->d.fieldstore.nulls, true,
3860 op->d.fieldstore.ncolumns * sizeof(bool));
3861 }
3862 else
3863 {
3864 /*
3865 * heap_deform_tuple needs a HeapTuple not a bare HeapTupleHeader. We
3866 * set all the fields in the struct just in case.
3867 */
3868 Datum tupDatum = *op->resvalue;
3869 HeapTupleHeader tuphdr;
3870 HeapTupleData tmptup;
3871 TupleDesc tupDesc;
3872
3873 tuphdr = DatumGetHeapTupleHeader(tupDatum);
3874 tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
3875 ItemPointerSetInvalid(&(tmptup.t_self));
3876 tmptup.t_tableOid = InvalidOid;
3877 tmptup.t_data = tuphdr;
3878
3879 /*
3880 * Lookup tupdesc if first time through or if type changes. Because
3881 * we don't pin the tupdesc, we must not do this lookup until after
3882 * doing DatumGetHeapTupleHeader: that could do database access while
3883 * detoasting the datum.
3884 */
3885 tupDesc = get_cached_rowtype(op->d.fieldstore.fstore->resulttype, -1,
3886 op->d.fieldstore.rowcache, NULL);
3887
3888 /* Check that current tupdesc doesn't have more fields than allocated */
3889 if (unlikely(tupDesc->natts > op->d.fieldstore.ncolumns))
3890 elog(ERROR, "too many columns in composite type %u",
3891 op->d.fieldstore.fstore->resulttype);
3892
3893 heap_deform_tuple(&tmptup, tupDesc,
3894 op->d.fieldstore.values,
3895 op->d.fieldstore.nulls);
3896 }
3897}
3898
3899/*
3900 * Compute the new composite datum after each individual field value of a
3901 * FieldStore expression has been evaluated.
3902 */
3903void
3904ExecEvalFieldStoreForm(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
3905{
3906 TupleDesc tupDesc;
3907 HeapTuple tuple;
3908
3909 /* Lookup tupdesc (should be valid already) */
3910 tupDesc = get_cached_rowtype(op->d.fieldstore.fstore->resulttype, -1,
3911 op->d.fieldstore.rowcache, NULL);
3912
3913 tuple = heap_form_tuple(tupDesc,
3914 op->d.fieldstore.values,
3915 op->d.fieldstore.nulls);
3916
3917 *op->resvalue = HeapTupleGetDatum(tuple);
3918 *op->resnull = false;
3919}
3920
3921/*
3922 * Evaluate a rowtype coercion operation.
3923 * This may require rearranging field positions.
3924 *
3925 * Source record is in step's result variable.
3926 */
3927void
3928ExecEvalConvertRowtype(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
3929{
3930 HeapTuple result;
3931 Datum tupDatum;
3932 HeapTupleHeader tuple;
3933 HeapTupleData tmptup;
3934 TupleDesc indesc,
3935 outdesc;
3936 bool changed = false;
3937
3938 /* NULL in -> NULL out */
3939 if (*op->resnull)
3940 return;
3941
3942 tupDatum = *op->resvalue;
3943 tuple = DatumGetHeapTupleHeader(tupDatum);
3944
3945 /*
3946 * Lookup tupdescs if first time through or if type changes. We'd better
3947 * pin them since type conversion functions could do catalog lookups and
3948 * hence cause cache invalidation.
3949 */
3950 indesc = get_cached_rowtype(op->d.convert_rowtype.inputtype, -1,
3951 op->d.convert_rowtype.incache,
3952 &changed);
3953 IncrTupleDescRefCount(indesc);
3954 outdesc = get_cached_rowtype(op->d.convert_rowtype.outputtype, -1,
3955 op->d.convert_rowtype.outcache,
3956 &changed);
3957 IncrTupleDescRefCount(outdesc);
3958
3959 /*
3960 * We used to be able to assert that incoming tuples are marked with
3961 * exactly the rowtype of indesc. However, now that ExecEvalWholeRowVar
3962 * might change the tuples' marking to plain RECORD due to inserting
3963 * aliases, we can only make this weak test:
3964 */
3965 Assert(HeapTupleHeaderGetTypeId(tuple) == indesc->tdtypeid ||
3966 HeapTupleHeaderGetTypeId(tuple) == RECORDOID);
3967
3968 /* if first time through, or after change, initialize conversion map */
3969 if (changed)
3970 {
3971 MemoryContext old_cxt;
3972
3973 /* allocate map in long-lived memory context */
3974 old_cxt = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
3975
3976 /* prepare map from old to new attribute numbers */
3977 op->d.convert_rowtype.map = convert_tuples_by_name(indesc, outdesc);
3978
3979 MemoryContextSwitchTo(old_cxt);
3980 }
3981
3982 /* Following steps need a HeapTuple not a bare HeapTupleHeader */
3983 tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
3984 tmptup.t_data = tuple;
3985
3986 if (op->d.convert_rowtype.map != NULL)
3987 {
3988 /* Full conversion with attribute rearrangement needed */
3989 result = execute_attr_map_tuple(&tmptup, op->d.convert_rowtype.map);
3990 /* Result already has appropriate composite-datum header fields */
3991 *op->resvalue = HeapTupleGetDatum(result);
3992 }
3993 else
3994 {
3995 /*
3996 * The tuple is physically compatible as-is, but we need to insert the
3997 * destination rowtype OID in its composite-datum header field, so we
3998 * have to copy it anyway. heap_copy_tuple_as_datum() is convenient
3999 * for this since it will both make the physical copy and insert the
4000 * correct composite header fields. Note that we aren't expecting to
4001 * have to flatten any toasted fields: the input was a composite
4002 * datum, so it shouldn't contain any. So heap_copy_tuple_as_datum()
4003 * is overkill here, but its check for external fields is cheap.
4004 */
4005 *op->resvalue = heap_copy_tuple_as_datum(&tmptup, outdesc);
4006 }
4007
4008 DecrTupleDescRefCount(indesc);
4009 DecrTupleDescRefCount(outdesc);
4010}
4011
4012/*
4013 * Evaluate "scalar op ANY/ALL (array)".
4014 *
4015 * Source array is in our result area, scalar arg is already evaluated into
4016 * fcinfo->args[0].
4017 *
4018 * The operator always yields boolean, and we combine the results across all
4019 * array elements using OR and AND (for ANY and ALL respectively). Of course
4020 * we short-circuit as soon as the result is known.
4021 */
4022void
4023ExecEvalScalarArrayOp(ExprState *state, ExprEvalStep *op)
4024{
4025 FunctionCallInfo fcinfo = op->d.scalararrayop.fcinfo_data;
4026 bool useOr = op->d.scalararrayop.useOr;
4027 bool strictfunc = op->d.scalararrayop.finfo->fn_strict;
4028 ArrayType *arr;
4029 int nitems;
4030 Datum result;
4031 bool resultnull;
4032 int16 typlen;
4033 bool typbyval;
4034 char typalign;
4035 char *s;
4036 bits8 *bitmap;
4037 int bitmask;
4038
4039 /*
4040 * If the array is NULL then we return NULL --- it's not very meaningful
4041 * to do anything else, even if the operator isn't strict.
4042 */
4043 if (*op->resnull)
4044 return;
4045
4046 /* Else okay to fetch and detoast the array */
4047 arr = DatumGetArrayTypeP(*op->resvalue);
4048
4049 /*
4050 * If the array is empty, we return either FALSE or TRUE per the useOr
4051 * flag. This is correct even if the scalar is NULL; since we would
4052 * evaluate the operator zero times, it matters not whether it would want
4053 * to return NULL.
4054 */
4055 nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr));
4056 if (nitems <= 0)
4057 {
4058 *op->resvalue = BoolGetDatum(!useOr);
4059 *op->resnull = false;
4060 return;
4061 }
4062
4063 /*
4064 * If the scalar is NULL, and the function is strict, return NULL; no
4065 * point in iterating the loop.
4066 */
4067 if (fcinfo->args[0].isnull && strictfunc)
4068 {
4069 *op->resnull = true;
4070 return;
4071 }
4072
4073 /*
4074 * We arrange to look up info about the element type only once per series
4075 * of calls, assuming the element type doesn't change underneath us.
4076 */
4077 if (op->d.scalararrayop.element_type != ARR_ELEMTYPE(arr))
4078 {
4079 get_typlenbyvalalign(ARR_ELEMTYPE(arr),
4080 &op->d.scalararrayop.typlen,
4081 &op->d.scalararrayop.typbyval,
4082 &op->d.scalararrayop.typalign);
4083 op->d.scalararrayop.element_type = ARR_ELEMTYPE(arr);
4084 }
4085
4086 typlen = op->d.scalararrayop.typlen;
4087 typbyval = op->d.scalararrayop.typbyval;
4088 typalign = op->d.scalararrayop.typalign;
4089
4090 /* Initialize result appropriately depending on useOr */
4091 result = BoolGetDatum(!useOr);
4092 resultnull = false;
4093
4094 /* Loop over the array elements */
4095 s = (char *) ARR_DATA_PTR(arr);
4096 bitmap = ARR_NULLBITMAP(arr);
4097 bitmask = 1;
4098
4099 for (int i = 0; i < nitems; i++)
4100 {
4101 Datum elt;
4102 Datum thisresult;
4103
4104 /* Get array element, checking for NULL */
4105 if (bitmap && (*bitmap & bitmask) == 0)
4106 {
4107 fcinfo->args[1].value = (Datum) 0;
4108 fcinfo->args[1].isnull = true;
4109 }
4110 else
4111 {
4112 elt = fetch_att(s, typbyval, typlen);
4113 s = att_addlength_pointer(s, typlen, s);
4114 s = (char *) att_align_nominal(s, typalign);
4115 fcinfo->args[1].value = elt;
4116 fcinfo->args[1].isnull = false;
4117 }
4118
4119 /* Call comparison function */
4120 if (fcinfo->args[1].isnull && strictfunc)
4121 {
4122 fcinfo->isnull = true;
4123 thisresult = (Datum) 0;
4124 }
4125 else
4126 {
4127 fcinfo->isnull = false;
4128 thisresult = op->d.scalararrayop.fn_addr(fcinfo);
4129 }
4130
4131 /* Combine results per OR or AND semantics */
4132 if (fcinfo->isnull)
4133 resultnull = true;
4134 else if (useOr)
4135 {
4136 if (DatumGetBool(thisresult))
4137 {
4138 result = BoolGetDatum(true);
4139 resultnull = false;
4140 break; /* needn't look at any more elements */
4141 }
4142 }
4143 else
4144 {
4145 if (!DatumGetBool(thisresult))
4146 {
4147 result = BoolGetDatum(false);
4148 resultnull = false;
4149 break; /* needn't look at any more elements */
4150 }
4151 }
4152
4153 /* advance bitmap pointer if any */
4154 if (bitmap)
4155 {
4156 bitmask <<= 1;
4157 if (bitmask == 0x100)
4158 {
4159 bitmap++;
4160 bitmask = 1;
4161 }
4162 }
4163 }
4164
4165 *op->resvalue = result;
4166 *op->resnull = resultnull;
4167}
4168
4169/*
4170 * Hash function for scalar array hash op elements.
4171 *
4172 * We use the element type's default hash opclass, and the column collation
4173 * if the type is collation-sensitive.
4174 */
4175static uint32
4176saop_element_hash(struct saophash_hash *tb, Datum key)
4177{
4178 ScalarArrayOpExprHashTable *elements_tab = (ScalarArrayOpExprHashTable *) tb->private_data;
4179 FunctionCallInfo fcinfo = &elements_tab->hash_fcinfo_data;
4180 Datum hash;
4181
4182 fcinfo->args[0].value = key;
4183 fcinfo->args[0].isnull = false;
4184
4185 hash = elements_tab->hash_finfo.fn_addr(fcinfo);
4186
4187 return DatumGetUInt32(hash);
4188}
4189
4190/*
4191 * Matching function for scalar array hash op elements, to be used in hashtable
4192 * lookups.
4193 */
4194static bool
4195saop_hash_element_match(struct saophash_hash *tb, Datum key1, Datum key2)
4196{
4197 Datum result;
4198
4199 ScalarArrayOpExprHashTable *elements_tab = (ScalarArrayOpExprHashTable *) tb->private_data;
4200 FunctionCallInfo fcinfo = elements_tab->op->d.hashedscalararrayop.fcinfo_data;
4201
4202 fcinfo->args[0].value = key1;
4203 fcinfo->args[0].isnull = false;
4204 fcinfo->args[1].value = key2;
4205 fcinfo->args[1].isnull = false;
4206
4207 result = elements_tab->op->d.hashedscalararrayop.finfo->fn_addr(fcinfo);
4208
4209 return DatumGetBool(result);
4210}
4211
4212/*
4213 * Evaluate "scalar op ANY (const array)".
4214 *
4215 * Similar to ExecEvalScalarArrayOp, but optimized for faster repeat lookups
4216 * by building a hashtable on the first lookup. This hashtable will be reused
4217 * by subsequent lookups. Unlike ExecEvalScalarArrayOp, this version only
4218 * supports OR semantics.
4219 *
4220 * Source array is in our result area, scalar arg is already evaluated into
4221 * fcinfo->args[0].
4222 *
4223 * The operator always yields boolean.
4224 */
4225void
4226ExecEvalHashedScalarArrayOp(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
4227{
4228 ScalarArrayOpExprHashTable *elements_tab = op->d.hashedscalararrayop.elements_tab;
4229 FunctionCallInfo fcinfo = op->d.hashedscalararrayop.fcinfo_data;
4230 bool inclause = op->d.hashedscalararrayop.inclause;
4231 bool strictfunc = op->d.hashedscalararrayop.finfo->fn_strict;
4232 Datum scalar = fcinfo->args[0].value;
4233 bool scalar_isnull = fcinfo->args[0].isnull;
4234 Datum result;
4235 bool resultnull;
4236 bool hashfound;
4237
4238 /* We don't setup a hashed scalar array op if the array const is null. */
4239 Assert(!*op->resnull);
4240
4241 /*
4242 * If the scalar is NULL, and the function is strict, return NULL; no
4243 * point in executing the search.
4244 */
4245 if (fcinfo->args[0].isnull && strictfunc)
4246 {
4247 *op->resnull = true;
4248 return;
4249 }
4250
4251 /* Build the hash table on first evaluation */
4252 if (elements_tab == NULL)
4253 {
4254 ScalarArrayOpExpr *saop;
4255 int16 typlen;
4256 bool typbyval;
4257 char typalign;
4258 int nitems;
4259 bool has_nulls = false;
4260 char *s;
4261 bits8 *bitmap;
4262 int bitmask;
4263 MemoryContext oldcontext;
4264 ArrayType *arr;
4265
4266 saop = op->d.hashedscalararrayop.saop;
4267
4268 arr = DatumGetArrayTypeP(*op->resvalue);
4269 nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr));
4270
4271 get_typlenbyvalalign(ARR_ELEMTYPE(arr),
4272 &typlen,
4273 &typbyval,
4274 &typalign);
4275
4276 oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
4277
4278 elements_tab = (ScalarArrayOpExprHashTable *)
4279 palloc0(offsetof(ScalarArrayOpExprHashTable, hash_fcinfo_data) +
4280 SizeForFunctionCallInfo(1));
4281 op->d.hashedscalararrayop.elements_tab = elements_tab;
4282 elements_tab->op = op;
4283
4284 fmgr_info(saop->hashfuncid, &elements_tab->hash_finfo);
4285 fmgr_info_set_expr((Node *) saop, &elements_tab->hash_finfo);
4286
4287 InitFunctionCallInfoData(elements_tab->hash_fcinfo_data,
4288 &elements_tab->hash_finfo,
4289 1,
4290 saop->inputcollid,
4291 NULL,
4292 NULL);
4293
4294 /*
4295 * Create the hash table sizing it according to the number of elements
4296 * in the array. This does assume that the array has no duplicates.
4297 * If the array happens to contain many duplicate values then it'll
4298 * just mean that we sized the table a bit on the large side.
4299 */
4300 elements_tab->hashtab = saophash_create(CurrentMemoryContext, nitems,
4301 elements_tab);
4302
4303 MemoryContextSwitchTo(oldcontext);
4304
4305 s = (char *) ARR_DATA_PTR(arr);
4306 bitmap = ARR_NULLBITMAP(arr);
4307 bitmask = 1;
4308 for (int i = 0; i < nitems; i++)
4309 {
4310 /* Get array element, checking for NULL. */
4311 if (bitmap && (*bitmap & bitmask) == 0)
4312 {
4313 has_nulls = true;
4314 }
4315 else
4316 {
4317 Datum element;
4318
4319 element = fetch_att(s, typbyval, typlen);
4320 s = att_addlength_pointer(s, typlen, s);
4321 s = (char *) att_align_nominal(s, typalign);
4322
4323 saophash_insert(elements_tab->hashtab, element, &hashfound);
4324 }
4325
4326 /* Advance bitmap pointer if any. */
4327 if (bitmap)
4328 {
4329 bitmask <<= 1;
4330 if (bitmask == 0x100)
4331 {
4332 bitmap++;
4333 bitmask = 1;
4334 }
4335 }
4336 }
4337
4338 /*
4339 * Remember if we had any nulls so that we know if we need to execute
4340 * non-strict functions with a null lhs value if no match is found.
4341 */
4342 op->d.hashedscalararrayop.has_nulls = has_nulls;
4343 }
4344
4345 /* Check the hash to see if we have a match. */
4346 hashfound = NULL != saophash_lookup(elements_tab->hashtab, scalar);
4347
4348 /* the result depends on if the clause is an IN or NOT IN clause */
4349 if (inclause)
4350 result = BoolGetDatum(hashfound); /* IN */
4351 else
4352 result = BoolGetDatum(!hashfound); /* NOT IN */
4353
4354 resultnull = false;
4355
4356 /*
4357 * If we didn't find a match in the array, we still might need to handle
4358 * the possibility of null values. We didn't put any NULLs into the
4359 * hashtable, but instead marked if we found any when building the table
4360 * in has_nulls.
4361 */
4362 if (!hashfound && op->d.hashedscalararrayop.has_nulls)
4363 {
4364 if (strictfunc)
4365 {
4366
4367 /*
4368 * We have nulls in the array so a non-null lhs and no match must
4369 * yield NULL.
4370 */
4371 result = (Datum) 0;
4372 resultnull = true;
4373 }
4374 else
4375 {
4376 /*
4377 * Execute function will null rhs just once.
4378 *
4379 * The hash lookup path will have scribbled on the lhs argument so
4380 * we need to set it up also (even though we entered this function
4381 * with it already set).
4382 */
4383 fcinfo->args[0].value = scalar;
4384 fcinfo->args[0].isnull = scalar_isnull;
4385 fcinfo->args[1].value = (Datum) 0;
4386 fcinfo->args[1].isnull = true;
4387
4388 result = op->d.hashedscalararrayop.finfo->fn_addr(fcinfo);
4389 resultnull = fcinfo->isnull;
4390
4391 /*
4392 * Reverse the result for NOT IN clauses since the above function
4393 * is the equality function and we need not-equals.
4394 */
4395 if (!inclause)
4396 result = BoolGetDatum(!DatumGetBool(result));
4397 }
4398 }
4399
4400 *op->resvalue = result;
4401 *op->resnull = resultnull;
4402}
4403
4404/*
4405 * Evaluate a NOT NULL domain constraint.
4406 */
4407void
4408ExecEvalConstraintNotNull(ExprState *state, ExprEvalStep *op)
4409{
4410 if (*op->resnull)
4411 errsave((Node *) op->d.domaincheck.escontext,
4412 (errcode(ERRCODE_NOT_NULL_VIOLATION),
4413 errmsg("domain %s does not allow null values",
4414 format_type_be(op->d.domaincheck.resulttype)),
4415 errdatatype(op->d.domaincheck.resulttype)));
4416}
4417
4418/*
4419 * Evaluate a CHECK domain constraint.
4420 */
4421void
4422ExecEvalConstraintCheck(ExprState *state, ExprEvalStep *op)
4423{
4424 if (!*op->d.domaincheck.checknull &&
4425 !DatumGetBool(*op->d.domaincheck.checkvalue))
4426 errsave((Node *) op->d.domaincheck.escontext,
4427 (errcode(ERRCODE_CHECK_VIOLATION),
4428 errmsg("value for domain %s violates check constraint \"%s\"",
4429 format_type_be(op->d.domaincheck.resulttype),
4430 op->d.domaincheck.constraintname),
4431 errdomainconstraint(op->d.domaincheck.resulttype,
4432 op->d.domaincheck.constraintname)));
4433}
4434
4435/*
4436 * Evaluate the various forms of XmlExpr.
4437 *
4438 * Arguments have been evaluated into named_argvalue/named_argnull
4439 * and/or argvalue/argnull arrays.
4440 */
4441void
4442ExecEvalXmlExpr(ExprState *state, ExprEvalStep *op)
4443{
4444 XmlExpr *xexpr = op->d.xmlexpr.xexpr;
4445 Datum value;
4446
4447 *op->resnull = true; /* until we get a result */
4448 *op->resvalue = (Datum) 0;
4449
4450 switch (xexpr->op)
4451 {
4452 case IS_XMLCONCAT:
4453 {
4454 Datum *argvalue = op->d.xmlexpr.argvalue;
4455 bool *argnull = op->d.xmlexpr.argnull;
4456 List *values = NIL;
4457
4458 for (int i = 0; i < list_length(xexpr->args); i++)
4459 {
4460 if (!argnull[i])
4461 values = lappend(values, DatumGetPointer(argvalue[i]));
4462 }
4463
4464 if (values != NIL)
4465 {
4466 *op->resvalue = PointerGetDatum(xmlconcat(values));
4467 *op->resnull = false;
4468 }
4469 }
4470 break;
4471
4472 case IS_XMLFOREST:
4473 {
4474 Datum *argvalue = op->d.xmlexpr.named_argvalue;
4475 bool *argnull = op->d.xmlexpr.named_argnull;
4476 StringInfoData buf;
4477 ListCell *lc;
4478 ListCell *lc2;
4479 int i;
4480
4481 initStringInfo(&buf);
4482
4483 i = 0;
4484 forboth(lc, xexpr->named_args, lc2, xexpr->arg_names)
4485 {
4486 Expr *e = (Expr *) lfirst(lc);
4487 char *argname = strVal(lfirst(lc2));
4488
4489 if (!argnull[i])
4490 {
4491 value = argvalue[i];
4492 appendStringInfo(&buf, "<%s>%s</%s>",
4493 argname,
4494 map_sql_value_to_xml_value(value,
4495 exprType((Node *) e), true),
4496 argname);
4497 *op->resnull = false;
4498 }
4499 i++;
4500 }
4501
4502 if (!*op->resnull)
4503 {
4504 text *result;
4505
4506 result = cstring_to_text_with_len(buf.data, buf.len);
4507 *op->resvalue = PointerGetDatum(result);
4508 }
4509
4510 pfree(buf.data);
4511 }
4512 break;
4513
4514 case IS_XMLELEMENT:
4515 *op->resvalue = PointerGetDatum(xmlelement(xexpr,
4516 op->d.xmlexpr.named_argvalue,
4517 op->d.xmlexpr.named_argnull,
4518 op->d.xmlexpr.argvalue,
4519 op->d.xmlexpr.argnull));
4520 *op->resnull = false;
4521 break;
4522
4523 case IS_XMLPARSE:
4524 {
4525 Datum *argvalue = op->d.xmlexpr.argvalue;
4526 bool *argnull = op->d.xmlexpr.argnull;
4527 text *data;
4528 bool preserve_whitespace;
4529
4530 /* arguments are known to be text, bool */
4531 Assert(list_length(xexpr->args) == 2);
4532
4533 if (argnull[0])
4534 return;
4535 value = argvalue[0];
4536 data = DatumGetTextPP(value);
4537
4538 if (argnull[1]) /* probably can't happen */
4539 return;
4540 value = argvalue[1];
4541 preserve_whitespace = DatumGetBool(value);
4542
4543 *op->resvalue = PointerGetDatum(xmlparse(data,
4544 xexpr->xmloption,
4545 preserve_whitespace));
4546 *op->resnull = false;
4547 }
4548 break;
4549
4550 case IS_XMLPI:
4551 {
4552 text *arg;
4553 bool isnull;
4554
4555 /* optional argument is known to be text */
4556 Assert(list_length(xexpr->args) <= 1);
4557
4558 if (xexpr->args)
4559 {
4560 isnull = op->d.xmlexpr.argnull[0];
4561 if (isnull)
4562 arg = NULL;
4563 else
4564 arg = DatumGetTextPP(op->d.xmlexpr.argvalue[0]);
4565 }
4566 else
4567 {
4568 arg = NULL;
4569 isnull = false;
4570 }
4571
4572 *op->resvalue = PointerGetDatum(xmlpi(xexpr->name,
4573 arg,
4574 isnull,
4575 op->resnull));
4576 }
4577 break;
4578
4579 case IS_XMLROOT:
4580 {
4581 Datum *argvalue = op->d.xmlexpr.argvalue;
4582 bool *argnull = op->d.xmlexpr.argnull;
4583 xmltype *data;
4584 text *version;
4585 int standalone;
4586
4587 /* arguments are known to be xml, text, int */
4588 Assert(list_length(xexpr->args) == 3);
4589
4590 if (argnull[0])
4591 return;
4592 data = DatumGetXmlP(argvalue[0]);
4593
4594 if (argnull[1])
4595 version = NULL;
4596 else
4597 version = DatumGetTextPP(argvalue[1]);
4598
4599 Assert(!argnull[2]); /* always present */
4600 standalone = DatumGetInt32(argvalue[2]);
4601
4602 *op->resvalue = PointerGetDatum(xmlroot(data,
4603 version,
4604 standalone));
4605 *op->resnull = false;
4606 }
4607 break;
4608
4609 case IS_XMLSERIALIZE:
4610 {
4611 Datum *argvalue = op->d.xmlexpr.argvalue;
4612 bool *argnull = op->d.xmlexpr.argnull;
4613
4614 /* argument type is known to be xml */
4615 Assert(list_length(xexpr->args) == 1);
4616
4617 if (argnull[0])
4618 return;
4619 value = argvalue[0];
4620
4621 *op->resvalue =
4622 PointerGetDatum(xmltotext_with_options(DatumGetXmlP(value),
4623 xexpr->xmloption,
4624 xexpr->indent));
4625 *op->resnull = false;
4626 }
4627 break;
4628
4629 case IS_DOCUMENT:
4630 {
4631 Datum *argvalue = op->d.xmlexpr.argvalue;
4632 bool *argnull = op->d.xmlexpr.argnull;
4633
4634 /* optional argument is known to be xml */
4635 Assert(list_length(xexpr->args) == 1);
4636
4637 if (argnull[0])
4638 return;
4639 value = argvalue[0];
4640
4641 *op->resvalue =
4642 BoolGetDatum(xml_is_document(DatumGetXmlP(value)));
4643 *op->resnull = false;
4644 }
4645 break;
4646
4647 default:
4648 elog(ERROR, "unrecognized XML operation");
4649 break;
4650 }
4651}
4652
4653/*
4654 * Evaluate a JSON constructor expression.
4655 */
4656void
4657ExecEvalJsonConstructor(ExprState *state, ExprEvalStep *op,
4658 ExprContext *econtext)
4659{
4660 Datum res;
4661 JsonConstructorExprState *jcstate = op->d.json_constructor.jcstate;
4662 JsonConstructorExpr *ctor = jcstate->constructor;
4663 bool is_jsonb = ctor->returning->format->format_type == JS_FORMAT_JSONB;
4664 bool isnull = false;
4665
4666 if (ctor->type == JSCTOR_JSON_ARRAY)
4667 res = (is_jsonb ?
4668 jsonb_build_array_worker :
4669 json_build_array_worker) (jcstate->nargs,
4670 jcstate->arg_values,
4671 jcstate->arg_nulls,
4672 jcstate->arg_types,
4673 jcstate->constructor->absent_on_null);
4674 else if (ctor->type == JSCTOR_JSON_OBJECT)
4675 res = (is_jsonb ?
4676 jsonb_build_object_worker :
4677 json_build_object_worker) (jcstate->nargs,
4678 jcstate->arg_values,
4679 jcstate->arg_nulls,
4680 jcstate->arg_types,
4681 jcstate->constructor->absent_on_null,
4682 jcstate->constructor->unique);
4683 else if (ctor->type == JSCTOR_JSON_SCALAR)
4684 {
4685 if (jcstate->arg_nulls[0])
4686 {
4687 res = (Datum) 0;
4688 isnull = true;
4689 }
4690 else
4691 {
4692 Datum value = jcstate->arg_values[0];
4693 Oid outfuncid = jcstate->arg_type_cache[0].outfuncid;
4694 JsonTypeCategory category = (JsonTypeCategory)
4695 jcstate->arg_type_cache[0].category;
4696
4697 if (is_jsonb)
4698 res = datum_to_jsonb(value, category, outfuncid);
4699 else
4700 res = datum_to_json(value, category, outfuncid);
4701 }
4702 }
4703 else if (ctor->type == JSCTOR_JSON_PARSE)
4704 {
4705 if (jcstate->arg_nulls[0])
4706 {
4707 res = (Datum) 0;
4708 isnull = true;
4709 }
4710 else
4711 {
4712 Datum value = jcstate->arg_values[0];
4713 text *js = DatumGetTextP(value);
4714
4715 if (is_jsonb)
4716 res = jsonb_from_text(js, true);
4717 else
4718 {
4719 (void) json_validate(js, true, true);
4720 res = value;
4721 }
4722 }
4723 }
4724 else
4725 elog(ERROR, "invalid JsonConstructorExpr type %d", ctor->type);
4726
4727 *op->resvalue = res;
4728 *op->resnull = isnull;
4729}
4730
4731/*
4732 * Evaluate a IS JSON predicate.
4733 */
4734void
4735ExecEvalJsonIsPredicate(ExprState *state, ExprEvalStep *op)
4736{
4737 JsonIsPredicate *pred = op->d.is_json.pred;
4738 Datum js = *op->resvalue;
4739 Oid exprtype;
4740 bool res;
4741
4742 if (*op->resnull)
4743 {
4744 *op->resvalue = BoolGetDatum(false);
4745 return;
4746 }
4747
4748 exprtype = exprType(pred->expr);
4749
4750 if (exprtype == TEXTOID || exprtype == JSONOID)
4751 {
4752 text *json = DatumGetTextP(js);
4753
4754 if (pred->item_type == JS_TYPE_ANY)
4755 res = true;
4756 else
4757 {
4758 switch (json_get_first_token(json, false))
4759 {
4760 case JSON_TOKEN_OBJECT_START:
4761 res = pred->item_type == JS_TYPE_OBJECT;
4762 break;
4763 case JSON_TOKEN_ARRAY_START:
4764 res = pred->item_type == JS_TYPE_ARRAY;
4765 break;
4766 case JSON_TOKEN_STRING:
4767 case JSON_TOKEN_NUMBER:
4768 case JSON_TOKEN_TRUE:
4769 case JSON_TOKEN_FALSE:
4770 case JSON_TOKEN_NULL:
4771 res = pred->item_type == JS_TYPE_SCALAR;
4772 break;
4773 default:
4774 res = false;
4775 break;
4776 }
4777 }
4778
4779 /*
4780 * Do full parsing pass only for uniqueness check or for JSON text
4781 * validation.
4782 */
4783 if (res && (pred->unique_keys || exprtype == TEXTOID))
4784 res = json_validate(json, pred->unique_keys, false);
4785 }
4786 else if (exprtype == JSONBOID)
4787 {
4788 if (pred->item_type == JS_TYPE_ANY)
4789 res = true;
4790 else
4791 {
4792 Jsonb *jb = DatumGetJsonbP(js);
4793
4794 switch (pred->item_type)
4795 {
4796 case JS_TYPE_OBJECT:
4797 res = JB_ROOT_IS_OBJECT(jb);
4798 break;
4799 case JS_TYPE_ARRAY:
4800 res = JB_ROOT_IS_ARRAY(jb) && !JB_ROOT_IS_SCALAR(jb);
4801 break;
4802 case JS_TYPE_SCALAR:
4803 res = JB_ROOT_IS_ARRAY(jb) && JB_ROOT_IS_SCALAR(jb);
4804 break;
4805 default:
4806 res = false;
4807 break;
4808 }
4809 }
4810
4811 /* Key uniqueness check is redundant for jsonb */
4812 }
4813 else
4814 res = false;
4815
4816 *op->resvalue = BoolGetDatum(res);
4817}
4818
4819/*
4820 * Evaluate a jsonpath against a document, both of which must have been
4821 * evaluated and their values saved in op->d.jsonexpr.jsestate.
4822 *
4823 * If an error occurs during JsonPath* evaluation or when coercing its result
4824 * to the RETURNING type, JsonExprState.error is set to true, provided the
4825 * ON ERROR behavior is not ERROR. Similarly, if JsonPath{Query|Value}() found
4826 * no matching items, JsonExprState.empty is set to true, provided the ON EMPTY
4827 * behavior is not ERROR. That is to signal to the subsequent steps that check
4828 * those flags to return the ON ERROR / ON EMPTY expression.
4829 *
4830 * Return value is the step address to be performed next. It will be one of
4831 * jump_error, jump_empty, jump_eval_coercion, or jump_end, all given in
4832 * op->d.jsonexpr.jsestate.
4833 */
4834int
4835ExecEvalJsonExprPath(ExprState *state, ExprEvalStep *op,
4836 ExprContext *econtext)
4837{
4838 JsonExprState *jsestate = op->d.jsonexpr.jsestate;
4839 JsonExpr *jsexpr = jsestate->jsexpr;
4840 Datum item;
4841 JsonPath *path;
4842 bool throw_error = jsexpr->on_error->btype == JSON_BEHAVIOR_ERROR;
4843 bool error = false,
4844 empty = false;
4845 int jump_eval_coercion = jsestate->jump_eval_coercion;
4846 char *val_string = NULL;
4847
4848 item = jsestate->formatted_expr.value;
4849 path = DatumGetJsonPathP(jsestate->pathspec.value);
4850
4851 /* Set error/empty to false. */
4852 memset(&jsestate->error, 0, sizeof(NullableDatum));
4853 memset(&jsestate->empty, 0, sizeof(NullableDatum));
4854
4855 /* Also reset ErrorSaveContext contents for the next row. */
4856 if (jsestate->escontext.details_wanted)
4857 {
4858 jsestate->escontext.error_data = NULL;
4859 jsestate->escontext.details_wanted = false;
4860 }
4861 jsestate->escontext.error_occurred = false;
4862
4863 switch (jsexpr->op)
4864 {
4865 case JSON_EXISTS_OP:
4866 {
4867 bool exists = JsonPathExists(item, path,
4868 !throw_error ? &error : NULL,
4869 jsestate->args);
4870
4871 if (!error)
4872 {
4873 *op->resnull = false;
4874 *op->resvalue = BoolGetDatum(exists);
4875 }
4876 }
4877 break;
4878
4879 case JSON_QUERY_OP:
4880 *op->resvalue = JsonPathQuery(item, path, jsexpr->wrapper, &empty,
4881 !throw_error ? &error : NULL,
4882 jsestate->args,
4883 jsexpr->column_name);
4884
4885 *op->resnull = (DatumGetPointer(*op->resvalue) == NULL);
4886 break;
4887
4888 case JSON_VALUE_OP:
4889 {
4890 JsonbValue *jbv = JsonPathValue(item, path, &empty,
4891 !throw_error ? &error : NULL,
4892 jsestate->args,
4893 jsexpr->column_name);
4894
4895 if (jbv == NULL)
4896 {
4897 /* Will be coerced with json_populate_type(), if needed. */
4898 *op->resvalue = (Datum) 0;
4899 *op->resnull = true;
4900 }
4901 else if (!error && !empty)
4902 {
4903 if (jsexpr->returning->typid == JSONOID ||
4904 jsexpr->returning->typid == JSONBOID)
4905 {
4906 val_string = DatumGetCString(DirectFunctionCall1(jsonb_out,
4907 JsonbPGetDatum(JsonbValueToJsonb(jbv))));
4908 }
4909 else if (jsexpr->use_json_coercion)
4910 {
4911 *op->resvalue = JsonbPGetDatum(JsonbValueToJsonb(jbv));
4912 *op->resnull = false;
4913 }
4914 else
4915 {
4916 val_string = ExecGetJsonValueItemString(jbv, op->resnull);
4917
4918 /*
4919 * Simply convert to the default RETURNING type (text)
4920 * if no coercion needed.
4921 */
4922 if (!jsexpr->use_io_coercion)
4923 *op->resvalue = DirectFunctionCall1(textin,
4924 CStringGetDatum(val_string));
4925 }
4926 }
4927 break;
4928 }
4929
4930 /* JSON_TABLE_OP can't happen here */
4931
4932 default:
4933 elog(ERROR, "unrecognized SQL/JSON expression op %d",
4934 (int) jsexpr->op);
4935 return false;
4936 }
4937
4938 /*
4939 * Coerce the result value to the RETURNING type by calling its input
4940 * function.
4941 */
4942 if (!*op->resnull && jsexpr->use_io_coercion)
4943 {
4944 FunctionCallInfo fcinfo;
4945
4946 Assert(jump_eval_coercion == -1);
4947 fcinfo = jsestate->input_fcinfo;
4948 Assert(fcinfo != NULL);
4949 Assert(val_string != NULL);
4950 fcinfo->args[0].value = PointerGetDatum(val_string);
4951 fcinfo->args[0].isnull = *op->resnull;
4952
4953 /*
4954 * Second and third arguments are already set up in
4955 * ExecInitJsonExpr().
4956 */
4957
4958 fcinfo->isnull = false;
4959 *op->resvalue = FunctionCallInvoke(fcinfo);
4960 if (SOFT_ERROR_OCCURRED(&jsestate->escontext))
4961 error = true;
4962 }
4963
4964 /*
4965 * When setting up the ErrorSaveContext (if needed) for capturing the
4966 * errors that occur when coercing the JsonBehavior expression, set
4967 * details_wanted to be able to show the actual error message as the
4968 * DETAIL of the error message that tells that it is the JsonBehavior
4969 * expression that caused the error; see ExecEvalJsonCoercionFinish().
4970 */
4971
4972 /* Handle ON EMPTY. */
4973 if (empty)
4974 {
4975 *op->resvalue = (Datum) 0;
4976 *op->resnull = true;
4977 if (jsexpr->on_empty)
4978 {
4979 if (jsexpr->on_empty->btype != JSON_BEHAVIOR_ERROR)
4980 {
4981 jsestate->empty.value = BoolGetDatum(true);
4982 /* Set up to catch coercion errors of the ON EMPTY value. */
4983 jsestate->escontext.error_occurred = false;
4984 jsestate->escontext.details_wanted = true;
4985 /* Jump to end if the ON EMPTY behavior is to return NULL */
4986 return jsestate->jump_empty >= 0 ? jsestate->jump_empty : jsestate->jump_end;
4987 }
4988 }
4989 else if (jsexpr->on_error->btype != JSON_BEHAVIOR_ERROR)
4990 {
4991 jsestate->error.value = BoolGetDatum(true);
4992 /* Set up to catch coercion errors of the ON ERROR value. */
4993 jsestate->escontext.error_occurred = false;
4994 jsestate->escontext.details_wanted = true;
4995 Assert(!throw_error);
4996 /* Jump to end if the ON ERROR behavior is to return NULL */
4997 return jsestate->jump_error >= 0 ? jsestate->jump_error : jsestate->jump_end;
4998 }
4999
5000 if (jsexpr->column_name)
5001 ereport(ERROR,
5002 errcode(ERRCODE_NO_SQL_JSON_ITEM),
5003 errmsg("no SQL/JSON item found for specified path of column \"%s\"",
5004 jsexpr->column_name));
5005 else
5006 ereport(ERROR,
5007 errcode(ERRCODE_NO_SQL_JSON_ITEM),
5008 errmsg("no SQL/JSON item found for specified path"));
5009 }
5010
5011 /*
5012 * ON ERROR. Wouldn't get here if the behavior is ERROR, because they
5013 * would have already been thrown.
5014 */
5015 if (error)
5016 {
5017 Assert(!throw_error);
5018 *op->resvalue = (Datum) 0;
5019 *op->resnull = true;
5020 jsestate->error.value = BoolGetDatum(true);
5021 /* Set up to catch coercion errors of the ON ERROR value. */
5022 jsestate->escontext.error_occurred = false;
5023 jsestate->escontext.details_wanted = true;
5024 /* Jump to end if the ON ERROR behavior is to return NULL */
5025 return jsestate->jump_error >= 0 ? jsestate->jump_error : jsestate->jump_end;
5026 }
5027
5028 return jump_eval_coercion >= 0 ? jump_eval_coercion : jsestate->jump_end;
5029}
5030
5031/*
5032 * Convert the given JsonbValue to its C string representation
5033 *
5034 * *resnull is set if the JsonbValue is a jbvNull.
5035 */
5036static char *
5037ExecGetJsonValueItemString(JsonbValue *item, bool *resnull)
5038{
5039 *resnull = false;
5040
5041 /* get coercion state reference and datum of the corresponding SQL type */
5042 switch (item->type)
5043 {
5044 case jbvNull:
5045 *resnull = true;
5046 return NULL;
5047
5048 case jbvString:
5049 {
5050 char *str = palloc(item->val.string.len + 1);
5051
5052 memcpy(str, item->val.string.val, item->val.string.len);
5053 str[item->val.string.len] = '\0';
5054 return str;
5055 }
5056
5057 case jbvNumeric:
5058 return DatumGetCString(DirectFunctionCall1(numeric_out,
5059 NumericGetDatum(item->val.numeric)));
5060
5061 case jbvBool:
5062 return DatumGetCString(DirectFunctionCall1(boolout,
5063 BoolGetDatum(item->val.boolean)));
5064
5065 case jbvDatetime:
5066 switch (item->val.datetime.typid)
5067 {
5068 case DATEOID:
5069 return DatumGetCString(DirectFunctionCall1(date_out,
5070 item->val.datetime.value));
5071 case TIMEOID:
5072 return DatumGetCString(DirectFunctionCall1(time_out,
5073 item->val.datetime.value));
5074 case TIMETZOID:
5075 return DatumGetCString(DirectFunctionCall1(timetz_out,
5076 item->val.datetime.value));
5077 case TIMESTAMPOID:
5078 return DatumGetCString(DirectFunctionCall1(timestamp_out,
5079 item->val.datetime.value));
5080 case TIMESTAMPTZOID:
5081 return DatumGetCString(DirectFunctionCall1(timestamptz_out,
5082 item->val.datetime.value));
5083 default:
5084 elog(ERROR, "unexpected jsonb datetime type oid %u",
5085 item->val.datetime.typid);
5086 }
5087 break;
5088
5089 case jbvArray:
5090 case jbvObject:
5091 case jbvBinary:
5092 return DatumGetCString(DirectFunctionCall1(jsonb_out,
5093 JsonbPGetDatum(JsonbValueToJsonb(item))));
5094
5095 default:
5096 elog(ERROR, "unexpected jsonb value type %d", item->type);
5097 }
5098
5099 Assert(false);
5100 *resnull = true;
5101 return NULL;
5102}
5103
5104/*
5105 * Coerce a jsonb value produced by ExecEvalJsonExprPath() or an ON ERROR /
5106 * ON EMPTY behavior expression to the target type.
5107 *
5108 * Any soft errors that occur here will be checked by
5109 * EEOP_JSONEXPR_COERCION_FINISH that will run after this.
5110 */
5111void
5112ExecEvalJsonCoercion(ExprState *state, ExprEvalStep *op,
5113 ExprContext *econtext)
5114{
5115 ErrorSaveContext *escontext = op->d.jsonexpr_coercion.escontext;
5116
5117 /*
5118 * Prepare to call json_populate_type() to coerce the boolean result of
5119 * JSON_EXISTS_OP to the target type. If the target type is integer or a
5120 * domain over integer, call the boolean-to-integer cast function instead,
5121 * because the integer's input function (which is what
5122 * json_populate_type() calls to coerce to scalar target types) doesn't
5123 * accept boolean literals as valid input. We only have a special case
5124 * for integer and domains thereof as it seems common to use those types
5125 * for EXISTS columns in JSON_TABLE().
5126 */
5127 if (op->d.jsonexpr_coercion.exists_coerce)
5128 {
5129 if (op->d.jsonexpr_coercion.exists_cast_to_int)
5130 {
5131 /* Check domain constraints if any. */
5132 if (op->d.jsonexpr_coercion.exists_check_domain &&
5133 !domain_check_safe(*op->resvalue, *op->resnull,
5134 op->d.jsonexpr_coercion.targettype,
5135 &op->d.jsonexpr_coercion.json_coercion_cache,
5136 econtext->ecxt_per_query_memory,
5137 (Node *) escontext))
5138 {
5139 *op->resnull = true;
5140 *op->resvalue = (Datum) 0;
5141 }
5142 else
5143 *op->resvalue = DirectFunctionCall1(bool_int4, *op->resvalue);
5144 return;
5145 }
5146
5147 *op->resvalue = DirectFunctionCall1(jsonb_in,
5148 DatumGetBool(*op->resvalue) ?
5149 CStringGetDatum("true") :
5150 CStringGetDatum("false"));
5151 }
5152
5153 *op->resvalue = json_populate_type(*op->resvalue, JSONBOID,
5154 op->d.jsonexpr_coercion.targettype,
5155 op->d.jsonexpr_coercion.targettypmod,
5156 &op->d.jsonexpr_coercion.json_coercion_cache,
5157 econtext->ecxt_per_query_memory,
5158 op->resnull,
5159 op->d.jsonexpr_coercion.omit_quotes,
5160 (Node *) escontext);
5161}
5162
5163static char *
5164GetJsonBehaviorValueString(JsonBehavior *behavior)
5165{
5166 /*
5167 * The order of array elements must correspond to the order of
5168 * JsonBehaviorType members.
5169 */
5170 const char *behavior_names[] =
5171 {
5172 "NULL",
5173 "ERROR",
5174 "EMPTY",
5175 "TRUE",
5176 "FALSE",
5177 "UNKNOWN",
5178 "EMPTY ARRAY",
5179 "EMPTY OBJECT",
5180 "DEFAULT"
5181 };
5182
5183 return pstrdup(behavior_names[behavior->btype]);
5184}
5185
5186/*
5187 * Checks if an error occurred in ExecEvalJsonCoercion(). If so, this sets
5188 * JsonExprState.error to trigger the ON ERROR handling steps, unless the
5189 * error is thrown when coercing a JsonBehavior value.
5190 */
5191void
5192ExecEvalJsonCoercionFinish(ExprState *state, ExprEvalStep *op)
5193{
5194 JsonExprState *jsestate = op->d.jsonexpr.jsestate;
5195
5196 if (SOFT_ERROR_OCCURRED(&jsestate->escontext))
5197 {
5198 /*
5199 * jsestate->error or jsestate->empty being set means that the error
5200 * occurred when coercing the JsonBehavior value. Throw the error in
5201 * that case with the actual coercion error message shown in the
5202 * DETAIL part.
5203 */
5204 if (DatumGetBool(jsestate->error.value))
5205 ereport(ERROR,
5206 (errcode(ERRCODE_DATATYPE_MISMATCH),
5207 /*- translator: first %s is a SQL/JSON clause (e.g. ON ERROR) */
5208 errmsg("could not coerce %s expression (%s) to the RETURNING type",
5209 "ON ERROR",
5210 GetJsonBehaviorValueString(jsestate->jsexpr->on_error)),
5211 errdetail("%s", jsestate->escontext.error_data->message)));
5212 else if (DatumGetBool(jsestate->empty.value))
5213 ereport(ERROR,
5214 (errcode(ERRCODE_DATATYPE_MISMATCH),
5215 /*- translator: first %s is a SQL/JSON clause (e.g. ON ERROR) */
5216 errmsg("could not coerce %s expression (%s) to the RETURNING type",
5217 "ON EMPTY",
5218 GetJsonBehaviorValueString(jsestate->jsexpr->on_empty)),
5219 errdetail("%s", jsestate->escontext.error_data->message)));
5220
5221 *op->resvalue = (Datum) 0;
5222 *op->resnull = true;
5223
5224 jsestate->error.value = BoolGetDatum(true);
5225
5226 /*
5227 * Reset for next use such as for catching errors when coercing a
5228 * JsonBehavior expression.
5229 */
5230 jsestate->escontext.error_occurred = false;
5231 jsestate->escontext.details_wanted = true;
5232 }
5233}
5234
5235/*
5236 * ExecEvalGroupingFunc
5237 *
5238 * Computes a bitmask with a bit for each (unevaluated) argument expression
5239 * (rightmost arg is least significant bit).
5240 *
5241 * A bit is set if the corresponding expression is NOT part of the set of
5242 * grouping expressions in the current grouping set.
5243 */
5244void
5245ExecEvalGroupingFunc(ExprState *state, ExprEvalStep *op)
5246{
5247 AggState *aggstate = castNode(AggState, state->parent);
5248 int result = 0;
5249 Bitmapset *grouped_cols = aggstate->grouped_cols;
5250 ListCell *lc;
5251
5252 foreach(lc, op->d.grouping_func.clauses)
5253 {
5254 int attnum = lfirst_int(lc);
5255
5256 result <<= 1;
5257
5258 if (!bms_is_member(attnum, grouped_cols))
5259 result |= 1;
5260 }
5261
5262 *op->resvalue = Int32GetDatum(result);
5263 *op->resnull = false;
5264}
5265
5266/*
5267 * ExecEvalMergeSupportFunc
5268 *
5269 * Returns information about the current MERGE action for its RETURNING list.
5270 */
5271void
5272ExecEvalMergeSupportFunc(ExprState *state, ExprEvalStep *op,
5273 ExprContext *econtext)
5274{
5275 ModifyTableState *mtstate = castNode(ModifyTableState, state->parent);
5276 MergeActionState *relaction = mtstate->mt_merge_action;
5277
5278 if (!relaction)
5279 elog(ERROR, "no merge action in progress");
5280
5281 /* Return the MERGE action ("INSERT", "UPDATE", or "DELETE") */
5282 switch (relaction->mas_action->commandType)
5283 {
5284 case CMD_INSERT:
5285 *op->resvalue = PointerGetDatum(cstring_to_text_with_len("INSERT", 6));
5286 *op->resnull = false;
5287 break;
5288 case CMD_UPDATE:
5289 *op->resvalue = PointerGetDatum(cstring_to_text_with_len("UPDATE", 6));
5290 *op->resnull = false;
5291 break;
5292 case CMD_DELETE:
5293 *op->resvalue = PointerGetDatum(cstring_to_text_with_len("DELETE", 6));
5294 *op->resnull = false;
5295 break;
5296 case CMD_NOTHING:
5297 elog(ERROR, "unexpected merge action: DO NOTHING");
5298 break;
5299 default:
5300 elog(ERROR, "unrecognized commandType: %d",
5301 (int) relaction->mas_action->commandType);
5302 }
5303}
5304
5305/*
5306 * Hand off evaluation of a subplan to nodeSubplan.c
5307 */
5308void
5309ExecEvalSubPlan(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
5310{
5311 SubPlanState *sstate = op->d.subplan.sstate;
5312
5313 /* could potentially be nested, so make sure there's enough stack */
5314 check_stack_depth();
5315
5316 *op->resvalue = ExecSubPlan(sstate, econtext, op->resnull);
5317}
5318
5319/*
5320 * Evaluate a wholerow Var expression.
5321 *
5322 * Returns a Datum whose value is the value of a whole-row range variable
5323 * with respect to given expression context.
5324 */
5325void
5326ExecEvalWholeRowVar(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
5327{
5328 Var *variable = op->d.wholerow.var;
5329 TupleTableSlot *slot = NULL;
5330 TupleDesc output_tupdesc;
5331 MemoryContext oldcontext;
5332 HeapTupleHeader dtuple;
5333 HeapTuple tuple;
5334
5335 /* This was checked by ExecInitExpr */
5336 Assert(variable->varattno == InvalidAttrNumber);
5337
5338 /* Get the input slot we want */
5339 switch (variable->varno)
5340 {
5341 case INNER_VAR:
5342 /* get the tuple from the inner node */
5343 slot = econtext->ecxt_innertuple;
5344 break;
5345
5346 case OUTER_VAR:
5347 /* get the tuple from the outer node */
5348 slot = econtext->ecxt_outertuple;
5349 break;
5350
5351 /* INDEX_VAR is handled by default case */
5352
5353 default:
5354
5355 /*
5356 * Get the tuple from the relation being scanned.
5357 *
5358 * By default, this uses the "scan" tuple slot, but a wholerow Var
5359 * in the RETURNING list may explicitly refer to OLD/NEW. If the
5360 * OLD/NEW row doesn't exist, we just return NULL.
5361 */
5362 switch (variable->varreturningtype)
5363 {
5364 case VAR_RETURNING_DEFAULT:
5365 slot = econtext->ecxt_scantuple;
5366 break;
5367
5368 case VAR_RETURNING_OLD:
5369 if (state->flags & EEO_FLAG_OLD_IS_NULL)
5370 {
5371 *op->resvalue = (Datum) 0;
5372 *op->resnull = true;
5373 return;
5374 }
5375 slot = econtext->ecxt_oldtuple;
5376 break;
5377
5378 case VAR_RETURNING_NEW:
5379 if (state->flags & EEO_FLAG_NEW_IS_NULL)
5380 {
5381 *op->resvalue = (Datum) 0;
5382 *op->resnull = true;
5383 return;
5384 }
5385 slot = econtext->ecxt_newtuple;
5386 break;
5387 }
5388 break;
5389 }
5390
5391 /* Apply the junkfilter if any */
5392 if (op->d.wholerow.junkFilter != NULL)
5393 slot = ExecFilterJunk(op->d.wholerow.junkFilter, slot);
5394
5395 /*
5396 * If first time through, obtain tuple descriptor and check compatibility.
5397 *
5398 * XXX: It'd be great if this could be moved to the expression
5399 * initialization phase, but due to using slots that's currently not
5400 * feasible.
5401 */
5402 if (op->d.wholerow.first)
5403 {
5404 /* optimistically assume we don't need slow path */
5405 op->d.wholerow.slow = false;
5406
5407 /*
5408 * If the Var identifies a named composite type, we must check that
5409 * the actual tuple type is compatible with it.
5410 */
5411 if (variable->vartype != RECORDOID)
5412 {
5413 TupleDesc var_tupdesc;
5414 TupleDesc slot_tupdesc;
5415
5416 /*
5417 * We really only care about numbers of attributes and data types.
5418 * Also, we can ignore type mismatch on columns that are dropped
5419 * in the destination type, so long as (1) the physical storage
5420 * matches or (2) the actual column value is NULL. Case (1) is
5421 * helpful in some cases involving out-of-date cached plans, while
5422 * case (2) is expected behavior in situations such as an INSERT
5423 * into a table with dropped columns (the planner typically
5424 * generates an INT4 NULL regardless of the dropped column type).
5425 * If we find a dropped column and cannot verify that case (1)
5426 * holds, we have to use the slow path to check (2) for each row.
5427 *
5428 * If vartype is a domain over composite, just look through that
5429 * to the base composite type.
5430 */
5431 var_tupdesc = lookup_rowtype_tupdesc_domain(variable->vartype,
5432 -1, false);
5433
5434 slot_tupdesc = slot->tts_tupleDescriptor;
5435
5436 if (var_tupdesc->natts != slot_tupdesc->natts)
5437 ereport(ERROR,
5438 (errcode(ERRCODE_DATATYPE_MISMATCH),
5439 errmsg("table row type and query-specified row type do not match"),
5440 errdetail_plural("Table row contains %d attribute, but query expects %d.",
5441 "Table row contains %d attributes, but query expects %d.",
5442 slot_tupdesc->natts,
5443 slot_tupdesc->natts,
5444 var_tupdesc->natts)));
5445
5446 for (int i = 0; i < var_tupdesc->natts; i++)
5447 {
5448 Form_pg_attribute vattr = TupleDescAttr(var_tupdesc, i);
5449 Form_pg_attribute sattr = TupleDescAttr(slot_tupdesc, i);
5450
5451 if (vattr->atttypid == sattr->atttypid)
5452 continue; /* no worries */
5453 if (!vattr->attisdropped)
5454 ereport(ERROR,
5455 (errcode(ERRCODE_DATATYPE_MISMATCH),
5456 errmsg("table row type and query-specified row type do not match"),
5457 errdetail("Table has type %s at ordinal position %d, but query expects %s.",
5458 format_type_be(sattr->atttypid),
5459 i + 1,
5460 format_type_be(vattr->atttypid))));
5461
5462 if (vattr->attlen != sattr->attlen ||
5463 vattr->attalign != sattr->attalign)
5464 op->d.wholerow.slow = true; /* need to check for nulls */
5465 }
5466
5467 /*
5468 * Use the variable's declared rowtype as the descriptor for the
5469 * output values. In particular, we *must* absorb any
5470 * attisdropped markings.
5471 */
5472 oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
5473 output_tupdesc = CreateTupleDescCopy(var_tupdesc);
5474 MemoryContextSwitchTo(oldcontext);
5475
5476 ReleaseTupleDesc(var_tupdesc);
5477 }
5478 else
5479 {
5480 /*
5481 * In the RECORD case, we use the input slot's rowtype as the
5482 * descriptor for the output values, modulo possibly assigning new
5483 * column names below.
5484 */
5485 oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
5486 output_tupdesc = CreateTupleDescCopy(slot->tts_tupleDescriptor);
5487 MemoryContextSwitchTo(oldcontext);
5488
5489 /*
5490 * It's possible that the input slot is a relation scan slot and
5491 * so is marked with that relation's rowtype. But we're supposed
5492 * to be returning RECORD, so reset to that.
5493 */
5494 output_tupdesc->tdtypeid = RECORDOID;
5495 output_tupdesc->tdtypmod = -1;
5496
5497 /*
5498 * We already got the correct physical datatype info above, but
5499 * now we should try to find the source RTE and adopt its column
5500 * aliases, since it's unlikely that the input slot has the
5501 * desired names.
5502 *
5503 * If we can't locate the RTE, assume the column names we've got
5504 * are OK. (As of this writing, the only cases where we can't
5505 * locate the RTE are in execution of trigger WHEN clauses, and
5506 * then the Var will have the trigger's relation's rowtype, so its
5507 * names are fine.) Also, if the creator of the RTE didn't bother
5508 * to fill in an eref field, assume our column names are OK. (This
5509 * happens in COPY, and perhaps other places.)
5510 */
5511 if (econtext->ecxt_estate &&
5512 variable->varno <= econtext->ecxt_estate->es_range_table_size)
5513 {
5514 RangeTblEntry *rte = exec_rt_fetch(variable->varno,
5515 econtext->ecxt_estate);
5516
5517 if (rte->eref)
5518 ExecTypeSetColNames(output_tupdesc, rte->eref->colnames);
5519 }
5520 }
5521
5522 /* Bless the tupdesc if needed, and save it in the execution state */
5523 op->d.wholerow.tupdesc = BlessTupleDesc(output_tupdesc);
5524
5525 op->d.wholerow.first = false;
5526 }
5527
5528 /*
5529 * Make sure all columns of the slot are accessible in the slot's
5530 * Datum/isnull arrays.
5531 */
5532 slot_getallattrs(slot);
5533
5534 if (op->d.wholerow.slow)
5535 {
5536 /* Check to see if any dropped attributes are non-null */
5537 TupleDesc tupleDesc = slot->tts_tupleDescriptor;
5538 TupleDesc var_tupdesc = op->d.wholerow.tupdesc;
5539
5540 Assert(var_tupdesc->natts == tupleDesc->natts);
5541
5542 for (int i = 0; i < var_tupdesc->natts; i++)
5543 {
5544 CompactAttribute *vattr = TupleDescCompactAttr(var_tupdesc, i);
5545 CompactAttribute *sattr = TupleDescCompactAttr(tupleDesc, i);
5546
5547 if (!vattr->attisdropped)
5548 continue; /* already checked non-dropped cols */
5549 if (slot->tts_isnull[i])
5550 continue; /* null is always okay */
5551 if (vattr->attlen != sattr->attlen ||
5552 vattr->attalignby != sattr->attalignby)
5553 ereport(ERROR,
5554 (errcode(ERRCODE_DATATYPE_MISMATCH),
5555 errmsg("table row type and query-specified row type do not match"),
5556 errdetail("Physical storage mismatch on dropped attribute at ordinal position %d.",
5557 i + 1)));
5558 }
5559 }
5560
5561 /*
5562 * Build a composite datum, making sure any toasted fields get detoasted.
5563 *
5564 * (Note: it is critical that we not change the slot's state here.)
5565 */
5566 tuple = toast_build_flattened_tuple(slot->tts_tupleDescriptor,
5567 slot->tts_values,
5568 slot->tts_isnull);
5569 dtuple = tuple->t_data;
5570
5571 /*
5572 * Label the datum with the composite type info we identified before.
5573 *
5574 * (Note: we could skip doing this by passing op->d.wholerow.tupdesc to
5575 * the tuple build step; but that seems a tad risky so let's not.)
5576 */
5577 HeapTupleHeaderSetTypeId(dtuple, op->d.wholerow.tupdesc->tdtypeid);
5578 HeapTupleHeaderSetTypMod(dtuple, op->d.wholerow.tupdesc->tdtypmod);
5579
5580 *op->resvalue = PointerGetDatum(dtuple);
5581 *op->resnull = false;
5582}
5583
5584void
5585ExecEvalSysVar(ExprState *state, ExprEvalStep *op, ExprContext *econtext,
5586 TupleTableSlot *slot)
5587{
5588 Datum d;
5589
5590 /* OLD/NEW system attribute is NULL if OLD/NEW row is NULL */
5591 if ((op->d.var.varreturningtype == VAR_RETURNING_OLD &&
5592 state->flags & EEO_FLAG_OLD_IS_NULL) ||
5593 (op->d.var.varreturningtype == VAR_RETURNING_NEW &&
5594 state->flags & EEO_FLAG_NEW_IS_NULL))
5595 {
5596 *op->resvalue = (Datum) 0;
5597 *op->resnull = true;
5598 return;
5599 }
5600
5601 /* slot_getsysattr has sufficient defenses against bad attnums */
5602 d = slot_getsysattr(slot,
5603 op->d.var.attnum,
5604 op->resnull);
5605 *op->resvalue = d;
5606 /* this ought to be unreachable, but it's cheap enough to check */
5607 if (unlikely(*op->resnull))
5608 elog(ERROR, "failed to fetch attribute from slot");
5609}
5610
5611/*
5612 * Transition value has not been initialized. This is the first non-NULL input
5613 * value for a group. We use it as the initial value for transValue.
5614 */
5615void
5616ExecAggInitGroup(AggState *aggstate, AggStatePerTrans pertrans, AggStatePerGroup pergroup,
5617 ExprContext *aggcontext)
5618{
5619 FunctionCallInfo fcinfo = pertrans->transfn_fcinfo;
5620 MemoryContext oldContext;
5621
5622 /*
5623 * We must copy the datum into aggcontext if it is pass-by-ref. We do not
5624 * need to pfree the old transValue, since it's NULL. (We already checked
5625 * that the agg's input type is binary-compatible with its transtype, so
5626 * straight copy here is OK.)
5627 */
5628 oldContext = MemoryContextSwitchTo(aggcontext->ecxt_per_tuple_memory);
5629 pergroup->transValue = datumCopy(fcinfo->args[1].value,
5630 pertrans->transtypeByVal,
5631 pertrans->transtypeLen);
5632 pergroup->transValueIsNull = false;
5633 pergroup->noTransValue = false;
5634 MemoryContextSwitchTo(oldContext);
5635}
5636
5637/*
5638 * Ensure that the new transition value is stored in the aggcontext,
5639 * rather than the per-tuple context. This should be invoked only when
5640 * we know (a) the transition data type is pass-by-reference, and (b)
5641 * the newValue is distinct from the oldValue.
5642 *
5643 * NB: This can change the current memory context.
5644 *
5645 * We copy the presented newValue into the aggcontext, except when the datum
5646 * points to a R/W expanded object that is already a child of the aggcontext,
5647 * in which case we need not copy. We then delete the oldValue, if not null.
5648 *
5649 * If the presented datum points to a R/W expanded object that is a child of
5650 * some other context, ideally we would just reparent it under the aggcontext.
5651 * Unfortunately, that doesn't work easily, and it wouldn't help anyway for
5652 * aggregate-aware transfns. We expect that a transfn that deals in expanded
5653 * objects and is aware of the memory management conventions for aggregate
5654 * transition values will (1) on first call, return a R/W expanded object that
5655 * is already in the right context, allowing us to do nothing here, and (2) on
5656 * subsequent calls, modify and return that same object, so that control
5657 * doesn't even reach here. However, if we have a generic transfn that
5658 * returns a new R/W expanded object (probably in the per-tuple context),
5659 * reparenting that result would cause problems. We'd pass that R/W object to
5660 * the next invocation of the transfn, and then it would be at liberty to
5661 * change or delete that object, and if it deletes it then our own attempt to
5662 * delete the now-old transvalue afterwards would be a double free. We avoid
5663 * this problem by forcing the stored transvalue to always be a flat
5664 * non-expanded object unless the transfn is visibly doing aggregate-aware
5665 * memory management. This is somewhat inefficient, but the best answer to
5666 * that is to write a smarter transfn.
5667 */
5668Datum
5669ExecAggCopyTransValue(AggState *aggstate, AggStatePerTrans pertrans,
5670 Datum newValue, bool newValueIsNull,
5671 Datum oldValue, bool oldValueIsNull)
5672{
5673 Assert(newValue != oldValue);
5674
5675 if (!newValueIsNull)
5676 {
5677 MemoryContextSwitchTo(aggstate->curaggcontext->ecxt_per_tuple_memory);
5678 if (DatumIsReadWriteExpandedObject(newValue,
5679 false,
5680 pertrans->transtypeLen) &&
5681 MemoryContextGetParent(DatumGetEOHP(newValue)->eoh_context) == CurrentMemoryContext)
5682 /* do nothing */ ;
5683 else
5684 newValue = datumCopy(newValue,
5685 pertrans->transtypeByVal,
5686 pertrans->transtypeLen);
5687 }
5688 else
5689 {
5690 /*
5691 * Ensure that AggStatePerGroup->transValue ends up being 0, so
5692 * callers can safely compare newValue/oldValue without having to
5693 * check their respective nullness.
5694 */
5695 newValue = (Datum) 0;
5696 }
5697
5698 if (!oldValueIsNull)
5699 {
5700 if (DatumIsReadWriteExpandedObject(oldValue,
5701 false,
5702 pertrans->transtypeLen))
5703 DeleteExpandedObject(oldValue);
5704 else
5705 pfree(DatumGetPointer(oldValue));
5706 }
5707
5708 return newValue;
5709}
5710
5711/*
5712 * ExecEvalPreOrderedDistinctSingle
5713 * Returns true when the aggregate transition value Datum is distinct
5714 * from the previous input Datum and returns false when the input Datum
5715 * matches the previous input Datum.
5716 */
5717bool
5718ExecEvalPreOrderedDistinctSingle(AggState *aggstate, AggStatePerTrans pertrans)
5719{
5720 Datum value = pertrans->transfn_fcinfo->args[1].value;
5721 bool isnull = pertrans->transfn_fcinfo->args[1].isnull;
5722
5723 if (!pertrans->haslast ||
5724 pertrans->lastisnull != isnull ||
5725 (!isnull && !DatumGetBool(FunctionCall2Coll(&pertrans->equalfnOne,
5726 pertrans->aggCollation,
5727 pertrans->lastdatum, value))))
5728 {
5729 if (pertrans->haslast && !pertrans->inputtypeByVal &&
5730 !pertrans->lastisnull)
5731 pfree(DatumGetPointer(pertrans->lastdatum));
5732
5733 pertrans->haslast = true;
5734 if (!isnull)
5735 {
5736 MemoryContext oldContext;
5737
5738 oldContext = MemoryContextSwitchTo(aggstate->curaggcontext->ecxt_per_tuple_memory);
5739
5740 pertrans->lastdatum = datumCopy(value, pertrans->inputtypeByVal,
5741 pertrans->inputtypeLen);
5742
5743 MemoryContextSwitchTo(oldContext);
5744 }
5745 else
5746 pertrans->lastdatum = (Datum) 0;
5747 pertrans->lastisnull = isnull;
5748 return true;
5749 }
5750
5751 return false;
5752}
5753
5754/*
5755 * ExecEvalPreOrderedDistinctMulti
5756 * Returns true when the aggregate input is distinct from the previous
5757 * input and returns false when the input matches the previous input, or
5758 * when there was no previous input.
5759 */
5760bool
5761ExecEvalPreOrderedDistinctMulti(AggState *aggstate, AggStatePerTrans pertrans)
5762{
5763 ExprContext *tmpcontext = aggstate->tmpcontext;
5764 bool isdistinct = false; /* for now */
5765 TupleTableSlot *save_outer;
5766 TupleTableSlot *save_inner;
5767
5768 for (int i = 0; i < pertrans->numTransInputs; i++)
5769 {
5770 pertrans->sortslot->tts_values[i] = pertrans->transfn_fcinfo->args[i + 1].value;
5771 pertrans->sortslot->tts_isnull[i] = pertrans->transfn_fcinfo->args[i + 1].isnull;
5772 }
5773
5774 ExecClearTuple(pertrans->sortslot);
5775 pertrans->sortslot->tts_nvalid = pertrans->numInputs;
5776 ExecStoreVirtualTuple(pertrans->sortslot);
5777
5778 /* save the previous slots before we overwrite them */
5779 save_outer = tmpcontext->ecxt_outertuple;
5780 save_inner = tmpcontext->ecxt_innertuple;
5781
5782 tmpcontext->ecxt_outertuple = pertrans->sortslot;
5783 tmpcontext->ecxt_innertuple = pertrans->uniqslot;
5784
5785 if (!pertrans->haslast ||
5786 !ExecQual(pertrans->equalfnMulti, tmpcontext))
5787 {
5788 if (pertrans->haslast)
5789 ExecClearTuple(pertrans->uniqslot);
5790
5791 pertrans->haslast = true;
5792 ExecCopySlot(pertrans->uniqslot, pertrans->sortslot);
5793
5794 isdistinct = true;
5795 }
5796
5797 /* restore the original slots */
5798 tmpcontext->ecxt_outertuple = save_outer;
5799 tmpcontext->ecxt_innertuple = save_inner;
5800
5801 return isdistinct;
5802}
5803
5804/*
5805 * Invoke ordered transition function, with a datum argument.
5806 */
5807void
5808ExecEvalAggOrderedTransDatum(ExprState *state, ExprEvalStep *op,
5809 ExprContext *econtext)
5810{
5811 AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
5812 int setno = op->d.agg_trans.setno;
5813
5814 tuplesort_putdatum(pertrans->sortstates[setno],
5815 *op->resvalue, *op->resnull);
5816}
5817
5818/*
5819 * Invoke ordered transition function, with a tuple argument.
5820 */
5821void
5833
5834/* implementation of transition function invocation for byval types */
5835static pg_attribute_always_inline void
5836ExecAggPlainTransByVal(AggState *aggstate, AggStatePerTrans pertrans,
5837 AggStatePerGroup pergroup,
5838 ExprContext *aggcontext, int setno)
5839{
5840 FunctionCallInfo fcinfo = pertrans->transfn_fcinfo;
5841 MemoryContext oldContext;
5842 Datum newVal;
5843
5844 /* cf. select_current_set() */
5845 aggstate->curaggcontext = aggcontext;
5846 aggstate->current_set = setno;
5847
5848 /* set up aggstate->curpertrans for AggGetAggref() */
5849 aggstate->curpertrans = pertrans;
5850
5851 /* invoke transition function in per-tuple context */
5852 oldContext = MemoryContextSwitchTo(aggstate->tmpcontext->ecxt_per_tuple_memory);
5853
5854 fcinfo->args[0].value = pergroup->transValue;
5855 fcinfo->args[0].isnull = pergroup->transValueIsNull;
5856 fcinfo->isnull = false; /* just in case transfn doesn't set it */
5857
5858 newVal = FunctionCallInvoke(fcinfo);
5859
5860 pergroup->transValue = newVal;
5861 pergroup->transValueIsNull = fcinfo->isnull;
5862
5863 MemoryContextSwitchTo(oldContext);
5864}
5865
5866/* implementation of transition function invocation for byref types */
5867static pg_attribute_always_inline void
5868ExecAggPlainTransByRef(AggState *aggstate, AggStatePerTrans pertrans,
5869 AggStatePerGroup pergroup,
5870 ExprContext *aggcontext, int setno)
5871{
5872 FunctionCallInfo fcinfo = pertrans->transfn_fcinfo;
5873 MemoryContext oldContext;
5874 Datum newVal;
5875
5876 /* cf. select_current_set() */
5877 aggstate->curaggcontext = aggcontext;
5878 aggstate->current_set = setno;
5879
5880 /* set up aggstate->curpertrans for AggGetAggref() */
5881 aggstate->curpertrans = pertrans;
5882
5883 /* invoke transition function in per-tuple context */
5884 oldContext = MemoryContextSwitchTo(aggstate->tmpcontext->ecxt_per_tuple_memory);
5885
5886 fcinfo->args[0].value = pergroup->transValue;
5887 fcinfo->args[0].isnull = pergroup->transValueIsNull;
5888 fcinfo->isnull = false; /* just in case transfn doesn't set it */
5889
5890 newVal = FunctionCallInvoke(fcinfo);
5891
5892 /*
5893 * For pass-by-ref datatype, must copy the new value into aggcontext and
5894 * free the prior transValue. But if transfn returned a pointer to its
5895 * first input, we don't need to do anything.
5896 *
5897 * It's safe to compare newVal with pergroup->transValue without regard
5898 * for either being NULL, because ExecAggCopyTransValue takes care to set
5899 * transValue to 0 when NULL. Otherwise we could end up accidentally not
5900 * reparenting, when the transValue has the same numerical value as
5901 * newValue, despite being NULL. This is a somewhat hot path, making it
5902 * undesirable to instead solve this with another branch for the common
5903 * case of the transition function returning its (modified) input
5904 * argument.
5905 */
5906 if (DatumGetPointer(newVal) != DatumGetPointer(pergroup->transValue))
5907 newVal = ExecAggCopyTransValue(aggstate, pertrans,
5908 newVal, fcinfo->isnull,
5909 pergroup->transValue,
5910 pergroup->transValueIsNull);
5911
5912 pergroup->transValue = newVal;
5913 pergroup->transValueIsNull = fcinfo->isnull;
5914
5915 MemoryContextSwitchTo(oldContext);
5916}
DatumGetArrayTypePCopy
#define DatumGetArrayTypePCopy(X)
Definition array.h:262
ARR_NDIM
#define ARR_NDIM(a)
Definition array.h:290
ARR_DATA_PTR
#define ARR_DATA_PTR(a)
Definition array.h:322
MAXDIM
#define MAXDIM
Definition array.h:75
ARR_NULLBITMAP
#define ARR_NULLBITMAP(a)
Definition array.h:300
ARR_OVERHEAD_WITHNULLS
#define ARR_OVERHEAD_WITHNULLS(ndims, nitems)
Definition array.h:312
DatumGetArrayTypeP
#define DatumGetArrayTypeP(X)
Definition array.h:261
ARR_ELEMTYPE
#define ARR_ELEMTYPE(a)
Definition array.h:292
ARR_SIZE
#define ARR_SIZE(a)
Definition array.h:289
ARR_OVERHEAD_NONULLS
#define ARR_OVERHEAD_NONULLS(ndims)
Definition array.h:310
ARR_DATA_OFFSET
#define ARR_DATA_OFFSET(a)
Definition array.h:316
ARR_DIMS
#define ARR_DIMS(a)
Definition array.h:294
ARR_HASNULL
#define ARR_HASNULL(a)
Definition array.h:291
ARR_LBOUND
#define ARR_LBOUND(a)
Definition array.h:296
construct_empty_array
ArrayType * construct_empty_array(Oid elmtype)
Definition arrayfuncs.c:3581
array_map
Datum array_map(Datum arrayd, ExprState *exprstate, ExprContext *econtext, Oid retType, ArrayMapState *amstate)
Definition arrayfuncs.c:3202
construct_md_array
ArrayType * construct_md_array(Datum *elems, bool *nulls, int ndims, int *dims, int *lbs, Oid elmtype, int elmlen, bool elmbyval, char elmalign)
Definition arrayfuncs.c:3495
array_bitmap_copy
void array_bitmap_copy(bits8 *destbitmap, int destoffset, const bits8 *srcbitmap, int srcoffset, int nitems)
Definition arrayfuncs.c:4967
ArrayGetNItems
int ArrayGetNItems(int ndim, const int *dims)
Definition arrayutils.c:57
ArrayCheckBounds
void ArrayCheckBounds(int ndim, const int *dims, const int *lb)
Definition arrayutils.c:117
AttrNumber
int16 AttrNumber
Definition attnum.h:21
InvalidAttrNumber
#define InvalidAttrNumber
Definition attnum.h:23
current_database
Datum current_database(PG_FUNCTION_ARGS)
Definition misc.c:209
numeric_out
Datum numeric_out(PG_FUNCTION_ARGS)
Definition numeric.c:799
GetSQLLocalTimestamp
Timestamp GetSQLLocalTimestamp(int32 typmod)
Definition timestamp.c:1677
timestamptz_out
Datum timestamptz_out(PG_FUNCTION_ARGS)
Definition timestamp.c:776
timestamp_out
Datum timestamp_out(PG_FUNCTION_ARGS)
Definition timestamp.c:234
GetSQLCurrentTimestamp
TimestampTz GetSQLCurrentTimestamp(int32 typmod)
Definition timestamp.c:1663
bms_is_member
bool bms_is_member(int x, const Bitmapset *a)
Definition bitmapset.c:510
boolout
Datum boolout(PG_FUNCTION_ARGS)
Definition bool.c:158
values
static Datum values[MAXATTR]
Definition bootstrap.c:155
likely
#define likely(x)
Definition c.h:411
PG_USED_FOR_ASSERTS_ONLY
#define PG_USED_FOR_ASSERTS_ONLY
Definition c.h:223
Assert
#define Assert(condition)
Definition c.h:873
int64
int64_t int64
Definition c.h:543
pg_attribute_always_inline
#define pg_attribute_always_inline
Definition c.h:279
int16
int16_t int16
Definition c.h:541
bits8
uint8 bits8
Definition c.h:553
int32
int32_t int32
Definition c.h:542
pg_unreachable
#define pg_unreachable()
Definition c.h:341
unlikely
#define unlikely(x)
Definition c.h:412
uint32
uint32_t uint32
Definition c.h:546
lengthof
#define lengthof(array)
Definition c.h:803
StaticAssertDecl
#define StaticAssertDecl(condition, errmessage)
Definition c.h:942
OidIsValid
#define OidIsValid(objectId)
Definition c.h:788
CompareType
CompareType
Definition cmptype.h:32
COMPARE_LE
@ COMPARE_LE
Definition cmptype.h:35
COMPARE_GT
@ COMPARE_GT
Definition cmptype.h:38
COMPARE_GE
@ COMPARE_GE
Definition cmptype.h:37
COMPARE_LT
@ COMPARE_LT
Definition cmptype.h:34
nextval_internal
int64 nextval_internal(Oid relid, bool check_permissions)
Definition sequence.c:624
GetSQLLocalTime
TimeADT GetSQLLocalTime(int32 typmod)
Definition date.c:371
date_out
Datum date_out(PG_FUNCTION_ARGS)
Definition date.c:186
time_out
Datum time_out(PG_FUNCTION_ARGS)
Definition date.c:1597
GetSQLCurrentDate
DateADT GetSQLCurrentDate(void)
Definition date.c:318
GetSQLCurrentTime
TimeTzADT * GetSQLCurrentTime(int32 typmod)
Definition date.c:351
timetz_out
Datum timetz_out(PG_FUNCTION_ARGS)
Definition date.c:2410
DateADTGetDatum
static Datum DateADTGetDatum(DateADT X)
Definition date.h:78
TimeTzADTPGetDatum
static Datum TimeTzADTPGetDatum(const TimeTzADT *X)
Definition date.h:90
TimeADTGetDatum
static Datum TimeADTGetDatum(TimeADT X)
Definition date.h:84
datumCopy
Datum datumCopy(Datum value, bool typByVal, int typLen)
Definition datum.c:132
errdatatype
int errdatatype(Oid datatypeOid)
Definition domains.c:407
errdomainconstraint
int errdomainconstraint(Oid datatypeOid, const char *conname)
Definition domains.c:431
domain_check_safe
bool domain_check_safe(Datum value, bool isnull, Oid domainType, void **extra, MemoryContext mcxt, Node *escontext)
Definition domains.c:355
errdetail
int errdetail(const char *fmt,...)
Definition elog.c:1216
errdetail_plural
int errdetail_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...)
Definition elog.c:1308
errcode
int errcode(int sqlerrcode)
Definition elog.c:863
errmsg
int errmsg(const char *fmt,...)
Definition elog.c:1080
errsave
#define errsave(context,...)
Definition elog.h:262
ERROR
#define ERROR
Definition elog.h:39
elog
#define elog(elevel,...)
Definition elog.h:226
ereport
#define ereport(elevel,...)
Definition elog.h:150
ExecEvalParamExtern
void ExecEvalParamExtern(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:3070
ExecEvalFieldStoreForm
void ExecEvalFieldStoreForm(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:3904
ExecEvalGroupingFunc
void ExecEvalGroupingFunc(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:5245
CheckVarSlotCompatibility
static void CheckVarSlotCompatibility(TupleTableSlot *slot, int attnum, Oid vartype)
Definition execExprInterp.c:2378
ExecEvalRow
void ExecEvalRow(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:3656
ExecJustVarVirtImpl
static pg_attribute_always_inline Datum ExecJustVarVirtImpl(ExprState *state, TupleTableSlot *slot, bool *isnull)
Definition execExprInterp.c:2679
ExecJustAssignVarImpl
static pg_attribute_always_inline Datum ExecJustAssignVarImpl(ExprState *state, TupleTableSlot *inslot, bool *isnull)
Definition execExprInterp.c:2584
ExecEvalFieldStoreDeForm
void ExecEvalFieldStoreDeForm(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:3854
ExecEvalCurrentOfExpr
void ExecEvalCurrentOfExpr(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:3262
ExecEvalSQLValueFunction
void ExecEvalSQLValueFunction(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:3195
EEO_SWITCH
#define EEO_SWITCH()
Definition execExprInterp.c:124
ExecEvalRowNull
void ExecEvalRowNull(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:3299
EEO_DISPATCH
#define EEO_DISPATCH()
Definition execExprInterp.c:126
ExecEvalArrayExpr
void ExecEvalArrayExpr(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:3401
ExecEvalParamSet
void ExecEvalParamSet(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:3113
ExecJustAssignInnerVarVirt
static Datum ExecJustAssignInnerVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2744
GetJsonBehaviorValueString
static char * GetJsonBehaviorValueString(JsonBehavior *behavior)
Definition execExprInterp.c:5164
ExecEvalCoerceViaIOSafe
void ExecEvalCoerceViaIOSafe(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:3135
ExecJustScanVarVirt
static Datum ExecJustScanVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2715
ExecJustApplyFuncToCase
static Datum ExecJustApplyFuncToCase(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2631
ExecInterpExprStillValid
Datum ExecInterpExprStillValid(ExprState *state, ExprContext *econtext, bool *isNull)
Definition execExprInterp.c:2287
ExecAggPlainTransByVal
static pg_attribute_always_inline void ExecAggPlainTransByVal(AggState *aggstate, AggStatePerTrans pertrans, AggStatePerGroup pergroup, ExprContext *aggcontext, int setno)
Definition execExprInterp.c:5836
ExecJustAssignScanVar
static Datum ExecJustAssignScanVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2624
ExecJustHashVarImpl
static pg_attribute_always_inline Datum ExecJustHashVarImpl(ExprState *state, TupleTableSlot *slot, bool *isnull)
Definition execExprInterp.c:2801
ExecEvalConvertRowtype
void ExecEvalConvertRowtype(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:3928
ExecJustHashInnerVarVirt
static Datum ExecJustHashInnerVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2859
ExecEvalPreOrderedDistinctMulti
bool ExecEvalPreOrderedDistinctMulti(AggState *aggstate, AggStatePerTrans pertrans)
Definition execExprInterp.c:5761
ExecEvalFieldSelect
void ExecEvalFieldSelect(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:3729
ExecJustInnerVarVirt
static Datum ExecJustInnerVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2701
ExecJustHashInnerVarWithIV
static Datum ExecJustHashInnerVarWithIV(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2767
ExecEvalJsonExprPath
int ExecEvalJsonExprPath(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:4835
ExecEvalConstraintNotNull
void ExecEvalConstraintNotNull(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:4408
ExecInitInterpreter
static void ExecInitInterpreter(void)
Definition execExprInterp.c:2928
EEO_NEXT
#define EEO_NEXT()
Definition execExprInterp.c:131
ExecEvalScalarArrayOp
void ExecEvalScalarArrayOp(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:4023
ExecEvalAggOrderedTransDatum
void ExecEvalAggOrderedTransDatum(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:5808
ExecJustConst
static Datum ExecJustConst(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2669
ExecJustOuterVar
static Datum ExecJustOuterVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2570
ExecEvalParamExec
void ExecEvalParamExec(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:3048
ExecEvalJsonCoercion
void ExecEvalJsonCoercion(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:5112
ExecAggInitGroup
void ExecAggInitGroup(AggState *aggstate, AggStatePerTrans pertrans, AggStatePerGroup pergroup, ExprContext *aggcontext)
Definition execExprInterp.c:5616
ExecJustAssignVarVirtImpl
static pg_attribute_always_inline Datum ExecJustAssignVarVirtImpl(ExprState *state, TupleTableSlot *inslot, bool *isnull)
Definition execExprInterp.c:2722
ExecEvalNextValueExpr
void ExecEvalNextValueExpr(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:3273
ExecEvalSysVar
void ExecEvalSysVar(ExprState *state, ExprEvalStep *op, ExprContext *econtext, TupleTableSlot *slot)
Definition execExprInterp.c:5585
saop_hash_element_match
static bool saop_hash_element_match(struct saophash_hash *tb, Datum key1, Datum key2)
Definition execExprInterp.c:4195
ExecEvalMinMax
void ExecEvalMinMax(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:3676
ExecEvalSubPlan
void ExecEvalSubPlan(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:5309
ExecEvalJsonIsPredicate
void ExecEvalJsonIsPredicate(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:4735
saop_element_hash
static uint32 saop_element_hash(struct saophash_hash *tb, Datum key)
Definition execExprInterp.c:4176
ExecJustInnerVar
static Datum ExecJustInnerVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2563
ExecAggCopyTransValue
Datum ExecAggCopyTransValue(AggState *aggstate, AggStatePerTrans pertrans, Datum newValue, bool newValueIsNull, Datum oldValue, bool oldValueIsNull)
Definition execExprInterp.c:5669
ExecJustAssignInnerVar
static Datum ExecJustAssignInnerVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2610
ExecJustHashOuterVarVirt
static Datum ExecJustHashOuterVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2867
ExecEvalMergeSupportFunc
void ExecEvalMergeSupportFunc(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:5272
CheckExprStillValid
void CheckExprStillValid(ExprState *state, ExprContext *econtext)
Definition execExprInterp.c:2307
ExecEvalJsonConstructor
void ExecEvalJsonConstructor(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:4657
ExecEvalWholeRowVar
void ExecEvalWholeRowVar(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:5326
ExecEvalHashedScalarArrayOp
void ExecEvalHashedScalarArrayOp(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:4226
ExecEvalJsonCoercionFinish
void ExecEvalJsonCoercionFinish(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:5192
ExecJustHashVarVirtImpl
static pg_attribute_always_inline Datum ExecJustHashVarVirtImpl(ExprState *state, TupleTableSlot *slot, bool *isnull)
Definition execExprInterp.c:2839
ExecReadyInterpretedExpr
void ExecReadyInterpretedExpr(ExprState *state)
Definition execExprInterp.c:242
ExecGetJsonValueItemString
static char * ExecGetJsonValueItemString(JsonbValue *item, bool *resnull)
Definition execExprInterp.c:5037
ExecJustAssignScanVarVirt
static Datum ExecJustAssignScanVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2758
ExecEvalRowNullInt
static void ExecEvalRowNullInt(ExprState *state, ExprEvalStep *op, ExprContext *econtext, bool checkisnull)
Definition execExprInterp.c:3315
ExecEvalRowNotNull
void ExecEvalRowNotNull(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:3308
ExecJustHashOuterVarStrict
static Datum ExecJustHashOuterVarStrict(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2877
ExecEvalStepOp
ExprEvalOp ExecEvalStepOp(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:2960
ExecJustAssignOuterVar
static Datum ExecJustAssignOuterVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2617
ExecJustHashOuterVar
static Datum ExecJustHashOuterVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2825
ExecJustAssignOuterVarVirt
static Datum ExecJustAssignOuterVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2751
ExecEvalConstraintCheck
void ExecEvalConstraintCheck(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:4422
ExecEvalArrayCoerce
void ExecEvalArrayCoerce(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:3615
CheckOpSlotCompatibility
static void CheckOpSlotCompatibility(ExprEvalStep *op, TupleTableSlot *slot)
Definition execExprInterp.c:2433
ExecEvalFuncExprStrictFusage
void ExecEvalFuncExprStrictFusage(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:3011
ExecJustOuterVarVirt
static Datum ExecJustOuterVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2708
ExecJustScanVar
static Datum ExecJustScanVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2577
EEO_CASE
#define EEO_CASE(name)
Definition execExprInterp.c:125
ExecInterpExpr
static Datum ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:460
ExecJustVarImpl
static pg_attribute_always_inline Datum ExecJustVarImpl(ExprState *state, TupleTableSlot *slot, bool *isnull)
Definition execExprInterp.c:2546
ExecEvalFuncExprFusage
void ExecEvalFuncExprFusage(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:2990
ExecEvalXmlExpr
void ExecEvalXmlExpr(ExprState *state, ExprEvalStep *op)
Definition execExprInterp.c:4442
ExecEvalPreOrderedDistinctSingle
bool ExecEvalPreOrderedDistinctSingle(AggState *aggstate, AggStatePerTrans pertrans)
Definition execExprInterp.c:5718
EEO_OPCODE
#define EEO_OPCODE(opcode)
Definition execExprInterp.c:127
ExecAggPlainTransByRef
static pg_attribute_always_inline void ExecAggPlainTransByRef(AggState *aggstate, AggStatePerTrans pertrans, AggStatePerGroup pergroup, ExprContext *aggcontext, int setno)
Definition execExprInterp.c:5868
ExecEvalAggOrderedTransTuple
void ExecEvalAggOrderedTransTuple(ExprState *state, ExprEvalStep *op, ExprContext *econtext)
Definition execExprInterp.c:5822
get_cached_rowtype
static TupleDesc get_cached_rowtype(Oid type_id, int32 typmod, ExprEvalRowtypeCache *rowcache, bool *changed)
Definition execExprInterp.c:2480
ExecJustHashInnerVar
static Datum ExecJustHashInnerVar(ExprState *state, ExprContext *econtext, bool *isnull)
Definition execExprInterp.c:2832
EEO_JUMP
#define EEO_JUMP(stepno)
Definition execExprInterp.c:137
EEO_FLAG_INTERPRETER_INITIALIZED
#define EEO_FLAG_INTERPRETER_INITIALIZED
Definition execExpr.h:29
EEO_FLAG_DIRECT_THREADED
#define EEO_FLAG_DIRECT_THREADED
Definition execExpr.h:31
ExprEvalOp
ExprEvalOp
Definition execExpr.h:67
EEOP_OLD_VAR
@ EEOP_OLD_VAR
Definition execExpr.h:85
EEOP_ASSIGN_TMP
@ EEOP_ASSIGN_TMP
Definition execExpr.h:110
EEOP_SUBPLAN
@ EEOP_SUBPLAN
Definition execExpr.h:275
EEOP_CONVERT_ROWTYPE
@ EEOP_CONVERT_ROWTYPE
Definition execExpr.h:262
EEOP_FUNCEXPR_STRICT_FUSAGE
@ EEOP_FUNCEXPR_STRICT_FUSAGE
Definition execExpr.h:127
EEOP_ARRAYEXPR
@ EEOP_ARRAYEXPR
Definition execExpr.h:196
EEOP_JSONEXPR_PATH
@ EEOP_JSONEXPR_PATH
Definition execExpr.h:268
EEOP_NOT_DISTINCT
@ EEOP_NOT_DISTINCT
Definition execExpr.h:190
EEOP_DOMAIN_TESTVAL
@ EEOP_DOMAIN_TESTVAL
Definition execExpr.h:245
EEOP_PARAM_EXTERN
@ EEOP_PARAM_EXTERN
Definition execExpr.h:174
EEOP_HASHDATUM_NEXT32_STRICT
@ EEOP_HASHDATUM_NEXT32_STRICT
Definition execExpr.h:259
EEOP_IOCOERCE_SAFE
@ EEOP_IOCOERCE_SAFE
Definition execExpr.h:188
EEOP_BOOL_AND_STEP
@ EEOP_BOOL_AND_STEP
Definition execExpr.h:136
EEOP_DONE_RETURN
@ EEOP_DONE_RETURN
Definition execExpr.h:69
EEOP_WHOLEROW
@ EEOP_WHOLEROW
Definition execExpr.h:96
EEOP_JSONEXPR_COERCION_FINISH
@ EEOP_JSONEXPR_COERCION_FINISH
Definition execExpr.h:270
EEOP_HASHDATUM_FIRST_STRICT
@ EEOP_HASHDATUM_FIRST_STRICT
Definition execExpr.h:257
EEOP_AGGREF
@ EEOP_AGGREF
Definition execExpr.h:271
EEOP_FUNCEXPR_STRICT_1
@ EEOP_FUNCEXPR_STRICT_1
Definition execExpr.h:124
EEOP_INNER_VAR
@ EEOP_INNER_VAR
Definition execExpr.h:82
EEOP_AGG_PLAIN_PERGROUP_NULLCHECK
@ EEOP_AGG_PLAIN_PERGROUP_NULLCHECK
Definition execExpr.h:283
EEOP_HASHDATUM_NEXT32
@ EEOP_HASHDATUM_NEXT32
Definition execExpr.h:258
EEOP_ROWCOMPARE_FINAL
@ EEOP_ROWCOMPARE_FINAL
Definition execExpr.h:207
EEOP_AGG_STRICT_DESERIALIZE
@ EEOP_AGG_STRICT_DESERIALIZE
Definition execExpr.h:278
EEOP_IOCOERCE
@ EEOP_IOCOERCE
Definition execExpr.h:187
EEOP_RETURNINGEXPR
@ EEOP_RETURNINGEXPR
Definition execExpr.h:195
EEOP_GROUPING_FUNC
@ EEOP_GROUPING_FUNC
Definition execExpr.h:272
EEOP_DOMAIN_CHECK
@ EEOP_DOMAIN_CHECK
Definition execExpr.h:252
EEOP_BOOLTEST_IS_NOT_FALSE
@ EEOP_BOOLTEST_IS_NOT_FALSE
Definition execExpr.h:170
EEOP_PARAM_SET
@ EEOP_PARAM_SET
Definition execExpr.h:177
EEOP_NEXTVALUEEXPR
@ EEOP_NEXTVALUEEXPR
Definition execExpr.h:194
EEOP_NEW_SYSVAR
@ EEOP_NEW_SYSVAR
Definition execExpr.h:93
EEOP_AGG_PLAIN_TRANS_BYREF
@ EEOP_AGG_PLAIN_TRANS_BYREF
Definition execExpr.h:289
EEOP_QUAL
@ EEOP_QUAL
Definition execExpr.h:148
EEOP_AGG_PRESORTED_DISTINCT_MULTI
@ EEOP_AGG_PRESORTED_DISTINCT_MULTI
Definition execExpr.h:291
EEOP_AGG_PLAIN_TRANS_BYVAL
@ EEOP_AGG_PLAIN_TRANS_BYVAL
Definition execExpr.h:286
EEOP_SCAN_VAR
@ EEOP_SCAN_VAR
Definition execExpr.h:84
EEOP_CASE_TESTVAL_EXT
@ EEOP_CASE_TESTVAL_EXT
Definition execExpr.h:181
EEOP_BOOL_NOT_STEP
@ EEOP_BOOL_NOT_STEP
Definition execExpr.h:145
EEOP_ASSIGN_SCAN_VAR
@ EEOP_ASSIGN_SCAN_VAR
Definition execExpr.h:105
EEOP_NEW_VAR
@ EEOP_NEW_VAR
Definition execExpr.h:86
EEOP_SCAN_SYSVAR
@ EEOP_SCAN_SYSVAR
Definition execExpr.h:91
EEOP_SCALARARRAYOP
@ EEOP_SCALARARRAYOP
Definition execExpr.h:263
EEOP_DOMAIN_NOTNULL
@ EEOP_DOMAIN_NOTNULL
Definition execExpr.h:249
EEOP_WINDOW_FUNC
@ EEOP_WINDOW_FUNC
Definition execExpr.h:273
EEOP_INNER_FETCHSOME
@ EEOP_INNER_FETCHSOME
Definition execExpr.h:75
EEOP_NULLTEST_ROWISNOTNULL
@ EEOP_NULLTEST_ROWISNOTNULL
Definition execExpr.h:164
EEOP_ASSIGN_OUTER_VAR
@ EEOP_ASSIGN_OUTER_VAR
Definition execExpr.h:104
EEOP_ROW
@ EEOP_ROW
Definition execExpr.h:198
EEOP_MAKE_READONLY
@ EEOP_MAKE_READONLY
Definition execExpr.h:184
EEOP_FIELDSTORE_FORM
@ EEOP_FIELDSTORE_FORM
Definition execExpr.h:226
EEOP_ASSIGN_OLD_VAR
@ EEOP_ASSIGN_OLD_VAR
Definition execExpr.h:106
EEOP_SBSREF_SUBSCRIPTS
@ EEOP_SBSREF_SUBSCRIPTS
Definition execExpr.h:229
EEOP_FUNCEXPR_STRICT_2
@ EEOP_FUNCEXPR_STRICT_2
Definition execExpr.h:125
EEOP_SBSREF_FETCH
@ EEOP_SBSREF_FETCH
Definition execExpr.h:242
EEOP_FUNCEXPR_STRICT
@ EEOP_FUNCEXPR_STRICT
Definition execExpr.h:123
EEOP_NULLIF
@ EEOP_NULLIF
Definition execExpr.h:191
EEOP_CURRENTOFEXPR
@ EEOP_CURRENTOFEXPR
Definition execExpr.h:193
EEOP_INNER_SYSVAR
@ EEOP_INNER_SYSVAR
Definition execExpr.h:89
EEOP_ASSIGN_TMP_MAKE_RO
@ EEOP_ASSIGN_TMP_MAKE_RO
Definition execExpr.h:112
EEOP_CONST
@ EEOP_CONST
Definition execExpr.h:115
EEOP_BOOL_OR_STEP_LAST
@ EEOP_BOOL_OR_STEP_LAST
Definition execExpr.h:142
EEOP_JSONEXPR_COERCION
@ EEOP_JSONEXPR_COERCION
Definition execExpr.h:269
EEOP_BOOL_OR_STEP_FIRST
@ EEOP_BOOL_OR_STEP_FIRST
Definition execExpr.h:140
EEOP_XMLEXPR
@ EEOP_XMLEXPR
Definition execExpr.h:265
EEOP_AGG_STRICT_INPUT_CHECK_NULLS
@ EEOP_AGG_STRICT_INPUT_CHECK_NULLS
Definition execExpr.h:282
EEOP_SBSREF_ASSIGN
@ EEOP_SBSREF_ASSIGN
Definition execExpr.h:239
EEOP_OUTER_SYSVAR
@ EEOP_OUTER_SYSVAR
Definition execExpr.h:90
EEOP_ASSIGN_INNER_VAR
@ EEOP_ASSIGN_INNER_VAR
Definition execExpr.h:103
EEOP_BOOL_OR_STEP
@ EEOP_BOOL_OR_STEP
Definition execExpr.h:141
EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1
@ EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1
Definition execExpr.h:281
EEOP_OUTER_FETCHSOME
@ EEOP_OUTER_FETCHSOME
Definition execExpr.h:76
EEOP_AGG_STRICT_INPUT_CHECK_ARGS
@ EEOP_AGG_STRICT_INPUT_CHECK_ARGS
Definition execExpr.h:280
EEOP_NULLTEST_ROWISNULL
@ EEOP_NULLTEST_ROWISNULL
Definition execExpr.h:163
EEOP_BOOLTEST_IS_TRUE
@ EEOP_BOOLTEST_IS_TRUE
Definition execExpr.h:167
EEOP_FUNCEXPR
@ EEOP_FUNCEXPR
Definition execExpr.h:122
EEOP_NULLTEST_ISNOTNULL
@ EEOP_NULLTEST_ISNOTNULL
Definition execExpr.h:160
EEOP_ROWCOMPARE_STEP
@ EEOP_ROWCOMPARE_STEP
Definition execExpr.h:204
EEOP_MERGE_SUPPORT_FUNC
@ EEOP_MERGE_SUPPORT_FUNC
Definition execExpr.h:274
EEOP_AGG_DESERIALIZE
@ EEOP_AGG_DESERIALIZE
Definition execExpr.h:279
EEOP_LAST
@ EEOP_LAST
Definition execExpr.h:296
EEOP_HASHDATUM_FIRST
@ EEOP_HASHDATUM_FIRST
Definition execExpr.h:256
EEOP_DISTINCT
@ EEOP_DISTINCT
Definition execExpr.h:189
EEOP_JUMP_IF_NOT_TRUE
@ EEOP_JUMP_IF_NOT_TRUE
Definition execExpr.h:156
EEOP_FUNCEXPR_FUSAGE
@ EEOP_FUNCEXPR_FUSAGE
Definition execExpr.h:126
EEOP_AGG_PRESORTED_DISTINCT_SINGLE
@ EEOP_AGG_PRESORTED_DISTINCT_SINGLE
Definition execExpr.h:290
EEOP_BOOL_AND_STEP_FIRST
@ EEOP_BOOL_AND_STEP_FIRST
Definition execExpr.h:135
EEOP_JUMP
@ EEOP_JUMP
Definition execExpr.h:151
EEOP_DONE_NO_RETURN
@ EEOP_DONE_NO_RETURN
Definition execExpr.h:72
EEOP_PARAM_CALLBACK
@ EEOP_PARAM_CALLBACK
Definition execExpr.h:175
EEOP_DOMAIN_TESTVAL_EXT
@ EEOP_DOMAIN_TESTVAL_EXT
Definition execExpr.h:246
EEOP_OLD_SYSVAR
@ EEOP_OLD_SYSVAR
Definition execExpr.h:92
EEOP_BOOL_AND_STEP_LAST
@ EEOP_BOOL_AND_STEP_LAST
Definition execExpr.h:137
EEOP_NEW_FETCHSOME
@ EEOP_NEW_FETCHSOME
Definition execExpr.h:79
EEOP_AGG_ORDERED_TRANS_DATUM
@ EEOP_AGG_ORDERED_TRANS_DATUM
Definition execExpr.h:292
EEOP_OLD_FETCHSOME
@ EEOP_OLD_FETCHSOME
Definition execExpr.h:78
EEOP_ASSIGN_NEW_VAR
@ EEOP_ASSIGN_NEW_VAR
Definition execExpr.h:107
EEOP_SBSREF_OLD
@ EEOP_SBSREF_OLD
Definition execExpr.h:236
EEOP_SQLVALUEFUNCTION
@ EEOP_SQLVALUEFUNCTION
Definition execExpr.h:192
EEOP_HASHDATUM_SET_INITVAL
@ EEOP_HASHDATUM_SET_INITVAL
Definition execExpr.h:255
EEOP_JUMP_IF_NOT_NULL
@ EEOP_JUMP_IF_NOT_NULL
Definition execExpr.h:155
EEOP_AGG_PLAIN_TRANS_STRICT_BYREF
@ EEOP_AGG_PLAIN_TRANS_STRICT_BYREF
Definition execExpr.h:288
EEOP_FIELDSTORE_DEFORM
@ EEOP_FIELDSTORE_DEFORM
Definition execExpr.h:219
EEOP_BOOLTEST_IS_FALSE
@ EEOP_BOOLTEST_IS_FALSE
Definition execExpr.h:169
EEOP_BOOLTEST_IS_NOT_TRUE
@ EEOP_BOOLTEST_IS_NOT_TRUE
Definition execExpr.h:168
EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL
@ EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL
Definition execExpr.h:284
EEOP_PARAM_EXEC
@ EEOP_PARAM_EXEC
Definition execExpr.h:173
EEOP_JSON_CONSTRUCTOR
@ EEOP_JSON_CONSTRUCTOR
Definition execExpr.h:266
EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL
@ EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL
Definition execExpr.h:285
EEOP_NULLTEST_ISNULL
@ EEOP_NULLTEST_ISNULL
Definition execExpr.h:159
EEOP_MINMAX
@ EEOP_MINMAX
Definition execExpr.h:210
EEOP_JUMP_IF_NULL
@ EEOP_JUMP_IF_NULL
Definition execExpr.h:154
EEOP_ARRAYCOERCE
@ EEOP_ARRAYCOERCE
Definition execExpr.h:197
EEOP_FIELDSELECT
@ EEOP_FIELDSELECT
Definition execExpr.h:213
EEOP_CASE_TESTVAL
@ EEOP_CASE_TESTVAL
Definition execExpr.h:180
EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF
@ EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF
Definition execExpr.h:287
EEOP_HASHED_SCALARARRAYOP
@ EEOP_HASHED_SCALARARRAYOP
Definition execExpr.h:264
EEOP_OUTER_VAR
@ EEOP_OUTER_VAR
Definition execExpr.h:83
EEOP_AGG_ORDERED_TRANS_TUPLE
@ EEOP_AGG_ORDERED_TRANS_TUPLE
Definition execExpr.h:293
EEOP_SCAN_FETCHSOME
@ EEOP_SCAN_FETCHSOME
Definition execExpr.h:77
EEOP_IS_JSON
@ EEOP_IS_JSON
Definition execExpr.h:267
ExecFilterJunk
TupleTableSlot * ExecFilterJunk(JunkFilter *junkfilter, TupleTableSlot *slot)
Definition execJunk.c:247
BlessTupleDesc
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
Definition execTuples.c:2260
TTSOpsVirtual
const TupleTableSlotOps TTSOpsVirtual
Definition execTuples.c:84
ExecStoreVirtualTuple
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition execTuples.c:1741
ExecTypeSetColNames
void ExecTypeSetColNames(TupleDesc typeInfo, List *namesList)
Definition execTuples.c:2219
TTSOpsBufferHeapTuple
const TupleTableSlotOps TTSOpsBufferHeapTuple
Definition execTuples.c:87
TTSOpsHeapTuple
const TupleTableSlotOps TTSOpsHeapTuple
Definition execTuples.c:85
ExprStateEvalFunc
Datum(* ExprStateEvalFunc)(ExprState *expression, ExprContext *econtext, bool *isNull)
Definition execnodes.h:70
EEO_FLAG_NEW_IS_NULL
#define EEO_FLAG_NEW_IS_NULL
Definition execnodes.h:84
EEO_FLAG_OLD_IS_NULL
#define EEO_FLAG_OLD_IS_NULL
Definition execnodes.h:82
exec_rt_fetch
static RangeTblEntry * exec_rt_fetch(Index rti, EState *estate)
Definition executor.h:697
ExecQual
static bool ExecQual(ExprState *state, ExprContext *econtext)
Definition executor.h:519
DatumGetEOHP
ExpandedObjectHeader * DatumGetEOHP(Datum d)
Definition expandeddatum.c:29
DeleteExpandedObject
void DeleteExpandedObject(Datum d)
Definition expandeddatum.c:136
MakeExpandedObjectReadOnlyInternal
Datum MakeExpandedObjectReadOnlyInternal(Datum d)
Definition expandeddatum.c:95
DatumIsReadWriteExpandedObject
#define DatumIsReadWriteExpandedObject(d, isnull, typlen)
Definition expandeddatum.h:151
expanded_record_get_field
static Datum expanded_record_get_field(ExpandedRecordHeader *erh, int fnumber, bool *isnull)
Definition expandedrecord.h:228
ER_MAGIC
#define ER_MAGIC
Definition expandedrecord.h:40
expanded_record_get_tupdesc
static TupleDesc expanded_record_get_tupdesc(ExpandedRecordHeader *erh)
Definition expandedrecord.h:218
MaxAllocSize
#define MaxAllocSize
Definition fe_memutils.h:22
FunctionCall2Coll
Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
Definition fmgr.c:1150
fmgr_info
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Definition fmgr.c:128
DatumGetHeapTupleHeader
#define DatumGetHeapTupleHeader(X)
Definition fmgr.h:296
DatumGetTextPP
#define DatumGetTextPP(X)
Definition fmgr.h:293
SizeForFunctionCallInfo
#define SizeForFunctionCallInfo(nargs)
Definition fmgr.h:102
InitFunctionCallInfoData
#define InitFunctionCallInfoData(Fcinfo, Flinfo, Nargs, Collation, Context, Resultinfo)
Definition fmgr.h:150
DirectFunctionCall1
#define DirectFunctionCall1(func, arg1)
Definition fmgr.h:684
LOCAL_FCINFO
#define LOCAL_FCINFO(name, nargs)
Definition fmgr.h:110
FunctionCallInvoke
#define FunctionCallInvoke(fcinfo)
Definition fmgr.h:172
fmgr_info_set_expr
#define fmgr_info_set_expr(expr, finfo)
Definition fmgr.h:135
DatumGetTextP
#define DatumGetTextP(X)
Definition fmgr.h:333
format_type_be
char * format_type_be(Oid type_oid)
Definition format_type.c:343
HeapTupleGetDatum
static Datum HeapTupleGetDatum(const HeapTupleData *tuple)
Definition funcapi.h:230
newval
#define newval
str
const char * str
Definition hashfn_unstable.h:261
toast_build_flattened_tuple
HeapTuple toast_build_flattened_tuple(TupleDesc tupleDesc, const Datum *values, const bool *isnull)
Definition heaptoast.c:563
heap_form_tuple
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition heaptuple.c:1117
heap_attisnull
bool heap_attisnull(HeapTuple tup, int attnum, TupleDesc tupleDesc)
Definition heaptuple.c:456
heap_deform_tuple
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition heaptuple.c:1346
heap_copy_tuple_as_datum
Datum heap_copy_tuple_as_datum(HeapTuple tuple, TupleDesc tupleDesc)
Definition heaptuple.c:1081
heap_getattr
static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition htup_details.h:904
HeapTupleHeaderSetTypMod
static void HeapTupleHeaderSetTypMod(HeapTupleHeaderData *tup, int32 typmod)
Definition htup_details.h:522
HeapTupleHeaderGetTypMod
static int32 HeapTupleHeaderGetTypMod(const HeapTupleHeaderData *tup)
Definition htup_details.h:516
HeapTupleHeaderSetTypeId
static void HeapTupleHeaderSetTypeId(HeapTupleHeaderData *tup, Oid datum_typeid)
Definition htup_details.h:510
HeapTupleHeaderGetDatumLength
static uint32 HeapTupleHeaderGetDatumLength(const HeapTupleHeaderData *tup)
Definition htup_details.h:492
HeapTupleHeaderGetTypeId
static Oid HeapTupleHeaderGetTypeId(const HeapTupleHeaderData *tup)
Definition htup_details.h:504
nitems
#define nitems(x)
Definition indent.h:31
val_string
char * val_string
Definition informix.c:694
value
static struct @172 value
bool_int4
Datum bool_int4(PG_FUNCTION_ARGS)
Definition int.c:372
b
int b
Definition isn.c:74
a
int a
Definition isn.c:73
i
int i
Definition isn.c:77
ItemPointerSetInvalid
static void ItemPointerSetInvalid(ItemPointerData *pointer)
Definition itemptr.h:184
json_build_array_worker
Datum json_build_array_worker(int nargs, const Datum *args, const bool *nulls, const Oid *types, bool absent_on_null)
Definition json.c:1346
json_build_object_worker
Datum json_build_object_worker(int nargs, const Datum *args, const bool *nulls, const Oid *types, bool absent_on_null, bool unique_keys)
Definition json.c:1226
datum_to_json
Datum datum_to_json(Datum val, JsonTypeCategory tcategory, Oid outfuncoid)
Definition json.c:764
json_validate
bool json_validate(text *json, bool check_unique_keys, bool throw_error)
Definition json.c:1814
JSON_TOKEN_FALSE
@ JSON_TOKEN_FALSE
Definition jsonapi.h:29
JSON_TOKEN_TRUE
@ JSON_TOKEN_TRUE
Definition jsonapi.h:28
JSON_TOKEN_NULL
@ JSON_TOKEN_NULL
Definition jsonapi.h:30
JSON_TOKEN_OBJECT_START
@ JSON_TOKEN_OBJECT_START
Definition jsonapi.h:22
JSON_TOKEN_NUMBER
@ JSON_TOKEN_NUMBER
Definition jsonapi.h:21
JSON_TOKEN_STRING
@ JSON_TOKEN_STRING
Definition jsonapi.h:20
JSON_TOKEN_ARRAY_START
@ JSON_TOKEN_ARRAY_START
Definition jsonapi.h:24
jsonb_from_text
Datum jsonb_from_text(text *js, bool unique_keys)
Definition jsonb.c:140
jsonb_build_array_worker
Datum jsonb_build_array_worker(int nargs, const Datum *args, const bool *nulls, const Oid *types, bool absent_on_null)
Definition jsonb.c:1247
jsonb_in
Datum jsonb_in(PG_FUNCTION_ARGS)
Definition jsonb.c:65
jsonb_out
Datum jsonb_out(PG_FUNCTION_ARGS)
Definition jsonb.c:100
jsonb_build_object_worker
Datum jsonb_build_object_worker(int nargs, const Datum *args, const bool *nulls, const Oid *types, bool absent_on_null, bool unique_keys)
Definition jsonb.c:1162
datum_to_jsonb
Datum datum_to_jsonb(Datum val, JsonTypeCategory tcategory, Oid outfuncoid)
Definition jsonb.c:1149
jbvObject
@ jbvObject
Definition jsonb.h:236
jbvNumeric
@ jbvNumeric
Definition jsonb.h:232
jbvBool
@ jbvBool
Definition jsonb.h:233
jbvArray
@ jbvArray
Definition jsonb.h:235
jbvBinary
@ jbvBinary
Definition jsonb.h:238
jbvNull
@ jbvNull
Definition jsonb.h:230
jbvDatetime
@ jbvDatetime
Definition jsonb.h:246
jbvString
@ jbvString
Definition jsonb.h:231
JB_ROOT_IS_OBJECT
#define JB_ROOT_IS_OBJECT(jbp_)
Definition jsonb.h:223
JsonbPGetDatum
static Datum JsonbPGetDatum(const Jsonb *p)
Definition jsonb.h:413
JB_ROOT_IS_ARRAY
#define JB_ROOT_IS_ARRAY(jbp_)
Definition jsonb.h:224
DatumGetJsonbP
static Jsonb * DatumGetJsonbP(Datum d)
Definition jsonb.h:401
JB_ROOT_IS_SCALAR
#define JB_ROOT_IS_SCALAR(jbp_)
Definition jsonb.h:222
JsonbValueToJsonb
Jsonb * JsonbValueToJsonb(JsonbValue *val)
Definition jsonb_util.c:96
json_populate_type
Datum json_populate_type(Datum json_val, Oid json_type, Oid typid, int32 typmod, void **cache, MemoryContext mcxt, bool *isnull, bool omit_quotes, Node *escontext)
Definition jsonfuncs.c:3342
json_get_first_token
JsonTokenType json_get_first_token(text *json, bool throw_error)
Definition jsonfuncs.c:5937
JsonTypeCategory
JsonTypeCategory
Definition jsonfuncs.h:69
DatumGetJsonPathP
static JsonPath * DatumGetJsonPathP(Datum d)
Definition jsonpath.h:35
JsonPathExists
bool JsonPathExists(Datum jb, JsonPath *jp, bool *error, List *vars)
Definition jsonpath_exec.c:3891
JsonPathQuery
Datum JsonPathQuery(Datum jb, JsonPath *jp, JsonWrapper wrapper, bool *empty, bool *error, List *vars, const char *column_name)
Definition jsonpath_exec.c:3914
JsonPathValue
JsonbValue * JsonPathValue(Datum jb, JsonPath *jp, bool *empty, bool *error, List *vars, const char *column_name)
Definition jsonpath_exec.c:4008
lappend
List * lappend(List *list, void *datum)
Definition list.c:339
get_typlenbyvalalign
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
Definition lsyscache.c:2421
pstrdup
char * pstrdup(const char *in)
Definition mcxt.c:1781
pfree
void pfree(void *pointer)
Definition mcxt.c:1616
palloc0
void * palloc0(Size size)
Definition mcxt.c:1417
palloc
void * palloc(Size size)
Definition mcxt.c:1387
CurrentMemoryContext
MemoryContext CurrentMemoryContext
Definition mcxt.c:160
MemoryContextGetParent
MemoryContext MemoryContextGetParent(MemoryContext context)
Definition mcxt.c:780
AllocSizeIsValid
#define AllocSizeIsValid(size)
Definition memutils.h:42
SOFT_ERROR_OCCURRED
#define SOFT_ERROR_OCCURRED(escontext)
Definition miscnodes.h:53
current_user
Datum current_user(PG_FUNCTION_ARGS)
Definition name.c:263
session_user
Datum session_user(PG_FUNCTION_ARGS)
Definition name.c:269
current_schema
Datum current_schema(PG_FUNCTION_ARGS)
Definition name.c:279
exprType
Oid exprType(const Node *expr)
Definition nodeFuncs.c:42
ExecSetParamPlan
void ExecSetParamPlan(SubPlanState *node, ExprContext *econtext)
Definition nodeSubplan.c:1118
ExecSubPlan
Datum ExecSubPlan(SubPlanState *node, ExprContext *econtext, bool *isNull)
Definition nodeSubplan.c:59
IsA
#define IsA(nodeptr, _type_)
Definition nodes.h:164
CMD_INSERT
@ CMD_INSERT
Definition nodes.h:277
CMD_DELETE
@ CMD_DELETE
Definition nodes.h:278
CMD_UPDATE
@ CMD_UPDATE
Definition nodes.h:276
CMD_NOTHING
@ CMD_NOTHING
Definition nodes.h:282
castNode
#define castNode(_type_, nodeptr)
Definition nodes.h:182
NumericGetDatum
static Datum NumericGetDatum(Numeric X)
Definition numeric.h:76
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition palloc.h:124
attnum
int16 attnum
Definition pg_attribute.h:74
Form_pg_attribute
FormData_pg_attribute * Form_pg_attribute
Definition pg_attribute.h:202
arg
void * arg
Definition pg_backup_utils.c:29
pg_rotate_left32
static uint32 pg_rotate_left32(uint32 word, int n)
Definition pg_bitutils.h:395
data
const void * data
Definition pg_crc32c_sse42.c:27
lfirst
#define lfirst(lc)
Definition pg_list.h:172
list_length
static int list_length(const List *l)
Definition pg_list.h:152
NIL
#define NIL
Definition pg_list.h:68
forboth
#define forboth(cell1, list1, cell2, list2)
Definition pg_list.h:518
lfirst_int
#define lfirst_int(lc)
Definition pg_list.h:173
buf
static char buf[DEFAULT_XLOG_SEG_SIZE]
Definition pg_test_fsync.c:71
pg_type.h
typalign
char typalign
Definition pg_type.h:176
pgstat_init_function_usage
void pgstat_init_function_usage(FunctionCallInfo fcinfo, PgStat_FunctionCallUsage *fcu)
Definition pgstat_function.c:72
pgstat_end_function_usage
void pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, bool finalize)
Definition pgstat_function.c:146
qsort
#define qsort(a, b, c, d)
Definition port.h:495
DatumGetUInt32
static uint32 DatumGetUInt32(Datum X)
Definition postgres.h:232
Int64GetDatum
static Datum Int64GetDatum(int64 X)
Definition postgres.h:423
DatumGetBool
static bool DatumGetBool(Datum X)
Definition postgres.h:100
PointerGetDatum
static Datum PointerGetDatum(const void *X)
Definition postgres.h:352
Int16GetDatum
static Datum Int16GetDatum(int16 X)
Definition postgres.h:182
BoolGetDatum
static Datum BoolGetDatum(bool X)
Definition postgres.h:112
DatumGetCString
static char * DatumGetCString(Datum X)
Definition postgres.h:365
Datum
uint64_t Datum
Definition postgres.h:70
DatumGetPointer
static Pointer DatumGetPointer(Datum X)
Definition postgres.h:342
CStringGetDatum
static Datum CStringGetDatum(const char *X)
Definition postgres.h:380
Int32GetDatum
static Datum Int32GetDatum(int32 X)
Definition postgres.h:222
UInt32GetDatum
static Datum UInt32GetDatum(uint32 X)
Definition postgres.h:242
DatumGetInt32
static int32 DatumGetInt32(Datum X)
Definition postgres.h:212
InvalidOid
#define InvalidOid
Definition postgres_ext.h:37
Oid
unsigned int Oid
Definition postgres_ext.h:32
e
e
Definition preproc-init.c:82
fb
static int fb(int x)
Definition preproc-init.c:92
JS_FORMAT_JSONB
@ JS_FORMAT_JSONB
Definition primnodes.h:1665
MinMaxOp
MinMaxOp
Definition primnodes.h:1526
IS_LEAST
@ IS_LEAST
Definition primnodes.h:1528
IS_GREATEST
@ IS_GREATEST
Definition primnodes.h:1527
SVFOP_CURRENT_CATALOG
@ SVFOP_CURRENT_CATALOG
Definition primnodes.h:1574
SVFOP_LOCALTIME_N
@ SVFOP_LOCALTIME_N
Definition primnodes.h:1567
SVFOP_CURRENT_TIMESTAMP
@ SVFOP_CURRENT_TIMESTAMP
Definition primnodes.h:1564
SVFOP_LOCALTIME
@ SVFOP_LOCALTIME
Definition primnodes.h:1566
SVFOP_CURRENT_TIMESTAMP_N
@ SVFOP_CURRENT_TIMESTAMP_N
Definition primnodes.h:1565
SVFOP_CURRENT_ROLE
@ SVFOP_CURRENT_ROLE
Definition primnodes.h:1570
SVFOP_USER
@ SVFOP_USER
Definition primnodes.h:1572
SVFOP_CURRENT_SCHEMA
@ SVFOP_CURRENT_SCHEMA
Definition primnodes.h:1575
SVFOP_LOCALTIMESTAMP_N
@ SVFOP_LOCALTIMESTAMP_N
Definition primnodes.h:1569
SVFOP_CURRENT_DATE
@ SVFOP_CURRENT_DATE
Definition primnodes.h:1561
SVFOP_CURRENT_TIME_N
@ SVFOP_CURRENT_TIME_N
Definition primnodes.h:1563
SVFOP_CURRENT_TIME
@ SVFOP_CURRENT_TIME
Definition primnodes.h:1562
SVFOP_LOCALTIMESTAMP
@ SVFOP_LOCALTIMESTAMP
Definition primnodes.h:1568
SVFOP_CURRENT_USER
@ SVFOP_CURRENT_USER
Definition primnodes.h:1571
SVFOP_SESSION_USER
@ SVFOP_SESSION_USER
Definition primnodes.h:1573
IS_DOCUMENT
@ IS_DOCUMENT
Definition primnodes.h:1612
IS_XMLFOREST
@ IS_XMLFOREST
Definition primnodes.h:1607
IS_XMLCONCAT
@ IS_XMLCONCAT
Definition primnodes.h:1605
IS_XMLPI
@ IS_XMLPI
Definition primnodes.h:1609
IS_XMLPARSE
@ IS_XMLPARSE
Definition primnodes.h:1608
IS_XMLSERIALIZE
@ IS_XMLSERIALIZE
Definition primnodes.h:1611
IS_XMLROOT
@ IS_XMLROOT
Definition primnodes.h:1610
IS_XMLELEMENT
@ IS_XMLELEMENT
Definition primnodes.h:1606
VAR_RETURNING_OLD
@ VAR_RETURNING_OLD
Definition primnodes.h:257
VAR_RETURNING_NEW
@ VAR_RETURNING_NEW
Definition primnodes.h:258
VAR_RETURNING_DEFAULT
@ VAR_RETURNING_DEFAULT
Definition primnodes.h:256
JSON_BEHAVIOR_ERROR
@ JSON_BEHAVIOR_ERROR
Definition primnodes.h:1791
JSON_QUERY_OP
@ JSON_QUERY_OP
Definition primnodes.h:1828
JSON_EXISTS_OP
@ JSON_EXISTS_OP
Definition primnodes.h:1827
JSON_VALUE_OP
@ JSON_VALUE_OP
Definition primnodes.h:1829
JS_TYPE_ANY
@ JS_TYPE_ANY
Definition primnodes.h:1747
JS_TYPE_ARRAY
@ JS_TYPE_ARRAY
Definition primnodes.h:1749
JS_TYPE_OBJECT
@ JS_TYPE_OBJECT
Definition primnodes.h:1748
JS_TYPE_SCALAR
@ JS_TYPE_SCALAR
Definition primnodes.h:1750
OUTER_VAR
#define OUTER_VAR
Definition primnodes.h:243
JSCTOR_JSON_PARSE
@ JSCTOR_JSON_PARSE
Definition primnodes.h:1719
JSCTOR_JSON_OBJECT
@ JSCTOR_JSON_OBJECT
Definition primnodes.h:1715
JSCTOR_JSON_SCALAR
@ JSCTOR_JSON_SCALAR
Definition primnodes.h:1720
JSCTOR_JSON_ARRAY
@ JSCTOR_JSON_ARRAY
Definition primnodes.h:1716
INNER_VAR
#define INNER_VAR
Definition primnodes.h:242
element
static chr element(struct vars *v, const chr *startp, const chr *endp)
Definition regc_locale.c:376
hash
static unsigned hash(unsigned *uv, int n)
Definition rege_dfa.c:715
error
static void error(void)
Definition sql-dyntest.c:147
check_stack_depth
void check_stack_depth(void)
Definition stack_depth.c:95
appendStringInfo
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition stringinfo.c:145
initStringInfo
void initStringInfo(StringInfo str)
Definition stringinfo.c:97
AggStatePerTransData::equalfnOne
FmgrInfo equalfnOne
Definition nodeAgg.h:115
AggStatePerTransData::sortslot
TupleTableSlot * sortslot
Definition nodeAgg.h:141
AggStatePerTransData::equalfnMulti
ExprState * equalfnMulti
Definition nodeAgg.h:116
AggStatePerTransData::sortstates
Tuplesortstate ** sortstates
Definition nodeAgg.h:162
AggStatePerTransData::uniqslot
TupleTableSlot * uniqslot
Definition nodeAgg.h:142
AggStatePerTransData::transfn_fcinfo
FunctionCallInfo transfn_fcinfo
Definition nodeAgg.h:170
ArrayType::elemtype
Oid elemtype
Definition array.h:97
ArrayType::ndim
int ndim
Definition array.h:95
ArrayType::dataoffset
int32 dataoffset
Definition array.h:96
EState::es_range_table_size
Index es_range_table_size
Definition execnodes.h:665
ErrorData::message
char * message
Definition elog.h:432
ErrorSaveContext::error_data
ErrorData * error_data
Definition miscnodes.h:49
ExprContext::domainValue_datum
Datum domainValue_datum
Definition execnodes.h:306
ExprContext::ecxt_param_list_info
ParamListInfo ecxt_param_list_info
Definition execnodes.h:287
ExprContext::ecxt_per_tuple_memory
MemoryContext ecxt_per_tuple_memory
Definition execnodes.h:283
ExprContext::ecxt_innertuple
TupleTableSlot * ecxt_innertuple
Definition execnodes.h:277
ExprContext::ecxt_param_exec_vals
ParamExecData * ecxt_param_exec_vals
Definition execnodes.h:286
ExprContext::ecxt_aggvalues
Datum * ecxt_aggvalues
Definition execnodes.h:294
ExprContext::ecxt_newtuple
TupleTableSlot * ecxt_newtuple
Definition execnodes.h:314
ExprContext::caseValue_isNull
bool caseValue_isNull
Definition execnodes.h:302
ExprContext::ecxt_scantuple
TupleTableSlot * ecxt_scantuple
Definition execnodes.h:275
ExprContext::caseValue_datum
Datum caseValue_datum
Definition execnodes.h:300
ExprContext::ecxt_oldtuple
TupleTableSlot * ecxt_oldtuple
Definition execnodes.h:312
ExprContext::ecxt_aggnulls
bool * ecxt_aggnulls
Definition execnodes.h:296
ExprContext::ecxt_per_query_memory
MemoryContext ecxt_per_query_memory
Definition execnodes.h:282
ExprContext::domainValue_isNull
bool domainValue_isNull
Definition execnodes.h:308
ExprContext::ecxt_estate
struct EState * ecxt_estate
Definition execnodes.h:317
ExprContext::ecxt_outertuple
TupleTableSlot * ecxt_outertuple
Definition execnodes.h:279
ExprEvalStep::xexpr
XmlExpr * xexpr
Definition execExpr.h:653
ExprEvalStep::pred
JsonIsPredicate * pred
Definition execExpr.h:750
ExprEvalStep::op
MinMaxOp op
Definition execExpr.h:534
ExprEvalStep::typbyval
bool typbyval
Definition execExpr.h:631
ExprEvalStep::fieldnum
AttrNumber fieldnum
Definition execExpr.h:543
ExprEvalStep::has_nulls
bool has_nulls
Definition execExpr.h:642
ExprEvalStep::elements_tab
struct ScalarArrayOpExprHashTable * elements_tab
Definition execExpr.h:644
ExprEvalStep::inclause
bool inclause
Definition execExpr.h:643
ExprEvalStep::sstate
SubPlanState * sstate
Definition execExpr.h:691
ExprEvalStep::pertrans
AggStatePerTrans pertrans
Definition execExpr.h:731
ExprEvalStep::jsestate
struct JsonExprState * jsestate
Definition execExpr.h:756
ExprEvalStep::argnull
bool * argnull
Definition execExpr.h:659
ExprEvalStep::args
NullableDatum * args
Definition execExpr.h:715
ExprEvalStep::nulls
bool * nulls
Definition execExpr.h:531
ExprEvalStep::saop
ScalarArrayOpExpr * saop
Definition execExpr.h:647
ExprEvalStep::fcinfo_data
FunctionCallInfo fcinfo_data
Definition execExpr.h:389
ExprEvalStep::escontext
ErrorSaveContext * escontext
Definition execExpr.h:592
ExprEvalStep::cmptype
CompareType cmptype
Definition execExpr.h:523
ExprEvalStep::resnull
bool * resnull
Definition execExpr.h:311
ExprEvalStep::typlen
int16 typlen
Definition execExpr.h:630
ExprEvalStep::argvalue
Datum * argvalue
Definition execExpr.h:658
ExprEvalStep::d
union ExprEvalStep::@58 d
ExprEvalStep::rowcache
ExprEvalRowtypeCache rowcache
Definition execExpr.h:419
ExprEvalStep::hashedscalararrayop
struct ExprEvalStep::@58::@93 hashedscalararrayop
ExprEvalStep::jcstate
struct JsonConstructorExprState * jcstate
Definition execExpr.h:665
ExprEvalStep::finfo
FmgrInfo * finfo
Definition execExpr.h:388
ExprEvalStep::aggcontext
ExprContext * aggcontext
Definition execExpr.h:732
ExprEvalStep::element_type
Oid element_type
Definition execExpr.h:628
ExprEvalStep::var
struct ExprEvalStep::@58::@60 var
ExprEvalStep::svf
SQLValueFunction * svf
Definition execExpr.h:467
FmgrInfo::fn_addr
PGFunction fn_addr
Definition fmgr.h:58
FunctionCallInfoBaseData::args
NullableDatum args[FLEXIBLE_ARRAY_MEMBER]
Definition fmgr.h:95
HeapTupleData::t_data
HeapTupleHeader t_data
Definition htup.h:68
JsonBehavior::btype
JsonBehaviorType btype
Definition primnodes.h:1815
JsonConstructorExprState::constructor
JsonConstructorExpr * constructor
Definition execExpr.h:823
JsonConstructorExprState::arg_type_cache
struct JsonConstructorExprState::@108 * arg_type_cache
JsonConstructorExpr::returning
JsonReturning * returning
Definition primnodes.h:1735
JsonExprState::jump_eval_coercion
int jump_eval_coercion
Definition execnodes.h:1109
JsonExprState::empty
NullableDatum empty
Definition execnodes.h:1095
JsonExprState::input_fcinfo
FunctionCallInfo input_fcinfo
Definition execnodes.h:1123
JsonExprState::jsexpr
JsonExpr * jsexpr
Definition execnodes.h:1073
JsonExprState::error
NullableDatum error
Definition execnodes.h:1092
JsonExprState::pathspec
NullableDatum pathspec
Definition execnodes.h:1079
JsonExprState::escontext
ErrorSaveContext escontext
Definition execnodes.h:1132
JsonExprState::formatted_expr
NullableDatum formatted_expr
Definition execnodes.h:1076
JsonExpr::column_name
char * column_name
Definition primnodes.h:1844
JsonExpr::on_empty
JsonBehavior * on_empty
Definition primnodes.h:1864
JsonExpr::use_io_coercion
bool use_io_coercion
Definition primnodes.h:1871
JsonExpr::returning
JsonReturning * returning
Definition primnodes.h:1857
JsonExpr::use_json_coercion
bool use_json_coercion
Definition primnodes.h:1872
JsonExpr::wrapper
JsonWrapper wrapper
Definition primnodes.h:1875
JsonExpr::op
JsonExprOp op
Definition primnodes.h:1842
JsonExpr::on_error
JsonBehavior * on_error
Definition primnodes.h:1865
JsonFormat::format_type
JsonFormatType format_type
Definition primnodes.h:1676
JsonIsPredicate::item_type
JsonValueType item_type
Definition primnodes.h:1762
JsonReturning::format
JsonFormat * format
Definition primnodes.h:1688
JsonbValue::type
enum jbvType type
Definition jsonb.h:257
JsonbValue::val
char * val
Definition jsonb.h:266
Jsonb
Definition jsonb.h:215
List
Definition pg_list.h:54
ModifyTableState::mt_merge_action
MergeActionState * mt_merge_action
Definition execnodes.h:1453
Node
Definition nodes.h:135
NullableDatum::value
Datum value
Definition postgres.h:87
PgStat_FunctionCallUsage
Definition pgstat.h:93
SQLValueFunction::op
SQLValueFunctionOp op
Definition primnodes.h:1581
ScalarArrayOpExprHashTable::hash_fcinfo_data
FunctionCallInfoBaseData hash_fcinfo_data
Definition execExprInterp.c:222
ScalarArrayOpExprHashTable::op
struct ExprEvalStep * op
Definition execExprInterp.c:220
SubPlanState::subplan
SubPlan * subplan
Definition execnodes.h:1014
TupleDescData::tdtypmod
int32 tdtypmod
Definition tupdesc.h:139
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition tuptable.h:122
TupleTableSlot::tts_ops
const TupleTableSlotOps *const tts_ops
Definition tuptable.h:120
TupleTableSlot::tts_nvalid
AttrNumber tts_nvalid
Definition tuptable.h:119
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition tuptable.h:126
TupleTableSlot::tts_values
Datum * tts_values
Definition tuptable.h:124
TypeCacheEntry::tupDesc_identifier
uint64 tupDesc_identifier
Definition typcache.h:91
TypeCacheEntry::tupDesc
TupleDesc tupDesc
Definition typcache.h:90
XmlExpr::args
List * args
Definition primnodes.h:1633
XmlExpr::indent
bool indent
Definition primnodes.h:1637
XmlExpr::named_args
List * named_args
Definition primnodes.h:1629
XmlExpr::op
XmlExprOp op
Definition primnodes.h:1625
varlena
Definition c.h:706
convert_tuples_by_name
TupleConversionMap * convert_tuples_by_name(TupleDesc indesc, TupleDesc outdesc)
Definition tupconvert.c:103
execute_attr_map_tuple
HeapTuple execute_attr_map_tuple(HeapTuple tuple, TupleConversionMap *map)
Definition tupconvert.c:155
DecrTupleDescRefCount
void DecrTupleDescRefCount(TupleDesc tupdesc)
Definition tupdesc.c:577
IncrTupleDescRefCount
void IncrTupleDescRefCount(TupleDesc tupdesc)
Definition tupdesc.c:559
CreateTupleDescCopy
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
Definition tupdesc.c:252
ReleaseTupleDesc
#define ReleaseTupleDesc(tupdesc)
Definition tupdesc.h:219
TupleDescAttr
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition tupdesc.h:160
TupleDescCompactAttr
static CompactAttribute * TupleDescCompactAttr(TupleDesc tupdesc, int i)
Definition tupdesc.h:175
TupleDesc
struct TupleDescData * TupleDesc
Definition tupdesc.h:145
tuplesort_putdatum
void tuplesort_putdatum(Tuplesortstate *state, Datum val, bool isNull)
Definition tuplesortvariants.c:940
tuplesort_puttupleslot
void tuplesort_puttupleslot(Tuplesortstate *state, TupleTableSlot *slot)
Definition tuplesortvariants.c:752
att_align_nominal
#define att_align_nominal(cur_offset, attalign)
Definition tupmacs.h:145
att_addlength_pointer
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition tupmacs.h:180
fetch_att
static Datum fetch_att(const void *T, bool attbyval, int attlen)
Definition tupmacs.h:50
TTS_IS_VIRTUAL
#define TTS_IS_VIRTUAL(slot)
Definition tuptable.h:237
slot_getsomeattrs
static void slot_getsomeattrs(TupleTableSlot *slot, int attnum)
Definition tuptable.h:358
slot_getsysattr
static Datum slot_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition tuptable.h:419
TTS_FIXED
#define TTS_FIXED(slot)
Definition tuptable.h:107
slot_getattr
static Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition tuptable.h:398
ExecClearTuple
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition tuptable.h:457
slot_getallattrs
static void slot_getallattrs(TupleTableSlot *slot)
Definition tuptable.h:371
ExecCopySlot
static TupleTableSlot * ExecCopySlot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
Definition tuptable.h:524
lookup_rowtype_tupdesc
TupleDesc lookup_rowtype_tupdesc(Oid type_id, int32 typmod)
Definition typcache.c:1921
lookup_rowtype_tupdesc_domain
TupleDesc lookup_rowtype_tupdesc_domain(Oid type_id, int32 typmod, bool noError)
Definition typcache.c:1977
lookup_type_cache
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition typcache.c:386
TYPECACHE_TUPDESC
#define TYPECACHE_TUPDESC
Definition typcache.h:146
TimestampTzGetDatum
static Datum TimestampTzGetDatum(TimestampTz X)
Definition timestamp.h:52
TimestampGetDatum
static Datum TimestampGetDatum(Timestamp X)
Definition timestamp.h:46
strVal
#define strVal(v)
Definition value.h:82
VARATT_IS_EXTERNAL_EXPANDED
static bool VARATT_IS_EXTERNAL_EXPANDED(const void *PTR)
Definition varatt.h:389
SET_VARSIZE
static void SET_VARSIZE(void *PTR, Size len)
Definition varatt.h:432
cstring_to_text_with_len
text * cstring_to_text_with_len(const char *s, int len)
Definition varlena.c:193
textin
Datum textin(PG_FUNCTION_ARGS)
Definition varlena.c:275
xmlroot
xmltype * xmlroot(xmltype *data, text *version, int standalone)
Definition xml.c:1101
xmltotext_with_options
text * xmltotext_with_options(xmltype *data, XmlOptionType xmloption_arg, bool indent)
Definition xml.c:677
map_sql_value_to_xml_value
char * map_sql_value_to_xml_value(Datum value, Oid type, bool xml_escape_strings)
Definition xml.c:2516
xmlconcat
xmltype * xmlconcat(List *args)
Definition xml.c:574
xml_is_document
bool xml_is_document(xmltype *arg)
Definition xml.c:1167
xmlparse
xmltype * xmlparse(text *data, XmlOptionType xmloption_arg, bool preserve_whitespace)
Definition xml.c:1031
xmlelement
xmltype * xmlelement(XmlExpr *xexpr, const Datum *named_argvalue, const bool *named_argnull, const Datum *argvalue, const bool *argnull)
Definition xml.c:893
xmlpi
xmltype * xmlpi(const char *target, text *arg, bool arg_is_null, bool *result_is_null)
Definition xml.c:1049
DatumGetXmlP
static xmltype * DatumGetXmlP(Datum X)
Definition xml.h:51