SSL execExprInterp.c
Sprache: C
/*------------------------------------------------------------------------- * * execExprInterp . c * Interpreted evaluation of an expression step list . * * This file provides either a " direct threaded " ( for gcc , clang and * compatible ) or a " switch threaded " ( for all compilers ) implementation of * expression evaluation . The former is amongst the fastest known methods * of interpreting programs without resorting to assembly level work , or * just - in - time compilation , but it requires support for computed gotos . * The latter is amongst the fastest approaches doable in standard C . * * In either case we use ExprEvalStep - > opcode to dispatch to the code block * within ExecInterpExpr ( ) that implements the specific opcode type . * * Switch - threading uses a plain switch ( ) statement to perform the * dispatch . This has the advantages of being plain C and allowing the * compiler to warn if implementation of a specific opcode has been forgotten . * The disadvantage is that dispatches will , as commonly implemented by * compilers , happen from a single location , requiring more jumps and causing * bad branch prediction . * * In direct threading , we use gcc ' s label - as - values extension - also adopted * by some other compilers - to replace ExprEvalStep - > opcode with the address * of the block implementing the instruction . Dispatch to the next instruction * is done by a " computed goto " . This allows for better branch prediction * ( as the jumps are happening from different locations ) and fewer jumps * ( as no preparatory jump to a common dispatch location is needed ) . * * When using direct threading , ExecReadyInterpretedExpr will replace * each step ' s opcode field with the address of the relevant code block and * ExprState - > flags will contain EEO_FLAG_DIRECT_THREADED to remember that * that ' s been done . * * For very simple instructions the overhead of the full interpreter * " startup " , as minimal as it is , is noticeable . Therefore * ExecReadyInterpretedExpr will choose to implement certain simple * opcode patterns using special fast - path routines ( ExecJust * ) . * * Complex or uncommon instructions are not implemented in - line in * ExecInterpExpr ( ) , rather we call out to a helper function appearing later * in this file . For one reason , there ' d not be a noticeable performance * benefit , but more importantly those complex routines are intended to be * shared between different expression evaluation approaches . For instance * a JIT compiler would generate calls to them . ( This is why they are * exported rather than being " static " in this file . ) * * * Portions Copyright ( c ) 1996 - 2025 , PostgreSQL Global Development Group * Portions Copyright ( c ) 1994 , Regents of the University of California * * IDENTIFICATION * src / backend / executor / execExprInterp . c * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #include "postgres.h" #include "access/heaptoast.h" #include "catalog/pg_type.h" #include "commands/sequence.h" #include "executor/execExpr.h" #include "executor/nodeSubplan.h" #include "funcapi.h" #include "miscadmin.h" #include "nodes/miscnodes.h" #include "nodes/nodeFuncs.h" #include "pgstat.h" #include "utils/array.h" #include "utils/builtins.h" #include "utils/date.h" #include "utils/datum.h" #include "utils/expandedrecord.h" #include "utils/json.h" #include "utils/jsonfuncs.h" #include "utils/jsonpath.h" #include "utils/lsyscache.h" #include "utils/memutils.h" #include "utils/timestamp.h" #include "utils/typcache.h" #include "utils/xml.h" /* * Use computed - goto - based opcode dispatch when computed gotos are available . * But use a separate symbol so that it ' s easy to adjust locally in this file * for development and testing . #ifdef HAVE_COMPUTED_GOTO#define EEO_USE_COMPUTED_GOTO#endif /* HAVE_COMPUTED_GOTO */ /* * Macros for opcode dispatch . * * EEO_SWITCH - just hides the switch if not in use . * EEO_CASE - labels the implementation of named expression step type . * EEO_DISPATCH - jump to the implementation of the step type for ' op ' . * EEO_OPCODE - compute opcode required by used expression evaluation method . * EEO_NEXT - increment ' op ' and jump to correct next step type . * EEO_JUMP - jump to the specified step number within the current expression . #if defined (EEO_USE_COMPUTED_GOTO)/* struct for jump target -> opcode lookup table */ typedef struct ExprEvalOpLookupconst void *opcode;/* to make dispatch_table accessible outside ExecInterpExpr() */ static const void **dispatch_table = NULL;/* jump target -> opcode lookup table */ static ExprEvalOpLookup reverse_dispatch_table[EEOP_LAST];#define EEO_SWITCH()#define EEO_CASE(name) CASE_## name:#define EEO_DISPATCH() goto *((void *) op->opcode)#define EEO_OPCODE(opcode) ((intptr_t) dispatch_table[opcode])#else /* !EEO_USE_COMPUTED_GOTO */ #define EEO_SWITCH() starteval: switch ((ExprEvalOp) op->opcode)#define EEO_CASE(name) case name:#define EEO_DISPATCH() goto starteval#define EEO_OPCODE(opcode) (opcode)#endif /* EEO_USE_COMPUTED_GOTO */ #define EEO_NEXT() \do { \while (0 )#define EEO_JUMP(stepno) \do { \while (0 )static Datum ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull);static void ExecInitInterpreter(void );/* support functions */ static void CheckVarSlotCompatibility(TupleTableSlot *slot, int attnum, Oid vartype);static void CheckOpSlotCompatibility(ExprEvalStep *op, TupleTableSlot *slot);static TupleDesc get_cached_rowtype(Oid type_id, int32 typmod,bool *changed);static void ExecEvalRowNullInt(ExprState *state, ExprEvalStep *op,bool checkisnull);/* fast-path evaluation functions */ static Datum ExecJustInnerVar(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustOuterVar(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustScanVar(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustAssignInnerVar(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustAssignOuterVar(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustAssignScanVar(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustApplyFuncToCase(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustConst(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustInnerVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustOuterVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustScanVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustAssignInnerVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustAssignOuterVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustAssignScanVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustHashInnerVarWithIV(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustHashOuterVar(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustHashInnerVar(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustHashOuterVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustHashInnerVarVirt(ExprState *state, ExprContext *econtext, bool *isnull);static Datum ExecJustHashOuterVarStrict(ExprState *state, ExprContext *econtext, bool *isnull);/* execution helper functions */ static pg_attribute_always_inline void ExecEvalArrayCompareInternal(FunctionCallInfo fcinfo,bool typbyval,char typalign,bool useOr,bool *resultnull);static pg_attribute_always_inline void ExecAggPlainTransByVal(AggState *aggstate,int setno);static pg_attribute_always_inline void ExecAggPlainTransByRef(AggState *aggstate,int setno);static char *ExecGetJsonValueItemString(JsonbValue *item, bool *resnull);/* * ScalarArrayOpExprHashEntry * Hash table entry type used during EEOP_HASHED_SCALARARRAYOP typedef struct ScalarArrayOpExprHashEntry/* hash status */ /* hash value (cached) */ #define SH_PREFIX saophash#define SH_ELEMENT_TYPE ScalarArrayOpExprHashEntry#define SH_KEY_TYPE Datum#define SH_SCOPE static inline #define SH_DECLARE#include "lib/simplehash.h" static bool saop_hash_element_match(struct saophash_hash *tb, Datum key1,static uint32 saop_element_hash(struct saophash_hash *tb, Datum key);/* * ScalarArrayOpExprHashTable * Hash table for EEOP_HASHED_SCALARARRAYOP typedef struct ScalarArrayOpExprHashTable/* underlying hash table */ struct ExprEvalStep *op;/* function's lookup data */ /* arguments etc */ /* Define parameters for ScalarArrayOpExpr hash table code generation. */ #define SH_PREFIX saophash#define SH_ELEMENT_TYPE ScalarArrayOpExprHashEntry#define SH_KEY_TYPE Datum#define SH_KEY key#define SH_HASH_KEY(tb, key) saop_element_hash(tb, key)#define SH_EQUAL(tb, a, b) saop_hash_element_match(tb, a, b)#define SH_SCOPE static inline #define SH_STORE_HASH#define SH_GET_HASH(tb, a) a->hash#define SH_DEFINE#include "lib/simplehash.h" /* * Prepare ExprState for interpreted execution . void /* Ensure one-time interpreter setup has been done */ /* Simple validity checks on expression */ 1 );1 ].opcode == EEOP_DONE_RETURN ||1 ].opcode == EEOP_DONE_NO_RETURN);/* * Don ' t perform redundant initialization . This is unreachable in current * cases , but might be hit if there ' s additional expression evaluation * methods that rely on interpreted execution to work . if (state->flags & EEO_FLAG_INTERPRETER_INITIALIZED)return ;/* * First time through , check whether attribute matches Var . Might not be * ok anymore , due to schema changes . We do that by setting up a callback * that does checking on the first call , which then sets the evalfunc * callback to the actual method of execution . /* DIRECT_THREADED should not already be set */ 0 );/* * There shouldn ' t be any errors before the expression is fully * initialized , and even if so , it ' d lead to the expression being * abandoned . So we can set the flag now and save some code . /* * Select fast - path evalfuncs for very simple expressions . " Starting up " * the full interpreter is a measurable overhead for these , and these * patterns occur often enough to be worth optimizing . if (state->steps_len == 5 )0 ].opcode;1 ].opcode;2 ].opcode;3 ].opcode;if (step0 == EEOP_INNER_FETCHSOME &&void *) ExecJustHashInnerVarWithIV;return ;else if (state->steps_len == 4 )0 ].opcode;1 ].opcode;2 ].opcode;if (step0 == EEOP_OUTER_FETCHSOME &&void *) ExecJustHashOuterVar;return ;else if (step0 == EEOP_INNER_FETCHSOME &&void *) ExecJustHashInnerVar;return ;else if (step0 == EEOP_OUTER_FETCHSOME &&void *) ExecJustHashOuterVarStrict;return ;else if (state->steps_len == 3 )0 ].opcode;1 ].opcode;if (step0 == EEOP_INNER_FETCHSOME &&return ;else if (step0 == EEOP_OUTER_FETCHSOME &&return ;else if (step0 == EEOP_SCAN_FETCHSOME &&return ;else if (step0 == EEOP_INNER_FETCHSOME &&return ;else if (step0 == EEOP_OUTER_FETCHSOME &&return ;else if (step0 == EEOP_SCAN_FETCHSOME &&return ;else if (step0 == EEOP_CASE_TESTVAL &&return ;else if (step0 == EEOP_INNER_VAR &&void *) ExecJustHashInnerVarVirt;return ;else if (step0 == EEOP_OUTER_VAR &&void *) ExecJustHashOuterVarVirt;return ;else if (state->steps_len == 2 )0 ].opcode;if (step0 == EEOP_CONST)return ;else if (step0 == EEOP_INNER_VAR)return ;else if (step0 == EEOP_OUTER_VAR)return ;else if (step0 == EEOP_SCAN_VAR)return ;else if (step0 == EEOP_ASSIGN_INNER_VAR)return ;else if (step0 == EEOP_ASSIGN_OUTER_VAR)return ;else if (step0 == EEOP_ASSIGN_SCAN_VAR)return ;#if defined (EEO_USE_COMPUTED_GOTO)/* * In the direct - threaded implementation , replace each opcode with the * address to jump to . ( Use ExecEvalStepOp ( ) to get back the opcode . ) for (int off = 0 ; off < state->steps_len; off++)#endif /* EEO_USE_COMPUTED_GOTO */ /* * Evaluate expression identified by " state " in the execution context * given by " econtext " . * isnull is set to the is - null flag for the result , * and the Datum value is the function result . * * As a special case , return the dispatch table ' s address if state is NULL . * This is used by ExecInitInterpreter to set up the dispatch_table global . * ( Only applies when EEO_USE_COMPUTED_GOTO is defined . ) static Datumbool *isnull)/* * This array has to be in the same order as enum ExprEvalOp . #if defined (EEO_USE_COMPUTED_GOTO)static const void *const dispatch_table[] = {1 ,"dispatch_table out of whack with ExprEvalOp" );if (unlikely(state == NULL))return PointerGetDatum(dispatch_table);#else #endif /* EEO_USE_COMPUTED_GOTO */ /* setup state */ #if defined (EEO_USE_COMPUTED_GOTO)#endif return state->resvalue;return (Datum) 0 ;int attnum = op->d.var.attnum;/* * Since we already extracted all referenced columns from the * tuple with a FETCHSOME step , we can just grab the value * directly out of the slot ' s decomposed - data arrays . But let ' s * have an Assert to check that that did happen . 0 && attnum < innerslot->tts_nvalid);int attnum = op->d.var.attnum;/* See EEOP_INNER_VAR comments */ 0 && attnum < outerslot->tts_nvalid);int attnum = op->d.var.attnum;/* See EEOP_INNER_VAR comments */ 0 && attnum < scanslot->tts_nvalid);int attnum = op->d.var.attnum;/* See EEOP_INNER_VAR comments */ 0 && attnum < oldslot->tts_nvalid);int attnum = op->d.var.attnum;/* See EEOP_INNER_VAR comments */ 0 && attnum < newslot->tts_nvalid);/* too complex for an inline implementation */ int resultnum = op->d.assign_var.resultnum;int attnum = op->d.assign_var.attnum;/* * We do not need CheckVarSlotCompatibility here ; that was taken * care of at compilation time . But see EEOP_INNER_VAR comments . 0 && attnum < innerslot->tts_nvalid);0 && resultnum < resultslot->tts_tupleDescriptor->natts);int resultnum = op->d.assign_var.resultnum;int attnum = op->d.assign_var.attnum;/* * We do not need CheckVarSlotCompatibility here ; that was taken * care of at compilation time . But see EEOP_INNER_VAR comments . 0 && attnum < outerslot->tts_nvalid);0 && resultnum < resultslot->tts_tupleDescriptor->natts);int resultnum = op->d.assign_var.resultnum;int attnum = op->d.assign_var.attnum;/* * We do not need CheckVarSlotCompatibility here ; that was taken * care of at compilation time . But see EEOP_INNER_VAR comments . 0 && attnum < scanslot->tts_nvalid);0 && resultnum < resultslot->tts_tupleDescriptor->natts);int resultnum = op->d.assign_var.resultnum;int attnum = op->d.assign_var.attnum;/* * We do not need CheckVarSlotCompatibility here ; that was taken * care of at compilation time . But see EEOP_INNER_VAR comments . 0 && attnum < oldslot->tts_nvalid);0 && resultnum < resultslot->tts_tupleDescriptor->natts);int resultnum = op->d.assign_var.resultnum;int attnum = op->d.assign_var.attnum;/* * We do not need CheckVarSlotCompatibility here ; that was taken * care of at compilation time . But see EEOP_INNER_VAR comments . 0 && attnum < newslot->tts_nvalid);0 && resultnum < resultslot->tts_tupleDescriptor->natts);int resultnum = op->d.assign_tmp.resultnum;0 && resultnum < resultslot->tts_tupleDescriptor->natts);int resultnum = op->d.assign_tmp.resultnum;0 && resultnum < resultslot->tts_tupleDescriptor->natts);if (!resultslot->tts_isnull[resultnum])else /* * Function - call implementations . Arguments have previously been * evaluated directly into fcinfo - > args . * * As both STRICT checks and function - usage are noticeable performance * wise , and function calls are a very hot - path ( they also back * operators ! ) , it ' s worth having so many separate opcodes . * * Note : the reason for using a temporary variable " d " , here and in * other places , is that some compilers think " * op - > resvalue = f ( ) ; " * requires them to evaluate op - > resvalue into a register before * calling f ( ) , just in case f ( ) is able to modify op - > resvalue * somehow . The extra line of code can save a useless register spill * and reload across the function call . false ;/* strict function call with more than two arguments */ int nargs = op->d.func.nargs;2 );/* strict function, so check for NULL args */ for (int argno = 0 ; argno < nargs; argno++)if (args[argno].isnull)true ;goto strictfail;false ;/* strict function call with one argument */ 1 );/* strict function, so check for NULL args */ if (args[0 ].isnull)true ;else false ;/* strict function call with two arguments */ 2 );/* strict function, so check for NULL args */ if (args[0 ].isnull || args[1 ].isnull)true ;else false ;/* not common enough to inline */ /* not common enough to inline */ /* * If any of its clauses is FALSE , an AND ' s result is FALSE regardless * of the states of the rest of the clauses , so we can stop evaluating * and return FALSE immediately . If none are FALSE and one or more is * NULL , we return NULL ; otherwise we return TRUE . This makes sense * when you interpret NULL as " don ' t know " : perhaps one of the " don ' t * knows " would have been FALSE if we ' d known its value . Only when * all the inputs are known to be TRUE can we state confidently that * the AND ' s result is TRUE . false ;/* * EEOP_BOOL_AND_STEP_FIRST resets anynull , otherwise it ' s the * same as EEOP_BOOL_AND_STEP - so fall through to that . /* FALL THROUGH */ if (*op->resnull)true ;else if (!DatumGetBool(*op->resvalue))/* result is already set to FALSE, need not change it */ /* bail out early */ if (*op->resnull)/* result is already set to NULL, need not change it */ else if (!DatumGetBool(*op->resvalue))/* result is already set to FALSE, need not change it */ /* * No point jumping early to jumpdone - would be same target * ( as this is the last argument to the AND expression ) , * except more expensive . else if (*op->d.boolexpr.anynull)0 ;true ;else /* result is already set to TRUE, need not change it */ /* * If any of its clauses is TRUE , an OR ' s result is TRUE regardless of * the states of the rest of the clauses , so we can stop evaluating * and return TRUE immediately . If none are TRUE and one or more is * NULL , we return NULL ; otherwise we return FALSE . This makes sense * when you interpret NULL as " don ' t know " : perhaps one of the " don ' t * knows " would have been TRUE if we ' d known its value . Only when all * the inputs are known to be FALSE can we state confidently that the * OR ' s result is FALSE . false ;/* * EEOP_BOOL_OR_STEP_FIRST resets anynull , otherwise it ' s the same * as EEOP_BOOL_OR_STEP - so fall through to that . /* FALL THROUGH */ if (*op->resnull)true ;else if (DatumGetBool(*op->resvalue))/* result is already set to TRUE, need not change it */ /* bail out early */ if (*op->resnull)/* result is already set to NULL, need not change it */ else if (DatumGetBool(*op->resvalue))/* result is already set to TRUE, need not change it */ /* * No point jumping to jumpdone - would be same target ( as * this is the last argument to the AND expression ) , except * more expensive . else if (*op->d.boolexpr.anynull)0 ;true ;else /* result is already set to FALSE, need not change it */ /* * Evaluation of ' not ' is simple . . . if expr is false , then return * ' true ' and vice versa . It ' s safe to do this even on a * nominally null value , so we ignore resnull ; that means that * NULL in produces NULL out , which is what we want . /* simplified version of BOOL_AND_STEP for use by ExecQual() */ /* If argument (also result) is false or null ... */ if (*op->resnull ||/* ... bail out early, returning FALSE */ false ;false );/* * Otherwise , leave the TRUE value in place , in case this is the * last qual . Then , TRUE is the correct answer . /* Unconditionally jump to target step */ /* Transfer control if current result is null */ if (*op->resnull)/* Transfer control if current result is non-null */ if (!*op->resnull)/* Transfer control if current result is null or false */ if (*op->resnull || !DatumGetBool(*op->resvalue))false ;false ;/* out of line implementation: too large */ /* out of line implementation: too large */ /* BooleanTest implementations for all booltesttypes */ if (*op->resnull)false );false ;/* else, input value is the correct output as well */ if (*op->resnull)true );false ;else if (*op->resnull)false );false ;else if (*op->resnull)true );false ;/* else, input value is the correct output as well */ /* out of line implementation: too large */ /* out of line implementation: too large */ /* allow an extension module to supply a PARAM_EXTERN value */ /* out of line, unlikely to matter performance-wise */ /* * Force a varlena value that might be read multiple times to R / O if (!*op->d.make_readonly.isnull)/* * Evaluate a CoerceViaIO node . This can be quite a hot path , so * inline as much work as possible . The source value is in our * result variable . * * Also look at ExecEvalCoerceViaIOSafe ( ) if you change anything * here . char *str;/* call output function (similar to OutputFunctionCall) */ if (*op->resnull)/* output functions are not called on nulls */ else 0 ].value = *op->resvalue;0 ].isnull = false ;false ;/* OutputFunctionCall assumes result isn't null */ /* call input function (similar to InputFunctionCall) */ if (!op->d.iocoerce.finfo_in->fn_strict || str != NULL)0 ].value = PointerGetDatum(str);0 ].isnull = *op->resnull;/* second and third arguments are already set up */ false ;/* Should get null result if and only if str is NULL */ if (str == NULL)else /* * IS DISTINCT FROM must evaluate arguments ( already done into * fcinfo - > args ) to determine whether they are NULL ; if either is * NULL then the result is determined . If neither is NULL , then * proceed to evaluate the comparison function , which is just the * type ' s standard equality operator . We need not care whether * that function is strict . Because the handling of nulls is * different , we can ' t just reuse EEOP_FUNCEXPR . /* check function arguments for NULLness */ if (fcinfo->args[0 ].isnull && fcinfo->args[1 ].isnull)/* Both NULL? Then is not distinct... */ false );false ;else if (fcinfo->args[0 ].isnull || fcinfo->args[1 ].isnull)/* Only one is NULL? Then is distinct... */ true );false ;else /* Neither null, so apply the equality function */ false ;/* Must invert result of "="; safe to do even if null */ /* see EEOP_DISTINCT for comments, this is just inverted */ if (fcinfo->args[0 ].isnull && fcinfo->args[1 ].isnull)true );false ;else if (fcinfo->args[0 ].isnull || fcinfo->args[1 ].isnull)false );false ;else false ;/* * The arguments are already evaluated into fcinfo - > args . 0 ].value;/* if either argument is NULL they can't be equal */ if (!fcinfo->args[0 ].isnull && !fcinfo->args[1 ].isnull)/* * If first argument is of varlena type , it might be an * expanded datum . We need to ensure that the value passed to * the comparison function is a read - only pointer . However , * if we end by returning the first argument , that will be the * original read - write pointer if it was read - write . if (op->d.func.make_ro)0 ].value =false ;/* if the arguments are equal return null */ if (!fcinfo->isnull && DatumGetBool(result))0 ;true ;/* Arguments aren't equal, so return the first one */ 0 ].isnull;/* * Doesn ' t seem worthwhile to have an inline implementation * efficiency - wise . /* error invocation uses space, and shouldn't ever occur */ /* * Doesn ' t seem worthwhile to have an inline implementation * efficiency - wise . /* * The next op actually evaluates the expression . If the OLD / NEW * row doesn ' t exist , skip that and return NULL . if (state->flags & op->d.returningexpr.nullflag)0 ;true ;/* too complex for an inline implementation */ /* too complex for an inline implementation */ /* too complex for an inline implementation */ /* force NULL result if strict fn and NULL input */ if (op->d.rowcompare_step.finfo->fn_strict &&0 ].isnull || fcinfo->args[1 ].isnull))true ;/* Apply comparison function */ false ;/* force NULL result if NULL function result */ if (fcinfo->isnull)true ;false ;/* If unequal, no need to compare remaining columns */ if (DatumGetInt32(*op->resvalue) != 0 )false ;switch (cmptype)/* EQ and NE cases aren't allowed here */ case COMPARE_LT:0 );break ;case COMPARE_LE:0 );break ;case COMPARE_GE:0 );break ;case COMPARE_GT:0 );break ;default :false );break ;/* too complex for an inline implementation */ /* too complex for an inline implementation */ /* too complex for an inline implementation */ /* too complex for an inline implementation */ /* Precheck SubscriptingRef subscript(s) */ if (op->d.sbsref_subscript.subscriptfunc(state, op, econtext))else /* Subscript is null, short-circuit SubscriptingRef to NULL */ /* Perform a SubscriptingRef fetch or assignment */ /* too complex for an inline implementation */ /* too complex for an inline implementation */ /* too complex for an inline implementation */ /* too complex for an inline implementation */ /* too complex for an inline implementation */ false ;/* * Save the Datum on non - null inputs , otherwise store 0 so that * subsequent NEXT32 operations combine with an initialized value . if (!fcinfo->args[0 ].isnull)else 0 ;false ;if (fcinfo->args[0 ].isnull)/* * With strict we have the expression return NULL instead of * ignoring NULL input values . We ' ve nothing more to do after * finding a NULL . true ;0 ;/* execute the hash function and save the resulting value */ false ;/* combine successive hash values by rotating */ 1 );/* leave the hash value alone on NULL inputs */ if (!fcinfo->args[0 ].isnull)/* execute hash func and combine with previous hash value */ false ;if (fcinfo->args[0 ].isnull)/* * With strict we have the expression return NULL instead of * ignoring NULL input values . We ' ve nothing more to do after * finding a NULL . true ;0 ;else /* combine successive hash values by rotating */ 1 );/* execute hash func and combine with previous hash value */ false ;/* too complex for an inline implementation */ /* too complex for an inline implementation */ /* too complex for an inline implementation */ /* too complex for an inline implementation */ /* too complex for an inline implementation */ /* too complex for an inline implementation */ /* * Returns a Datum whose value is the precomputed aggregate value * found in the given expression context . int aggno = op->d.aggref.aggno;/* too complex/uncommon for an inline implementation */ /* * Like Aggref , just return a precomputed value from the econtext . /* too complex/uncommon for an inline implementation */ /* too complex for an inline implementation */ /* evaluate a strict aggregate deserialization function */ /* Don't call a strict deserialization function with NULL input */ if (op->d.agg_deserialize.fcinfo_data->args[0 ].isnull)/* fallthrough */ /* evaluate aggregate deserialization function (non-strict portion) */ /* * We run the deserialization functions in per - input - tuple memory * context . false ;/* * Check that a strict aggregate transition / combination function ' s * input is not NULL . /* when checking more than one argument */ int nargs = op->d.agg_strict_input_check.nargs;1 );for (int argno = 0 ; argno < nargs; argno++)if (args[argno].isnull)/* special case for just one argument */ int nargs = op->d.agg_strict_input_check.nargs;1 );if (args[0 ].isnull)bool *nulls = op->d.agg_strict_input_check.nulls;int nargs = op->d.agg_strict_input_check.nargs;for (int argno = 0 ; argno < nargs; argno++)if (nulls[argno])/* * Check for a NULL pointer to the per - group states . if (pergroup_allaggs == NULL)/* * Different types of aggregate transition functions are implemented * as different types of steps , to avoid incurring unnecessary * overhead . There ' s a step type for each valid combination of having * a by value / by reference transition type , [ not ] needing to the * initialize the transition value for the first row in a group from * input , and [ not ] strict transition function . * * Could optimize further by splitting off by - reference for * fixed - length types , but currently that doesn ' t seem worth it . if (pergroup->noTransValue)/* If transValue has not yet been initialized, do so now. */ /* copied trans value from input, done this round */ else if (likely(!pergroup->transValueIsNull))/* invoke transition function, unless prevented by strictness */ /* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */ if (likely(!pergroup->transValueIsNull))/* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */ /* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */ if (pergroup->noTransValue)else if (likely(!pergroup->transValueIsNull))/* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */ if (likely(!pergroup->transValueIsNull))/* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */ if (ExecEvalPreOrderedDistinctSingle(aggstate, pertrans))else if (ExecEvalPreOrderedDistinctMulti(aggstate, pertrans))else /* process single-column ordered aggregate datum */ /* too complex for an inline implementation */ /* process multi-column ordered aggregate tuple */ /* too complex for an inline implementation */ /* unreachable */ false );goto out_error;return (Datum) 0 ;/* * Expression evaluation callback that performs extra checks before executing * the expression . Declared extern so other methods of execution can use it * too . bool *isNull)/* * First time through , check whether attribute matches Var . Might not be * ok anymore , due to schema changes . /* skip the check during further executions */ /* and actually execute */ return state->evalfunc(state, econtext, isNull);/* * Check that an expression is still valid in the face of potential schema * changes since the plan has been created . void for (int i = 0 ; i < state->steps_len; i++)switch (ExecEvalStepOp(state, op))case EEOP_INNER_VAR:int attnum = op->d.var.attnum;1 , op->d.var.vartype);break ;case EEOP_OUTER_VAR:int attnum = op->d.var.attnum;1 , op->d.var.vartype);break ;case EEOP_SCAN_VAR:int attnum = op->d.var.attnum;1 , op->d.var.vartype);break ;case EEOP_OLD_VAR:int attnum = op->d.var.attnum;1 , op->d.var.vartype);break ;case EEOP_NEW_VAR:int attnum = op->d.var.attnum;1 , op->d.var.vartype);break ;default :break ;/* * Check whether a user attribute in a slot can be referenced by a Var * expression . This should succeed unless there have been schema changes * since the expression tree has been created . static void int attnum, Oid vartype)/* * What we have to check for here is the possibility of an attribute * having been dropped or changed in type since the plan tree was created . * Ideally the plan will get invalidated and not re - used , but just in * case , we keep these defenses . Fortunately it ' s sufficient to check * once on the first time through . * * Note : ideally we ' d check typmod as well as typid , but that seems * impractical at the moment : in many cases the tupdesc will have been * generated by ExecTypeFromTL ( ) , and that can ' t guarantee to generate an * accurate typmod in all cases , because some expression node types don ' t * carry typmod . Fortunately , for precisely that reason , there should be * no places with a critical dependency on the typmod of a value . * * System attributes don ' t require checking since their types never * change . if (attnum > 0 )if (attnum > slot_tupdesc->natts) /* should never happen */ "attribute number %d exceeds number of columns %d" ,1 );/* Internal error: somebody forgot to expand it. */ if (attr->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)"unexpected virtual generated column reference" );if (attr->attisdropped)"attribute %d of type %s has been dropped" ,if (vartype != attr->atttypid)"attribute %d of type %s has wrong type" ,"Table has type %s, but query expects %s." ,/* * Verify that the slot is compatible with a EEOP_ * _ FETCHSOME operation . static void #ifdef USE_ASSERT_CHECKING/* there's nothing to check */ if (!op->d.fetch.fixed)return ;/* * Should probably fixed at some point , but for now it ' s easier to allow * buffer and heap tuples to be used interchangeably . if (slot->tts_ops == &TTSOpsBufferHeapTuple &&return ;if (slot->tts_ops == &TTSOpsHeapTuple &&return ;/* * At the moment we consider it OK if a virtual slot is used instead of a * specific type of slot , as a virtual slot never needs to be deformed . if (slot->tts_ops == &TTSOpsVirtual)return ;#endif /* * get_cached_rowtype : utility function to lookup a rowtype tupdesc * * type_id , typmod : identity of the rowtype * rowcache : space for caching identity info * ( rowcache - > cacheptr must be initialized to NULL ) * changed : if not NULL , * changed is set to true on any update * * The returned TupleDesc is not guaranteed pinned ; caller must pin it * to use it across any operation that might incur cache invalidation , * including for example detoasting of input tuples . * ( The TupleDesc is always refcounted , so just use IncrTupleDescRefCount . ) * * NOTE : because composite types can change contents , we must be prepared * to re - do this during any node execution ; cannot call just once during * expression initialization . static TupleDescbool *changed)if (type_id != RECORDOID)/* * It ' s a named composite type , so use the regular typcache . Do a * lookup first time through , or if the composite type changed . Note : * " tupdesc_id = = 0 " may look redundant , but it protects against the * admittedly - theoretical possibility that type_id was RECORDOID the * last time through , so that the cacheptr isn ' t TypeCacheEntry * . if (unlikely(typentry == NULL ||0 ||if (typentry->tupDesc == NULL)"type %s is not composite" ,if (changed)true ;return typentry->tupDesc;else /* * A RECORD type , once registered , doesn ' t change for the life of the * backend . So we don ' t need a typcache entry as such , which is good * because there isn ' t one . It ' s possible that the caller is asking * about a different type than before , though . if (unlikely(tupDesc == NULL ||0 ||/* Drop pin acquired by lookup_rowtype_tupdesc */ 0 ; /* not a valid value for non-RECORD */ if (changed)true ;return tupDesc;/* * Fast - path functions , for very simple expressions /* implementation of ExecJust(Inner|Outer|Scan)Var */ static pg_attribute_always_inline Datumbool *isnull)1 ];int attnum = op->d.var.attnum + 1 ;0 ], slot);/* * Since we use slot_getattr ( ) , we don ' t need to implement the FETCHSOME * step explicitly , and we also needn ' t Assert that the attnum is in range * - - - slot_getattr ( ) will take care of any problems . return slot_getattr(slot, attnum, isnull);/* Simple reference to inner Var */ static Datumbool *isnull)return ExecJustVarImpl(state, econtext->ecxt_innertuple, isnull);/* Simple reference to outer Var */ static Datumbool *isnull)return ExecJustVarImpl(state, econtext->ecxt_outertuple, isnull);/* Simple reference to scan Var */ static Datumbool *isnull)return ExecJustVarImpl(state, econtext->ecxt_scantuple, isnull);/* implementation of ExecJustAssign(Inner|Outer|Scan)Var */ static pg_attribute_always_inline Datumbool *isnull)1 ];int attnum = op->d.assign_var.attnum + 1 ;int resultnum = op->d.assign_var.resultnum;0 ], inslot);/* * We do not need CheckVarSlotCompatibility here ; that was taken care of * at compilation time . * * Since we use slot_getattr ( ) , we don ' t need to implement the FETCHSOME * step explicitly , and we also needn ' t Assert that the attnum is in range * - - - slot_getattr ( ) will take care of any problems . Nonetheless , check * that resultnum is in range . 0 && resultnum < outslot->tts_tupleDescriptor->natts);return 0 ;/* Evaluate inner Var and assign to appropriate column of result tuple */ static Datumbool *isnull)return ExecJustAssignVarImpl(state, econtext->ecxt_innertuple, isnull);/* Evaluate outer Var and assign to appropriate column of result tuple */ static Datumbool *isnull)return ExecJustAssignVarImpl(state, econtext->ecxt_outertuple, isnull);/* Evaluate scan Var and assign to appropriate column of result tuple */ static Datumbool *isnull)return ExecJustAssignVarImpl(state, econtext->ecxt_scantuple, isnull);/* Evaluate CASE_TESTVAL and apply a strict function to it */ static Datumbool *isnull)0 ];int nargs;/* * XXX with some redesign of the CaseTestExpr mechanism , maybe we could * get rid of this data shuffling ? /* strict function, so check for NULL args */ for (int argno = 0 ; argno < nargs; argno++)if (args[argno].isnull)true ;return (Datum) 0 ;false ;return d;/* Simple Const expression */ static Datumbool *isnull)0 ];return op->d.constval.value;/* implementation of ExecJust(Inner|Outer|Scan)VarVirt */ static pg_attribute_always_inline Datumbool *isnull)0 ];int attnum = op->d.var.attnum;/* * As it is guaranteed that a virtual slot is used , there never is a need * to perform tuple deforming ( nor would it be possible ) . Therefore * execExpr . c has not emitted an EEOP_ * _ FETCHSOME step . Verify , as much as * possible , that that determination was accurate . 0 && attnum < slot->tts_nvalid);return slot->tts_values[attnum];/* Like ExecJustInnerVar, optimized for virtual slots */ static Datumbool *isnull)return ExecJustVarVirtImpl(state, econtext->ecxt_innertuple, isnull);/* Like ExecJustOuterVar, optimized for virtual slots */ static Datumbool *isnull)return ExecJustVarVirtImpl(state, econtext->ecxt_outertuple, isnull);/* Like ExecJustScanVar, optimized for virtual slots */ static Datumbool *isnull)return ExecJustVarVirtImpl(state, econtext->ecxt_scantuple, isnull);/* implementation of ExecJustAssign(Inner|Outer|Scan)VarVirt */ static pg_attribute_always_inline Datumbool *isnull)0 ];int attnum = op->d.assign_var.attnum;int resultnum = op->d.assign_var.resultnum;/* see ExecJustVarVirtImpl for comments */ 0 && attnum < inslot->tts_nvalid);0 && resultnum < outslot->tts_tupleDescriptor->natts);return 0 ;/* Like ExecJustAssignInnerVar, optimized for virtual slots */ static Datumbool *isnull)return ExecJustAssignVarVirtImpl(state, econtext->ecxt_innertuple, isnull);/* Like ExecJustAssignOuterVar, optimized for virtual slots */ static Datumbool *isnull)return ExecJustAssignVarVirtImpl(state, econtext->ecxt_outertuple, isnull);/* Like ExecJustAssignScanVar, optimized for virtual slots */ static Datumbool *isnull)return ExecJustAssignVarVirtImpl(state, econtext->ecxt_scantuple, isnull);/* * implementation for hashing an inner Var , seeding with an initial value . static Datumbool *isnull)0 ];1 ];2 ];3 ];int attnum = innervar->d.var.attnum;0 ].value = econtext->ecxt_innertuple->tts_values[attnum];0 ].isnull = econtext->ecxt_innertuple->tts_isnull[attnum];1 );if (!fcinfo->args[0 ].isnull)false ;return UInt32GetDatum(hashkey);/* implementation of ExecJustHash(Inner|Outer)Var */ static pg_attribute_always_inline Datumbool *isnull)0 ];1 ];2 ];int attnum = var->d.var.attnum;0 ].value = slot->tts_values[attnum];0 ].isnull = slot->tts_isnull[attnum];false ;if (!fcinfo->args[0 ].isnull)return DatumGetUInt32(hashop->d.hashdatum.fn_addr(fcinfo));else return (Datum) 0 ;/* implementation for hashing an outer Var */ static Datumbool *isnull)return ExecJustHashVarImpl(state, econtext->ecxt_outertuple, isnull);/* implementation for hashing an inner Var */ static Datumbool *isnull)return ExecJustHashVarImpl(state, econtext->ecxt_innertuple, isnull);/* implementation of ExecJustHash(Inner|Outer)VarVirt */ static pg_attribute_always_inline Datumbool *isnull)0 ];1 ];int attnum = var->d.var.attnum;0 ].value = slot->tts_values[attnum];0 ].isnull = slot->tts_isnull[attnum];false ;if (!fcinfo->args[0 ].isnull)return DatumGetUInt32(hashop->d.hashdatum.fn_addr(fcinfo));else return (Datum) 0 ;/* Like ExecJustHashInnerVar, optimized for virtual slots */ static Datumbool *isnull)return ExecJustHashVarVirtImpl(state, econtext->ecxt_innertuple, isnull);/* Like ExecJustHashOuterVar, optimized for virtual slots */ static Datumbool *isnull)return ExecJustHashVarVirtImpl(state, econtext->ecxt_outertuple, isnull);/* * implementation for hashing an outer Var . Returns NULL on NULL input . static Datumbool *isnull)0 ];1 ];2 ];int attnum = var->d.var.attnum;0 ].value = econtext->ecxt_outertuple->tts_values[attnum];0 ].isnull = econtext->ecxt_outertuple->tts_isnull[attnum];if (!fcinfo->args[0 ].isnull)false ;return DatumGetUInt32(hashop->d.hashdatum.fn_addr(fcinfo));else /* return NULL on NULL input */ true ;return (Datum) 0 ;#if defined (EEO_USE_COMPUTED_GOTO)/* * Comparator used when building address - > opcode lookup table for * ExecEvalStepOp ( ) in the threaded dispatch case . static int const void *a, const void *b)const ExprEvalOpLookup *la = (const ExprEvalOpLookup *) a;const ExprEvalOpLookup *lb = (const ExprEvalOpLookup *) b;if (la->opcode < lb->opcode)return -1 ;else if (la->opcode > lb->opcode)return 1 ;return 0 ;#endif /* * Do one - time initialization of interpretation machinery . static void void )#if defined (EEO_USE_COMPUTED_GOTO)/* Set up externally-visible pointer to dispatch table */ if (dispatch_table == NULL)const void **)/* build reverse lookup table */ for (int i = 0 ; i < EEOP_LAST; i++)/* make it bsearch()able */ /* nmembers */ , sizeof (ExprEvalOpLookup),#endif /* * Function to return the opcode of an expression step . * * When direct - threading is in use , ExprState - > opcode isn ' t easily * decipherable . This function returns the appropriate enum member . #if defined (EEO_USE_COMPUTED_GOTO)if (state->flags & EEO_FLAG_DIRECT_THREADED)void *) op->opcode;/* nmembers */ , sizeof (ExprEvalOpLookup),/* unknown ops shouldn't get looked up */ return res->op;#endif return (ExprEvalOp) op->opcode;/* * Out - of - line helper functions for complex instructions . /* * Evaluate EEOP_FUNCEXPR_FUSAGE void false ;true );/* * Evaluate EEOP_FUNCEXPR_STRICT_FUSAGE void int nargs = op->d.func.nargs;/* strict function, so check for NULL args */ for (int argno = 0 ; argno < nargs; argno++)if (args[argno].isnull)true ;return ;false ;true );/* * Evaluate a PARAM_EXEC parameter . * * PARAM_EXEC params ( internal executor parameters ) are stored in the * ecxt_param_exec_vals array , and can be accessed by array index . void if (unlikely(prm->execPlan != NULL))/* Parameter not evaluated yet, so go do it */ /* ExecSetParamPlan should have processed this param... */ /* * Evaluate a PARAM_EXTERN parameter . * * PARAM_EXTERN parameters must be sought in ecxt_param_list_info . void int paramId = op->d.param.paramid;if (likely(paramInfo &&0 && paramId <= paramInfo->numParams))/* give hook a chance in case parameter is dynamic */ if (paramInfo->paramFetch != NULL)false , &prmdata);else 1 ];if (likely(OidIsValid(prm->ptype)))/* safety check in case hook did something unexpected */ if (unlikely(prm->ptype != op->d.param.paramtype))"type of parameter %d (%s) does not match that when preparing the plan (%s)" ,return ;"no value found for parameter %d" , paramId)));/* * Set value of a param ( currently always PARAM_EXEC ) from * op - > res { value , null } . void /* Shouldn't have a pending evaluation anymore */ /* * Evaluate a CoerceViaIO node in soft - error mode . * * The source value is in op ' s result variable . * * Note : This implements EEOP_IOCOERCE_SAFE . If you change anything here , * also look at the inline code for EEOP_IOCOERCE . void char *str;/* call output function (similar to OutputFunctionCall) */ if (*op->resnull)/* output functions are not called on nulls */ else 0 ].value = *op->resvalue;0 ].isnull = false ;false ;/* OutputFunctionCall assumes result isn't null */ /* call input function (similar to InputFunctionCallSafe) */ if (!op->d.iocoerce.finfo_in->fn_strict || str != NULL)0 ].value = PointerGetDatum(str);0 ].isnull = *op->resnull;/* second and third arguments are already set up */ /* ErrorSaveContext must be present. */ false ;if (SOFT_ERROR_OCCURRED(fcinfo_in->context))true ;0 ;return ;/* Should get null result if and only if str is NULL */ if (str == NULL)else /* * Evaluate a SQLValueFunction expression . void 0 );false ;/* * Note : current_schema ( ) can return NULL . current_user ( ) etc currently * cannot , but might as well code those cases the same way for safety . switch (svf->op)case SVFOP_CURRENT_DATE:break ;case SVFOP_CURRENT_TIME:case SVFOP_CURRENT_TIME_N:break ;case SVFOP_CURRENT_TIMESTAMP:case SVFOP_CURRENT_TIMESTAMP_N:break ;case SVFOP_LOCALTIME:case SVFOP_LOCALTIME_N:break ;case SVFOP_LOCALTIMESTAMP:case SVFOP_LOCALTIMESTAMP_N:break ;case SVFOP_CURRENT_ROLE:case SVFOP_CURRENT_USER:case SVFOP_USER:0 , InvalidOid, NULL, NULL);break ;case SVFOP_SESSION_USER:0 , InvalidOid, NULL, NULL);break ;case SVFOP_CURRENT_CATALOG:0 , InvalidOid, NULL, NULL);break ;case SVFOP_CURRENT_SCHEMA:0 , InvalidOid, NULL, NULL);break ;/* * Raise error if a CURRENT OF expression is evaluated . * * The planner should convert CURRENT OF into a TidScan qualification , or some * other special handling in a ForeignScan node . So we have to be able to do * ExecInitExpr on a CurrentOfExpr , but we shouldn ' t ever actually execute it . * If we get here , we suppose we must be dealing with CURRENT OF on a foreign * table whose FDW doesn ' t handle it , and complain accordingly . void "WHERE CURRENT OF is not supported for this table type" )));/* * Evaluate NextValueExpr . void false );switch (op->d.nextvalueexpr.seqtypid)case INT2OID:break ;case INT4OID:break ;case INT8OID:break ;default :"unsupported sequence type %u" ,false ;/* * Evaluate NullTest / IS NULL for rows . void true );/* * Evaluate NullTest / IS NOT NULL for rows . void false );/* Common code for IS [NOT] NULL on a row value */ static void bool checkisnull)bool isnull = *op->resnull;false ;/* NULL row variables are treated just as NULL scalar columns */ if (isnull)return ;/* * The SQL standard defines IS [ NOT ] NULL for a non - null rowtype argument * as : * * " R IS NULL " is true if every field is the null value . * * " R IS NOT NULL " is true if no field is the null value . * * This definition is ( apparently intentionally ) not recursive ; so our * tests on the fields are primitive attisnull tests , not recursive checks * to see if they are all - nulls or no - nulls rowtypes . * * The standard does not consider the possibility of zero - field rows , but * here we consider them to vacuously satisfy both predicates . /* Lookup tupdesc if first time through or if type changes */ /* * heap_attisnull needs a HeapTuple not a bare HeapTupleHeader . for (int att = 1 ; att <= tupDesc->natts; att++)/* ignore dropped columns */ if (TupleDescCompactAttr(tupDesc, att - 1 )->attisdropped)continue ;if (heap_attisnull(&tmptup, att, tupDesc))/* null field disproves IS NOT NULL */ if (!checkisnull)false );return ;else /* non-null field disproves IS NULL */ if (checkisnull)false );return ;true );/* * Evaluate an ARRAY [ ] expression . * * The individual array elements ( or subarrays ) have already been evaluated * into op - > d . arrayexpr . elemvalues [ ] / elemnulls [ ] . void int nelems = op->d.arrayexpr.nelems;int ndims = 0 ;int dims[MAXDIM];int lbs[MAXDIM];/* Set non-null as default */ false ;if (!op->d.arrayexpr.multidims)/* Elements are presumably of scalar type */ bool *dnulls = op->d.arrayexpr.elemnulls;/* setup for 1-D array of the given length */ 1 ;0 ] = nelems;0 ] = 1 ;else /* Must be nested array expressions */ int nbytes = 0 ;int nitems;int outer_nelems = 0 ;int elem_ndims = 0 ;int *elem_dims = NULL;int *elem_lbs = NULL;bool firstone = true ;bool havenulls = false ;bool haveempty = false ;char **subdata;int *subbytes;int *subnitems;char *dat;int iitem;char **) palloc(nelems * sizeof (char *));sizeof (bits8 *));int *) palloc(nelems * sizeof (int ));int *) palloc(nelems * sizeof (int ));/* loop through and get data area from each element */ for (int elemoff = 0 ; elemoff < nelems; elemoff++)bool eisnull;int this_ndims;/* temporarily ignore null subarrays */ if (eisnull)true ;continue ;/* run-time double-check on element type */ if (element_type != ARR_ELEMTYPE(array))"cannot merge incompatible arrays" ),"Array with element type %s cannot be " "included in ARRAY construct with element type %s." ,/* temporarily ignore zero-dimensional subarrays */ if (this_ndims <= 0 )true ;continue ;if (firstone)/* Get sub-array details from first member */ 1 ;if (ndims <= 0 || ndims > MAXDIM)"number of array dimensions (%d) exceeds the maximum allowed (%d)" ,int *) palloc(elem_ndims * sizeof (int ));sizeof (int ));int *) palloc(elem_ndims * sizeof (int ));sizeof (int ));false ;else /* Check other sub-arrays are compatible */ if (elem_ndims != this_ndims ||sizeof (int )) != 0 ||sizeof (int )) != 0 )"multidimensional arrays must have array " "expressions with matching dimensions" )));/* check for overflow of total request */ if (!AllocSizeIsValid(nbytes))"array size exceeds the maximum allowed (%d)" ,int ) MaxAllocSize)));/* * If all items were null or empty arrays , return an empty array ; * otherwise , if some were and some weren ' t , raise error . ( Note : we * must special - case this somehow to avoid trying to generate a 1 - D * array formed from empty arrays . It ' s not ideal . . . ) if (haveempty)if (ndims == 0 ) /* didn't find any nonempty array */ return ;"multidimensional arrays must have array " "expressions with matching dimensions" )));/* setup for multi-D array */ 0 ] = outer_nelems;0 ] = 1 ;for (int i = 1 ; i < ndims; i++)1 ];1 ];/* check for subscript overflow */ if (havenulls)else 0 ; /* marker for no null bitmap */ sizeof (int ));sizeof (int ));0 ;for (int i = 0 ; i < outer_nelems; i++)if (havenulls)0 ,/* * Evaluate an ArrayCoerceExpr expression . * * Source array is in step ' s result variable . void /* NULL array -> NULL result */ if (*op->resnull)return ;/* * If it ' s binary - compatible , modify the element type in the array header , * but otherwise leave the array as we received it . if (op->d.arraycoerce.elemexprstate == NULL)/* Detoast input array if necessary, and copy in any case */ return ;/* * Use array_map to apply the sub - expression to each array element . /* * Evaluate a ROW ( ) expression . * * The individual columns have already been evaluated into * op - > d . row . elemvalues [ ] / elemnulls [ ] . void /* build tuple from evaluated field values */ false ;/* * Evaluate GREATEST ( ) or LEAST ( ) expression ( note this is * not * MIN ( ) / MAX ( ) ) . * * All of the to - be - compared expressions have already been evaluated into * op - > d . minmax . values [ ] / nulls [ ] . void bool *nulls = op->d.minmax.nulls;operator = op->d.minmax.op;/* set at initialization */ 0 ].isnull == false );1 ].isnull == false );/* default to null result */ true ;for (int off = 0 ; off < op->d.minmax.nelems; off++)/* ignore NULL inputs */ if (nulls[off])continue ;if (*op->resnull)/* first nonnull input, adopt value */ false ;else int cmpresult;/* apply comparison function */ 0 ].value = *op->resvalue;1 ].value = values[off];false ;if (fcinfo->isnull) /* probably should not happen */ continue ;if (cmpresult > 0 && operator == IS_LEAST)else if (cmpresult < 0 && operator == IS_GREATEST)/* * Evaluate a FieldSelect node . * * Source record is in step ' s result variable . void /* NULL record -> NULL result */ if (*op->resnull)return ;/* We can special-case expanded records for speed */ if (VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(tupDatum)))/* Extract record's TupleDesc */ /* * Find field ' s attr record . Note we don ' t support system columns * here : a datum tuple doesn ' t have valid values for most of the * interesting system columns anyway . if (fieldnum <= 0 ) /* should never happen */ "unsupported reference to system column %d in FieldSelect" ,if (fieldnum > tupDesc->natts) /* should never happen */ "attribute number %d exceeds number of columns %d" ,1 );/* Check for dropped column, and force a NULL result if so */ if (attr->attisdropped)true ;return ;/* Check for type mismatch --- possible after ALTER COLUMN TYPE? */ /* As in CheckVarSlotCompatibility, we should but can't check typmod */ if (op->d.fieldselect.resulttype != attr->atttypid)"attribute %d has wrong type" , fieldnum),"Table has type %s, but query expects %s." ,/* extract the field */ else /* Get the composite datum and extract its type fields */ /* Lookup tupdesc if first time through or if type changes */ /* * Find field ' s attr record . Note we don ' t support system columns * here : a datum tuple doesn ' t have valid values for most of the * interesting system columns anyway . if (fieldnum <= 0 ) /* should never happen */ "unsupported reference to system column %d in FieldSelect" ,if (fieldnum > tupDesc->natts) /* should never happen */ "attribute number %d exceeds number of columns %d" ,1 );/* Check for dropped column, and force a NULL result if so */ if (attr->attisdropped)true ;return ;/* Check for type mismatch --- possible after ALTER COLUMN TYPE? */ /* As in CheckVarSlotCompatibility, we should but can't check typmod */ if (op->d.fieldselect.resulttype != attr->atttypid)"attribute %d has wrong type" , fieldnum),"Table has type %s, but query expects %s." ,/* heap_getattr needs a HeapTuple not a bare HeapTupleHeader */ /* extract the field */ /* * Deform source tuple , filling in the step ' s values / nulls arrays , before * evaluating individual new values as part of a FieldStore expression . * Subsequent steps will overwrite individual elements of the values / nulls * arrays with the new field values , and then FIELDSTORE_FORM will build the * new tuple value . * * Source record is in step ' s result variable . void if (*op->resnull)/* Convert null input tuple into an all-nulls row */ true ,sizeof (bool ));else /* * heap_deform_tuple needs a HeapTuple not a bare HeapTupleHeader . We * set all the fields in the struct just in case . /* * Lookup tupdesc if first time through or if type changes . Because * we don ' t pin the tupdesc , we must not do this lookup until after * doing DatumGetHeapTupleHeader : that could do database access while * detoasting the datum . 1 ,/* Check that current tupdesc doesn't have more fields than allocated */ if (unlikely(tupDesc->natts > op->d.fieldstore.ncolumns))"too many columns in composite type %u" ,/* * Compute the new composite datum after each individual field value of a * FieldStore expression has been evaluated . void /* Lookup tupdesc (should be valid already) */ 1 ,false ;/* * Evaluate a rowtype coercion operation . * This may require rearranging field positions . * * Source record is in step ' s result variable . void bool changed = false ;/* NULL in -> NULL out */ if (*op->resnull)return ;/* * Lookup tupdescs if first time through or if type changes . We ' d better * pin them since type conversion functions could do catalog lookups and * hence cause cache invalidation . 1 ,1 ,/* * We used to be able to assert that incoming tuples are marked with * exactly the rowtype of indesc . However , now that ExecEvalWholeRowVar * might change the tuples ' marking to plain RECORD due to inserting * aliases , we can only make this weak test : /* if first time through, or after change, initialize conversion map */ if (changed)/* allocate map in long-lived memory context */ /* prepare map from old to new attribute numbers */ /* Following steps need a HeapTuple not a bare HeapTupleHeader */ if (op->d.convert_rowtype.map != NULL)/* Full conversion with attribute rearrangement needed */ /* Result already has appropriate composite-datum header fields */ else /* * The tuple is physically compatible as - is , but we need to insert the * destination rowtype OID in its composite - datum header field , so we * have to copy it anyway . heap_copy_tuple_as_datum ( ) is convenient * for this since it will both make the physical copy and insert the * correct composite header fields . Note that we aren ' t expecting to * have to flatten any toasted fields : the input was a composite * datum , so it shouldn ' t contain any . So heap_copy_tuple_as_datum ( ) * is overkill here , but its check for external fields is cheap . /* * Evaluate " scalar op ANY / ALL ( array ) " . * * Source array is in our result area , scalar arg is already evaluated into * fcinfo - > args [ 0 ] . * * The operator always yields boolean , and we combine the results across all * array elements using OR and AND ( for ANY and ALL respectively ) . Of course * we short - circuit as soon as the result is known . void bool useOr = op->d.scalararrayop.useOr;bool strictfunc = op->d.scalararrayop.finfo->fn_strict;int nitems;bool resultnull;/* * If the array is NULL then we return NULL - - - it ' s not very meaningful * to do anything else , even if the operator isn ' t strict . if (*op->resnull)return ;/* Else okay to fetch and detoast the array */ /* * If the array is empty , we return either FALSE or TRUE per the useOr * flag . This is correct even if the scalar is NULL ; since we would * evaluate the operator zero times , it matters not whether it would want * to return NULL . if (nitems <= 0 )false ;return ;/* * If the scalar is NULL , and the function is strict , return NULL ; no * point in iterating the loop . if (fcinfo->args[0 ].isnull && strictfunc)true ;return ;/* * We arrange to look up info about the element type only once per series * of calls , assuming the element type doesn ' t change underneath us . if (op->d.scalararrayop.element_type != ARR_ELEMTYPE(arr))/* * Shared helper for ExecEvalScalarArrayOp ( ) and the NULL - LHS fallback for * non - strict ExecEvalHashedScalarArrayOp ( ) . * * Callers must handle the strict LHS - is - NULL ; return NULL fast path prior to * calling this . static pg_attribute_always_inline void bool typbyval, char typalign,bool useOr, Datum *result, bool *resultnull)int nitems;char *s;int bitmask;bool strictfunc = fcinfo->flinfo->fn_strict;/* Initialize result appropriately depending on useOr */ false ;/* Loop over the array elements */ char *) ARR_DATA_PTR(arr);1 ;for (int i = 0 ; i < nitems; i++)/* Get array element, checking for NULL */ if (bitmap && (*bitmap & bitmask) == 0 )1 ].value = (Datum) 0 ;1 ].isnull = true ;else char *) att_align_nominal(s, typalign);1 ].value = elt;1 ].isnull = false ;/* Call comparison function */ if (fcinfo->args[1 ].isnull && strictfunc)true ;0 ;else false ;/* Combine results per OR or AND semantics */ if (fcinfo->isnull)true ;else if (useOr)if (DatumGetBool(thisresult))true );false ;break ; /* needn't look at any more elements */ else if (!DatumGetBool(thisresult))false );false ;break ; /* needn't look at any more elements */ /* advance bitmap pointer if any */ if (bitmap)1 ;if (bitmask == 0 x100)1 ;/* * Hash function for scalar array hash op elements . * * We use the element type ' s default hash opclass , and the column collation * if the type is collation - sensitive . static uint32struct saophash_hash *tb, Datum key)data;0 ].value = key;0 ].isnull = false ;return DatumGetUInt32(hash);/* * Matching function for scalar array hash op elements , to be used in hashtable * lookups . static bool struct saophash_hash *tb, Datum key1, Datum key2)data;0 ].value = key1;0 ].isnull = false ;1 ].value = key2;1 ].isnull = false ;return DatumGetBool(result);/* * Evaluate " scalar op ANY ( const array ) " . * * Similar to ExecEvalScalarArrayOp , but optimized for faster repeat lookups * by building a hashtable on the first lookup . This hashtable will be reused * by subsequent lookups . Unlike ExecEvalScalarArrayOp , this version only * supports OR semantics . * * Source array is in our result area , scalar arg is already evaluated into * fcinfo - > args [ 0 ] . * * The operator always yields boolean . void )bool inclause = op->d.hashedscalararrayop.inclause;bool strictfunc = op->d.hashedscalararrayop.finfo->fn_strict;0 ].value;bool scalar_isnull = fcinfo->args[0 ].isnull;bool resultnull;bool hashfound;/* We don't setup a hashed scalar array op if the array const is null. */ /* * If the scalar is NULL , and the function is strict , return NULL ; no * point in executing the search . if (scalar_isnull && strictfunc)true ;return ;/* Build the hash table on first evaluation */ if (elements_tab == NULL)bool typbyval;char typalign;int nitems;bool has_nulls = false ;char *s;int bitmask;1 ));1 ,/* * Create the hash table sizing it according to the number of elements * in the array . This does assume that the array has no duplicates . * If the array happens to contain many duplicate values then it ' ll * just mean that we sized the table a bit on the large side . char *) ARR_DATA_PTR(arr);1 ;for (int i = 0 ; i < nitems; i++)/* Get array element, checking for NULL. */ if (bitmap && (*bitmap & bitmask) == 0 )true ;else char *) att_align_nominal(s, typalign);/* Advance bitmap pointer if any. */ if (bitmap)1 ;if (bitmask == 0 x100)1 ;/* * Remember if we had any nulls so that we know if we need to execute * non - strict functions with a null lhs value if no match is found . /* * When we have a non - strict equality function , check and cache the * result from looking up a NULL . Non - strict functions are free to * treat a NULL as equal to any other value , e . g . a 0 or an empty * string . Here we perform a linear search over the array and cache * the outcome so that we can use that result any time we receive a * NULL . if (!strictfunc)bool null_lhs_result;0 ].value = (Datum) 0 ;0 ].isnull = true ;true , &result,/* invert non-NULL results for NOT IN */ if (!resultnull && !inclause)/* * When looking up an SQL NULL value with non - strict functions , we defer * to the value we cached when building the hash table . if (scalar_isnull)return ;/* Check the hash to see if we have a match. */ /* the result depends on if the clause is an IN or NOT IN clause */ if (inclause)/* IN */ else /* NOT IN */ false ;/* * If we didn ' t find a match in the array , we still might need to handle * the possibility of null values . We didn ' t put any NULLs into the * hashtable , but instead marked if we found any when building the table * in has_nulls . if (!hashfound && op->d.hashedscalararrayop.has_nulls)if (strictfunc)/* * We have nulls in the array so a non - null lhs and no match must * yield NULL . 0 ;true ;else /* * Execute function will null rhs just once . * * The hash lookup path will have scribbled on the lhs argument so * we need to set it up also ( even though we entered this function * with it already set ) . 0 ].value = scalar;0 ].isnull = scalar_isnull;1 ].value = (Datum) 0 ;1 ].isnull = true ;/* * Reverse the result for NOT IN clauses since the above function * is the equality function and we need not - equals . if (!inclause)/* * Evaluate a NOT NULL domain constraint . void if (*op->resnull)"domain %s does not allow null values" ,/* * Evaluate a CHECK domain constraint . void if (!*op->d.domaincheck.checknull &&"value for domain %s violates check constraint \" %s\"" ,/* * Evaluate the various forms of XmlExpr . * * Arguments have been evaluated into named_argvalue / named_argnull * and / or argvalue / argnull arrays . void true ; /* until we get a result */ 0 ;switch (xexpr->op)case IS_XMLCONCAT:bool *argnull = op->d.xmlexpr.argnull;for (int i = 0 ; i < list_length(xexpr->args); i++)if (!argnull[i])if (values != NIL)false ;break ;case IS_XMLFOREST:bool *argnull = op->d.xmlexpr.named_argnull;int i;0 ;char *argname = strVal(lfirst(lc2));if (!argnull[i])"<%s>%s</%s>" ,true ),false ;if (!*op->resnull)break ;case IS_XMLELEMENT:false ;break ;case IS_XMLPARSE:bool *argnull = op->d.xmlexpr.argnull;bool preserve_whitespace;/* arguments are known to be text, bool */ 2 );if (argnull[0 ])return ;0 ];if (argnull[1 ]) /* probably can't happen */ return ;1 ];false ;break ;case IS_XMLPI:bool isnull;/* optional argument is known to be text */ 1 );if (xexpr->args)0 ];if (isnull)else 0 ]);else false ;break ;case IS_XMLROOT:bool *argnull = op->d.xmlexpr.argnull;int standalone;/* arguments are known to be xml, text, int */ 3 );if (argnull[0 ])return ;0 ]);if (argnull[1 ])else 1 ]);2 ]); /* always present */ 2 ]);false ;break ;case IS_XMLSERIALIZE:bool *argnull = op->d.xmlexpr.argnull;/* argument type is known to be xml */ 1 );if (argnull[0 ])return ;0 ];false ;break ;case IS_DOCUMENT:bool *argnull = op->d.xmlexpr.argnull;/* optional argument is known to be xml */ 1 );if (argnull[0 ])return ;0 ];false ;break ;default :"unrecognized XML operation" );break ;/* * Evaluate a JSON constructor expression . void bool is_jsonb = ctor->returning->format->format_type == JS_FORMAT_JSONB;bool isnull = false ;if (ctor->type == JSCTOR_JSON_ARRAY)else if (ctor->type == JSCTOR_JSON_OBJECT)else if (ctor->type == JSCTOR_JSON_SCALAR)if (jcstate->arg_nulls[0 ])0 ;true ;else 0 ];0 ].outfuncid;0 ].category;if (is_jsonb)else else if (ctor->type == JSCTOR_JSON_PARSE)if (jcstate->arg_nulls[0 ])0 ;true ;else 0 ];if (is_jsonb)true );else void ) json_validate(js, true , true );else "invalid JsonConstructorExpr type %d" , ctor->type);/* * Evaluate a IS JSON predicate . void bool res;if (*op->resnull)false );return ;if (exprtype == TEXTOID || exprtype == JSONOID)if (pred->item_type == JS_TYPE_ANY)true ;else switch (json_get_first_token(json, false ))case JSON_TOKEN_OBJECT_START:break ;case JSON_TOKEN_ARRAY_START:break ;case JSON_TOKEN_STRING:case JSON_TOKEN_NUMBER:case JSON_TOKEN_TRUE:case JSON_TOKEN_FALSE:case JSON_TOKEN_NULL:break ;default :false ;break ;/* * Do full parsing pass only for uniqueness check or for JSON text * validation . if (res && (pred->unique_keys || exprtype == TEXTOID))false );else if (exprtype == JSONBOID)if (pred->item_type == JS_TYPE_ANY)true ;else switch (pred->item_type)case JS_TYPE_OBJECT:break ;case JS_TYPE_ARRAY:break ;case JS_TYPE_SCALAR:break ;default :false ;break ;/* Key uniqueness check is redundant for jsonb */ else false ;/* * Evaluate a jsonpath against a document , both of which must have been * evaluated and their values saved in op - > d . jsonexpr . jsestate . * * If an error occurs during JsonPath * evaluation or when coercing its result * to the RETURNING type , JsonExprState . error is set to true , provided the * ON ERROR behavior is not ERROR . Similarly , if JsonPath { Query | Value } ( ) found * no matching items , JsonExprState . empty is set to true , provided the ON EMPTY * behavior is not ERROR . That is to signal to the subsequent steps that check * those flags to return the ON ERROR / ON EMPTY expression . * * Return value is the step address to be performed next . It will be one of * jump_error , jump_empty , jump_eval_coercion , or jump_end , all given in * op - > d . jsonexpr . jsestate . int bool throw_error = jsexpr->on_error->btype == JSON_BEHAVIOR_ERROR;bool error = false ,false ;int jump_eval_coercion = jsestate->jump_eval_coercion;char *val_string = NULL;/* Set error/empty to false. */ 0 , sizeof (NullableDatum));0 , sizeof (NullableDatum));/* Also reset ErrorSaveContext contents for the next row. */ if (jsestate->escontext.details_wanted)false ;false ;switch (jsexpr->op)case JSON_EXISTS_OP:bool exists = JsonPathExists(item, path,if (!error)false ;break ;case JSON_QUERY_OP:break ;case JSON_VALUE_OP:if (jbv == NULL)/* Will be coerced with json_populate_type(), if needed. */ 0 ;true ;else if (!error && !empty)if (jsexpr->returning->typid == JSONOID ||else if (jsexpr->use_json_coercion)false ;else /* * Simply convert to the default RETURNING type ( text ) * if no coercion needed . if (!jsexpr->use_io_coercion)break ;/* JSON_TABLE_OP can't happen here */ default :"unrecognized SQL/JSON expression op %d" ,int ) jsexpr->op);return false ;/* * Coerce the result value to the RETURNING type by calling its input * function . if (!*op->resnull && jsexpr->use_io_coercion)1 );0 ].value = PointerGetDatum(val_string);0 ].isnull = *op->resnull;/* * Second and third arguments are already set up in * ExecInitJsonExpr ( ) . false ;if (SOFT_ERROR_OCCURRED(&jsestate->escontext))true ;/* * When setting up the ErrorSaveContext ( if needed ) for capturing the * errors that occur when coercing the JsonBehavior expression , set * details_wanted to be able to show the actual error message as the * DETAIL of the error message that tells that it is the JsonBehavior * expression that caused the error ; see ExecEvalJsonCoercionFinish ( ) . /* Handle ON EMPTY. */ if (empty)0 ;true ;if (jsexpr->on_empty)if (jsexpr->on_empty->btype != JSON_BEHAVIOR_ERROR)true );/* Set up to catch coercion errors of the ON EMPTY value. */ false ;true ;/* Jump to end if the ON EMPTY behavior is to return NULL */ return jsestate->jump_empty >= 0 ? jsestate->jump_empty : jsestate->jump_end;else if (jsexpr->on_error->btype != JSON_BEHAVIOR_ERROR)true );/* Set up to catch coercion errors of the ON ERROR value. */ false ;true ;/* Jump to end if the ON ERROR behavior is to return NULL */ return jsestate->jump_error >= 0 ? jsestate->jump_error : jsestate->jump_end;if (jsexpr->column_name)"no SQL/JSON item found for specified path of column \" %s\"" ,else "no SQL/JSON item found for specified path" ));/* * ON ERROR . Wouldn ' t get here if the behavior is ERROR , because they * would have already been thrown . if (error)0 ;true ;true );/* Set up to catch coercion errors of the ON ERROR value. */ false ;true ;/* Jump to end if the ON ERROR behavior is to return NULL */ return jsestate->jump_error >= 0 ? jsestate->jump_error : jsestate->jump_end;return jump_eval_coercion >= 0 ? jump_eval_coercion : jsestate->jump_end;/* * Convert the given JsonbValue to its C string representation * * * resnull is set if the JsonbValue is a jbvNull . static char *bool *resnull)false ;/* get coercion state reference and datum of the corresponding SQL type */ switch (item->type)case jbvNull:true ;return NULL;case jbvString:char *str = palloc(item->val.string.len + 1 );'\0' ;return str;case jbvNumeric:return DatumGetCString(DirectFunctionCall1(numeric_out,case jbvBool:return DatumGetCString(DirectFunctionCall1(boolout,case jbvDatetime:switch (item->val.datetime.typid)case DATEOID:return DatumGetCString(DirectFunctionCall1(date_out,case TIMEOID:return DatumGetCString(DirectFunctionCall1(time_out,case TIMETZOID:return DatumGetCString(DirectFunctionCall1(timetz_out,case TIMESTAMPOID:return DatumGetCString(DirectFunctionCall1(timestamp_out,case TIMESTAMPTZOID:return DatumGetCString(DirectFunctionCall1(timestamptz_out,default :"unexpected jsonb datetime type oid %u" ,break ;case jbvArray:case jbvObject:case jbvBinary:return DatumGetCString(DirectFunctionCall1(jsonb_out,default :"unexpected jsonb value type %d" , item->type);false );true ;return NULL;/* * Coerce a jsonb value produced by ExecEvalJsonExprPath ( ) or an ON ERROR / * ON EMPTY behavior expression to the target type . * * Any soft errors that occur here will be checked by * EEOP_JSONEXPR_COERCION_FINISH that will run after this . void /* * Prepare to call json_populate_type ( ) to coerce the boolean result of * JSON_EXISTS_OP to the target type . If the target type is integer or a * domain over integer , call the boolean - to - integer cast function instead , * because the integer ' s input function ( which is what * json_populate_type ( ) calls to coerce to scalar target types ) doesn ' t * accept boolean literals as valid input . We only have a special case * for integer and domains thereof as it seems common to use those types * for EXISTS columns in JSON_TABLE ( ) . if (op->d.jsonexpr_coercion.exists_coerce)if (op->d.jsonexpr_coercion.exists_cast_to_int)/* Check domain constraints if any. */ if (op->d.jsonexpr_coercion.exists_check_domain &&true ;0 ;else return ;"true" ) :"false" ));static char */* * The order of array elements must correspond to the order of * JsonBehaviorType members . const char *behavior_names[] ="NULL" ,"ERROR" ,"EMPTY" ,"TRUE" ,"FALSE" ,"UNKNOWN" ,"EMPTY ARRAY" ,"EMPTY OBJECT" ,"DEFAULT" return pstrdup(behavior_names[behavior->btype]);/* * Checks if an error occurred in ExecEvalJsonCoercion ( ) . If so , this sets * JsonExprState . error to trigger the ON ERROR handling steps , unless the * error is thrown when coercing a JsonBehavior value . void if (SOFT_ERROR_OCCURRED(&jsestate->escontext))/* * jsestate - > error or jsestate - > empty being set means that the error * occurred when coercing the JsonBehavior value . Throw the error in * that case with the actual coercion error message shown in the * DETAIL part . if (DatumGetBool(jsestate->error.value))/*- translator: first %s is a SQL/JSON clause (e.g. ON ERROR) */ "could not coerce %s expression (%s) to the RETURNING type" ,"ON ERROR" ,"%s" , jsestate->escontext.error_data->message)));else if (DatumGetBool(jsestate->empty.value))/*- translator: first %s is a SQL/JSON clause (e.g. ON ERROR) */ "could not coerce %s expression (%s) to the RETURNING type" ,"ON EMPTY" ,"%s" , jsestate->escontext.error_data->message)));0 ;true ;true );/* * Reset for next use such as for catching errors when coercing a * JsonBehavior expression . false ;true ;/* * ExecEvalGroupingFunc * * Computes a bitmask with a bit for each ( unevaluated ) argument expression * ( rightmost arg is least significant bit ) . * * A bit is set if the corresponding expression is NOT part of the set of * grouping expressions in the current grouping set . void int result = 0 ;int attnum = lfirst_int(lc);1 ;if (!bms_is_member(attnum, grouped_cols))1 ;false ;/* * ExecEvalMergeSupportFunc * * Returns information about the current MERGE action for its RETURNING list . void if (!relaction)"no merge action in progress" );/* Return the MERGE action ("INSERT", "UPDATE", or "DELETE") */ switch (relaction->mas_action->commandType)case CMD_INSERT:"INSERT" , 6 ));false ;break ;case CMD_UPDATE:"UPDATE" , 6 ));false ;break ;case CMD_DELETE:"DELETE" , 6 ));false ;break ;case CMD_NOTHING:"unexpected merge action: DO NOTHING" );break ;default :"unrecognized commandType: %d" ,int ) relaction->mas_action->commandType);/* * Hand off evaluation of a subplan to nodeSubplan . c void /* could potentially be nested, so make sure there's enough stack */ /* * Evaluate a wholerow Var expression . * * Returns a Datum whose value is the value of a whole - row range variable * with respect to given expression context . void /* This was checked by ExecInitExpr */ /* Get the input slot we want */ switch (variable->varno)case INNER_VAR:/* get the tuple from the inner node */ break ;case OUTER_VAR:/* get the tuple from the outer node */ break ;/* INDEX_VAR is handled by default case */ default :/* * Get the tuple from the relation being scanned . * * By default , this uses the " scan " tuple slot , but a wholerow Var * in the RETURNING list may explicitly refer to OLD / NEW . If the * OLD / NEW row doesn ' t exist , we just return NULL . switch (variable->varreturningtype)case VAR_RETURNING_DEFAULT:break ;case VAR_RETURNING_OLD:if (state->flags & EEO_FLAG_OLD_IS_NULL)0 ;true ;return ;break ;case VAR_RETURNING_NEW:if (state->flags & EEO_FLAG_NEW_IS_NULL)0 ;true ;return ;break ;break ;/* Apply the junkfilter if any */ if (op->d.wholerow.junkFilter != NULL)/* * If first time through , obtain tuple descriptor and check compatibility . * * XXX : It ' d be great if this could be moved to the expression * initialization phase , but due to using slots that ' s currently not * feasible . if (op->d.wholerow.first)/* optimistically assume we don't need slow path */ false ;/* * If the Var identifies a named composite type , we must check that * the actual tuple type is compatible with it . if (variable->vartype != RECORDOID)/* * We really only care about numbers of attributes and data types . * Also , we can ignore type mismatch on columns that are dropped * in the destination type , so long as ( 1 ) the physical storage * matches or ( 2 ) the actual column value is NULL . Case ( 1 ) is * helpful in some cases involving out - of - date cached plans , while * case ( 2 ) is expected behavior in situations such as an INSERT * into a table with dropped columns ( the planner typically * generates an INT4 NULL regardless of the dropped column type ) . * If we find a dropped column and cannot verify that case ( 1 ) * holds , we have to use the slow path to check ( 2 ) for each row . * * If vartype is a domain over composite , just look through that * to the base composite type . 1 , false );if (var_tupdesc->natts != slot_tupdesc->natts)"table row type and query-specified row type do not match" ),"Table row contains %d attribute, but query expects %d." ,"Table row contains %d attributes, but query expects %d." ,for (int i = 0 ; i < var_tupdesc->natts; i++)if (vattr->atttypid == sattr->atttypid)continue ; /* no worries */ if (!vattr->attisdropped)"table row type and query-specified row type do not match" ),"Table has type %s at ordinal position %d, but query expects %s." ,1 ,if (vattr->attlen != sattr->attlen ||true ; /* need to check for nulls */ /* * Use the variable ' s declared rowtype as the descriptor for the * output values . In particular , we * must * absorb any * attisdropped markings . else /* * In the RECORD case , we use the input slot ' s rowtype as the * descriptor for the output values , modulo possibly assigning new * column names below . /* * It ' s possible that the input slot is a relation scan slot and * so is marked with that relation ' s rowtype . But we ' re supposed * to be returning RECORD , so reset to that . 1 ;/* * We already got the correct physical datatype info above , but * now we should try to find the source RTE and adopt its column * aliases , since it ' s unlikely that the input slot has the * desired names . * * If we can ' t locate the RTE , assume the column names we ' ve got * are OK . ( As of this writing , the only cases where we can ' t * locate the RTE are in execution of trigger WHEN clauses , and * then the Var will have the trigger ' s relation ' s rowtype , so its * names are fine . ) Also , if the creator of the RTE didn ' t bother * to fill in an eref field , assume our column names are OK . ( This * happens in COPY , and perhaps other places . ) if (econtext->ecxt_estate &&if (rte->eref)/* Bless the tupdesc if needed, and save it in the execution state */ false ;/* * Make sure all columns of the slot are accessible in the slot ' s * Datum / isnull arrays . if (op->d.wholerow.slow)/* Check to see if any dropped attributes are non-null */ for (int i = 0 ; i < var_tupdesc->natts; i++)if (!vattr->attisdropped)continue ; /* already checked non-dropped cols */ if (slot->tts_isnull[i])continue ; /* null is always okay */ if (vattr->attlen != sattr->attlen ||"table row type and query-specified row type do not match" ),"Physical storage mismatch on dropped attribute at ordinal position %d." ,1 )));/* * Build a composite datum , making sure any toasted fields get detoasted . * * ( Note : it is critical that we not change the slot ' s state here . ) /* * Label the datum with the composite type info we identified before . * * ( Note : we could skip doing this by passing op - > d . wholerow . tupdesc to * the tuple build step ; but that seems a tad risky so let ' s not . ) false ;void /* OLD/NEW system attribute is NULL if OLD/NEW row is NULL */ if ((op->d.var.varreturningtype == VAR_RETURNING_OLD &&0 ;true ;return ;/* slot_getsysattr has sufficient defenses against bad attnums */ /* this ought to be unreachable, but it's cheap enough to check */ if (unlikely(*op->resnull))"failed to fetch attribute from slot" );/* * Transition value has not been initialized . This is the first non - NULL input * value for a group . We use it as the initial value for transValue . void roup,/* * We must copy the datum into aggcontext if it is pass - by - ref . We do not * need to pfree the old transValue , since it ' s NULL . ( We already checked * that the agg ' s input type is binary - compatible with its transtype , so * straight copy here is OK . ) 1 ].value,false ;false ;/* * Ensure that the new transition value is stored in the aggcontext , * rather than the per - tuple context . This should be invoked only when * we know ( a ) the transition data type is pass - by - reference , and ( b ) * the newValue is distinct from the oldValue . * * NB : This can change the current memory context . * * We copy the presented newValue into the aggcontext , except when the datum * points to a R / W expanded object that is already a child of the aggcontext , * in which case we need not copy . We then delete the oldValue , if not null . * * If the presented datum points to a R / W expanded object that is a child of * some other context , ideally we would just reparent it under the aggcontext . * Unfortunately , that doesn ' t work easily , and it wouldn ' t help anyway for * aggregate - aware transfns . We expect that a transfn that deals in expanded * objects and is aware of the memory management conventions for aggregate * transition values will ( 1 ) on first call , return a R / W expanded object that * is already in the right context , allowing us to do nothing here , and ( 2 ) on * subsequent calls , modify and return that same object , so that control * doesn ' t even reach here . However , if we have a generic transfn that * returns a new R / W expanded object ( probably in the per - tuple context ) , * reparenting that result would cause problems . We ' d pass that R / W object to * the next invocation of the transfn , and then it would be at liberty to * change or delete that object , and if it deletes it then our own attempt to * delete the now - old transvalue afterwards would be a double free . We avoid * this problem by forcing the stored transvalue to always be a flat * non - expanded object unless the transfn is visibly doing aggregate - aware * memory management . This is somewhat inefficient , but the best answer to * that is to write a smarter transfn . bool newValueIsNull,bool oldValueIsNull)if (!newValueIsNull)if (DatumIsReadWriteExpandedObject(newValue,false ,)/* do nothing */ ; else else /* * Ensure that AggStatePerGroup - > transValue ends up being 0 , so * callers can safely compare newValue / oldValue without having to * check their respective nullness . 0 ;if (!oldValueIsNull)if (DatumIsReadWriteExpandedObject(oldValue,false ,else return newValue;/* * ExecEvalPreOrderedDistinctSingle * Returns true when the aggregate transition value Datum is distinct * from the previous input Datum and returns false when the input Datum * matches the previous input Datum . bool 1 ].value;bool isnull = pertrans->transfn_fcinfo->args[1 ].isnull;if (!pertrans->haslast ||if (pertrans->haslast && !pertrans->inputtypeByVal &&true ;if (!isnull)else 0 ;return true ;return false ;/* * ExecEvalPreOrderedDistinctMulti * Returns true when the aggregate input is distinct from the previous * input and returns false when the input matches the previous input , or * when there was no previous input . bool bool isdistinct = false ; /* for now */ for (int i = 0 ; i < pertrans->numTransInputs; i++)1 ].value;1 ].isnull;/* save the previous slots before we overwrite them */ if (!pertrans->haslast ||if (pertrans->haslast)true ;true ;/* restore the original slots */ return isdistinct;/* * Invoke ordered transition function , with a datum argument . void int setno = op->d.agg_trans.setno;/* * Invoke ordered transition function , with a tuple argument . void int setno = op->d.agg_trans.setno;/* implementation of transition function invocation for byval types */ static pg_attribute_always_inline void int setno)/* cf. select_current_set() */ /* set up aggstate->curpertrans for AggGetAggref() */ /* invoke transition function in per-tuple context */ 0 ].value = pergroup->transValue;0 ].isnull = pergroup->transValueIsNull;false ; /* just in case transfn doesn't set it */ /* implementation of transition function invocation for byref types */ static pg_attribute_always_inline void int setno)/* cf. select_current_set() */ /* set up aggstate->curpertrans for AggGetAggref() */ /* invoke transition function in per-tuple context */ 0 ].value = pergroup->transValue;0 ].isnull = pergroup->transValueIsNull;false ; /* just in case transfn doesn't set it */ /* * For pass - by - ref datatype , must copy the new value into aggcontext and * free the prior transValue . But if transfn returned a pointer to its * first input , we don ' t need to do anything . * * It ' s safe to compare newVal with pergroup - > transValue without regard * for either being NULL , because ExecAggCopyTransValue takes care to set * transValue to 0 when NULL . Otherwise we could end up accidentally not * reparenting , when the transValue has the same numerical value as * newValue , despite being NULL . This is a somewhat hot path , making it * undesirable to instead solve this with another branch for the common * case of the transition function returning its ( modified ) input * argument . if (DatumGetPointer(newVal) != DatumGetPointer(pergroup->transValue))
Messung V0.5 in Prozent C=92 H=95 G=93
¤ Dauer der Verarbeitung: 0.228 Sekunden
(vorverarbeitet am 2026-08-08)
¤ *© Formatika GbR, Deutschland
2026-08-25
Neuigkeiten Aktuelles Motto des Tages Open Source Software
Jenseits des Üblichen ....
Besucherstatistik
Statistik #Sources=141584 #Domains=738142
