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