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