execExpr.h File Reference

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

Include dependency graph for execExpr.h:

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

Go to the source code of this file.

Data Structures
struct	ExprEvalRowtypeCache
struct	ExprEvalStep
struct	SubscriptingRefState
struct	SubscriptExecSteps
struct	JsonConstructorExprState

Macros
#define	EEO_FLAG_INTERPRETER_INITIALIZED   (1 << 1)
#define	EEO_FLAG_DIRECT_THREADED   (1 << 2)

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 , EEOP_INNER_FETCHSOME , EEOP_OUTER_FETCHSOME , EEOP_SCAN_FETCHSOME ,   EEOP_INNER_VAR , EEOP_OUTER_VAR , EEOP_SCAN_VAR , EEOP_INNER_SYSVAR ,   EEOP_OUTER_SYSVAR , EEOP_SCAN_SYSVAR , EEOP_WHOLEROW , EEOP_ASSIGN_INNER_VAR ,   EEOP_ASSIGN_OUTER_VAR , EEOP_ASSIGN_SCAN_VAR , EEOP_ASSIGN_TMP , EEOP_ASSIGN_TMP_MAKE_RO ,   EEOP_CONST , EEOP_FUNCEXPR , EEOP_FUNCEXPR_STRICT , 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_CASE_TESTVAL , EEOP_MAKE_READONLY , EEOP_IOCOERCE , EEOP_DISTINCT ,   EEOP_NOT_DISTINCT , EEOP_NULLIF , EEOP_SQLVALUEFUNCTION , EEOP_CURRENTOFEXPR ,   EEOP_NEXTVALUEEXPR , 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_NOTNULL ,   EEOP_DOMAIN_CHECK , EEOP_CONVERT_ROWTYPE , EEOP_SCALARARRAYOP , EEOP_HASHED_SCALARARRAYOP ,   EEOP_XMLEXPR , EEOP_JSON_CONSTRUCTOR , EEOP_IS_JSON , EEOP_AGGREF ,   EEOP_GROUPING_FUNC , EEOP_WINDOW_FUNC , EEOP_SUBPLAN , EEOP_AGG_STRICT_DESERIALIZE ,   EEOP_AGG_DESERIALIZE , EEOP_AGG_STRICT_INPUT_CHECK_ARGS , 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	ExecEvalParamExtern (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
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)
void	ExecEvalGroupingFunc (ExprState *state, ExprEvalStep *op)
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 << 2)

Definition at line 30 of file execExpr.h.

EEO_FLAG_INTERPRETER_INITIALIZED

#define EEO_FLAG_INTERPRETER_INITIALIZED   (1 << 1)

Definition at line 28 of file execExpr.h.

Typedef Documentation

ExecEvalBoolSubroutine

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

Definition at line 38 of file execExpr.h.

ExecEvalSubroutine

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

Definition at line 33 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
EEOP_INNER_FETCHSOME
EEOP_OUTER_FETCHSOME
EEOP_SCAN_FETCHSOME
EEOP_INNER_VAR
EEOP_OUTER_VAR
EEOP_SCAN_VAR
EEOP_INNER_SYSVAR
EEOP_OUTER_SYSVAR
EEOP_SCAN_SYSVAR
EEOP_WHOLEROW
EEOP_ASSIGN_INNER_VAR
EEOP_ASSIGN_OUTER_VAR
EEOP_ASSIGN_SCAN_VAR
EEOP_ASSIGN_TMP
EEOP_ASSIGN_TMP_MAKE_RO
EEOP_CONST
EEOP_FUNCEXPR
EEOP_FUNCEXPR_STRICT
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_CASE_TESTVAL
EEOP_MAKE_READONLY
EEOP_IOCOERCE
EEOP_DISTINCT
EEOP_NOT_DISTINCT
EEOP_NULLIF
EEOP_SQLVALUEFUNCTION
EEOP_CURRENTOFEXPR
EEOP_NEXTVALUEEXPR
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_NOTNULL
EEOP_DOMAIN_CHECK
EEOP_CONVERT_ROWTYPE
EEOP_SCALARARRAYOP
EEOP_HASHED_SCALARARRAYOP
EEOP_XMLEXPR
EEOP_JSON_CONSTRUCTOR
EEOP_IS_JSON
EEOP_AGGREF
EEOP_GROUPING_FUNC
EEOP_WINDOW_FUNC
EEOP_SUBPLAN
EEOP_AGG_STRICT_DESERIALIZE
EEOP_AGG_DESERIALIZE
EEOP_AGG_STRICT_INPUT_CHECK_ARGS
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 65 of file execExpr.h.

{
    /* entire expression has been evaluated completely, return */
    EEOP_DONE,
 
    /* apply slot_getsomeattrs on corresponding tuple slot */
    EEOP_INNER_FETCHSOME,
    EEOP_OUTER_FETCHSOME,
    EEOP_SCAN_FETCHSOME,
 
    /* compute non-system Var value */
    EEOP_INNER_VAR,
    EEOP_OUTER_VAR,
    EEOP_SCAN_VAR,
 
    /* compute system Var value */
    EEOP_INNER_SYSVAR,
    EEOP_OUTER_SYSVAR,
    EEOP_SCAN_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,
 
    /* 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 and/or
     * requires usage stats tracking.
     */
    EEOP_FUNCEXPR,
    EEOP_FUNCEXPR_STRICT,
    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,
 
    /* return CaseTestExpr value */
    EEOP_CASE_TESTVAL,
 
    /* apply MakeExpandedObjectReadOnly() to target value */
    EEOP_MAKE_READONLY,
 
    /* evaluate assorted special-purpose expression types */
    EEOP_IOCOERCE,
    EEOP_DISTINCT,
    EEOP_NOT_DISTINCT,
    EEOP_NULLIF,
    EEOP_SQLVALUEFUNCTION,
    EEOP_CURRENTOFEXPR,
    EEOP_NEXTVALUEEXPR,
    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,
 
    /* evaluate a domain's NOT NULL constraint */
    EEOP_DOMAIN_NOTNULL,
 
    /* evaluate a single domain CHECK constraint */
    EEOP_DOMAIN_CHECK,
 
    /* evaluate assorted special-purpose expression types */
    EEOP_CONVERT_ROWTYPE,
    EEOP_SCALARARRAYOP,
    EEOP_HASHED_SCALARARRAYOP,
    EEOP_XMLEXPR,
    EEOP_JSON_CONSTRUCTOR,
    EEOP_IS_JSON,
    EEOP_AGGREF,
    EEOP_GROUPING_FUNC,
    EEOP_WINDOW_FUNC,
    EEOP_SUBPLAN,
 
    /* aggregation related nodes */
    EEOP_AGG_STRICT_DESERIALIZE,
    EEOP_AGG_DESERIALIZE,
    EEOP_AGG_STRICT_INPUT_CHECK_ARGS,
    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 1878 of file execExprInterp.c.

{
    TupleTableSlot *innerslot;
    TupleTableSlot *outerslot;
    TupleTableSlot *scanslot;
 
    innerslot = econtext->ecxt_innertuple;
    outerslot = econtext->ecxt_outertuple;
    scanslot = econtext->ecxt_scantuple;
 
    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;
                }
            default:
                break;
        }
    }
}

References attnum, CheckVarSlotCompatibility(), ExprContext::ecxt_innertuple, ExprContext::ecxt_outertuple, ExprContext::ecxt_scantuple, EEOP_INNER_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 4448 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 4395 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 4573 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 4587 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 2936 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 2722 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().

ExecEvalConstraintCheck()

void ExecEvalConstraintCheck	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3739 of file execExprInterp.c.

{
    if (!*op->d.domaincheck.checknull &&
        !DatumGetBool(*op->d.domaincheck.checkvalue))
        ereport(ERROR,
                (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(), ereport, errcode(), errdomainconstraint(), errmsg(), ERROR, format_type_be(), and ExprEvalStep::op.

Referenced by ExecInterpExpr().

ExecEvalConstraintNotNull()

void ExecEvalConstraintNotNull	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3725 of file execExprInterp.c.

{
    if (*op->resnull)
        ereport(ERROR,
                (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 ereport, errcode(), errdatatype(), errmsg(), ERROR, format_type_be(), and ExprEvalStep::op.

Referenced by ExecInterpExpr().

ExecEvalConvertRowtype()

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

Definition at line 3245 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 2583 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 3050 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 3175 of file execExprInterp.c.

{
    TupleDesc   tupDesc;
 
    /* Lookup tupdesc if first time through or if type changes */
    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 we allocated */
    if (unlikely(tupDesc->natts > op->d.fieldstore.ncolumns))
        elog(ERROR, "too many columns in composite type %u",
             op->d.fieldstore.fstore->resulttype);
 
    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;
 
        tuphdr = DatumGetHeapTupleHeader(tupDatum);
        tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
        ItemPointerSetInvalid(&(tmptup.t_self));
        tmptup.t_tableOid = InvalidOid;
        tmptup.t_data = tuphdr;
 
        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 3221 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 2394 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 2415 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 4106 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 3543 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().

ExecEvalJsonConstructor()

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

Definition at line 3974 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
        elog(ERROR, "invalid JsonConstructorExpr type %d", ctor->type);
 
    *op->resvalue = res;
    *op->resnull = isnull;
}

References JsonConstructorExpr::absent_on_null, JsonConstructorExprState::arg_nulls, JsonConstructorExprState::arg_types, JsonConstructorExprState::arg_values, JsonConstructorExprState::constructor, elog(), ERROR, JsonReturning::format, JsonFormat::format_type, ExprEvalStep::isnull, ExprEvalStep::jcstate, JS_FORMAT_JSONB, JSCTOR_JSON_ARRAY, JSCTOR_JSON_OBJECT, json_build_array_worker(), json_build_object_worker(), jsonb_build_array_worker(), jsonb_build_object_worker(), JsonConstructorExprState::nargs, ExprEvalStep::op, res, JsonConstructorExpr::returning, JsonConstructorExpr::type, and JsonConstructorExpr::unique.

Referenced by ExecInterpExpr().

ExecEvalJsonIsPredicate()

void ExecEvalJsonIsPredicate	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4011 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, res, and JsonIsPredicate::unique_keys.

Referenced by ExecInterpExpr().

ExecEvalMinMax()

void ExecEvalMinMax	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 2997 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 2594 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 2452 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 2474 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().

ExecEvalPreOrderedDistinctMulti()

bool ExecEvalPreOrderedDistinctMulti	(	AggState *	aggstate,
		AggStatePerTrans	pertrans
	)

Definition at line 4539 of file execExprInterp.c.

{
    ExprContext *tmpcontext = aggstate->tmpcontext;
 
    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);
 
    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);
        return true;
    }
    return false;
}

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 4497 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;
}

References AggStatePerTransData::aggCollation, FunctionCallInfoBaseData::args, AggState::curaggcontext, datumCopy(), DatumGetBool(), DatumGetPointer(), ExprContext::ecxt_per_tuple_memory, AggStatePerTransData::equalfnOne, FunctionCall2Coll(), AggStatePerTransData::haslast, AggStatePerTransData::inputtypeByVal, AggStatePerTransData::inputtypeLen, ExprEvalStep::isnull, NullableDatum::isnull, AggStatePerTransData::lastdatum, AggStatePerTransData::lastisnull, MemoryContextSwitchTo(), ExprEvalStep::pertrans, pfree(), AggStatePerTransData::transfn_fcinfo, NullableDatum::value, and value.

Referenced by ExecInterpExpr().

ExecEvalRow()

void ExecEvalRow	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 2977 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 2629 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 2620 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 3340 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 2516 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 2364 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, ExprEvalStep::op, and res.

Referenced by CheckExprStillValid().

ExecEvalSubPlan()

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

Definition at line 4131 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 4375 of file execExprInterp.c.

{
    Datum       d;
 
    /* 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, elog(), ERROR, ExprEvalStep::op, slot_getsysattr(), and unlikely.

Referenced by ExecInterpExpr().

ExecEvalWholeRowVar()

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

Definition at line 4148 of file execExprInterp.c.

{
    Var        *variable = op->d.wholerow.var;
    TupleTableSlot *slot;
    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 */
            slot = econtext->ecxt_scantuple;
            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++)
        {
            Form_pg_attribute vattr = TupleDescAttr(var_tupdesc, i);
            Form_pg_attribute sattr = TupleDescAttr(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->attalign != sattr->attalign)
                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(), BlessTupleDesc(), Alias::colnames, CreateTupleDescCopy(), ExprContext::ecxt_estate, ExprContext::ecxt_innertuple, ExprContext::ecxt_outertuple, ExprContext::ecxt_per_query_memory, ExprContext::ecxt_scantuple, RangeTblEntry::eref, 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, and TupleDescAttr.

Referenced by ExecInterpExpr().

ExecEvalXmlExpr()

void ExecEvalXmlExpr	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3759 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 1858 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 235 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);
 
    /*
     * 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 == 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 = (void *) ExecJustInnerVar;
            return;
        }
        else if (step0 == EEOP_OUTER_FETCHSOME &&
                 step1 == EEOP_OUTER_VAR)
        {
            state->evalfunc_private = (void *) ExecJustOuterVar;
            return;
        }
        else if (step0 == EEOP_SCAN_FETCHSOME &&
                 step1 == EEOP_SCAN_VAR)
        {
            state->evalfunc_private = (void *) ExecJustScanVar;
            return;
        }
        else if (step0 == EEOP_INNER_FETCHSOME &&
                 step1 == EEOP_ASSIGN_INNER_VAR)
        {
            state->evalfunc_private = (void *) ExecJustAssignInnerVar;
            return;
        }
        else if (step0 == EEOP_OUTER_FETCHSOME &&
                 step1 == EEOP_ASSIGN_OUTER_VAR)
        {
            state->evalfunc_private = (void *) ExecJustAssignOuterVar;
            return;
        }
        else if (step0 == EEOP_SCAN_FETCHSOME &&
                 step1 == EEOP_ASSIGN_SCAN_VAR)
        {
            state->evalfunc_private = (void *) ExecJustAssignScanVar;
            return;
        }
        else if (step0 == EEOP_CASE_TESTVAL &&
                 step1 == EEOP_FUNCEXPR_STRICT &&
                 state->steps[0].d.casetest.value)
        {
            state->evalfunc_private = (void *) ExecJustApplyFuncToCase;
            return;
        }
    }
    else if (state->steps_len == 2)
    {
        ExprEvalOp  step0 = state->steps[0].opcode;
 
        if (step0 == EEOP_CONST)
        {
            state->evalfunc_private = (void *) ExecJustConst;
            return;
        }
        else if (step0 == EEOP_INNER_VAR)
        {
            state->evalfunc_private = (void *) ExecJustInnerVarVirt;
            return;
        }
        else if (step0 == EEOP_OUTER_VAR)
        {
            state->evalfunc_private = (void *) ExecJustOuterVarVirt;
            return;
        }
        else if (step0 == EEOP_SCAN_VAR)
        {
            state->evalfunc_private = (void *) ExecJustScanVarVirt;
            return;
        }
        else if (step0 == EEOP_ASSIGN_INNER_VAR)
        {
            state->evalfunc_private = (void *) ExecJustAssignInnerVarVirt;
            return;
        }
        else if (step0 == EEOP_ASSIGN_OUTER_VAR)
        {
            state->evalfunc_private = (void *) ExecJustAssignOuterVarVirt;
            return;
        }
        else if (step0 == EEOP_ASSIGN_SCAN_VAR)
        {
            state->evalfunc_private = (void *) 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 = (void *) 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, EEOP_FUNCEXPR_STRICT, 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(), ExecJustInnerVar(), ExecJustInnerVarVirt(), ExecJustOuterVar(), ExecJustOuterVarVirt(), ExecJustScanVar(), ExecJustScanVarVirt(), and ExprEvalStep::op.

Referenced by ExecReadyExpr().

ExprEvalPushStep()

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

Definition at line 2536 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(), ExecBuildParamSetEqual(), ExecBuildProjectionInfo(), ExecBuildUpdateProjection(), ExecInitCoerceToDomain(), ExecInitExpr(), ExecInitExprRec(), ExecInitExprWithParams(), ExecInitQual(), ExecInitSubscriptingRef(), ExecPushExprSetupSteps(), and plpgsql_param_compile().

StaticAssertDecl()

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