#include "executor/nodeAgg.h"
#include "nodes/execnodes.h"
#include "nodes/miscnodes.h"

Include dependency graph for execExpr.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	ExprEvalRowtypeCache

struct	ExprEvalStep

struct	SubscriptingRefState

struct	SubscriptExecSteps

struct	JsonConstructorExprState

Macros
#define	EEO_FLAG_INTERPRETER_INITIALIZED (1 << 5)

#define	EEO_FLAG_DIRECT_THREADED (1 << 6)

Typedefs
typedef void(*	ExecEvalSubroutine) (ExprState state, struct ExprEvalStep op, ExprContext *econtext)

typedef bool(*	ExecEvalBoolSubroutine) (ExprState state, struct ExprEvalStep op, ExprContext *econtext)

typedef struct ExprEvalRowtypeCache	ExprEvalRowtypeCache

typedef enum ExprEvalOp	ExprEvalOp

typedef struct ExprEvalStep	ExprEvalStep

typedef struct SubscriptingRefState	SubscriptingRefState

typedef struct SubscriptExecSteps	SubscriptExecSteps

typedef struct JsonConstructorExprState	JsonConstructorExprState

Enumerations
enum	ExprEvalOp { EEOP_DONE_RETURN , EEOP_DONE_NO_RETURN , EEOP_INNER_FETCHSOME , EEOP_OUTER_FETCHSOME , EEOP_SCAN_FETCHSOME , EEOP_OLD_FETCHSOME , EEOP_NEW_FETCHSOME , EEOP_INNER_VAR , EEOP_OUTER_VAR , EEOP_SCAN_VAR , EEOP_OLD_VAR , EEOP_NEW_VAR , EEOP_INNER_SYSVAR , EEOP_OUTER_SYSVAR , EEOP_SCAN_SYSVAR , EEOP_OLD_SYSVAR , EEOP_NEW_SYSVAR , EEOP_WHOLEROW , EEOP_ASSIGN_INNER_VAR , EEOP_ASSIGN_OUTER_VAR , EEOP_ASSIGN_SCAN_VAR , EEOP_ASSIGN_OLD_VAR , EEOP_ASSIGN_NEW_VAR , EEOP_ASSIGN_TMP , EEOP_ASSIGN_TMP_MAKE_RO , EEOP_CONST , EEOP_FUNCEXPR , EEOP_FUNCEXPR_STRICT , EEOP_FUNCEXPR_STRICT_1 , EEOP_FUNCEXPR_STRICT_2 , EEOP_FUNCEXPR_FUSAGE , EEOP_FUNCEXPR_STRICT_FUSAGE , EEOP_BOOL_AND_STEP_FIRST , EEOP_BOOL_AND_STEP , EEOP_BOOL_AND_STEP_LAST , EEOP_BOOL_OR_STEP_FIRST , EEOP_BOOL_OR_STEP , EEOP_BOOL_OR_STEP_LAST , EEOP_BOOL_NOT_STEP , EEOP_QUAL , EEOP_JUMP , EEOP_JUMP_IF_NULL , EEOP_JUMP_IF_NOT_NULL , EEOP_JUMP_IF_NOT_TRUE , EEOP_NULLTEST_ISNULL , EEOP_NULLTEST_ISNOTNULL , EEOP_NULLTEST_ROWISNULL , EEOP_NULLTEST_ROWISNOTNULL , EEOP_BOOLTEST_IS_TRUE , EEOP_BOOLTEST_IS_NOT_TRUE , EEOP_BOOLTEST_IS_FALSE , EEOP_BOOLTEST_IS_NOT_FALSE , EEOP_PARAM_EXEC , EEOP_PARAM_EXTERN , EEOP_PARAM_CALLBACK , EEOP_PARAM_SET , EEOP_CASE_TESTVAL , EEOP_CASE_TESTVAL_EXT , EEOP_MAKE_READONLY , EEOP_IOCOERCE , EEOP_IOCOERCE_SAFE , EEOP_DISTINCT , EEOP_NOT_DISTINCT , EEOP_NULLIF , EEOP_SQLVALUEFUNCTION , EEOP_CURRENTOFEXPR , EEOP_NEXTVALUEEXPR , EEOP_RETURNINGEXPR , EEOP_ARRAYEXPR , EEOP_ARRAYCOERCE , EEOP_ROW , EEOP_ROWCOMPARE_STEP , EEOP_ROWCOMPARE_FINAL , EEOP_MINMAX , EEOP_FIELDSELECT , EEOP_FIELDSTORE_DEFORM , EEOP_FIELDSTORE_FORM , EEOP_SBSREF_SUBSCRIPTS , EEOP_SBSREF_OLD , EEOP_SBSREF_ASSIGN , EEOP_SBSREF_FETCH , EEOP_DOMAIN_TESTVAL , EEOP_DOMAIN_TESTVAL_EXT , EEOP_DOMAIN_NOTNULL , EEOP_DOMAIN_CHECK , EEOP_HASHDATUM_SET_INITVAL , EEOP_HASHDATUM_FIRST , EEOP_HASHDATUM_FIRST_STRICT , EEOP_HASHDATUM_NEXT32 , EEOP_HASHDATUM_NEXT32_STRICT , EEOP_CONVERT_ROWTYPE , EEOP_SCALARARRAYOP , EEOP_HASHED_SCALARARRAYOP , EEOP_XMLEXPR , EEOP_JSON_CONSTRUCTOR , EEOP_IS_JSON , EEOP_JSONEXPR_PATH , EEOP_JSONEXPR_COERCION , EEOP_JSONEXPR_COERCION_FINISH , EEOP_AGGREF , EEOP_GROUPING_FUNC , EEOP_WINDOW_FUNC , EEOP_MERGE_SUPPORT_FUNC , EEOP_SUBPLAN , EEOP_AGG_STRICT_DESERIALIZE , EEOP_AGG_DESERIALIZE , EEOP_AGG_STRICT_INPUT_CHECK_ARGS , EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1 , EEOP_AGG_STRICT_INPUT_CHECK_NULLS , EEOP_AGG_PLAIN_PERGROUP_NULLCHECK , EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL , EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL , EEOP_AGG_PLAIN_TRANS_BYVAL , EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF , EEOP_AGG_PLAIN_TRANS_STRICT_BYREF , EEOP_AGG_PLAIN_TRANS_BYREF , EEOP_AGG_PRESORTED_DISTINCT_SINGLE , EEOP_AGG_PRESORTED_DISTINCT_MULTI , EEOP_AGG_ORDERED_TRANS_DATUM , EEOP_AGG_ORDERED_TRANS_TUPLE , EEOP_LAST }

Functions
	StaticAssertDecl (sizeof(ExprEvalStep)<=64, "size of ExprEvalStep exceeds 64 bytes")

void	ExprEvalPushStep (ExprState es, const ExprEvalStep s)

void	ExecReadyInterpretedExpr (ExprState *state)

ExprEvalOp	ExecEvalStepOp (ExprState state, ExprEvalStep op)

Datum	ExecInterpExprStillValid (ExprState state, ExprContext econtext, bool *isNull)

void	CheckExprStillValid (ExprState state, ExprContext econtext)

void	ExecEvalFuncExprFusage (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalFuncExprStrictFusage (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalParamExec (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalParamSet (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalParamExtern (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalCoerceViaIOSafe (ExprState state, ExprEvalStep op)

void	ExecEvalSQLValueFunction (ExprState state, ExprEvalStep op)

void	ExecEvalCurrentOfExpr (ExprState state, ExprEvalStep op)

void	ExecEvalNextValueExpr (ExprState state, ExprEvalStep op)

void	ExecEvalRowNull (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalRowNotNull (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalArrayExpr (ExprState state, ExprEvalStep op)

void	ExecEvalArrayCoerce (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalRow (ExprState state, ExprEvalStep op)

void	ExecEvalMinMax (ExprState state, ExprEvalStep op)

void	ExecEvalFieldSelect (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalFieldStoreDeForm (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalFieldStoreForm (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalConvertRowtype (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalScalarArrayOp (ExprState state, ExprEvalStep op)

void	ExecEvalHashedScalarArrayOp (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalConstraintNotNull (ExprState state, ExprEvalStep op)

void	ExecEvalConstraintCheck (ExprState state, ExprEvalStep op)

void	ExecEvalXmlExpr (ExprState state, ExprEvalStep op)

void	ExecEvalJsonConstructor (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalJsonIsPredicate (ExprState state, ExprEvalStep op)

int	ExecEvalJsonExprPath (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalJsonCoercion (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalJsonCoercionFinish (ExprState state, ExprEvalStep op)

void	ExecEvalGroupingFunc (ExprState state, ExprEvalStep op)

void	ExecEvalMergeSupportFunc (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalSubPlan (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalWholeRowVar (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalSysVar (ExprState state, ExprEvalStep op, ExprContext econtext, TupleTableSlot slot)

void	ExecAggInitGroup (AggState aggstate, AggStatePerTrans pertrans, AggStatePerGroup pergroup, ExprContext aggcontext)

Datum	ExecAggCopyTransValue (AggState *aggstate, AggStatePerTrans pertrans, Datum newValue, bool newValueIsNull, Datum oldValue, bool oldValueIsNull)

bool	ExecEvalPreOrderedDistinctSingle (AggState *aggstate, AggStatePerTrans pertrans)

bool	ExecEvalPreOrderedDistinctMulti (AggState *aggstate, AggStatePerTrans pertrans)

void	ExecEvalAggOrderedTransDatum (ExprState state, ExprEvalStep op, ExprContext *econtext)

void	ExecEvalAggOrderedTransTuple (ExprState state, ExprEvalStep op, ExprContext *econtext)

Macro Definition Documentation

◆ EEO_FLAG_DIRECT_THREADED

#define EEO_FLAG_DIRECT_THREADED (1 << 6)

Definition at line 31 of file execExpr.h.

◆ EEO_FLAG_INTERPRETER_INITIALIZED

#define EEO_FLAG_INTERPRETER_INITIALIZED (1 << 5)

Definition at line 29 of file execExpr.h.

Typedef Documentation

◆ ExecEvalBoolSubroutine

typedef bool(* ExecEvalBoolSubroutine) (ExprState *state, struct ExprEvalStep *op, ExprContext *econtext)

Definition at line 39 of file execExpr.h.

◆ ExecEvalSubroutine

typedef void(* ExecEvalSubroutine) (ExprState *state, struct ExprEvalStep *op, ExprContext *econtext)

Definition at line 34 of file execExpr.h.

◆ ExprEvalOp

typedef enum ExprEvalOp ExprEvalOp

◆ ExprEvalRowtypeCache

typedef struct ExprEvalRowtypeCache ExprEvalRowtypeCache

◆ ExprEvalStep

typedef struct ExprEvalStep ExprEvalStep

◆ JsonConstructorExprState

typedef struct JsonConstructorExprState JsonConstructorExprState

◆ SubscriptExecSteps

typedef struct SubscriptExecSteps SubscriptExecSteps

◆ SubscriptingRefState

typedef struct SubscriptingRefState SubscriptingRefState

Enumeration Type Documentation

◆ ExprEvalOp

enum ExprEvalOp

Enumerator
EEOP_DONE_RETURN
EEOP_DONE_NO_RETURN
EEOP_INNER_FETCHSOME
EEOP_OUTER_FETCHSOME
EEOP_SCAN_FETCHSOME
EEOP_OLD_FETCHSOME
EEOP_NEW_FETCHSOME
EEOP_INNER_VAR
EEOP_OUTER_VAR
EEOP_SCAN_VAR
EEOP_OLD_VAR
EEOP_NEW_VAR
EEOP_INNER_SYSVAR
EEOP_OUTER_SYSVAR
EEOP_SCAN_SYSVAR
EEOP_OLD_SYSVAR
EEOP_NEW_SYSVAR
EEOP_WHOLEROW
EEOP_ASSIGN_INNER_VAR
EEOP_ASSIGN_OUTER_VAR
EEOP_ASSIGN_SCAN_VAR
EEOP_ASSIGN_OLD_VAR
EEOP_ASSIGN_NEW_VAR
EEOP_ASSIGN_TMP
EEOP_ASSIGN_TMP_MAKE_RO
EEOP_CONST
EEOP_FUNCEXPR
EEOP_FUNCEXPR_STRICT
EEOP_FUNCEXPR_STRICT_1
EEOP_FUNCEXPR_STRICT_2
EEOP_FUNCEXPR_FUSAGE
EEOP_FUNCEXPR_STRICT_FUSAGE
EEOP_BOOL_AND_STEP_FIRST
EEOP_BOOL_AND_STEP
EEOP_BOOL_AND_STEP_LAST
EEOP_BOOL_OR_STEP_FIRST
EEOP_BOOL_OR_STEP
EEOP_BOOL_OR_STEP_LAST
EEOP_BOOL_NOT_STEP
EEOP_QUAL
EEOP_JUMP
EEOP_JUMP_IF_NULL
EEOP_JUMP_IF_NOT_NULL
EEOP_JUMP_IF_NOT_TRUE
EEOP_NULLTEST_ISNULL
EEOP_NULLTEST_ISNOTNULL
EEOP_NULLTEST_ROWISNULL
EEOP_NULLTEST_ROWISNOTNULL
EEOP_BOOLTEST_IS_TRUE
EEOP_BOOLTEST_IS_NOT_TRUE
EEOP_BOOLTEST_IS_FALSE
EEOP_BOOLTEST_IS_NOT_FALSE
EEOP_PARAM_EXEC
EEOP_PARAM_EXTERN
EEOP_PARAM_CALLBACK
EEOP_PARAM_SET
EEOP_CASE_TESTVAL
EEOP_CASE_TESTVAL_EXT
EEOP_MAKE_READONLY
EEOP_IOCOERCE
EEOP_IOCOERCE_SAFE
EEOP_DISTINCT
EEOP_NOT_DISTINCT
EEOP_NULLIF
EEOP_SQLVALUEFUNCTION
EEOP_CURRENTOFEXPR
EEOP_NEXTVALUEEXPR
EEOP_RETURNINGEXPR
EEOP_ARRAYEXPR
EEOP_ARRAYCOERCE
EEOP_ROW
EEOP_ROWCOMPARE_STEP
EEOP_ROWCOMPARE_FINAL
EEOP_MINMAX
EEOP_FIELDSELECT
EEOP_FIELDSTORE_DEFORM
EEOP_FIELDSTORE_FORM
EEOP_SBSREF_SUBSCRIPTS
EEOP_SBSREF_OLD
EEOP_SBSREF_ASSIGN
EEOP_SBSREF_FETCH
EEOP_DOMAIN_TESTVAL
EEOP_DOMAIN_TESTVAL_EXT
EEOP_DOMAIN_NOTNULL
EEOP_DOMAIN_CHECK
EEOP_HASHDATUM_SET_INITVAL
EEOP_HASHDATUM_FIRST
EEOP_HASHDATUM_FIRST_STRICT
EEOP_HASHDATUM_NEXT32
EEOP_HASHDATUM_NEXT32_STRICT
EEOP_CONVERT_ROWTYPE
EEOP_SCALARARRAYOP
EEOP_HASHED_SCALARARRAYOP
EEOP_XMLEXPR
EEOP_JSON_CONSTRUCTOR
EEOP_IS_JSON
EEOP_JSONEXPR_PATH
EEOP_JSONEXPR_COERCION
EEOP_JSONEXPR_COERCION_FINISH
EEOP_AGGREF
EEOP_GROUPING_FUNC
EEOP_WINDOW_FUNC
EEOP_MERGE_SUPPORT_FUNC
EEOP_SUBPLAN
EEOP_AGG_STRICT_DESERIALIZE
EEOP_AGG_DESERIALIZE
EEOP_AGG_STRICT_INPUT_CHECK_ARGS
EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1
EEOP_AGG_STRICT_INPUT_CHECK_NULLS
EEOP_AGG_PLAIN_PERGROUP_NULLCHECK
EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL
EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL
EEOP_AGG_PLAIN_TRANS_BYVAL
EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF
EEOP_AGG_PLAIN_TRANS_STRICT_BYREF
EEOP_AGG_PLAIN_TRANS_BYREF
EEOP_AGG_PRESORTED_DISTINCT_SINGLE
EEOP_AGG_PRESORTED_DISTINCT_MULTI
EEOP_AGG_ORDERED_TRANS_DATUM
EEOP_AGG_ORDERED_TRANS_TUPLE
EEOP_LAST

Definition at line 66 of file execExpr.h.

{
    /* entire expression has been evaluated, return value */
    EEOP_DONE_RETURN,
 
    /* entire expression has been evaluated, no return value */
    EEOP_DONE_NO_RETURN,
 
    /* apply slot_getsomeattrs on corresponding tuple slot */
    EEOP_INNER_FETCHSOME,
    EEOP_OUTER_FETCHSOME,
    EEOP_SCAN_FETCHSOME,
    EEOP_OLD_FETCHSOME,
    EEOP_NEW_FETCHSOME,
 
    /* compute non-system Var value */
    EEOP_INNER_VAR,
    EEOP_OUTER_VAR,
    EEOP_SCAN_VAR,
    EEOP_OLD_VAR,
    EEOP_NEW_VAR,
 
    /* compute system Var value */
    EEOP_INNER_SYSVAR,
    EEOP_OUTER_SYSVAR,
    EEOP_SCAN_SYSVAR,
    EEOP_OLD_SYSVAR,
    EEOP_NEW_SYSVAR,
 
    /* compute wholerow Var */
    EEOP_WHOLEROW,
 
    /*
     * Compute non-system Var value, assign it into ExprState's resultslot.
     * These are not used if a CheckVarSlotCompatibility() check would be
     * needed.
     */
    EEOP_ASSIGN_INNER_VAR,
    EEOP_ASSIGN_OUTER_VAR,
    EEOP_ASSIGN_SCAN_VAR,
    EEOP_ASSIGN_OLD_VAR,
    EEOP_ASSIGN_NEW_VAR,
 
    /* assign ExprState's resvalue/resnull to a column of its resultslot */
    EEOP_ASSIGN_TMP,
    /* ditto, applying MakeExpandedObjectReadOnly() */
    EEOP_ASSIGN_TMP_MAKE_RO,
 
    /* evaluate Const value */
    EEOP_CONST,
 
    /*
     * Evaluate function call (including OpExprs etc).  For speed, we
     * distinguish in the opcode whether the function is strict with 1, 2, or
     * more arguments and/or requires usage stats tracking.
     */
    EEOP_FUNCEXPR,
    EEOP_FUNCEXPR_STRICT,
    EEOP_FUNCEXPR_STRICT_1,
    EEOP_FUNCEXPR_STRICT_2,
    EEOP_FUNCEXPR_FUSAGE,
    EEOP_FUNCEXPR_STRICT_FUSAGE,
 
    /*
     * Evaluate boolean AND expression, one step per subexpression. FIRST/LAST
     * subexpressions are special-cased for performance.  Since AND always has
     * at least two subexpressions, FIRST and LAST never apply to the same
     * subexpression.
     */
    EEOP_BOOL_AND_STEP_FIRST,
    EEOP_BOOL_AND_STEP,
    EEOP_BOOL_AND_STEP_LAST,
 
    /* similarly for boolean OR expression */
    EEOP_BOOL_OR_STEP_FIRST,
    EEOP_BOOL_OR_STEP,
    EEOP_BOOL_OR_STEP_LAST,
 
    /* evaluate boolean NOT expression */
    EEOP_BOOL_NOT_STEP,
 
    /* simplified version of BOOL_AND_STEP for use by ExecQual() */
    EEOP_QUAL,
 
    /* unconditional jump to another step */
    EEOP_JUMP,
 
    /* conditional jumps based on current result value */
    EEOP_JUMP_IF_NULL,
    EEOP_JUMP_IF_NOT_NULL,
    EEOP_JUMP_IF_NOT_TRUE,
 
    /* perform NULL tests for scalar values */
    EEOP_NULLTEST_ISNULL,
    EEOP_NULLTEST_ISNOTNULL,
 
    /* perform NULL tests for row values */
    EEOP_NULLTEST_ROWISNULL,
    EEOP_NULLTEST_ROWISNOTNULL,
 
    /* evaluate a BooleanTest expression */
    EEOP_BOOLTEST_IS_TRUE,
    EEOP_BOOLTEST_IS_NOT_TRUE,
    EEOP_BOOLTEST_IS_FALSE,
    EEOP_BOOLTEST_IS_NOT_FALSE,
 
    /* evaluate PARAM_EXEC/EXTERN parameters */
    EEOP_PARAM_EXEC,
    EEOP_PARAM_EXTERN,
    EEOP_PARAM_CALLBACK,
    /* set PARAM_EXEC value */
    EEOP_PARAM_SET,
 
    /* return CaseTestExpr value */
    EEOP_CASE_TESTVAL,
    EEOP_CASE_TESTVAL_EXT,
 
    /* apply MakeExpandedObjectReadOnly() to target value */
    EEOP_MAKE_READONLY,
 
    /* evaluate assorted special-purpose expression types */
    EEOP_IOCOERCE,
    EEOP_IOCOERCE_SAFE,
    EEOP_DISTINCT,
    EEOP_NOT_DISTINCT,
    EEOP_NULLIF,
    EEOP_SQLVALUEFUNCTION,
    EEOP_CURRENTOFEXPR,
    EEOP_NEXTVALUEEXPR,
    EEOP_RETURNINGEXPR,
    EEOP_ARRAYEXPR,
    EEOP_ARRAYCOERCE,
    EEOP_ROW,
 
    /*
     * Compare two individual elements of each of two compared ROW()
     * expressions.  Skip to ROWCOMPARE_FINAL if elements are not equal.
     */
    EEOP_ROWCOMPARE_STEP,
 
    /* evaluate boolean value based on previous ROWCOMPARE_STEP operations */
    EEOP_ROWCOMPARE_FINAL,
 
    /* evaluate GREATEST() or LEAST() */
    EEOP_MINMAX,
 
    /* evaluate FieldSelect expression */
    EEOP_FIELDSELECT,
 
    /*
     * Deform tuple before evaluating new values for individual fields in a
     * FieldStore expression.
     */
    EEOP_FIELDSTORE_DEFORM,
 
    /*
     * Form the new tuple for a FieldStore expression.  Individual fields will
     * have been evaluated into columns of the tuple deformed by the preceding
     * DEFORM step.
     */
    EEOP_FIELDSTORE_FORM,
 
    /* Process container subscripts; possibly short-circuit result to NULL */
    EEOP_SBSREF_SUBSCRIPTS,
 
    /*
     * Compute old container element/slice when a SubscriptingRef assignment
     * expression contains SubscriptingRef/FieldStore subexpressions. Value is
     * accessed using the CaseTest mechanism.
     */
    EEOP_SBSREF_OLD,
 
    /* compute new value for SubscriptingRef assignment expression */
    EEOP_SBSREF_ASSIGN,
 
    /* compute element/slice for SubscriptingRef fetch expression */
    EEOP_SBSREF_FETCH,
 
    /* evaluate value for CoerceToDomainValue */
    EEOP_DOMAIN_TESTVAL,
    EEOP_DOMAIN_TESTVAL_EXT,
 
    /* evaluate a domain's NOT NULL constraint */
    EEOP_DOMAIN_NOTNULL,
 
    /* evaluate a single domain CHECK constraint */
    EEOP_DOMAIN_CHECK,
 
    /* evaluation steps for hashing */
    EEOP_HASHDATUM_SET_INITVAL,
    EEOP_HASHDATUM_FIRST,
    EEOP_HASHDATUM_FIRST_STRICT,
    EEOP_HASHDATUM_NEXT32,
    EEOP_HASHDATUM_NEXT32_STRICT,
 
    /* evaluate assorted special-purpose expression types */
    EEOP_CONVERT_ROWTYPE,
    EEOP_SCALARARRAYOP,
    EEOP_HASHED_SCALARARRAYOP,
    EEOP_XMLEXPR,
    EEOP_JSON_CONSTRUCTOR,
    EEOP_IS_JSON,
    EEOP_JSONEXPR_PATH,
    EEOP_JSONEXPR_COERCION,
    EEOP_JSONEXPR_COERCION_FINISH,
    EEOP_AGGREF,
    EEOP_GROUPING_FUNC,
    EEOP_WINDOW_FUNC,
    EEOP_MERGE_SUPPORT_FUNC,
    EEOP_SUBPLAN,
 
    /* aggregation related nodes */
    EEOP_AGG_STRICT_DESERIALIZE,
    EEOP_AGG_DESERIALIZE,
    EEOP_AGG_STRICT_INPUT_CHECK_ARGS,
    EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1,
    EEOP_AGG_STRICT_INPUT_CHECK_NULLS,
    EEOP_AGG_PLAIN_PERGROUP_NULLCHECK,
    EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL,
    EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL,
    EEOP_AGG_PLAIN_TRANS_BYVAL,
    EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF,
    EEOP_AGG_PLAIN_TRANS_STRICT_BYREF,
    EEOP_AGG_PLAIN_TRANS_BYREF,
    EEOP_AGG_PRESORTED_DISTINCT_SINGLE,
    EEOP_AGG_PRESORTED_DISTINCT_MULTI,
    EEOP_AGG_ORDERED_TRANS_DATUM,
    EEOP_AGG_ORDERED_TRANS_TUPLE,
 
    /* non-existent operation, used e.g. to check array lengths */
    EEOP_LAST
} ExprEvalOp;

Function Documentation

◆ CheckExprStillValid()

void CheckExprStillValid	(	ExprState *	state,
		ExprContext *	econtext
	)

Definition at line 2307 of file execExprInterp.c.

{
    TupleTableSlot *innerslot;
    TupleTableSlot *outerslot;
    TupleTableSlot *scanslot;
    TupleTableSlot *oldslot;
    TupleTableSlot *newslot;
 
    innerslot = econtext->ecxt_innertuple;
    outerslot = econtext->ecxt_outertuple;
    scanslot = econtext->ecxt_scantuple;
    oldslot = econtext->ecxt_oldtuple;
    newslot = econtext->ecxt_newtuple;
 
    for (int i = 0; i < state->steps_len; i++)
    {
        ExprEvalStep *op = &state->steps[i];
 
        switch (ExecEvalStepOp(state, op))
        {
            case EEOP_INNER_VAR:
                {
                    int         attnum = op->d.var.attnum;
 
                    CheckVarSlotCompatibility(innerslot, attnum + 1, op->d.var.vartype);
                    break;
                }
 
            case EEOP_OUTER_VAR:
                {
                    int         attnum = op->d.var.attnum;
 
                    CheckVarSlotCompatibility(outerslot, attnum + 1, op->d.var.vartype);
                    break;
                }
 
            case EEOP_SCAN_VAR:
                {
                    int         attnum = op->d.var.attnum;
 
                    CheckVarSlotCompatibility(scanslot, attnum + 1, op->d.var.vartype);
                    break;
                }
 
            case EEOP_OLD_VAR:
                {
                    int         attnum = op->d.var.attnum;
 
                    CheckVarSlotCompatibility(oldslot, attnum + 1, op->d.var.vartype);
                    break;
                }
 
            case EEOP_NEW_VAR:
                {
                    int         attnum = op->d.var.attnum;
 
                    CheckVarSlotCompatibility(newslot, attnum + 1, op->d.var.vartype);
                    break;
                }
            default:
                break;
        }
    }
}

References attnum, CheckVarSlotCompatibility(), ExprContext::ecxt_innertuple, ExprContext::ecxt_newtuple, ExprContext::ecxt_oldtuple, ExprContext::ecxt_outertuple, ExprContext::ecxt_scantuple, EEOP_INNER_VAR, EEOP_NEW_VAR, EEOP_OLD_VAR, EEOP_OUTER_VAR, EEOP_SCAN_VAR, ExecEvalStepOp(), i, and ExprEvalStep::op.

Referenced by ExecInterpExprStillValid(), and ExecRunCompiledExpr().

◆ ExecAggCopyTransValue()

Datum ExecAggCopyTransValue	(	AggState *	aggstate,
		AggStatePerTrans	pertrans,
		Datum	newValue,
		bool	newValueIsNull,
		Datum	oldValue,
		bool	oldValueIsNull
	)

Definition at line 5670 of file execExprInterp.c.

{
    Assert(newValue != oldValue);
 
    if (!newValueIsNull)
    {
        MemoryContextSwitchTo(aggstate->curaggcontext->ecxt_per_tuple_memory);
        if (DatumIsReadWriteExpandedObject(newValue,
                                           false,
                                           pertrans->transtypeLen) &&
            MemoryContextGetParent(DatumGetEOHP(newValue)->eoh_context) == CurrentMemoryContext)
             /* do nothing */ ;
        else
            newValue = datumCopy(newValue,
                                 pertrans->transtypeByVal,
                                 pertrans->transtypeLen);
    }
    else
    {
        /*
         * Ensure that AggStatePerGroup->transValue ends up being 0, so
         * callers can safely compare newValue/oldValue without having to
         * check their respective nullness.
         */
        newValue = (Datum) 0;
    }
 
    if (!oldValueIsNull)
    {
        if (DatumIsReadWriteExpandedObject(oldValue,
                                           false,
                                           pertrans->transtypeLen))
            DeleteExpandedObject(oldValue);
        else
            pfree(DatumGetPointer(oldValue));
    }
 
    return newValue;
}

References Assert(), AggState::curaggcontext, CurrentMemoryContext, datumCopy(), DatumGetEOHP(), DatumGetPointer(), DatumIsReadWriteExpandedObject, DeleteExpandedObject(), ExprContext::ecxt_per_tuple_memory, MemoryContextGetParent(), MemoryContextSwitchTo(), ExprEvalStep::pertrans, pfree(), AggStatePerTransData::transtypeByVal, and AggStatePerTransData::transtypeLen.

Referenced by advance_transition_function(), and ExecAggPlainTransByRef().

◆ ExecAggInitGroup()

void ExecAggInitGroup	(	AggState *	aggstate,
		AggStatePerTrans	pertrans,
		AggStatePerGroup	pergroup,
		ExprContext *	aggcontext
	)

Definition at line 5617 of file execExprInterp.c.

{
    FunctionCallInfo fcinfo = pertrans->transfn_fcinfo;
    MemoryContext oldContext;
 
    /*
     * 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.)
     */
    oldContext = MemoryContextSwitchTo(aggcontext->ecxt_per_tuple_memory);
    pergroup->transValue = datumCopy(fcinfo->args[1].value,
                                     pertrans->transtypeByVal,
                                     pertrans->transtypeLen);
    pergroup->transValueIsNull = false;
    pergroup->noTransValue = false;
    MemoryContextSwitchTo(oldContext);
}

References ExprEvalStep::aggcontext, FunctionCallInfoBaseData::args, datumCopy(), ExprContext::ecxt_per_tuple_memory, MemoryContextSwitchTo(), AggStatePerGroupData::noTransValue, ExprEvalStep::pertrans, AggStatePerTransData::transfn_fcinfo, AggStatePerTransData::transtypeByVal, AggStatePerTransData::transtypeLen, AggStatePerGroupData::transValue, AggStatePerGroupData::transValueIsNull, and NullableDatum::value.

Referenced by ExecInterpExpr().

◆ ExecEvalAggOrderedTransDatum()

void ExecEvalAggOrderedTransDatum	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 5809 of file execExprInterp.c.

{
    AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
    int         setno = op->d.agg_trans.setno;
 
    tuplesort_putdatum(pertrans->sortstates[setno],
                       *op->resvalue, *op->resnull);
}

References ExprEvalStep::op, ExprEvalStep::pertrans, ExprEvalStep::setno, AggStatePerTransData::sortstates, and tuplesort_putdatum().

Referenced by ExecInterpExpr().

◆ ExecEvalAggOrderedTransTuple()

void ExecEvalAggOrderedTransTuple	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 5823 of file execExprInterp.c.

{
    AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
    int         setno = op->d.agg_trans.setno;
 
    ExecClearTuple(pertrans->sortslot);
    pertrans->sortslot->tts_nvalid = pertrans->numInputs;
    ExecStoreVirtualTuple(pertrans->sortslot);
    tuplesort_puttupleslot(pertrans->sortstates[setno], pertrans->sortslot);
}

References ExecClearTuple(), ExecStoreVirtualTuple(), AggStatePerTransData::numInputs, ExprEvalStep::op, ExprEvalStep::pertrans, ExprEvalStep::setno, AggStatePerTransData::sortslot, AggStatePerTransData::sortstates, TupleTableSlot::tts_nvalid, and tuplesort_puttupleslot().

Referenced by ExecInterpExpr().

◆ ExecEvalArrayCoerce()

void ExecEvalArrayCoerce	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 3615 of file execExprInterp.c.

{
    Datum       arraydatum;
 
    /* NULL array -> NULL result */
    if (*op->resnull)
        return;
 
    arraydatum = *op->resvalue;
 
    /*
     * 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 */
        ArrayType  *array = DatumGetArrayTypePCopy(arraydatum);
 
        ARR_ELEMTYPE(array) = op->d.arraycoerce.resultelemtype;
        *op->resvalue = PointerGetDatum(array);
        return;
    }
 
    /*
     * Use array_map to apply the sub-expression to each array element.
     */
    *op->resvalue = array_map(arraydatum,
                              op->d.arraycoerce.elemexprstate,
                              econtext,
                              op->d.arraycoerce.resultelemtype,
                              op->d.arraycoerce.amstate);
}

References ARR_ELEMTYPE, array_map(), DatumGetArrayTypePCopy, ExprEvalStep::op, and PointerGetDatum().

Referenced by ExecInterpExpr().

◆ ExecEvalArrayExpr()

void ExecEvalArrayExpr	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3401 of file execExprInterp.c.

{
    ArrayType  *result;
    Oid         element_type = op->d.arrayexpr.elemtype;
    int         nelems = op->d.arrayexpr.nelems;
    int         ndims = 0;
    int         dims[MAXDIM];
    int         lbs[MAXDIM];
 
    /* Set non-null as default */
    *op->resnull = false;
 
    if (!op->d.arrayexpr.multidims)
    {
        /* Elements are presumably of scalar type */
        Datum      *dvalues = op->d.arrayexpr.elemvalues;
        bool       *dnulls = op->d.arrayexpr.elemnulls;
 
        /* setup for 1-D array of the given length */
        ndims = 1;
        dims[0] = nelems;
        lbs[0] = 1;
 
        result = construct_md_array(dvalues, dnulls, ndims, dims, lbs,
                                    element_type,
                                    op->d.arrayexpr.elemlength,
                                    op->d.arrayexpr.elembyval,
                                    op->d.arrayexpr.elemalign);
    }
    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;
        bits8     **subbitmaps;
        int        *subbytes;
        int        *subnitems;
        int32       dataoffset;
        char       *dat;
        int         iitem;
 
        subdata = (char **) palloc(nelems * sizeof(char *));
        subbitmaps = (bits8 **) palloc(nelems * sizeof(bits8 *));
        subbytes = (int *) palloc(nelems * sizeof(int));
        subnitems = (int *) palloc(nelems * sizeof(int));
 
        /* loop through and get data area from each element */
        for (int elemoff = 0; elemoff < nelems; elemoff++)
        {
            Datum       arraydatum;
            bool        eisnull;
            ArrayType  *array;
            int         this_ndims;
 
            arraydatum = op->d.arrayexpr.elemvalues[elemoff];
            eisnull = op->d.arrayexpr.elemnulls[elemoff];
 
            /* temporarily ignore null subarrays */
            if (eisnull)
            {
                haveempty = true;
                continue;
            }
 
            array = DatumGetArrayTypeP(arraydatum);
 
            /* run-time double-check on element type */
            if (element_type != ARR_ELEMTYPE(array))
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("cannot merge incompatible arrays"),
                         errdetail("Array with element type %s cannot be "
                                   "included in ARRAY construct with element type %s.",
                                   format_type_be(ARR_ELEMTYPE(array)),
                                   format_type_be(element_type))));
 
            this_ndims = ARR_NDIM(array);
            /* temporarily ignore zero-dimensional subarrays */
            if (this_ndims <= 0)
            {
                haveempty = true;
                continue;
            }
 
            if (firstone)
            {
                /* Get sub-array details from first member */
                elem_ndims = this_ndims;
                ndims = elem_ndims + 1;
                if (ndims <= 0 || ndims > MAXDIM)
                    ereport(ERROR,
                            (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                             errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
                                    ndims, MAXDIM)));
 
                elem_dims = (int *) palloc(elem_ndims * sizeof(int));
                memcpy(elem_dims, ARR_DIMS(array), elem_ndims * sizeof(int));
                elem_lbs = (int *) palloc(elem_ndims * sizeof(int));
                memcpy(elem_lbs, ARR_LBOUND(array), elem_ndims * sizeof(int));
 
                firstone = false;
            }
            else
            {
                /* Check other sub-arrays are compatible */
                if (elem_ndims != this_ndims ||
                    memcmp(elem_dims, ARR_DIMS(array),
                           elem_ndims * sizeof(int)) != 0 ||
                    memcmp(elem_lbs, ARR_LBOUND(array),
                           elem_ndims * sizeof(int)) != 0)
                    ereport(ERROR,
                            (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                             errmsg("multidimensional arrays must have array "
                                    "expressions with matching dimensions")));
            }
 
            subdata[outer_nelems] = ARR_DATA_PTR(array);
            subbitmaps[outer_nelems] = ARR_NULLBITMAP(array);
            subbytes[outer_nelems] = ARR_SIZE(array) - ARR_DATA_OFFSET(array);
            nbytes += subbytes[outer_nelems];
            /* check for overflow of total request */
            if (!AllocSizeIsValid(nbytes))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("array size exceeds the maximum allowed (%d)",
                                (int) MaxAllocSize)));
            subnitems[outer_nelems] = ArrayGetNItems(this_ndims,
                                                     ARR_DIMS(array));
            havenulls |= ARR_HASNULL(array);
            outer_nelems++;
        }
 
        /*
         * 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 */
            {
                *op->resvalue = PointerGetDatum(construct_empty_array(element_type));
                return;
            }
            ereport(ERROR,
                    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                     errmsg("multidimensional arrays must have array "
                            "expressions with matching dimensions")));
        }
 
        /* setup for multi-D array */
        dims[0] = outer_nelems;
        lbs[0] = 1;
        for (int i = 1; i < ndims; i++)
        {
            dims[i] = elem_dims[i - 1];
            lbs[i] = elem_lbs[i - 1];
        }
 
        /* check for subscript overflow */
        nitems = ArrayGetNItems(ndims, dims);
        ArrayCheckBounds(ndims, dims, lbs);
 
        if (havenulls)
        {
            dataoffset = ARR_OVERHEAD_WITHNULLS(ndims, nitems);
            nbytes += dataoffset;
        }
        else
        {
            dataoffset = 0;     /* marker for no null bitmap */
            nbytes += ARR_OVERHEAD_NONULLS(ndims);
        }
 
        result = (ArrayType *) palloc0(nbytes);
        SET_VARSIZE(result, nbytes);
        result->ndim = ndims;
        result->dataoffset = dataoffset;
        result->elemtype = element_type;
        memcpy(ARR_DIMS(result), dims, ndims * sizeof(int));
        memcpy(ARR_LBOUND(result), lbs, ndims * sizeof(int));
 
        dat = ARR_DATA_PTR(result);
        iitem = 0;
        for (int i = 0; i < outer_nelems; i++)
        {
            memcpy(dat, subdata[i], subbytes[i]);
            dat += subbytes[i];
            if (havenulls)
                array_bitmap_copy(ARR_NULLBITMAP(result), iitem,
                                  subbitmaps[i], 0,
                                  subnitems[i]);
            iitem += subnitems[i];
        }
    }
 
    *op->resvalue = PointerGetDatum(result);
}

References AllocSizeIsValid, ARR_DATA_OFFSET, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_LBOUND, ARR_NDIM, ARR_NULLBITMAP, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, ARR_SIZE, array_bitmap_copy(), ArrayCheckBounds(), ArrayGetNItems(), construct_empty_array(), construct_md_array(), ArrayType::dataoffset, DatumGetArrayTypeP, ExprEvalStep::element_type, ArrayType::elemtype, ereport, errcode(), errdetail(), errmsg(), ERROR, format_type_be(), i, MaxAllocSize, MAXDIM, ArrayType::ndim, ExprEvalStep::nelems, nitems, ExprEvalStep::op, palloc(), palloc0(), PointerGetDatum(), and SET_VARSIZE.

Referenced by ExecInterpExpr().

◆ ExecEvalCoerceViaIOSafe()

void ExecEvalCoerceViaIOSafe	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3135 of file execExprInterp.c.

{
    char       *str;
 
    /* call output function (similar to OutputFunctionCall) */
    if (*op->resnull)
    {
        /* output functions are not called on nulls */
        str = NULL;
    }
    else
    {
        FunctionCallInfo fcinfo_out;
 
        fcinfo_out = op->d.iocoerce.fcinfo_data_out;
        fcinfo_out->args[0].value = *op->resvalue;
        fcinfo_out->args[0].isnull = false;
 
        fcinfo_out->isnull = false;
        str = DatumGetCString(FunctionCallInvoke(fcinfo_out));
 
        /* OutputFunctionCall assumes result isn't null */
        Assert(!fcinfo_out->isnull);
    }
 
    /* call input function (similar to InputFunctionCallSafe) */
    if (!op->d.iocoerce.finfo_in->fn_strict || str != NULL)
    {
        FunctionCallInfo fcinfo_in;
 
        fcinfo_in = op->d.iocoerce.fcinfo_data_in;
        fcinfo_in->args[0].value = PointerGetDatum(str);
        fcinfo_in->args[0].isnull = *op->resnull;
        /* second and third arguments are already set up */
 
        /* ErrorSaveContext must be present. */
        Assert(IsA(fcinfo_in->context, ErrorSaveContext));
 
        fcinfo_in->isnull = false;
        *op->resvalue = FunctionCallInvoke(fcinfo_in);
 
        if (SOFT_ERROR_OCCURRED(fcinfo_in->context))
        {
            *op->resnull = true;
            *op->resvalue = (Datum) 0;
            return;
        }
 
        /* Should get null result if and only if str is NULL */
        if (str == NULL)
            Assert(*op->resnull);
        else
            Assert(!*op->resnull);
    }
}

References FunctionCallInfoBaseData::args, Assert(), FunctionCallInfoBaseData::context, DatumGetCString(), FunctionCallInvoke, IsA, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, ExprEvalStep::op, PointerGetDatum(), SOFT_ERROR_OCCURRED, str, and NullableDatum::value.

Referenced by ExecInterpExpr().

◆ ExecEvalConstraintCheck()

void ExecEvalConstraintCheck	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4422 of file execExprInterp.c.

{
    if (!*op->d.domaincheck.checknull &&
        !DatumGetBool(*op->d.domaincheck.checkvalue))
        errsave((Node *) op->d.domaincheck.escontext,
                (errcode(ERRCODE_CHECK_VIOLATION),
                 errmsg("value for domain %s violates check constraint \"%s\"",
                        format_type_be(op->d.domaincheck.resulttype),
                        op->d.domaincheck.constraintname),
                 errdomainconstraint(op->d.domaincheck.resulttype,
                                     op->d.domaincheck.constraintname)));
}

References DatumGetBool(), errcode(), errdomainconstraint(), errmsg(), errsave, format_type_be(), and ExprEvalStep::op.

Referenced by ExecInterpExpr().

◆ ExecEvalConstraintNotNull()

void ExecEvalConstraintNotNull	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4408 of file execExprInterp.c.

{
    if (*op->resnull)
        errsave((Node *) op->d.domaincheck.escontext,
                (errcode(ERRCODE_NOT_NULL_VIOLATION),
                 errmsg("domain %s does not allow null values",
                        format_type_be(op->d.domaincheck.resulttype)),
                 errdatatype(op->d.domaincheck.resulttype)));
}

References errcode(), errdatatype(), errmsg(), errsave, format_type_be(), and ExprEvalStep::op.

Referenced by ExecInterpExpr().

◆ ExecEvalConvertRowtype()

void ExecEvalConvertRowtype	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 3928 of file execExprInterp.c.

{
    HeapTuple   result;
    Datum       tupDatum;
    HeapTupleHeader tuple;
    HeapTupleData tmptup;
    TupleDesc   indesc,
                outdesc;
    bool        changed = false;
 
    /* NULL in -> NULL out */
    if (*op->resnull)
        return;
 
    tupDatum = *op->resvalue;
    tuple = DatumGetHeapTupleHeader(tupDatum);
 
    /*
     * 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.
     */
    indesc = get_cached_rowtype(op->d.convert_rowtype.inputtype, -1,
                                op->d.convert_rowtype.incache,
                                &changed);
    IncrTupleDescRefCount(indesc);
    outdesc = get_cached_rowtype(op->d.convert_rowtype.outputtype, -1,
                                 op->d.convert_rowtype.outcache,
                                 &changed);
    IncrTupleDescRefCount(outdesc);
 
    /*
     * 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:
     */
    Assert(HeapTupleHeaderGetTypeId(tuple) == indesc->tdtypeid ||
           HeapTupleHeaderGetTypeId(tuple) == RECORDOID);
 
    /* if first time through, or after change, initialize conversion map */
    if (changed)
    {
        MemoryContext old_cxt;
 
        /* allocate map in long-lived memory context */
        old_cxt = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
        /* prepare map from old to new attribute numbers */
        op->d.convert_rowtype.map = convert_tuples_by_name(indesc, outdesc);
 
        MemoryContextSwitchTo(old_cxt);
    }
 
    /* Following steps need a HeapTuple not a bare HeapTupleHeader */
    tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
    tmptup.t_data = tuple;
 
    if (op->d.convert_rowtype.map != NULL)
    {
        /* Full conversion with attribute rearrangement needed */
        result = execute_attr_map_tuple(&tmptup, op->d.convert_rowtype.map);
        /* Result already has appropriate composite-datum header fields */
        *op->resvalue = HeapTupleGetDatum(result);
    }
    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.
         */
        *op->resvalue = heap_copy_tuple_as_datum(&tmptup, outdesc);
    }
 
    DecrTupleDescRefCount(indesc);
    DecrTupleDescRefCount(outdesc);
}

References Assert(), convert_tuples_by_name(), DatumGetHeapTupleHeader, DecrTupleDescRefCount(), ExprContext::ecxt_per_query_memory, execute_attr_map_tuple(), get_cached_rowtype(), heap_copy_tuple_as_datum(), HeapTupleGetDatum(), HeapTupleHeaderGetDatumLength(), HeapTupleHeaderGetTypeId(), IncrTupleDescRefCount(), MemoryContextSwitchTo(), ExprEvalStep::op, HeapTupleData::t_data, HeapTupleData::t_len, and TupleDescData::tdtypeid.

Referenced by ExecInterpExpr().

◆ ExecEvalCurrentOfExpr()

void ExecEvalCurrentOfExpr	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3262 of file execExprInterp.c.

{
    ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             errmsg("WHERE CURRENT OF is not supported for this table type")));
}

References ereport, errcode(), errmsg(), and ERROR.

Referenced by ExecInterpExpr().

◆ ExecEvalFieldSelect()

void ExecEvalFieldSelect	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 3729 of file execExprInterp.c.

{
    AttrNumber  fieldnum = op->d.fieldselect.fieldnum;
    Datum       tupDatum;
    HeapTupleHeader tuple;
    Oid         tupType;
    int32       tupTypmod;
    TupleDesc   tupDesc;
    Form_pg_attribute attr;
    HeapTupleData tmptup;
 
    /* NULL record -> NULL result */
    if (*op->resnull)
        return;
 
    tupDatum = *op->resvalue;
 
    /* We can special-case expanded records for speed */
    if (VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(tupDatum)))
    {
        ExpandedRecordHeader *erh = (ExpandedRecordHeader *) DatumGetEOHP(tupDatum);
 
        Assert(erh->er_magic == ER_MAGIC);
 
        /* Extract record's TupleDesc */
        tupDesc = expanded_record_get_tupdesc(erh);
 
        /*
         * 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 */
            elog(ERROR, "unsupported reference to system column %d in FieldSelect",
                 fieldnum);
        if (fieldnum > tupDesc->natts)  /* should never happen */
            elog(ERROR, "attribute number %d exceeds number of columns %d",
                 fieldnum, tupDesc->natts);
        attr = TupleDescAttr(tupDesc, fieldnum - 1);
 
        /* Check for dropped column, and force a NULL result if so */
        if (attr->attisdropped)
        {
            *op->resnull = 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)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("attribute %d has wrong type", fieldnum),
                     errdetail("Table has type %s, but query expects %s.",
                               format_type_be(attr->atttypid),
                               format_type_be(op->d.fieldselect.resulttype))));
 
        /* extract the field */
        *op->resvalue = expanded_record_get_field(erh, fieldnum,
                                                  op->resnull);
    }
    else
    {
        /* Get the composite datum and extract its type fields */
        tuple = DatumGetHeapTupleHeader(tupDatum);
 
        tupType = HeapTupleHeaderGetTypeId(tuple);
        tupTypmod = HeapTupleHeaderGetTypMod(tuple);
 
        /* Lookup tupdesc if first time through or if type changes */
        tupDesc = get_cached_rowtype(tupType, tupTypmod,
                                     &op->d.fieldselect.rowcache, NULL);
 
        /*
         * 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 */
            elog(ERROR, "unsupported reference to system column %d in FieldSelect",
                 fieldnum);
        if (fieldnum > tupDesc->natts)  /* should never happen */
            elog(ERROR, "attribute number %d exceeds number of columns %d",
                 fieldnum, tupDesc->natts);
        attr = TupleDescAttr(tupDesc, fieldnum - 1);
 
        /* Check for dropped column, and force a NULL result if so */
        if (attr->attisdropped)
        {
            *op->resnull = 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)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("attribute %d has wrong type", fieldnum),
                     errdetail("Table has type %s, but query expects %s.",
                               format_type_be(attr->atttypid),
                               format_type_be(op->d.fieldselect.resulttype))));
 
        /* heap_getattr needs a HeapTuple not a bare HeapTupleHeader */
        tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
        tmptup.t_data = tuple;
 
        /* extract the field */
        *op->resvalue = heap_getattr(&tmptup,
                                     fieldnum,
                                     tupDesc,
                                     op->resnull);
    }
}

References Assert(), DatumGetEOHP(), DatumGetHeapTupleHeader, DatumGetPointer(), elog, ER_MAGIC, ExpandedRecordHeader::er_magic, ereport, errcode(), errdetail(), errmsg(), ERROR, expanded_record_get_field(), expanded_record_get_tupdesc(), ExprEvalStep::fieldnum, format_type_be(), get_cached_rowtype(), heap_getattr(), HeapTupleHeaderGetDatumLength(), HeapTupleHeaderGetTypeId(), HeapTupleHeaderGetTypMod(), TupleDescData::natts, ExprEvalStep::op, HeapTupleData::t_data, HeapTupleData::t_len, TupleDescAttr(), and VARATT_IS_EXTERNAL_EXPANDED.

Referenced by ExecInterpExpr().

◆ ExecEvalFieldStoreDeForm()

void ExecEvalFieldStoreDeForm	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 3854 of file execExprInterp.c.

{
    if (*op->resnull)
    {
        /* Convert null input tuple into an all-nulls row */
        memset(op->d.fieldstore.nulls, true,
               op->d.fieldstore.ncolumns * sizeof(bool));
    }
    else
    {
        /*
         * heap_deform_tuple needs a HeapTuple not a bare HeapTupleHeader. We
         * set all the fields in the struct just in case.
         */
        Datum       tupDatum = *op->resvalue;
        HeapTupleHeader tuphdr;
        HeapTupleData tmptup;
        TupleDesc   tupDesc;
 
        tuphdr = DatumGetHeapTupleHeader(tupDatum);
        tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
        ItemPointerSetInvalid(&(tmptup.t_self));
        tmptup.t_tableOid = InvalidOid;
        tmptup.t_data = tuphdr;
 
        /*
         * 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.
         */
        tupDesc = get_cached_rowtype(op->d.fieldstore.fstore->resulttype, -1,
                                     op->d.fieldstore.rowcache, NULL);
 
        /* Check that current tupdesc doesn't have more fields than allocated */
        if (unlikely(tupDesc->natts > op->d.fieldstore.ncolumns))
            elog(ERROR, "too many columns in composite type %u",
                 op->d.fieldstore.fstore->resulttype);
 
        heap_deform_tuple(&tmptup, tupDesc,
                          op->d.fieldstore.values,
                          op->d.fieldstore.nulls);
    }
}

References DatumGetHeapTupleHeader, elog, ERROR, get_cached_rowtype(), heap_deform_tuple(), HeapTupleHeaderGetDatumLength(), InvalidOid, ItemPointerSetInvalid(), TupleDescData::natts, ExprEvalStep::op, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, and unlikely.

Referenced by ExecInterpExpr().

◆ ExecEvalFieldStoreForm()

void ExecEvalFieldStoreForm	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 3904 of file execExprInterp.c.

{
    TupleDesc   tupDesc;
    HeapTuple   tuple;
 
    /* Lookup tupdesc (should be valid already) */
    tupDesc = get_cached_rowtype(op->d.fieldstore.fstore->resulttype, -1,
                                 op->d.fieldstore.rowcache, NULL);
 
    tuple = heap_form_tuple(tupDesc,
                            op->d.fieldstore.values,
                            op->d.fieldstore.nulls);
 
    *op->resvalue = HeapTupleGetDatum(tuple);
    *op->resnull = false;
}

References get_cached_rowtype(), heap_form_tuple(), HeapTupleGetDatum(), and ExprEvalStep::op.

Referenced by ExecInterpExpr().

◆ ExecEvalFuncExprFusage()

void ExecEvalFuncExprFusage	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 2990 of file execExprInterp.c.

{
    FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
    PgStat_FunctionCallUsage fcusage;
    Datum       d;
 
    pgstat_init_function_usage(fcinfo, &fcusage);
 
    fcinfo->isnull = false;
    d = op->d.func.fn_addr(fcinfo);
    *op->resvalue = d;
    *op->resnull = fcinfo->isnull;
 
    pgstat_end_function_usage(&fcusage, true);
}

References ExprEvalStep::d, FunctionCallInfoBaseData::isnull, ExprEvalStep::op, pgstat_end_function_usage(), and pgstat_init_function_usage().

Referenced by ExecInterpExpr().

◆ ExecEvalFuncExprStrictFusage()

void ExecEvalFuncExprStrictFusage	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 3011 of file execExprInterp.c.

{
 
    FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
    PgStat_FunctionCallUsage fcusage;
    NullableDatum *args = fcinfo->args;
    int         nargs = op->d.func.nargs;
    Datum       d;
 
    /* strict function, so check for NULL args */
    for (int argno = 0; argno < nargs; argno++)
    {
        if (args[argno].isnull)
        {
            *op->resnull = true;
            return;
        }
    }
 
    pgstat_init_function_usage(fcinfo, &fcusage);
 
    fcinfo->isnull = false;
    d = op->d.func.fn_addr(fcinfo);
    *op->resvalue = d;
    *op->resnull = fcinfo->isnull;
 
    pgstat_end_function_usage(&fcusage, true);
}

References generate_unaccent_rules::args, FunctionCallInfoBaseData::args, ExprEvalStep::d, ExprEvalStep::isnull, FunctionCallInfoBaseData::isnull, ExprEvalStep::nargs, ExprEvalStep::op, pgstat_end_function_usage(), and pgstat_init_function_usage().

Referenced by ExecInterpExpr().

◆ ExecEvalGroupingFunc()

void ExecEvalGroupingFunc	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 5246 of file execExprInterp.c.

{
    AggState   *aggstate = castNode(AggState, state->parent);
    int         result = 0;
    Bitmapset  *grouped_cols = aggstate->grouped_cols;
    ListCell   *lc;
 
    foreach(lc, op->d.grouping_func.clauses)
    {
        int         attnum = lfirst_int(lc);
 
        result <<= 1;
 
        if (!bms_is_member(attnum, grouped_cols))
            result |= 1;
    }
 
    *op->resvalue = Int32GetDatum(result);
    *op->resnull = false;
}

References attnum, bms_is_member(), castNode, AggState::grouped_cols, Int32GetDatum(), lfirst_int, and ExprEvalStep::op.

Referenced by ExecInterpExpr().

◆ ExecEvalHashedScalarArrayOp()

void ExecEvalHashedScalarArrayOp	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 4226 of file execExprInterp.c.

{
    ScalarArrayOpExprHashTable *elements_tab = op->d.hashedscalararrayop.elements_tab;
    FunctionCallInfo fcinfo = op->d.hashedscalararrayop.fcinfo_data;
    bool        inclause = op->d.hashedscalararrayop.inclause;
    bool        strictfunc = op->d.hashedscalararrayop.finfo->fn_strict;
    Datum       scalar = fcinfo->args[0].value;
    bool        scalar_isnull = fcinfo->args[0].isnull;
    Datum       result;
    bool        resultnull;
    bool        hashfound;
 
    /* We don't setup a hashed scalar array op if the array const is null. */
    Assert(!*op->resnull);
 
    /*
     * If the scalar is NULL, and the function is strict, return NULL; no
     * point in executing the search.
     */
    if (fcinfo->args[0].isnull && strictfunc)
    {
        *op->resnull = true;
        return;
    }
 
    /* Build the hash table on first evaluation */
    if (elements_tab == NULL)
    {
        ScalarArrayOpExpr *saop;
        int16       typlen;
        bool        typbyval;
        char        typalign;
        int         nitems;
        bool        has_nulls = false;
        char       *s;
        bits8      *bitmap;
        int         bitmask;
        MemoryContext oldcontext;
        ArrayType  *arr;
 
        saop = op->d.hashedscalararrayop.saop;
 
        arr = DatumGetArrayTypeP(*op->resvalue);
        nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr));
 
        get_typlenbyvalalign(ARR_ELEMTYPE(arr),
                             &typlen,
                             &typbyval,
                             &typalign);
 
        oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
        elements_tab = (ScalarArrayOpExprHashTable *)
            palloc0(offsetof(ScalarArrayOpExprHashTable, hash_fcinfo_data) +
                    SizeForFunctionCallInfo(1));
        op->d.hashedscalararrayop.elements_tab = elements_tab;
        elements_tab->op = op;
 
        fmgr_info(saop->hashfuncid, &elements_tab->hash_finfo);
        fmgr_info_set_expr((Node *) saop, &elements_tab->hash_finfo);
 
        InitFunctionCallInfoData(elements_tab->hash_fcinfo_data,
                                 &elements_tab->hash_finfo,
                                 1,
                                 saop->inputcollid,
                                 NULL,
                                 NULL);
 
        /*
         * 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.
         */
        elements_tab->hashtab = saophash_create(CurrentMemoryContext, nitems,
                                                elements_tab);
 
        MemoryContextSwitchTo(oldcontext);
 
        s = (char *) ARR_DATA_PTR(arr);
        bitmap = ARR_NULLBITMAP(arr);
        bitmask = 1;
        for (int i = 0; i < nitems; i++)
        {
            /* Get array element, checking for NULL. */
            if (bitmap && (*bitmap & bitmask) == 0)
            {
                has_nulls = true;
            }
            else
            {
                Datum       element;
 
                element = fetch_att(s, typbyval, typlen);
                s = att_addlength_pointer(s, typlen, s);
                s = (char *) att_align_nominal(s, typalign);
 
                saophash_insert(elements_tab->hashtab, element, &hashfound);
            }
 
            /* Advance bitmap pointer if any. */
            if (bitmap)
            {
                bitmask <<= 1;
                if (bitmask == 0x100)
                {
                    bitmap++;
                    bitmask = 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.
         */
        op->d.hashedscalararrayop.has_nulls = has_nulls;
    }
 
    /* Check the hash to see if we have a match. */
    hashfound = NULL != saophash_lookup(elements_tab->hashtab, scalar);
 
    /* the result depends on if the clause is an IN or NOT IN clause */
    if (inclause)
        result = BoolGetDatum(hashfound);   /* IN */
    else
        result = BoolGetDatum(!hashfound);  /* NOT IN */
 
    resultnull = 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.
             */
            result = (Datum) 0;
            resultnull = 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).
             */
            fcinfo->args[0].value = scalar;
            fcinfo->args[0].isnull = scalar_isnull;
            fcinfo->args[1].value = (Datum) 0;
            fcinfo->args[1].isnull = true;
 
            result = op->d.hashedscalararrayop.finfo->fn_addr(fcinfo);
            resultnull = fcinfo->isnull;
 
            /*
             * Reverse the result for NOT IN clauses since the above function
             * is the equality function and we need not-equals.
             */
            if (!inclause)
                result = !result;
        }
    }
 
    *op->resvalue = result;
    *op->resnull = resultnull;
}

References FunctionCallInfoBaseData::args, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_NDIM, ARR_NULLBITMAP, ArrayGetNItems(), Assert(), att_addlength_pointer, att_align_nominal, BoolGetDatum(), CurrentMemoryContext, DatumGetArrayTypeP, ExprContext::ecxt_per_query_memory, element(), ExprEvalStep::elements_tab, fetch_att(), fmgr_info(), fmgr_info_set_expr, get_typlenbyvalalign(), ExprEvalStep::has_nulls, ScalarArrayOpExprHashTable::hash_fcinfo_data, ScalarArrayOpExprHashTable::hash_finfo, ScalarArrayOpExprHashTable::hashtab, i, ExprEvalStep::inclause, InitFunctionCallInfoData, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, MemoryContextSwitchTo(), nitems, ScalarArrayOpExprHashTable::op, ExprEvalStep::op, palloc0(), ExprEvalStep::saop, SizeForFunctionCallInfo, typalign, ExprEvalStep::typbyval, ExprEvalStep::typlen, and NullableDatum::value.

Referenced by ExecInterpExpr().

◆ ExecEvalJsonCoercion()

void ExecEvalJsonCoercion	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 5112 of file execExprInterp.c.

{
    ErrorSaveContext *escontext = op->d.jsonexpr_coercion.escontext;
 
    /*
     * 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 &&
                !domain_check_safe(*op->resvalue, *op->resnull,
                                   op->d.jsonexpr_coercion.targettype,
                                   &op->d.jsonexpr_coercion.json_coercion_cache,
                                   econtext->ecxt_per_query_memory,
                                   (Node *) escontext))
            {
                *op->resnull = true;
                *op->resvalue = (Datum) 0;
            }
            else
                *op->resvalue = DirectFunctionCall1(bool_int4, *op->resvalue);
            return;
        }
 
        *op->resvalue = DirectFunctionCall1(jsonb_in,
                                            DatumGetBool(*op->resvalue) ?
                                            CStringGetDatum("true") :
                                            CStringGetDatum("false"));
    }
 
    *op->resvalue = json_populate_type(*op->resvalue, JSONBOID,
                                       op->d.jsonexpr_coercion.targettype,
                                       op->d.jsonexpr_coercion.targettypmod,
                                       &op->d.jsonexpr_coercion.json_coercion_cache,
                                       econtext->ecxt_per_query_memory,
                                       op->resnull,
                                       op->d.jsonexpr_coercion.omit_quotes,
                                       (Node *) escontext);
}

References bool_int4(), CStringGetDatum(), DatumGetBool(), DirectFunctionCall1, domain_check_safe(), ExprContext::ecxt_per_query_memory, ExprEvalStep::escontext, json_populate_type(), jsonb_in(), and ExprEvalStep::op.

Referenced by ExecInterpExpr().

◆ ExecEvalJsonCoercionFinish()

void ExecEvalJsonCoercionFinish	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 5192 of file execExprInterp.c.

{
    JsonExprState *jsestate = op->d.jsonexpr.jsestate;
 
    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))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
            /*- translator: first %s is a SQL/JSON clause (e.g. ON ERROR) */
                     errmsg("could not coerce %s expression (%s) to the RETURNING type",
                            "ON ERROR",
                            GetJsonBehaviorValueString(jsestate->jsexpr->on_error)),
                     errdetail("%s", jsestate->escontext.error_data->message)));
        else if (DatumGetBool(jsestate->empty.value))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
            /*- translator: first %s is a SQL/JSON clause (e.g. ON ERROR) */
                     errmsg("could not coerce %s expression (%s) to the RETURNING type",
                            "ON EMPTY",
                            GetJsonBehaviorValueString(jsestate->jsexpr->on_empty)),
                     errdetail("%s", jsestate->escontext.error_data->message)));
 
        *op->resvalue = (Datum) 0;
        *op->resnull = true;
 
        jsestate->error.value = BoolGetDatum(true);
 
        /*
         * Reset for next use such as for catching errors when coercing a
         * JsonBehavior expression.
         */
        jsestate->escontext.error_occurred = false;
        jsestate->escontext.error_occurred = false;
        jsestate->escontext.details_wanted = true;
    }
}

References BoolGetDatum(), DatumGetBool(), ErrorSaveContext::details_wanted, JsonExprState::empty, ereport, errcode(), errdetail(), errmsg(), JsonExprState::error, ERROR, ErrorSaveContext::error_data, ErrorSaveContext::error_occurred, JsonExprState::escontext, GetJsonBehaviorValueString(), ExprEvalStep::jsestate, JsonExprState::jsexpr, ErrorData::message, JsonExpr::on_empty, JsonExpr::on_error, ExprEvalStep::op, SOFT_ERROR_OCCURRED, and NullableDatum::value.

Referenced by ExecInterpExpr().

◆ ExecEvalJsonConstructor()

void ExecEvalJsonConstructor	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 4657 of file execExprInterp.c.

{
    Datum       res;
    JsonConstructorExprState *jcstate = op->d.json_constructor.jcstate;
    JsonConstructorExpr *ctor = jcstate->constructor;
    bool        is_jsonb = ctor->returning->format->format_type == JS_FORMAT_JSONB;
    bool        isnull = false;
 
    if (ctor->type == JSCTOR_JSON_ARRAY)
        res = (is_jsonb ?
               jsonb_build_array_worker :
               json_build_array_worker) (jcstate->nargs,
                                         jcstate->arg_values,
                                         jcstate->arg_nulls,
                                         jcstate->arg_types,
                                         jcstate->constructor->absent_on_null);
    else if (ctor->type == JSCTOR_JSON_OBJECT)
        res = (is_jsonb ?
               jsonb_build_object_worker :
               json_build_object_worker) (jcstate->nargs,
                                          jcstate->arg_values,
                                          jcstate->arg_nulls,
                                          jcstate->arg_types,
                                          jcstate->constructor->absent_on_null,
                                          jcstate->constructor->unique);
    else if (ctor->type == JSCTOR_JSON_SCALAR)
    {
        if (jcstate->arg_nulls[0])
        {
            res = (Datum) 0;
            isnull = true;
        }
        else
        {
            Datum       value = jcstate->arg_values[0];
            Oid         outfuncid = jcstate->arg_type_cache[0].outfuncid;
            JsonTypeCategory category = (JsonTypeCategory)
                jcstate->arg_type_cache[0].category;
 
            if (is_jsonb)
                res = datum_to_jsonb(value, category, outfuncid);
            else
                res = datum_to_json(value, category, outfuncid);
        }
    }
    else if (ctor->type == JSCTOR_JSON_PARSE)
    {
        if (jcstate->arg_nulls[0])
        {
            res = (Datum) 0;
            isnull = true;
        }
        else
        {
            Datum       value = jcstate->arg_values[0];
            text       *js = DatumGetTextP(value);
 
            if (is_jsonb)
                res = jsonb_from_text(js, true);
            else
            {
                (void) json_validate(js, true, true);
                res = value;
            }
        }
    }
    else
        elog(ERROR, "invalid JsonConstructorExpr type %d", ctor->type);
 
    *op->resvalue = res;
    *op->resnull = isnull;
}

Referenced by ExecInterpExpr().

◆ ExecEvalJsonExprPath()

int ExecEvalJsonExprPath	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 4835 of file execExprInterp.c.

{
    JsonExprState *jsestate = op->d.jsonexpr.jsestate;
    JsonExpr   *jsexpr = jsestate->jsexpr;
    Datum       item;
    JsonPath   *path;
    bool        throw_error = jsexpr->on_error->btype == JSON_BEHAVIOR_ERROR;
    bool        error = false,
                empty = false;
    int         jump_eval_coercion = jsestate->jump_eval_coercion;
    char       *val_string = NULL;
 
    item = jsestate->formatted_expr.value;
    path = DatumGetJsonPathP(jsestate->pathspec.value);
 
    /* Set error/empty to false. */
    memset(&jsestate->error, 0, sizeof(NullableDatum));
    memset(&jsestate->empty, 0, sizeof(NullableDatum));
 
    /* Also reset ErrorSaveContext contents for the next row. */
    if (jsestate->escontext.details_wanted)
    {
        jsestate->escontext.error_data = NULL;
        jsestate->escontext.details_wanted = false;
    }
    jsestate->escontext.error_occurred = false;
 
    switch (jsexpr->op)
    {
        case JSON_EXISTS_OP:
            {
                bool        exists = JsonPathExists(item, path,
                                                    !throw_error ? &error : NULL,
                                                    jsestate->args);
 
                if (!error)
                {
                    *op->resnull = false;
                    *op->resvalue = BoolGetDatum(exists);
                }
            }
            break;
 
        case JSON_QUERY_OP:
            *op->resvalue = JsonPathQuery(item, path, jsexpr->wrapper, &empty,
                                          !throw_error ? &error : NULL,
                                          jsestate->args,
                                          jsexpr->column_name);
 
            *op->resnull = (DatumGetPointer(*op->resvalue) == NULL);
            break;
 
        case JSON_VALUE_OP:
            {
                JsonbValue *jbv = JsonPathValue(item, path, &empty,
                                                !throw_error ? &error : NULL,
                                                jsestate->args,
                                                jsexpr->column_name);
 
                if (jbv == NULL)
                {
                    /* Will be coerced with json_populate_type(), if needed. */
                    *op->resvalue = (Datum) 0;
                    *op->resnull = true;
                }
                else if (!error && !empty)
                {
                    if (jsexpr->returning->typid == JSONOID ||
                        jsexpr->returning->typid == JSONBOID)
                    {
                        val_string = DatumGetCString(DirectFunctionCall1(jsonb_out,
                                                                         JsonbPGetDatum(JsonbValueToJsonb(jbv))));
                    }
                    else if (jsexpr->use_json_coercion)
                    {
                        *op->resvalue = JsonbPGetDatum(JsonbValueToJsonb(jbv));
                        *op->resnull = false;
                    }
                    else
                    {
                        val_string = ExecGetJsonValueItemString(jbv, op->resnull);
 
                        /*
                         * Simply convert to the default RETURNING type (text)
                         * if no coercion needed.
                         */
                        if (!jsexpr->use_io_coercion)
                            *op->resvalue = DirectFunctionCall1(textin,
                                                                CStringGetDatum(val_string));
                    }
                }
                break;
            }
 
            /* JSON_TABLE_OP can't happen here */
 
        default:
            elog(ERROR, "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)
    {
        FunctionCallInfo fcinfo;
 
        Assert(jump_eval_coercion == -1);
        fcinfo = jsestate->input_fcinfo;
        Assert(fcinfo != NULL);
        Assert(val_string != NULL);
        fcinfo->args[0].value = PointerGetDatum(val_string);
        fcinfo->args[0].isnull = *op->resnull;
 
        /*
         * Second and third arguments are already set up in
         * ExecInitJsonExpr().
         */
 
        fcinfo->isnull = false;
        *op->resvalue = FunctionCallInvoke(fcinfo);
        if (SOFT_ERROR_OCCURRED(&jsestate->escontext))
            error = 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)
    {
        *op->resvalue = (Datum) 0;
        *op->resnull = true;
        if (jsexpr->on_empty)
        {
            if (jsexpr->on_empty->btype != JSON_BEHAVIOR_ERROR)
            {
                jsestate->empty.value = BoolGetDatum(true);
                /* Set up to catch coercion errors of the ON EMPTY value. */
                jsestate->escontext.error_occurred = false;
                jsestate->escontext.details_wanted = 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)
        {
            jsestate->error.value = BoolGetDatum(true);
            /* Set up to catch coercion errors of the ON ERROR value. */
            jsestate->escontext.error_occurred = false;
            jsestate->escontext.details_wanted = true;
            Assert(!throw_error);
            /* 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)
            ereport(ERROR,
                    errcode(ERRCODE_NO_SQL_JSON_ITEM),
                    errmsg("no SQL/JSON item found for specified path of column \"%s\"",
                           jsexpr->column_name));
        else
            ereport(ERROR,
                    errcode(ERRCODE_NO_SQL_JSON_ITEM),
                    errmsg("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)
    {
        Assert(!throw_error);
        *op->resvalue = (Datum) 0;
        *op->resnull = true;
        jsestate->error.value = BoolGetDatum(true);
        /* Set up to catch coercion errors of the ON ERROR value. */
        jsestate->escontext.error_occurred = false;
        jsestate->escontext.details_wanted = 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;
}

References FunctionCallInfoBaseData::args, JsonExprState::args, Assert(), BoolGetDatum(), JsonBehavior::btype, JsonExpr::column_name, CStringGetDatum(), DatumGetCString(), DatumGetJsonPathP(), DatumGetPointer(), ErrorSaveContext::details_wanted, DirectFunctionCall1, elog, JsonExprState::empty, ereport, errcode(), errmsg(), JsonExprState::error, ERROR, error(), ErrorSaveContext::error_data, ErrorSaveContext::error_occurred, JsonExprState::escontext, ExecGetJsonValueItemString(), JsonExprState::formatted_expr, FunctionCallInvoke, JsonExprState::input_fcinfo, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, ExprEvalStep::jsestate, JsonExprState::jsexpr, JSON_BEHAVIOR_ERROR, JSON_EXISTS_OP, JSON_QUERY_OP, JSON_VALUE_OP, jsonb_out(), JsonbPGetDatum(), JsonbValueToJsonb(), JsonPathExists(), JsonPathQuery(), JsonPathValue(), JsonExprState::jump_empty, JsonExprState::jump_end, JsonExprState::jump_error, JsonExprState::jump_eval_coercion, JsonExpr::on_empty, JsonExpr::on_error, ExprEvalStep::op, JsonExpr::op, JsonExprState::pathspec, PointerGetDatum(), JsonExpr::returning, SOFT_ERROR_OCCURRED, textin(), JsonReturning::typid, JsonExpr::use_io_coercion, JsonExpr::use_json_coercion, val_string, NullableDatum::value, and JsonExpr::wrapper.

Referenced by ExecInterpExpr().

◆ ExecEvalJsonIsPredicate()

void ExecEvalJsonIsPredicate	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4735 of file execExprInterp.c.

{
    JsonIsPredicate *pred = op->d.is_json.pred;
    Datum       js = *op->resvalue;
    Oid         exprtype;
    bool        res;
 
    if (*op->resnull)
    {
        *op->resvalue = BoolGetDatum(false);
        return;
    }
 
    exprtype = exprType(pred->expr);
 
    if (exprtype == TEXTOID || exprtype == JSONOID)
    {
        text       *json = DatumGetTextP(js);
 
        if (pred->item_type == JS_TYPE_ANY)
            res = true;
        else
        {
            switch (json_get_first_token(json, false))
            {
                case JSON_TOKEN_OBJECT_START:
                    res = pred->item_type == JS_TYPE_OBJECT;
                    break;
                case JSON_TOKEN_ARRAY_START:
                    res = pred->item_type == JS_TYPE_ARRAY;
                    break;
                case JSON_TOKEN_STRING:
                case JSON_TOKEN_NUMBER:
                case JSON_TOKEN_TRUE:
                case JSON_TOKEN_FALSE:
                case JSON_TOKEN_NULL:
                    res = pred->item_type == JS_TYPE_SCALAR;
                    break;
                default:
                    res = false;
                    break;
            }
        }
 
        /*
         * Do full parsing pass only for uniqueness check or for JSON text
         * validation.
         */
        if (res && (pred->unique_keys || exprtype == TEXTOID))
            res = json_validate(json, pred->unique_keys, false);
    }
    else if (exprtype == JSONBOID)
    {
        if (pred->item_type == JS_TYPE_ANY)
            res = true;
        else
        {
            Jsonb      *jb = DatumGetJsonbP(js);
 
            switch (pred->item_type)
            {
                case JS_TYPE_OBJECT:
                    res = JB_ROOT_IS_OBJECT(jb);
                    break;
                case JS_TYPE_ARRAY:
                    res = JB_ROOT_IS_ARRAY(jb) && !JB_ROOT_IS_SCALAR(jb);
                    break;
                case JS_TYPE_SCALAR:
                    res = JB_ROOT_IS_ARRAY(jb) && JB_ROOT_IS_SCALAR(jb);
                    break;
                default:
                    res = false;
                    break;
            }
        }
 
        /* Key uniqueness check is redundant for jsonb */
    }
    else
        res = false;
 
    *op->resvalue = BoolGetDatum(res);
}

References BoolGetDatum(), DatumGetJsonbP(), DatumGetTextP, JsonIsPredicate::expr, exprType(), JsonIsPredicate::item_type, JB_ROOT_IS_ARRAY, JB_ROOT_IS_OBJECT, JB_ROOT_IS_SCALAR, JS_TYPE_ANY, JS_TYPE_ARRAY, JS_TYPE_OBJECT, JS_TYPE_SCALAR, json_get_first_token(), JSON_TOKEN_ARRAY_START, JSON_TOKEN_FALSE, JSON_TOKEN_NULL, JSON_TOKEN_NUMBER, JSON_TOKEN_OBJECT_START, JSON_TOKEN_STRING, JSON_TOKEN_TRUE, json_validate(), ExprEvalStep::op, ExprEvalStep::pred, and JsonIsPredicate::unique_keys.

Referenced by ExecInterpExpr().

◆ ExecEvalMergeSupportFunc()

void ExecEvalMergeSupportFunc	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 5273 of file execExprInterp.c.

{
    ModifyTableState *mtstate = castNode(ModifyTableState, state->parent);
    MergeActionState *relaction = mtstate->mt_merge_action;
 
    if (!relaction)
        elog(ERROR, "no merge action in progress");
 
    /* Return the MERGE action ("INSERT", "UPDATE", or "DELETE") */
    switch (relaction->mas_action->commandType)
    {
        case CMD_INSERT:
            *op->resvalue = PointerGetDatum(cstring_to_text_with_len("INSERT", 6));
            *op->resnull = false;
            break;
        case CMD_UPDATE:
            *op->resvalue = PointerGetDatum(cstring_to_text_with_len("UPDATE", 6));
            *op->resnull = false;
            break;
        case CMD_DELETE:
            *op->resvalue = PointerGetDatum(cstring_to_text_with_len("DELETE", 6));
            *op->resnull = false;
            break;
        case CMD_NOTHING:
            elog(ERROR, "unexpected merge action: DO NOTHING");
            break;
        default:
            elog(ERROR, "unrecognized commandType: %d",
                 (int) relaction->mas_action->commandType);
    }
}

References castNode, CMD_DELETE, CMD_INSERT, CMD_NOTHING, CMD_UPDATE, MergeAction::commandType, cstring_to_text_with_len(), elog, ERROR, MergeActionState::mas_action, ModifyTableState::mt_merge_action, ExprEvalStep::op, and PointerGetDatum().

Referenced by ExecInterpExpr().

◆ ExecEvalMinMax()

void ExecEvalMinMax	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3676 of file execExprInterp.c.

{
    Datum      *values = op->d.minmax.values;
    bool       *nulls = op->d.minmax.nulls;
    FunctionCallInfo fcinfo = op->d.minmax.fcinfo_data;
    MinMaxOp    operator = op->d.minmax.op;
 
    /* set at initialization */
    Assert(fcinfo->args[0].isnull == false);
    Assert(fcinfo->args[1].isnull == false);
 
    /* default to null result */
    *op->resnull = 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 */
            *op->resvalue = values[off];
            *op->resnull = false;
        }
        else
        {
            int         cmpresult;
 
            /* apply comparison function */
            fcinfo->args[0].value = *op->resvalue;
            fcinfo->args[1].value = values[off];
 
            fcinfo->isnull = false;
            cmpresult = DatumGetInt32(FunctionCallInvoke(fcinfo));
            if (fcinfo->isnull) /* probably should not happen */
                continue;
 
            if (cmpresult > 0 && operator == IS_LEAST)
                *op->resvalue = values[off];
            else if (cmpresult < 0 && operator == IS_GREATEST)
                *op->resvalue = values[off];
        }
    }
}

References FunctionCallInfoBaseData::args, Assert(), DatumGetInt32(), FunctionCallInvoke, IS_GREATEST, IS_LEAST, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, ExprEvalStep::nulls, ExprEvalStep::op, NullableDatum::value, and values.

Referenced by ExecInterpExpr().

◆ ExecEvalNextValueExpr()

void ExecEvalNextValueExpr	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3273 of file execExprInterp.c.

{
    int64       newval = nextval_internal(op->d.nextvalueexpr.seqid, false);
 
    switch (op->d.nextvalueexpr.seqtypid)
    {
        case INT2OID:
            *op->resvalue = Int16GetDatum((int16) newval);
            break;
        case INT4OID:
            *op->resvalue = Int32GetDatum((int32) newval);
            break;
        case INT8OID:
            *op->resvalue = Int64GetDatum((int64) newval);
            break;
        default:
            elog(ERROR, "unsupported sequence type %u",
                 op->d.nextvalueexpr.seqtypid);
    }
    *op->resnull = false;
}

References elog, ERROR, Int16GetDatum(), Int32GetDatum(), Int64GetDatum(), newval, nextval_internal(), and ExprEvalStep::op.

Referenced by ExecInterpExpr().

◆ ExecEvalParamExec()

void ExecEvalParamExec	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 3048 of file execExprInterp.c.

{
    ParamExecData *prm;
 
    prm = &(econtext->ecxt_param_exec_vals[op->d.param.paramid]);
    if (unlikely(prm->execPlan != NULL))
    {
        /* Parameter not evaluated yet, so go do it */
        ExecSetParamPlan(prm->execPlan, econtext);
        /* ExecSetParamPlan should have processed this param... */
        Assert(prm->execPlan == NULL);
    }
    *op->resvalue = prm->value;
    *op->resnull = prm->isnull;
}

References Assert(), ExprContext::ecxt_param_exec_vals, ParamExecData::execPlan, ExecSetParamPlan(), ParamExecData::isnull, ExprEvalStep::op, unlikely, and ParamExecData::value.

Referenced by ExecInterpExpr().

◆ ExecEvalParamExtern()

void ExecEvalParamExtern	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 3070 of file execExprInterp.c.

{
    ParamListInfo paramInfo = econtext->ecxt_param_list_info;
    int         paramId = op->d.param.paramid;
 
    if (likely(paramInfo &&
               paramId > 0 && paramId <= paramInfo->numParams))
    {
        ParamExternData *prm;
        ParamExternData prmdata;
 
        /* give hook a chance in case parameter is dynamic */
        if (paramInfo->paramFetch != NULL)
            prm = paramInfo->paramFetch(paramInfo, paramId, false, &prmdata);
        else
            prm = &paramInfo->params[paramId - 1];
 
        if (likely(OidIsValid(prm->ptype)))
        {
            /* safety check in case hook did something unexpected */
            if (unlikely(prm->ptype != op->d.param.paramtype))
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("type of parameter %d (%s) does not match that when preparing the plan (%s)",
                                paramId,
                                format_type_be(prm->ptype),
                                format_type_be(op->d.param.paramtype))));
            *op->resvalue = prm->value;
            *op->resnull = prm->isnull;
            return;
        }
    }
 
    ereport(ERROR,
            (errcode(ERRCODE_UNDEFINED_OBJECT),
             errmsg("no value found for parameter %d", paramId)));
}

References ExprContext::ecxt_param_list_info, ereport, errcode(), errmsg(), ERROR, format_type_be(), ParamExternData::isnull, likely, OidIsValid, ExprEvalStep::op, ParamListInfoData::paramFetch, ParamListInfoData::params, ParamExternData::ptype, unlikely, and ParamExternData::value.

Referenced by ExecInterpExpr().

◆ ExecEvalParamSet()

void ExecEvalParamSet	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 3113 of file execExprInterp.c.

{
    ParamExecData *prm;
 
    prm = &(econtext->ecxt_param_exec_vals[op->d.param.paramid]);
 
    /* Shouldn't have a pending evaluation anymore */
    Assert(prm->execPlan == NULL);
 
    prm->value = state->resvalue;
    prm->isnull = state->resnull;
}

References Assert(), ExprContext::ecxt_param_exec_vals, ParamExecData::execPlan, ParamExecData::isnull, ExprEvalStep::op, and ParamExecData::value.

Referenced by ExecInterpExpr().

◆ ExecEvalPreOrderedDistinctMulti()

bool ExecEvalPreOrderedDistinctMulti	(	AggState *	aggstate,
		AggStatePerTrans	pertrans
	)

Definition at line 5762 of file execExprInterp.c.

{
    ExprContext *tmpcontext = aggstate->tmpcontext;
    bool        isdistinct = false; /* for now */
    TupleTableSlot *save_outer;
    TupleTableSlot *save_inner;
 
    for (int i = 0; i < pertrans->numTransInputs; i++)
    {
        pertrans->sortslot->tts_values[i] = pertrans->transfn_fcinfo->args[i + 1].value;
        pertrans->sortslot->tts_isnull[i] = pertrans->transfn_fcinfo->args[i + 1].isnull;
    }
 
    ExecClearTuple(pertrans->sortslot);
    pertrans->sortslot->tts_nvalid = pertrans->numInputs;
    ExecStoreVirtualTuple(pertrans->sortslot);
 
    /* save the previous slots before we overwrite them */
    save_outer = tmpcontext->ecxt_outertuple;
    save_inner = tmpcontext->ecxt_innertuple;
 
    tmpcontext->ecxt_outertuple = pertrans->sortslot;
    tmpcontext->ecxt_innertuple = pertrans->uniqslot;
 
    if (!pertrans->haslast ||
        !ExecQual(pertrans->equalfnMulti, tmpcontext))
    {
        if (pertrans->haslast)
            ExecClearTuple(pertrans->uniqslot);
 
        pertrans->haslast = true;
        ExecCopySlot(pertrans->uniqslot, pertrans->sortslot);
 
        isdistinct = true;
    }
 
    /* restore the original slots */
    tmpcontext->ecxt_outertuple = save_outer;
    tmpcontext->ecxt_innertuple = save_inner;
 
    return isdistinct;
}

References FunctionCallInfoBaseData::args, ExprContext::ecxt_innertuple, ExprContext::ecxt_outertuple, AggStatePerTransData::equalfnMulti, ExecClearTuple(), ExecCopySlot(), ExecQual(), ExecStoreVirtualTuple(), AggStatePerTransData::haslast, i, NullableDatum::isnull, AggStatePerTransData::numInputs, AggStatePerTransData::numTransInputs, ExprEvalStep::pertrans, AggStatePerTransData::sortslot, AggState::tmpcontext, AggStatePerTransData::transfn_fcinfo, TupleTableSlot::tts_isnull, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_values, AggStatePerTransData::uniqslot, and NullableDatum::value.

Referenced by ExecInterpExpr().

◆ ExecEvalPreOrderedDistinctSingle()

bool ExecEvalPreOrderedDistinctSingle	(	AggState *	aggstate,
		AggStatePerTrans	pertrans
	)

Definition at line 5719 of file execExprInterp.c.

{
    Datum       value = pertrans->transfn_fcinfo->args[1].value;
    bool        isnull = pertrans->transfn_fcinfo->args[1].isnull;
 
    if (!pertrans->haslast ||
        pertrans->lastisnull != isnull ||
        (!isnull && !DatumGetBool(FunctionCall2Coll(&pertrans->equalfnOne,
                                                    pertrans->aggCollation,
                                                    pertrans->lastdatum, value))))
    {
        if (pertrans->haslast && !pertrans->inputtypeByVal &&
            !pertrans->lastisnull)
            pfree(DatumGetPointer(pertrans->lastdatum));
 
        pertrans->haslast = true;
        if (!isnull)
        {
            MemoryContext oldContext;
 
            oldContext = MemoryContextSwitchTo(aggstate->curaggcontext->ecxt_per_tuple_memory);
 
            pertrans->lastdatum = datumCopy(value, pertrans->inputtypeByVal,
                                            pertrans->inputtypeLen);
 
            MemoryContextSwitchTo(oldContext);
        }
        else
            pertrans->lastdatum = (Datum) 0;
        pertrans->lastisnull = isnull;
        return true;
    }
 
    return false;
}

Referenced by ExecInterpExpr().

◆ ExecEvalRow()

void ExecEvalRow	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3656 of file execExprInterp.c.

{
    HeapTuple   tuple;
 
    /* build tuple from evaluated field values */
    tuple = heap_form_tuple(op->d.row.tupdesc,
                            op->d.row.elemvalues,
                            op->d.row.elemnulls);
 
    *op->resvalue = HeapTupleGetDatum(tuple);
    *op->resnull = false;
}

References heap_form_tuple(), HeapTupleGetDatum(), and ExprEvalStep::op.

Referenced by ExecInterpExpr().

◆ ExecEvalRowNotNull()

void ExecEvalRowNotNull	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 3308 of file execExprInterp.c.

{
    ExecEvalRowNullInt(state, op, econtext, false);
}

References ExecEvalRowNullInt(), and ExprEvalStep::op.

Referenced by ExecInterpExpr().

◆ ExecEvalRowNull()

void ExecEvalRowNull	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 3299 of file execExprInterp.c.

{
    ExecEvalRowNullInt(state, op, econtext, true);
}

References ExecEvalRowNullInt(), and ExprEvalStep::op.

Referenced by ExecInterpExpr().

◆ ExecEvalScalarArrayOp()

void ExecEvalScalarArrayOp	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4023 of file execExprInterp.c.

{
    FunctionCallInfo fcinfo = op->d.scalararrayop.fcinfo_data;
    bool        useOr = op->d.scalararrayop.useOr;
    bool        strictfunc = op->d.scalararrayop.finfo->fn_strict;
    ArrayType  *arr;
    int         nitems;
    Datum       result;
    bool        resultnull;
    int16       typlen;
    bool        typbyval;
    char        typalign;
    char       *s;
    bits8      *bitmap;
    int         bitmask;
 
    /*
     * 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 */
    arr = DatumGetArrayTypeP(*op->resvalue);
 
    /*
     * 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.
     */
    nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr));
    if (nitems <= 0)
    {
        *op->resvalue = BoolGetDatum(!useOr);
        *op->resnull = 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)
    {
        *op->resnull = 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))
    {
        get_typlenbyvalalign(ARR_ELEMTYPE(arr),
                             &op->d.scalararrayop.typlen,
                             &op->d.scalararrayop.typbyval,
                             &op->d.scalararrayop.typalign);
        op->d.scalararrayop.element_type = ARR_ELEMTYPE(arr);
    }
 
    typlen = op->d.scalararrayop.typlen;
    typbyval = op->d.scalararrayop.typbyval;
    typalign = op->d.scalararrayop.typalign;
 
    /* Initialize result appropriately depending on useOr */
    result = BoolGetDatum(!useOr);
    resultnull = false;
 
    /* Loop over the array elements */
    s = (char *) ARR_DATA_PTR(arr);
    bitmap = ARR_NULLBITMAP(arr);
    bitmask = 1;
 
    for (int i = 0; i < nitems; i++)
    {
        Datum       elt;
        Datum       thisresult;
 
        /* Get array element, checking for NULL */
        if (bitmap && (*bitmap & bitmask) == 0)
        {
            fcinfo->args[1].value = (Datum) 0;
            fcinfo->args[1].isnull = true;
        }
        else
        {
            elt = fetch_att(s, typbyval, typlen);
            s = att_addlength_pointer(s, typlen, s);
            s = (char *) att_align_nominal(s, typalign);
            fcinfo->args[1].value = elt;
            fcinfo->args[1].isnull = false;
        }
 
        /* Call comparison function */
        if (fcinfo->args[1].isnull && strictfunc)
        {
            fcinfo->isnull = true;
            thisresult = (Datum) 0;
        }
        else
        {
            fcinfo->isnull = false;
            thisresult = op->d.scalararrayop.fn_addr(fcinfo);
        }
 
        /* Combine results per OR or AND semantics */
        if (fcinfo->isnull)
            resultnull = true;
        else if (useOr)
        {
            if (DatumGetBool(thisresult))
            {
                result = BoolGetDatum(true);
                resultnull = false;
                break;          /* needn't look at any more elements */
            }
        }
        else
        {
            if (!DatumGetBool(thisresult))
            {
                result = BoolGetDatum(false);
                resultnull = false;
                break;          /* needn't look at any more elements */
            }
        }
 
        /* advance bitmap pointer if any */
        if (bitmap)
        {
            bitmask <<= 1;
            if (bitmask == 0x100)
            {
                bitmap++;
                bitmask = 1;
            }
        }
    }
 
    *op->resvalue = result;
    *op->resnull = resultnull;
}

References FunctionCallInfoBaseData::args, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_NDIM, ARR_NULLBITMAP, ArrayGetNItems(), att_addlength_pointer, att_align_nominal, BoolGetDatum(), DatumGetArrayTypeP, DatumGetBool(), fetch_att(), get_typlenbyvalalign(), i, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, nitems, ExprEvalStep::op, typalign, ExprEvalStep::typbyval, ExprEvalStep::typlen, ExprEvalStep::useOr, and NullableDatum::value.

Referenced by ExecInterpExpr().

◆ ExecEvalSQLValueFunction()

void ExecEvalSQLValueFunction	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3195 of file execExprInterp.c.

{
    LOCAL_FCINFO(fcinfo, 0);
    SQLValueFunction *svf = op->d.sqlvaluefunction.svf;
 
    *op->resnull = 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:
            *op->resvalue = DateADTGetDatum(GetSQLCurrentDate());
            break;
        case SVFOP_CURRENT_TIME:
        case SVFOP_CURRENT_TIME_N:
            *op->resvalue = TimeTzADTPGetDatum(GetSQLCurrentTime(svf->typmod));
            break;
        case SVFOP_CURRENT_TIMESTAMP:
        case SVFOP_CURRENT_TIMESTAMP_N:
            *op->resvalue = TimestampTzGetDatum(GetSQLCurrentTimestamp(svf->typmod));
            break;
        case SVFOP_LOCALTIME:
        case SVFOP_LOCALTIME_N:
            *op->resvalue = TimeADTGetDatum(GetSQLLocalTime(svf->typmod));
            break;
        case SVFOP_LOCALTIMESTAMP:
        case SVFOP_LOCALTIMESTAMP_N:
            *op->resvalue = TimestampGetDatum(GetSQLLocalTimestamp(svf->typmod));
            break;
        case SVFOP_CURRENT_ROLE:
        case SVFOP_CURRENT_USER:
        case SVFOP_USER:
            InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
            *op->resvalue = current_user(fcinfo);
            *op->resnull = fcinfo->isnull;
            break;
        case SVFOP_SESSION_USER:
            InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
            *op->resvalue = session_user(fcinfo);
            *op->resnull = fcinfo->isnull;
            break;
        case SVFOP_CURRENT_CATALOG:
            InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
            *op->resvalue = current_database(fcinfo);
            *op->resnull = fcinfo->isnull;
            break;
        case SVFOP_CURRENT_SCHEMA:
            InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
            *op->resvalue = current_schema(fcinfo);
            *op->resnull = fcinfo->isnull;
            break;
    }
}

References current_database(), current_schema(), current_user(), DateADTGetDatum(), GetSQLCurrentDate(), GetSQLCurrentTime(), GetSQLCurrentTimestamp(), GetSQLLocalTime(), GetSQLLocalTimestamp(), InitFunctionCallInfoData, InvalidOid, LOCAL_FCINFO, ExprEvalStep::op, SQLValueFunction::op, session_user(), ExprEvalStep::svf, SVFOP_CURRENT_CATALOG, SVFOP_CURRENT_DATE, SVFOP_CURRENT_ROLE, SVFOP_CURRENT_SCHEMA, SVFOP_CURRENT_TIME, SVFOP_CURRENT_TIME_N, SVFOP_CURRENT_TIMESTAMP, SVFOP_CURRENT_TIMESTAMP_N, SVFOP_CURRENT_USER, SVFOP_LOCALTIME, SVFOP_LOCALTIME_N, SVFOP_LOCALTIMESTAMP, SVFOP_LOCALTIMESTAMP_N, SVFOP_SESSION_USER, SVFOP_USER, TimeADTGetDatum(), TimestampGetDatum(), TimestampTzGetDatum(), TimeTzADTPGetDatum(), and SQLValueFunction::typmod.

Referenced by ExecInterpExpr().

◆ ExecEvalStepOp()

ExprEvalOp ExecEvalStepOp	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 2960 of file execExprInterp.c.

{
#if defined(EEO_USE_COMPUTED_GOTO)
    if (state->flags & EEO_FLAG_DIRECT_THREADED)
    {
        ExprEvalOpLookup key;
        ExprEvalOpLookup *res;
 
        key.opcode = (void *) op->opcode;
        res = bsearch(&key,
                      reverse_dispatch_table,
                      EEOP_LAST /* nmembers */ ,
                      sizeof(ExprEvalOpLookup),
                      dispatch_compare_ptr);
        Assert(res);            /* unknown ops shouldn't get looked up */
        return res->op;
    }
#endif
    return (ExprEvalOp) op->opcode;
}

References Assert(), EEO_FLAG_DIRECT_THREADED, EEOP_LAST, sort-test::key, and ExprEvalStep::op.

Referenced by CheckExprStillValid().

◆ ExecEvalSubPlan()

void ExecEvalSubPlan	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 5310 of file execExprInterp.c.

{
    SubPlanState *sstate = op->d.subplan.sstate;
 
    /* could potentially be nested, so make sure there's enough stack */
    check_stack_depth();
 
    *op->resvalue = ExecSubPlan(sstate, econtext, op->resnull);
}

References check_stack_depth(), ExecSubPlan(), ExprEvalStep::op, and ExprEvalStep::sstate.

Referenced by ExecInterpExpr().

◆ ExecEvalSysVar()

void ExecEvalSysVar	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext,
		TupleTableSlot *	slot
	)

Definition at line 5586 of file execExprInterp.c.

{
    Datum       d;
 
    /* OLD/NEW system attribute is NULL if OLD/NEW row is NULL */
    if ((op->d.var.varreturningtype == VAR_RETURNING_OLD &&
         state->flags & EEO_FLAG_OLD_IS_NULL) ||
        (op->d.var.varreturningtype == VAR_RETURNING_NEW &&
         state->flags & EEO_FLAG_NEW_IS_NULL))
    {
        *op->resvalue = (Datum) 0;
        *op->resnull = true;
        return;
    }
 
    /* slot_getsysattr has sufficient defenses against bad attnums */
    d = slot_getsysattr(slot,
                        op->d.var.attnum,
                        op->resnull);
    *op->resvalue = d;
    /* this ought to be unreachable, but it's cheap enough to check */
    if (unlikely(*op->resnull))
        elog(ERROR, "failed to fetch attribute from slot");
}

References ExprEvalStep::d, EEO_FLAG_NEW_IS_NULL, EEO_FLAG_OLD_IS_NULL, elog, ERROR, ExprEvalStep::op, slot_getsysattr(), unlikely, VAR_RETURNING_NEW, and VAR_RETURNING_OLD.

Referenced by ExecInterpExpr().

◆ ExecEvalWholeRowVar()

void ExecEvalWholeRowVar	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

Definition at line 5327 of file execExprInterp.c.

{
    Var        *variable = op->d.wholerow.var;
    TupleTableSlot *slot = NULL;
    TupleDesc   output_tupdesc;
    MemoryContext oldcontext;
    HeapTupleHeader dtuple;
    HeapTuple   tuple;
 
    /* This was checked by ExecInitExpr */
    Assert(variable->varattno == InvalidAttrNumber);
 
    /* Get the input slot we want */
    switch (variable->varno)
    {
        case INNER_VAR:
            /* get the tuple from the inner node */
            slot = econtext->ecxt_innertuple;
            break;
 
        case OUTER_VAR:
            /* get the tuple from the outer node */
            slot = econtext->ecxt_outertuple;
            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:
                    slot = econtext->ecxt_scantuple;
                    break;
 
                case VAR_RETURNING_OLD:
                    if (state->flags & EEO_FLAG_OLD_IS_NULL)
                    {
                        *op->resvalue = (Datum) 0;
                        *op->resnull = true;
                        return;
                    }
                    slot = econtext->ecxt_oldtuple;
                    break;
 
                case VAR_RETURNING_NEW:
                    if (state->flags & EEO_FLAG_NEW_IS_NULL)
                    {
                        *op->resvalue = (Datum) 0;
                        *op->resnull = true;
                        return;
                    }
                    slot = econtext->ecxt_newtuple;
                    break;
            }
            break;
    }
 
    /* Apply the junkfilter if any */
    if (op->d.wholerow.junkFilter != NULL)
        slot = ExecFilterJunk(op->d.wholerow.junkFilter, slot);
 
    /*
     * 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 */
        op->d.wholerow.slow = 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)
        {
            TupleDesc   var_tupdesc;
            TupleDesc   slot_tupdesc;
 
            /*
             * 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.
             */
            var_tupdesc = lookup_rowtype_tupdesc_domain(variable->vartype,
                                                        -1, false);
 
            slot_tupdesc = slot->tts_tupleDescriptor;
 
            if (var_tupdesc->natts != slot_tupdesc->natts)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("table row type and query-specified row type do not match"),
                         errdetail_plural("Table row contains %d attribute, but query expects %d.",
                                          "Table row contains %d attributes, but query expects %d.",
                                          slot_tupdesc->natts,
                                          slot_tupdesc->natts,
                                          var_tupdesc->natts)));
 
            for (int i = 0; i < var_tupdesc->natts; i++)
            {
                Form_pg_attribute vattr = TupleDescAttr(var_tupdesc, i);
                Form_pg_attribute sattr = TupleDescAttr(slot_tupdesc, i);
 
                if (vattr->atttypid == sattr->atttypid)
                    continue;   /* no worries */
                if (!vattr->attisdropped)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("table row type and query-specified row type do not match"),
                             errdetail("Table has type %s at ordinal position %d, but query expects %s.",
                                       format_type_be(sattr->atttypid),
                                       i + 1,
                                       format_type_be(vattr->atttypid))));
 
                if (vattr->attlen != sattr->attlen ||
                    vattr->attalign != sattr->attalign)
                    op->d.wholerow.slow = 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.
             */
            oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
            output_tupdesc = CreateTupleDescCopy(var_tupdesc);
            MemoryContextSwitchTo(oldcontext);
 
            ReleaseTupleDesc(var_tupdesc);
        }
        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.
             */
            oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
            output_tupdesc = CreateTupleDescCopy(slot->tts_tupleDescriptor);
            MemoryContextSwitchTo(oldcontext);
 
            /*
             * 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.
             */
            output_tupdesc->tdtypeid = RECORDOID;
            output_tupdesc->tdtypmod = -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 &&
                variable->varno <= econtext->ecxt_estate->es_range_table_size)
            {
                RangeTblEntry *rte = exec_rt_fetch(variable->varno,
                                                   econtext->ecxt_estate);
 
                if (rte->eref)
                    ExecTypeSetColNames(output_tupdesc, rte->eref->colnames);
            }
        }
 
        /* Bless the tupdesc if needed, and save it in the execution state */
        op->d.wholerow.tupdesc = BlessTupleDesc(output_tupdesc);
 
        op->d.wholerow.first = false;
    }
 
    /*
     * Make sure all columns of the slot are accessible in the slot's
     * Datum/isnull arrays.
     */
    slot_getallattrs(slot);
 
    if (op->d.wholerow.slow)
    {
        /* Check to see if any dropped attributes are non-null */
        TupleDesc   tupleDesc = slot->tts_tupleDescriptor;
        TupleDesc   var_tupdesc = op->d.wholerow.tupdesc;
 
        Assert(var_tupdesc->natts == tupleDesc->natts);
 
        for (int i = 0; i < var_tupdesc->natts; i++)
        {
            CompactAttribute *vattr = TupleDescCompactAttr(var_tupdesc, i);
            CompactAttribute *sattr = TupleDescCompactAttr(tupleDesc, 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 ||
                vattr->attalignby != sattr->attalignby)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("table row type and query-specified row type do not match"),
                         errdetail("Physical storage mismatch on dropped attribute at ordinal position %d.",
                                   i + 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.)
     */
    tuple = toast_build_flattened_tuple(slot->tts_tupleDescriptor,
                                        slot->tts_values,
                                        slot->tts_isnull);
    dtuple = tuple->t_data;
 
    /*
     * 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.)
     */
    HeapTupleHeaderSetTypeId(dtuple, op->d.wholerow.tupdesc->tdtypeid);
    HeapTupleHeaderSetTypMod(dtuple, op->d.wholerow.tupdesc->tdtypmod);
 
    *op->resvalue = PointerGetDatum(dtuple);
    *op->resnull = false;
}

References Assert(), CompactAttribute::attalignby, CompactAttribute::attisdropped, CompactAttribute::attlen, BlessTupleDesc(), CreateTupleDescCopy(), ExprContext::ecxt_estate, ExprContext::ecxt_innertuple, ExprContext::ecxt_newtuple, ExprContext::ecxt_oldtuple, ExprContext::ecxt_outertuple, ExprContext::ecxt_per_query_memory, ExprContext::ecxt_scantuple, EEO_FLAG_NEW_IS_NULL, EEO_FLAG_OLD_IS_NULL, ereport, errcode(), errdetail(), errdetail_plural(), errmsg(), ERROR, EState::es_range_table_size, exec_rt_fetch(), ExecFilterJunk(), ExecTypeSetColNames(), format_type_be(), HeapTupleHeaderSetTypeId(), HeapTupleHeaderSetTypMod(), i, INNER_VAR, InvalidAttrNumber, lookup_rowtype_tupdesc_domain(), MemoryContextSwitchTo(), TupleDescData::natts, ExprEvalStep::op, OUTER_VAR, PointerGetDatum(), ReleaseTupleDesc, slot_getallattrs(), HeapTupleData::t_data, TupleDescData::tdtypeid, TupleDescData::tdtypmod, toast_build_flattened_tuple(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, TupleDescAttr(), TupleDescCompactAttr(), VAR_RETURNING_DEFAULT, VAR_RETURNING_NEW, and VAR_RETURNING_OLD.

Referenced by ExecInterpExpr().

◆ ExecEvalXmlExpr()

void ExecEvalXmlExpr	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4442 of file execExprInterp.c.

{
    XmlExpr    *xexpr = op->d.xmlexpr.xexpr;
    Datum       value;
 
    *op->resnull = true;        /* until we get a result */
    *op->resvalue = (Datum) 0;
 
    switch (xexpr->op)
    {
        case IS_XMLCONCAT:
            {
                Datum      *argvalue = op->d.xmlexpr.argvalue;
                bool       *argnull = op->d.xmlexpr.argnull;
                List       *values = NIL;
 
                for (int i = 0; i < list_length(xexpr->args); i++)
                {
                    if (!argnull[i])
                        values = lappend(values, DatumGetPointer(argvalue[i]));
                }
 
                if (values != NIL)
                {
                    *op->resvalue = PointerGetDatum(xmlconcat(values));
                    *op->resnull = false;
                }
            }
            break;
 
        case IS_XMLFOREST:
            {
                Datum      *argvalue = op->d.xmlexpr.named_argvalue;
                bool       *argnull = op->d.xmlexpr.named_argnull;
                StringInfoData buf;
                ListCell   *lc;
                ListCell   *lc2;
                int         i;
 
                initStringInfo(&buf);
 
                i = 0;
                forboth(lc, xexpr->named_args, lc2, xexpr->arg_names)
                {
                    Expr       *e = (Expr *) lfirst(lc);
                    char       *argname = strVal(lfirst(lc2));
 
                    if (!argnull[i])
                    {
                        value = argvalue[i];
                        appendStringInfo(&buf, "<%s>%s</%s>",
                                         argname,
                                         map_sql_value_to_xml_value(value,
                                                                    exprType((Node *) e), true),
                                         argname);
                        *op->resnull = false;
                    }
                    i++;
                }
 
                if (!*op->resnull)
                {
                    text       *result;
 
                    result = cstring_to_text_with_len(buf.data, buf.len);
                    *op->resvalue = PointerGetDatum(result);
                }
 
                pfree(buf.data);
            }
            break;
 
        case IS_XMLELEMENT:
            *op->resvalue = PointerGetDatum(xmlelement(xexpr,
                                                       op->d.xmlexpr.named_argvalue,
                                                       op->d.xmlexpr.named_argnull,
                                                       op->d.xmlexpr.argvalue,
                                                       op->d.xmlexpr.argnull));
            *op->resnull = false;
            break;
 
        case IS_XMLPARSE:
            {
                Datum      *argvalue = op->d.xmlexpr.argvalue;
                bool       *argnull = op->d.xmlexpr.argnull;
                text       *data;
                bool        preserve_whitespace;
 
                /* arguments are known to be text, bool */
                Assert(list_length(xexpr->args) == 2);
 
                if (argnull[0])
                    return;
                value = argvalue[0];
                data = DatumGetTextPP(value);
 
                if (argnull[1]) /* probably can't happen */
                    return;
                value = argvalue[1];
                preserve_whitespace = DatumGetBool(value);
 
                *op->resvalue = PointerGetDatum(xmlparse(data,
                                                         xexpr->xmloption,
                                                         preserve_whitespace));
                *op->resnull = false;
            }
            break;
 
        case IS_XMLPI:
            {
                text       *arg;
                bool        isnull;
 
                /* optional argument is known to be text */
                Assert(list_length(xexpr->args) <= 1);
 
                if (xexpr->args)
                {
                    isnull = op->d.xmlexpr.argnull[0];
                    if (isnull)
                        arg = NULL;
                    else
                        arg = DatumGetTextPP(op->d.xmlexpr.argvalue[0]);
                }
                else
                {
                    arg = NULL;
                    isnull = false;
                }
 
                *op->resvalue = PointerGetDatum(xmlpi(xexpr->name,
                                                      arg,
                                                      isnull,
                                                      op->resnull));
            }
            break;
 
        case IS_XMLROOT:
            {
                Datum      *argvalue = op->d.xmlexpr.argvalue;
                bool       *argnull = op->d.xmlexpr.argnull;
                xmltype    *data;
                text       *version;
                int         standalone;
 
                /* arguments are known to be xml, text, int */
                Assert(list_length(xexpr->args) == 3);
 
                if (argnull[0])
                    return;
                data = DatumGetXmlP(argvalue[0]);
 
                if (argnull[1])
                    version = NULL;
                else
                    version = DatumGetTextPP(argvalue[1]);
 
                Assert(!argnull[2]);    /* always present */
                standalone = DatumGetInt32(argvalue[2]);
 
                *op->resvalue = PointerGetDatum(xmlroot(data,
                                                        version,
                                                        standalone));
                *op->resnull = false;
            }
            break;
 
        case IS_XMLSERIALIZE:
            {
                Datum      *argvalue = op->d.xmlexpr.argvalue;
                bool       *argnull = op->d.xmlexpr.argnull;
 
                /* argument type is known to be xml */
                Assert(list_length(xexpr->args) == 1);
 
                if (argnull[0])
                    return;
                value = argvalue[0];
 
                *op->resvalue =
                    PointerGetDatum(xmltotext_with_options(DatumGetXmlP(value),
                                                           xexpr->xmloption,
                                                           xexpr->indent));
                *op->resnull = false;
            }
            break;
 
        case IS_DOCUMENT:
            {
                Datum      *argvalue = op->d.xmlexpr.argvalue;
                bool       *argnull = op->d.xmlexpr.argnull;
 
                /* optional argument is known to be xml */
                Assert(list_length(xexpr->args) == 1);
 
                if (argnull[0])
                    return;
                value = argvalue[0];
 
                *op->resvalue =
                    BoolGetDatum(xml_is_document(DatumGetXmlP(value)));
                *op->resnull = false;
            }
            break;
 
        default:
            elog(ERROR, "unrecognized XML operation");
            break;
    }
}

References appendStringInfo(), arg, ExprEvalStep::argnull, XmlExpr::args, ExprEvalStep::argvalue, Assert(), BoolGetDatum(), buf, cstring_to_text_with_len(), data, DatumGetBool(), DatumGetInt32(), DatumGetPointer(), DatumGetTextPP, DatumGetXmlP(), elog, ERROR, exprType(), forboth, i, XmlExpr::indent, initStringInfo(), IS_DOCUMENT, IS_XMLCONCAT, IS_XMLELEMENT, IS_XMLFOREST, IS_XMLPARSE, IS_XMLPI, IS_XMLROOT, IS_XMLSERIALIZE, ExprEvalStep::isnull, lappend(), lfirst, list_length(), map_sql_value_to_xml_value(), XmlExpr::named_args, NIL, ExprEvalStep::op, XmlExpr::op, pfree(), PointerGetDatum(), strVal, value, values, ExprEvalStep::xexpr, xml_is_document(), xmlconcat(), xmlelement(), xmlparse(), xmlpi(), xmlroot(), and xmltotext_with_options().

Referenced by ExecInterpExpr().

◆ ExecInterpExprStillValid()

Datum ExecInterpExprStillValid	(	ExprState *	state,
		ExprContext *	econtext,
		bool *	isNull
	)

Definition at line 2287 of file execExprInterp.c.

{
    /*
     * First time through, check whether attribute matches Var.  Might not be
     * ok anymore, due to schema changes.
     */
    CheckExprStillValid(state, econtext);
 
    /* skip the check during further executions */
    state->evalfunc = (ExprStateEvalFunc) state->evalfunc_private;
 
    /* and actually execute */
    return state->evalfunc(state, econtext, isNull);
}

References CheckExprStillValid().

Referenced by ExecReadyInterpretedExpr().

◆ ExecReadyInterpretedExpr()

void ExecReadyInterpretedExpr ( ExprState * state )

Definition at line 242 of file execExprInterp.c.

{
    /* Ensure one-time interpreter setup has been done */
    ExecInitInterpreter();
 
    /* Simple validity checks on expression */
    Assert(state->steps_len >= 1);
    Assert(state->steps[state->steps_len - 1].opcode == EEOP_DONE_RETURN ||
           state->steps[state->steps_len - 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.
     */
    state->evalfunc = ExecInterpExprStillValid;
 
    /* DIRECT_THREADED should not already be set */
    Assert((state->flags & EEO_FLAG_DIRECT_THREADED) == 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.
     */
    state->flags |= EEO_FLAG_INTERPRETER_INITIALIZED;
 
    /*
     * 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)
    {
        ExprEvalOp  step0 = state->steps[0].opcode;
        ExprEvalOp  step1 = state->steps[1].opcode;
        ExprEvalOp  step2 = state->steps[2].opcode;
        ExprEvalOp  step3 = state->steps[3].opcode;
 
        if (step0 == EEOP_INNER_FETCHSOME &&
            step1 == EEOP_HASHDATUM_SET_INITVAL &&
            step2 == EEOP_INNER_VAR &&
            step3 == EEOP_HASHDATUM_NEXT32)
        {
            state->evalfunc_private = (void *) ExecJustHashInnerVarWithIV;
            return;
        }
    }
    else if (state->steps_len == 4)
    {
        ExprEvalOp  step0 = state->steps[0].opcode;
        ExprEvalOp  step1 = state->steps[1].opcode;
        ExprEvalOp  step2 = state->steps[2].opcode;
 
        if (step0 == EEOP_OUTER_FETCHSOME &&
            step1 == EEOP_OUTER_VAR &&
            step2 == EEOP_HASHDATUM_FIRST)
        {
            state->evalfunc_private = (void *) ExecJustHashOuterVar;
            return;
        }
        else if (step0 == EEOP_INNER_FETCHSOME &&
                 step1 == EEOP_INNER_VAR &&
                 step2 == EEOP_HASHDATUM_FIRST)
        {
            state->evalfunc_private = (void *) ExecJustHashInnerVar;
            return;
        }
        else if (step0 == EEOP_OUTER_FETCHSOME &&
                 step1 == EEOP_OUTER_VAR &&
                 step2 == EEOP_HASHDATUM_FIRST_STRICT)
        {
            state->evalfunc_private = (void *) ExecJustHashOuterVarStrict;
            return;
        }
    }
    else if (state->steps_len == 3)
    {
        ExprEvalOp  step0 = state->steps[0].opcode;
        ExprEvalOp  step1 = state->steps[1].opcode;
 
        if (step0 == EEOP_INNER_FETCHSOME &&
            step1 == EEOP_INNER_VAR)
        {
            state->evalfunc_private = ExecJustInnerVar;
            return;
        }
        else if (step0 == EEOP_OUTER_FETCHSOME &&
                 step1 == EEOP_OUTER_VAR)
        {
            state->evalfunc_private = ExecJustOuterVar;
            return;
        }
        else if (step0 == EEOP_SCAN_FETCHSOME &&
                 step1 == EEOP_SCAN_VAR)
        {
            state->evalfunc_private = ExecJustScanVar;
            return;
        }
        else if (step0 == EEOP_INNER_FETCHSOME &&
                 step1 == EEOP_ASSIGN_INNER_VAR)
        {
            state->evalfunc_private = ExecJustAssignInnerVar;
            return;
        }
        else if (step0 == EEOP_OUTER_FETCHSOME &&
                 step1 == EEOP_ASSIGN_OUTER_VAR)
        {
            state->evalfunc_private = ExecJustAssignOuterVar;
            return;
        }
        else if (step0 == EEOP_SCAN_FETCHSOME &&
                 step1 == EEOP_ASSIGN_SCAN_VAR)
        {
            state->evalfunc_private = ExecJustAssignScanVar;
            return;
        }
        else if (step0 == EEOP_CASE_TESTVAL &&
                 (step1 == EEOP_FUNCEXPR_STRICT ||
                  step1 == EEOP_FUNCEXPR_STRICT_1 ||
                  step1 == EEOP_FUNCEXPR_STRICT_2))
        {
            state->evalfunc_private = ExecJustApplyFuncToCase;
            return;
        }
        else if (step0 == EEOP_INNER_VAR &&
                 step1 == EEOP_HASHDATUM_FIRST)
        {
            state->evalfunc_private = (void *) ExecJustHashInnerVarVirt;
            return;
        }
        else if (step0 == EEOP_OUTER_VAR &&
                 step1 == EEOP_HASHDATUM_FIRST)
        {
            state->evalfunc_private = (void *) ExecJustHashOuterVarVirt;
            return;
        }
    }
    else if (state->steps_len == 2)
    {
        ExprEvalOp  step0 = state->steps[0].opcode;
 
        if (step0 == EEOP_CONST)
        {
            state->evalfunc_private = ExecJustConst;
            return;
        }
        else if (step0 == EEOP_INNER_VAR)
        {
            state->evalfunc_private = ExecJustInnerVarVirt;
            return;
        }
        else if (step0 == EEOP_OUTER_VAR)
        {
            state->evalfunc_private = ExecJustOuterVarVirt;
            return;
        }
        else if (step0 == EEOP_SCAN_VAR)
        {
            state->evalfunc_private = ExecJustScanVarVirt;
            return;
        }
        else if (step0 == EEOP_ASSIGN_INNER_VAR)
        {
            state->evalfunc_private = ExecJustAssignInnerVarVirt;
            return;
        }
        else if (step0 == EEOP_ASSIGN_OUTER_VAR)
        {
            state->evalfunc_private = ExecJustAssignOuterVarVirt;
            return;
        }
        else if (step0 == EEOP_ASSIGN_SCAN_VAR)
        {
            state->evalfunc_private = ExecJustAssignScanVarVirt;
            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++)
    {
        ExprEvalStep *op = &state->steps[off];
 
        op->opcode = EEO_OPCODE(op->opcode);
    }
 
    state->flags |= EEO_FLAG_DIRECT_THREADED;
#endif                          /* EEO_USE_COMPUTED_GOTO */
 
    state->evalfunc_private = ExecInterpExpr;
}

References Assert(), EEO_FLAG_DIRECT_THREADED, EEO_FLAG_INTERPRETER_INITIALIZED, EEO_OPCODE, EEOP_ASSIGN_INNER_VAR, EEOP_ASSIGN_OUTER_VAR, EEOP_ASSIGN_SCAN_VAR, EEOP_CASE_TESTVAL, EEOP_CONST, EEOP_DONE_NO_RETURN, EEOP_DONE_RETURN, EEOP_FUNCEXPR_STRICT, EEOP_FUNCEXPR_STRICT_1, EEOP_FUNCEXPR_STRICT_2, EEOP_HASHDATUM_FIRST, EEOP_HASHDATUM_FIRST_STRICT, EEOP_HASHDATUM_NEXT32, EEOP_HASHDATUM_SET_INITVAL, EEOP_INNER_FETCHSOME, EEOP_INNER_VAR, EEOP_OUTER_FETCHSOME, EEOP_OUTER_VAR, EEOP_SCAN_FETCHSOME, EEOP_SCAN_VAR, ExecInitInterpreter(), ExecInterpExpr(), ExecInterpExprStillValid(), ExecJustApplyFuncToCase(), ExecJustAssignInnerVar(), ExecJustAssignInnerVarVirt(), ExecJustAssignOuterVar(), ExecJustAssignOuterVarVirt(), ExecJustAssignScanVar(), ExecJustAssignScanVarVirt(), ExecJustConst(), ExecJustHashInnerVar(), ExecJustHashInnerVarVirt(), ExecJustHashInnerVarWithIV(), ExecJustHashOuterVar(), ExecJustHashOuterVarStrict(), ExecJustHashOuterVarVirt(), ExecJustInnerVar(), ExecJustInnerVarVirt(), ExecJustOuterVar(), ExecJustOuterVarVirt(), ExecJustScanVar(), ExecJustScanVarVirt(), and ExprEvalStep::op.

Referenced by ExecReadyExpr().

◆ ExprEvalPushStep()

void ExprEvalPushStep	(	ExprState *	es,
		const ExprEvalStep *	s
	)

Definition at line 2678 of file execExpr.c.

{
    if (es->steps_alloc == 0)
    {
        es->steps_alloc = 16;
        es->steps = palloc(sizeof(ExprEvalStep) * es->steps_alloc);
    }
    else if (es->steps_alloc == es->steps_len)
    {
        es->steps_alloc *= 2;
        es->steps = repalloc(es->steps,
                             sizeof(ExprEvalStep) * es->steps_alloc);
    }
 
    memcpy(&es->steps[es->steps_len++], s, sizeof(ExprEvalStep));
}

References palloc(), repalloc(), ExprState::steps, ExprState::steps_alloc, and ExprState::steps_len.

Referenced by ExecBuildAggTrans(), ExecBuildAggTransCall(), ExecBuildGroupingEqual(), ExecBuildHash32Expr(), ExecBuildHash32FromAttrs(), ExecBuildParamSetEqual(), ExecBuildProjectionInfo(), ExecBuildUpdateProjection(), ExecInitCoerceToDomain(), ExecInitExpr(), ExecInitExprRec(), ExecInitExprWithParams(), ExecInitJsonCoercion(), ExecInitJsonExpr(), ExecInitQual(), ExecInitSubPlanExpr(), ExecInitSubscriptingRef(), ExecPushExprSetupSteps(), and plpgsql_param_compile().

◆ StaticAssertDecl()

StaticAssertDecl	(	sizeof(ExprEvalStep)<=	64,
		"size of ExprEvalStep exceeds 64 bytes"
	)

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ EEO_FLAG_DIRECT_THREADED

◆ EEO_FLAG_INTERPRETER_INITIALIZED

Typedef Documentation

◆ ExecEvalBoolSubroutine

◆ ExecEvalSubroutine

◆ ExprEvalOp

◆ ExprEvalRowtypeCache

◆ ExprEvalStep

◆ JsonConstructorExprState

◆ SubscriptExecSteps

◆ SubscriptingRefState

Enumeration Type Documentation

◆ ExprEvalOp

Function Documentation

◆ CheckExprStillValid()

◆ ExecAggCopyTransValue()

◆ ExecAggInitGroup()

◆ ExecEvalAggOrderedTransDatum()

◆ ExecEvalAggOrderedTransTuple()

◆ ExecEvalArrayCoerce()

◆ ExecEvalArrayExpr()

◆ ExecEvalCoerceViaIOSafe()

◆ ExecEvalConstraintCheck()

◆ ExecEvalConstraintNotNull()

◆ ExecEvalConvertRowtype()

◆ ExecEvalCurrentOfExpr()

◆ ExecEvalFieldSelect()

◆ ExecEvalFieldStoreDeForm()

◆ ExecEvalFieldStoreForm()

◆ ExecEvalFuncExprFusage()

◆ ExecEvalFuncExprStrictFusage()

◆ ExecEvalGroupingFunc()

◆ ExecEvalHashedScalarArrayOp()

◆ ExecEvalJsonCoercion()

◆ ExecEvalJsonCoercionFinish()

◆ ExecEvalJsonConstructor()

◆ ExecEvalJsonExprPath()

◆ ExecEvalJsonIsPredicate()

◆ ExecEvalMergeSupportFunc()

◆ ExecEvalMinMax()

◆ ExecEvalNextValueExpr()

◆ ExecEvalParamExec()

◆ ExecEvalParamExtern()

◆ ExecEvalParamSet()

◆ ExecEvalPreOrderedDistinctMulti()

◆ ExecEvalPreOrderedDistinctSingle()

◆ ExecEvalRow()

◆ ExecEvalRowNotNull()

◆ ExecEvalRowNull()

◆ ExecEvalScalarArrayOp()

◆ ExecEvalSQLValueFunction()

◆ ExecEvalStepOp()

◆ ExecEvalSubPlan()

◆ ExecEvalSysVar()

◆ ExecEvalWholeRowVar()

◆ ExecEvalXmlExpr()

◆ ExecInterpExprStillValid()

◆ ExecReadyInterpretedExpr()

◆ ExprEvalPushStep()

◆ StaticAssertDecl()