#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:

Data Structures
struct	ExprEvalRowtypeCache

struct	ExprEvalStep

struct	SubscriptingRefState

struct	SubscriptExecSteps

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

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_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_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
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	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	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	ExecAggTransReparent (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 29 of file execExpr.h.

◆ EEO_FLAG_INTERPRETER_INITIALIZED

#define EEO_FLAG_INTERPRETER_INITIALIZED (1 << 1)

Definition at line 27 of file execExpr.h.

Typedef Documentation

◆ ExecEvalBoolSubroutine

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

Definition at line 37 of file execExpr.h.

◆ ExecEvalSubroutine

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

Definition at line 32 of file execExpr.h.

◆ ExprEvalOp

typedef enum ExprEvalOp ExprEvalOp

◆ ExprEvalRowtypeCache

typedef struct ExprEvalRowtypeCache ExprEvalRowtypeCache

◆ ExprEvalStep

typedef struct ExprEvalStep ExprEvalStep

◆ 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_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_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 64 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_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_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 1846 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().

◆ ExecAggInitGroup()

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

Definition at line 4169 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().

◆ ExecAggTransReparent()

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

Definition at line 4197 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().

◆ ExecEvalAggOrderedTransDatum()

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

Definition at line 4321 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 4335 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 2838 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 2629 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 = 0;
         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];
             subnitems[outer_nelems] = ArrayGetNItems(this_ndims,
                                                      ARR_DIMS(array));
             nitems += subnitems[outer_nelems];
             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 */
         (void) 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 *) palloc(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 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, MAXDIM, ArrayType::ndim, ExprEvalStep::nelems, ExprEvalStep::op, palloc(), PointerGetDatum(), and SET_VARSIZE.

Referenced by ExecInterpExpr().

◆ ExecEvalConstraintCheck()

void ExecEvalConstraintCheck	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3641 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 3627 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 3147 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 2490 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 2952 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 3077 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 3123 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 2362 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 2383 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 3880 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 3445 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, ScalarArrayOpExpr::inputcollid, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, MemoryContextSwitchTo(), ScalarArrayOpExprHashTable::op, ExprEvalStep::op, palloc0(), ExprEvalStep::saop, SizeForFunctionCallInfo, typalign, ExprEvalStep::typbyval, ExprEvalStep::typlen, and NullableDatum::value.

Referenced by ExecInterpExpr().

◆ ExecEvalMinMax()

void ExecEvalMinMax	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 2899 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 2501 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 2420 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 2442 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 4287 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 4246 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 ||
         !DatumGetBool(FunctionCall2Coll(&pertrans->equalfnOne,
                                         pertrans->aggCollation,
                                         pertrans->lastdatum, value)))
     {
         if (pertrans->haslast && !pertrans->inputtypeByVal)
             pfree(DatumGetPointer(pertrans->lastdatum));
  
         pertrans->haslast = true;
         if (!isnull)
         {
             MemoryContext oldContext;
  
             oldContext = MemoryContextSwitchTo(aggstate->curaggcontext->ecxt_per_tuple_memory);
  
             pertrans->lastdatum = datumCopy(value, pertrans->inputtypeByVal,
                                             pertrans->inputtypeLen);
  
             MemoryContextSwitchTo(oldContext);
         }
         else
             pertrans->lastdatum = (Datum) 0;
         pertrans->lastisnull = isnull;
         return true;
     }
  
     return false;
 }

Referenced by ExecInterpExpr().

◆ ExecEvalRow()

void ExecEvalRow	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 2879 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 2536 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 2527 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 3242 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, ExprEvalStep::op, typalign, ExprEvalStep::typbyval, ExprEvalStep::typlen, ExprEvalStep::useOr, and NullableDatum::value.

Referenced by ExecInterpExpr().

◆ ExecEvalStepOp()

ExprEvalOp ExecEvalStepOp	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 2332 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 3905 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 4149 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 3922 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 3661 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_xmloption(DatumGetXmlP(value),
                                                                          xexpr->xmloption));
                 *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, XmlExpr::arg_names, 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, 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::name, XmlExpr::named_args, NIL, ExprEvalStep::op, XmlExpr::op, pfree(), PointerGetDatum(), strVal, value, values, ExprEvalStep::xexpr, xml_is_document(), xmlconcat(), xmlelement(), XmlExpr::xmloption, xmlparse(), xmlpi(), xmlroot(), and xmltotext_with_xmloption().

Referenced by ExecInterpExpr().

◆ ExecInterpExprStillValid()

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

Definition at line 1826 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 232 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 2418 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(), ExecPushExprSlots(), and plpgsql_param_compile().

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ EEO_FLAG_DIRECT_THREADED

◆ EEO_FLAG_INTERPRETER_INITIALIZED

Typedef Documentation

◆ ExecEvalBoolSubroutine

◆ ExecEvalSubroutine

◆ ExprEvalOp

◆ ExprEvalRowtypeCache

◆ ExprEvalStep

◆ SubscriptExecSteps

◆ SubscriptingRefState

Enumeration Type Documentation

◆ ExprEvalOp

Function Documentation

◆ CheckExprStillValid()

◆ ExecAggInitGroup()

◆ ExecAggTransReparent()

◆ ExecEvalAggOrderedTransDatum()

◆ ExecEvalAggOrderedTransTuple()

◆ ExecEvalArrayCoerce()

◆ ExecEvalArrayExpr()

◆ ExecEvalConstraintCheck()

◆ ExecEvalConstraintNotNull()

◆ ExecEvalConvertRowtype()

◆ ExecEvalCurrentOfExpr()

◆ ExecEvalFieldSelect()

◆ ExecEvalFieldStoreDeForm()

◆ ExecEvalFieldStoreForm()

◆ ExecEvalFuncExprFusage()

◆ ExecEvalFuncExprStrictFusage()

◆ ExecEvalGroupingFunc()

◆ ExecEvalHashedScalarArrayOp()

◆ ExecEvalMinMax()

◆ ExecEvalNextValueExpr()

◆ ExecEvalParamExec()

◆ ExecEvalParamExtern()

◆ ExecEvalPreOrderedDistinctMulti()

◆ ExecEvalPreOrderedDistinctSingle()

◆ ExecEvalRow()

◆ ExecEvalRowNotNull()

◆ ExecEvalRowNull()

◆ ExecEvalScalarArrayOp()

◆ ExecEvalStepOp()

◆ ExecEvalSubPlan()

◆ ExecEvalSysVar()

◆ ExecEvalWholeRowVar()

◆ ExecEvalXmlExpr()

◆ ExecInterpExprStillValid()

◆ ExecReadyInterpretedExpr()

◆ ExprEvalPushStep()