execExprInterp.c File Reference

#include "postgres.h"
#include "access/heaptoast.h"
#include "access/tupconvert.h"
#include "catalog/pg_type.h"
#include "commands/sequence.h"
#include "executor/execExpr.h"
#include "executor/nodeSubplan.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "nodes/miscnodes.h"
#include "nodes/nodeFuncs.h"
#include "pgstat.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/date.h"
#include "utils/datum.h"
#include "utils/expandedrecord.h"
#include "utils/json.h"
#include "utils/jsonfuncs.h"
#include "utils/jsonpath.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/timestamp.h"
#include "utils/tuplesort.h"
#include "utils/typcache.h"
#include "utils/xml.h"
#include "lib/simplehash.h"

Include dependency graph for execExprInterp.c:

Go to the source code of this file.

Data Structures
struct	ScalarArrayOpExprHashEntry
struct	ScalarArrayOpExprHashTable

Macros
#define	EEO_SWITCH()   starteval: switch ((ExprEvalOp) op->opcode)
#define	EEO_CASE(name)   case name:
#define	EEO_DISPATCH()   goto starteval
#define	EEO_OPCODE(opcode)   (opcode)
#define	EEO_NEXT()
#define	EEO_JUMP(stepno)
#define	SH_PREFIX   saophash
#define	SH_ELEMENT_TYPE   ScalarArrayOpExprHashEntry
#define	SH_KEY_TYPE   Datum
#define	SH_SCOPE   static inline
#define	SH_DECLARE
#define	SH_PREFIX   saophash
#define	SH_ELEMENT_TYPE   ScalarArrayOpExprHashEntry
#define	SH_KEY_TYPE   Datum
#define	SH_KEY   key
#define	SH_HASH_KEY(tb, key)   saop_element_hash(tb, key)
#define	SH_EQUAL(tb, a, b)   saop_hash_element_match(tb, a, b)
#define	SH_SCOPE   static inline
#define	SH_STORE_HASH
#define	SH_GET_HASH(tb, a)   a->hash
#define	SH_DEFINE

Typedefs
typedef struct ScalarArrayOpExprHashEntry	ScalarArrayOpExprHashEntry
typedef struct ScalarArrayOpExprHashTable	ScalarArrayOpExprHashTable

Functions
static Datum	ExecInterpExpr (ExprState *state, ExprContext *econtext, bool *isnull)
static void	ExecInitInterpreter (void)
static void	CheckVarSlotCompatibility (TupleTableSlot *slot, int attnum, Oid vartype)
static void	CheckOpSlotCompatibility (ExprEvalStep *op, TupleTableSlot *slot)
static TupleDesc	get_cached_rowtype (Oid type_id, int32 typmod, ExprEvalRowtypeCache *rowcache, bool *changed)
static void	ExecEvalRowNullInt (ExprState *state, ExprEvalStep *op, ExprContext *econtext, bool checkisnull)
static Datum	ExecJustInnerVar (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustOuterVar (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustScanVar (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustAssignInnerVar (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustAssignOuterVar (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustAssignScanVar (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustApplyFuncToCase (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustConst (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustInnerVarVirt (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustOuterVarVirt (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustScanVarVirt (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustAssignInnerVarVirt (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustAssignOuterVarVirt (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustAssignScanVarVirt (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustHashInnerVarWithIV (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustHashOuterVar (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustHashInnerVar (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustHashOuterVarVirt (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustHashInnerVarVirt (ExprState *state, ExprContext *econtext, bool *isnull)
static Datum	ExecJustHashOuterVarStrict (ExprState *state, ExprContext *econtext, bool *isnull)
static pg_attribute_always_inline void	ExecEvalArrayCompareInternal (FunctionCallInfo fcinfo, ArrayType *arr, int16 typlen, bool typbyval, char typalign, bool useOr, Datum *result, bool *resultnull)
static pg_attribute_always_inline void	ExecAggPlainTransByVal (AggState *aggstate, AggStatePerTrans pertrans, AggStatePerGroup pergroup, ExprContext *aggcontext, int setno)
static pg_attribute_always_inline void	ExecAggPlainTransByRef (AggState *aggstate, AggStatePerTrans pertrans, AggStatePerGroup pergroup, ExprContext *aggcontext, int setno)
static char *	ExecGetJsonValueItemString (JsonbValue *item, bool *resnull)
static bool	saop_hash_element_match (struct saophash_hash *tb, Datum key1, Datum key2)
static uint32	saop_element_hash (struct saophash_hash *tb, Datum key)
void	ExecReadyInterpretedExpr (ExprState *state)
Datum	ExecInterpExprStillValid (ExprState *state, ExprContext *econtext, bool *isNull)
void	CheckExprStillValid (ExprState *state, ExprContext *econtext)
static pg_attribute_always_inline Datum	ExecJustVarImpl (ExprState *state, TupleTableSlot *slot, bool *isnull)
static pg_attribute_always_inline Datum	ExecJustAssignVarImpl (ExprState *state, TupleTableSlot *inslot, bool *isnull)
static pg_attribute_always_inline Datum	ExecJustVarVirtImpl (ExprState *state, TupleTableSlot *slot, bool *isnull)
static pg_attribute_always_inline Datum	ExecJustAssignVarVirtImpl (ExprState *state, TupleTableSlot *inslot, bool *isnull)
static pg_attribute_always_inline Datum	ExecJustHashVarImpl (ExprState *state, TupleTableSlot *slot, bool *isnull)
static pg_attribute_always_inline Datum	ExecJustHashVarVirtImpl (ExprState *state, TupleTableSlot *slot, bool *isnull)
ExprEvalOp	ExecEvalStepOp (ExprState *state, ExprEvalStep *op)
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	ExecEvalParamSet (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalCoerceViaIOSafe (ExprState *state, ExprEvalStep *op)
void	ExecEvalSQLValueFunction (ExprState *state, ExprEvalStep *op)
void	ExecEvalCurrentOfExpr (ExprState *state, ExprEvalStep *op)
void	ExecEvalNextValueExpr (ExprState *state, ExprEvalStep *op)
void	ExecEvalRowNull (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalRowNotNull (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalArrayExpr (ExprState *state, ExprEvalStep *op)
void	ExecEvalArrayCoerce (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalRow (ExprState *state, ExprEvalStep *op)
void	ExecEvalMinMax (ExprState *state, ExprEvalStep *op)
void	ExecEvalFieldSelect (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalFieldStoreDeForm (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalFieldStoreForm (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalConvertRowtype (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalScalarArrayOp (ExprState *state, ExprEvalStep *op)
void	ExecEvalHashedScalarArrayOp (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalConstraintNotNull (ExprState *state, ExprEvalStep *op)
void	ExecEvalConstraintCheck (ExprState *state, ExprEvalStep *op)
void	ExecEvalXmlExpr (ExprState *state, ExprEvalStep *op)
void	ExecEvalJsonConstructor (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalJsonIsPredicate (ExprState *state, ExprEvalStep *op)
int	ExecEvalJsonExprPath (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalJsonCoercion (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
static char *	GetJsonBehaviorValueString (JsonBehavior *behavior)
void	ExecEvalJsonCoercionFinish (ExprState *state, ExprEvalStep *op)
void	ExecEvalGroupingFunc (ExprState *state, ExprEvalStep *op)
void	ExecEvalMergeSupportFunc (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalSubPlan (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalWholeRowVar (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalSysVar (ExprState *state, ExprEvalStep *op, ExprContext *econtext, TupleTableSlot *slot)
void	ExecAggInitGroup (AggState *aggstate, AggStatePerTrans pertrans, AggStatePerGroup pergroup, ExprContext *aggcontext)
Datum	ExecAggCopyTransValue (AggState *aggstate, AggStatePerTrans pertrans, Datum newValue, bool newValueIsNull, Datum oldValue, bool oldValueIsNull)
bool	ExecEvalPreOrderedDistinctSingle (AggState *aggstate, AggStatePerTrans pertrans)
bool	ExecEvalPreOrderedDistinctMulti (AggState *aggstate, AggStatePerTrans pertrans)
void	ExecEvalAggOrderedTransDatum (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
void	ExecEvalAggOrderedTransTuple (ExprState *state, ExprEvalStep *op, ExprContext *econtext)

Macro Definition Documentation

EEO_CASE

#define EEO_CASE

(

name

)

case name:

Definition at line 127 of file execExprInterp.c.

EEO_DISPATCH

#define EEO_DISPATCH

(

)

goto starteval

Definition at line 128 of file execExprInterp.c.

EEO_JUMP

#define EEO_JUMP

(

stepno

)

Value:

    do { \
        op = &state->steps[stepno]; \
		EEO_DISPATCH(); \
    } while (0)

Definition at line 139 of file execExprInterp.c.

       { \
        op = &state->steps[stepno]; \
		EEO_DISPATCH(); \
    } while (0)

EEO_NEXT

#define EEO_NEXT

(

)

Value:

    do { \
        op++; \
		EEO_DISPATCH(); \
    } while (0)

Definition at line 133 of file execExprInterp.c.

       { \
        op++; \
		EEO_DISPATCH(); \
    } while (0)

EEO_OPCODE

#define EEO_OPCODE

(

opcode

)

(opcode)

Definition at line 129 of file execExprInterp.c.

EEO_SWITCH

#define EEO_SWITCH

(

)

starteval: switch ((ExprEvalOp) op->opcode)

Definition at line 126 of file execExprInterp.c.

SH_DECLARE

#define SH_DECLARE

Definition at line 216 of file execExprInterp.c.

SH_DEFINE

#define SH_DEFINE

Definition at line 245 of file execExprInterp.c.

SH_ELEMENT_TYPE [1/2]

#define SH_ELEMENT_TYPE   ScalarArrayOpExprHashEntry

Definition at line 213 of file execExprInterp.c.

SH_ELEMENT_TYPE [2/2]

#define SH_ELEMENT_TYPE   ScalarArrayOpExprHashEntry

Definition at line 213 of file execExprInterp.c.

SH_EQUAL

#define SH_EQUAL	(		tb,
			a,
			b
	)		saop_hash_element_match(tb, a, b)

Definition at line 241 of file execExprInterp.c.

SH_GET_HASH

#define SH_GET_HASH	(		tb,
			a
	)		a->hash

Definition at line 244 of file execExprInterp.c.

SH_HASH_KEY

#define SH_HASH_KEY	(		tb,
			key
	)		saop_element_hash(tb, key)

Definition at line 240 of file execExprInterp.c.

SH_KEY

#define SH_KEY   key

Definition at line 239 of file execExprInterp.c.

SH_KEY_TYPE [1/2]

#define SH_KEY_TYPE   Datum

Definition at line 214 of file execExprInterp.c.

SH_KEY_TYPE [2/2]

#define SH_KEY_TYPE   Datum

Definition at line 214 of file execExprInterp.c.

SH_PREFIX [1/2]

#define SH_PREFIX   saophash

Definition at line 212 of file execExprInterp.c.

SH_PREFIX [2/2]

#define SH_PREFIX   saophash

Definition at line 212 of file execExprInterp.c.

SH_SCOPE [1/2]

#define SH_SCOPE   static inline

Definition at line 215 of file execExprInterp.c.

SH_SCOPE [2/2]

#define SH_SCOPE   static inline

Definition at line 215 of file execExprInterp.c.

SH_STORE_HASH

#define SH_STORE_HASH

Definition at line 243 of file execExprInterp.c.

Typedef Documentation

ScalarArrayOpExprHashEntry

typedef struct ScalarArrayOpExprHashEntry ScalarArrayOpExprHashEntry

ScalarArrayOpExprHashTable

typedef struct ScalarArrayOpExprHashTable ScalarArrayOpExprHashTable

Function Documentation

CheckExprStillValid()

void CheckExprStillValid	(	ExprState *	state,
		ExprContext *	econtext
	)

Definition at line 2317 of file execExprInterp.c.

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

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

Referenced by ExecInterpExprStillValid(), and ExecRunCompiledExpr().

CheckOpSlotCompatibility()

static void CheckOpSlotCompatibility ( ExprEvalStep *  op, TupleTableSlot *  slot  )

static

Definition at line 2443 of file execExprInterp.c.

{
#ifdef USE_ASSERT_CHECKING
    /* there's nothing to check */
    if (!op->d.fetch.fixed)
        return;
 
    /*
     * Should probably fixed at some point, but for now it's easier to allow
     * buffer and heap tuples to be used interchangeably.
     */
    if (slot->tts_ops == &TTSOpsBufferHeapTuple &&
        op->d.fetch.kind == &TTSOpsHeapTuple)
        return;
    if (slot->tts_ops == &TTSOpsHeapTuple &&
        op->d.fetch.kind == &TTSOpsBufferHeapTuple)
        return;
 
    /*
     * At the moment we consider it OK if a virtual slot is used instead of a
     * specific type of slot, as a virtual slot never needs to be deformed.
     */
    if (slot->tts_ops == &TTSOpsVirtual)
        return;
 
    Assert(op->d.fetch.kind == slot->tts_ops);
#endif
}

References Assert, ExprEvalStep::op, TupleTableSlot::tts_ops, TTSOpsBufferHeapTuple, TTSOpsHeapTuple, and TTSOpsVirtual.

Referenced by ExecInterpExpr(), ExecJustAssignVarImpl(), ExecJustHashInnerVarWithIV(), ExecJustHashOuterVarStrict(), ExecJustHashVarImpl(), and ExecJustVarImpl().

CheckVarSlotCompatibility()

static void CheckVarSlotCompatibility ( TupleTableSlot *  slot, int  attnum, Oid  vartype  )

static

Definition at line 2388 of file execExprInterp.c.

{
    /*
     * What we have to check for here is the possibility of an attribute
     * having been dropped or changed in type since the plan tree was created.
     * Ideally the plan will get invalidated and not re-used, but just in
     * case, we keep these defenses.  Fortunately it's sufficient to check
     * once on the first time through.
     *
     * Note: ideally we'd check typmod as well as typid, but that seems
     * impractical at the moment: in many cases the tupdesc will have been
     * generated by ExecTypeFromTL(), and that can't guarantee to generate an
     * accurate typmod in all cases, because some expression node types don't
     * carry typmod.  Fortunately, for precisely that reason, there should be
     * no places with a critical dependency on the typmod of a value.
     *
     * System attributes don't require checking since their types never
     * change.
     */
    if (attnum > 0)
    {
        TupleDesc   slot_tupdesc = slot->tts_tupleDescriptor;
        Form_pg_attribute attr;
 
        if (attnum > slot_tupdesc->natts)   /* should never happen */
            elog(ERROR, "attribute number %d exceeds number of columns %d",
                 attnum, slot_tupdesc->natts);
 
        attr = TupleDescAttr(slot_tupdesc, attnum - 1);
 
        /* Internal error: somebody forgot to expand it. */
        if (attr->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
            elog(ERROR, "unexpected virtual generated column reference");
 
        if (attr->attisdropped)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("attribute %d of type %s has been dropped",
                            attnum, format_type_be(slot_tupdesc->tdtypeid))));
 
        if (vartype != attr->atttypid)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("attribute %d of type %s has wrong type",
                            attnum, format_type_be(slot_tupdesc->tdtypeid)),
                     errdetail("Table has type %s, but query expects %s.",
                               format_type_be(attr->atttypid),
                               format_type_be(vartype))));
    }
}

References attnum, elog, ereport, errcode(), errdetail(), errmsg, ERROR, fb(), format_type_be(), TupleTableSlot::tts_tupleDescriptor, TupleDescAttr(), and ExprEvalStep::vartype.

Referenced by CheckExprStillValid().

ExecAggCopyTransValue()

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

Definition at line 5743 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, CurrentMemoryContext, datumCopy(), DatumGetEOHP(), DatumGetPointer(), DatumIsReadWriteExpandedObject, DeleteExpandedObject(), fb(), MemoryContextGetParent(), MemoryContextSwitchTo(), ExprEvalStep::pertrans, pfree(), AggStatePerTransData::transtypeByVal, and AggStatePerTransData::transtypeLen.

Referenced by advance_transition_function(), and ExecAggPlainTransByRef().

ExecAggInitGroup()

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

Definition at line 5690 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, fb(), MemoryContextSwitchTo(), ExprEvalStep::pertrans, AggStatePerTransData::transfn_fcinfo, AggStatePerTransData::transtypeByVal, AggStatePerTransData::transtypeLen, and NullableDatum::value.

Referenced by ExecInterpExpr().

ExecAggPlainTransByRef()

static pg_attribute_always_inline void ExecAggPlainTransByRef ( AggState *  aggstate, AggStatePerTrans  pertrans, AggStatePerGroup  pergroup, ExprContext *  aggcontext, int  setno  )

static

Definition at line 5942 of file execExprInterp.c.

{
    FunctionCallInfo fcinfo = pertrans->transfn_fcinfo;
    MemoryContext oldContext;
    Datum       newVal;
 
    /* cf. select_current_set() */
    aggstate->curaggcontext = aggcontext;
    aggstate->current_set = setno;
 
    /* set up aggstate->curpertrans for AggGetAggref() */
    aggstate->curpertrans = pertrans;
 
    /* invoke transition function in per-tuple context */
    oldContext = MemoryContextSwitchTo(aggstate->tmpcontext->ecxt_per_tuple_memory);
 
    fcinfo->args[0].value = pergroup->transValue;
    fcinfo->args[0].isnull = pergroup->transValueIsNull;
    fcinfo->isnull = false;     /* just in case transfn doesn't set it */
 
    newVal = FunctionCallInvoke(fcinfo);
 
    /*
     * For pass-by-ref datatype, must copy the new value into aggcontext and
     * free the prior transValue.  But if transfn returned a pointer to its
     * first input, we don't need to do anything.
     *
     * It's safe to compare newVal with pergroup->transValue without regard
     * for either being NULL, because ExecAggCopyTransValue takes care to set
     * transValue to 0 when NULL. Otherwise we could end up accidentally not
     * reparenting, when the transValue has the same numerical value as
     * newValue, despite being NULL.  This is a somewhat hot path, making it
     * undesirable to instead solve this with another branch for the common
     * case of the transition function returning its (modified) input
     * argument.
     */
    if (DatumGetPointer(newVal) != DatumGetPointer(pergroup->transValue))
        newVal = ExecAggCopyTransValue(aggstate, pertrans,
                                       newVal, fcinfo->isnull,
                                       pergroup->transValue,
                                       pergroup->transValueIsNull);
 
    pergroup->transValue = newVal;
    pergroup->transValueIsNull = fcinfo->isnull;
 
    MemoryContextSwitchTo(oldContext);
}

References ExprEvalStep::aggcontext, FunctionCallInfoBaseData::args, DatumGetPointer(), ExecAggCopyTransValue(), fb(), FunctionCallInvoke, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, MemoryContextSwitchTo(), ExprEvalStep::pertrans, ExprEvalStep::setno, AggStatePerTransData::transfn_fcinfo, and NullableDatum::value.

Referenced by ExecInterpExpr().

ExecAggPlainTransByVal()

static pg_attribute_always_inline void ExecAggPlainTransByVal ( AggState *  aggstate, AggStatePerTrans  pertrans, AggStatePerGroup  pergroup, ExprContext *  aggcontext, int  setno  )

static

Definition at line 5910 of file execExprInterp.c.

{
    FunctionCallInfo fcinfo = pertrans->transfn_fcinfo;
    MemoryContext oldContext;
    Datum       newVal;
 
    /* cf. select_current_set() */
    aggstate->curaggcontext = aggcontext;
    aggstate->current_set = setno;
 
    /* set up aggstate->curpertrans for AggGetAggref() */
    aggstate->curpertrans = pertrans;
 
    /* invoke transition function in per-tuple context */
    oldContext = MemoryContextSwitchTo(aggstate->tmpcontext->ecxt_per_tuple_memory);
 
    fcinfo->args[0].value = pergroup->transValue;
    fcinfo->args[0].isnull = pergroup->transValueIsNull;
    fcinfo->isnull = false;     /* just in case transfn doesn't set it */
 
    newVal = FunctionCallInvoke(fcinfo);
 
    pergroup->transValue = newVal;
    pergroup->transValueIsNull = fcinfo->isnull;
 
    MemoryContextSwitchTo(oldContext);
}

References ExprEvalStep::aggcontext, FunctionCallInfoBaseData::args, fb(), FunctionCallInvoke, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, MemoryContextSwitchTo(), ExprEvalStep::pertrans, ExprEvalStep::setno, AggStatePerTransData::transfn_fcinfo, and NullableDatum::value.

Referenced by ExecInterpExpr().

ExecEvalAggOrderedTransDatum()

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

Definition at line 5882 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 5896 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 3625 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, fb(), ExprEvalStep::op, and PointerGetDatum.

Referenced by ExecInterpExpr().

ExecEvalArrayCompareInternal()

static pg_attribute_always_inline void ExecEvalArrayCompareInternal ( FunctionCallInfo  fcinfo, ArrayType *  arr, int16  typlen, bool  typbyval, char  typalign, bool  useOr, Datum *  result, bool *  resultnull  )

static

Definition at line 4111 of file execExprInterp.c.

{
    uint8       typalignby = typalign_to_alignby(typalign);
    int         nitems;
    char       *s;
    uint8      *bitmap;
    int         bitmask;
    bool        strictfunc = fcinfo->flinfo->fn_strict;
 
    nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr));
 
    /* 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_nominal_alignby(s, typalignby);
            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 = fcinfo->flinfo->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;
            }
        }
    }
}

References FunctionCallInfoBaseData::args, ARR_DATA_PTR, ARR_DIMS, ARR_NDIM, ARR_NULLBITMAP, ArrayGetNItems(), att_addlength_pointer, att_nominal_alignby, BoolGetDatum(), DatumGetBool(), fb(), fetch_att(), FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_addr, FmgrInfo::fn_strict, i, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, nitems, result, typalign, typalign_to_alignby(), ExprEvalStep::typbyval, ExprEvalStep::typlen, ExprEvalStep::useOr, and NullableDatum::value.

Referenced by ExecEvalHashedScalarArrayOp(), and ExecEvalScalarArrayOp().

ExecEvalArrayExpr()

void ExecEvalArrayExpr	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3411 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalCoerceViaIOSafe()

void ExecEvalCoerceViaIOSafe	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3145 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalConstraintCheck()

void ExecEvalConstraintCheck	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4498 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalConstraintNotNull()

void ExecEvalConstraintNotNull	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4484 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalConvertRowtype()

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

Definition at line 3938 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(), fb(), get_cached_rowtype(), heap_copy_tuple_as_datum(), HeapTupleGetDatum(), HeapTupleHeaderGetDatumLength(), HeapTupleHeaderGetTypeId(), IncrTupleDescRefCount(), MemoryContextSwitchTo(), ExprEvalStep::op, result, and TupleDescData::tdtypeid.

Referenced by ExecInterpExpr().

ExecEvalCurrentOfExpr()

void ExecEvalCurrentOfExpr	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3272 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, ERROR, and fb().

Referenced by ExecInterpExpr().

ExecEvalFieldSelect()

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

Definition at line 3739 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(), fb(), ExprEvalStep::fieldnum, format_type_be(), get_cached_rowtype(), heap_getattr(), HeapTupleHeaderGetDatumLength(), HeapTupleHeaderGetTypeId(), HeapTupleHeaderGetTypMod(), TupleDescData::natts, ExprEvalStep::op, TupleDescAttr(), and VARATT_IS_EXTERNAL_EXPANDED().

Referenced by ExecInterpExpr().

ExecEvalFieldStoreDeForm()

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

Definition at line 3864 of file execExprInterp.c.

{
    if (*op->resnull)
    {
        /* Convert null input tuple into an all-nulls row */
        memset(op->d.fieldstore.nulls, true,
               op->d.fieldstore.ncolumns * sizeof(bool));
    }
    else
    {
        /*
         * heap_deform_tuple needs a HeapTuple not a bare HeapTupleHeader. We
         * set all the fields in the struct just in case.
         */
        Datum       tupDatum = *op->resvalue;
        HeapTupleHeader tuphdr;
        HeapTupleData tmptup;
        TupleDesc   tupDesc;
 
        tuphdr = DatumGetHeapTupleHeader(tupDatum);
        tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
        ItemPointerSetInvalid(&(tmptup.t_self));
        tmptup.t_tableOid = InvalidOid;
        tmptup.t_data = tuphdr;
 
        /*
         * Lookup tupdesc if first time through or if type changes.  Because
         * we don't pin the tupdesc, we must not do this lookup until after
         * doing DatumGetHeapTupleHeader: that could do database access while
         * detoasting the datum.
         */
        tupDesc = get_cached_rowtype(op->d.fieldstore.fstore->resulttype, -1,
                                     op->d.fieldstore.rowcache, NULL);
 
        /* Check that current tupdesc doesn't have more fields than allocated */
        if (unlikely(tupDesc->natts > op->d.fieldstore.ncolumns))
            elog(ERROR, "too many columns in composite type %u",
                 op->d.fieldstore.fstore->resulttype);
 
        heap_deform_tuple(&tmptup, tupDesc,
                          op->d.fieldstore.values,
                          op->d.fieldstore.nulls);
    }
}

References DatumGetHeapTupleHeader, elog, ERROR, fb(), get_cached_rowtype(), heap_deform_tuple(), HeapTupleHeaderGetDatumLength(), InvalidOid, ItemPointerSetInvalid(), TupleDescData::natts, ExprEvalStep::op, and unlikely.

Referenced by ExecInterpExpr().

ExecEvalFieldStoreForm()

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

Definition at line 3914 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 fb(), 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 3000 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, fb(), 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 3021 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 ExprEvalStep::args, FunctionCallInfoBaseData::args, ExprEvalStep::d, fb(), 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 5319 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, fb(), Int32GetDatum(), lfirst_int, ExprEvalStep::op, and result.

Referenced by ExecInterpExpr().

ExecEvalHashedScalarArrayOp()

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

Definition at line 4257 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 (scalar_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;
        uint8       typalignby;
        int         nitems;
        bool        has_nulls = false;
        char       *s;
        uint8      *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);
        typalignby = typalign_to_alignby(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_nominal_alignby(s, typalignby);
 
                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;
 
        /*
         * When we have a non-strict equality function, check and cache the
         * result from looking up a NULL.  Non-strict functions are free to
         * treat a NULL as equal to any other value, e.g. a 0 or an empty
         * string.  Here we perform a linear search over the array and cache
         * the outcome so that we can use that result any time we receive a
         * NULL.
         */
        if (!strictfunc)
        {
            bool        null_lhs_result;
 
            fcinfo->args[0].value = (Datum) 0;
            fcinfo->args[0].isnull = true;
 
            ExecEvalArrayCompareInternal(fcinfo, arr, typlen, typbyval,
                                         typalign, true, &result,
                                         &resultnull);
 
            null_lhs_result = DatumGetBool(result);
 
            /* invert non-NULL results for NOT IN */
            if (!resultnull && !inclause)
                null_lhs_result = !null_lhs_result;
 
            op->d.hashedscalararrayop.null_lhs_isnull = resultnull;
            op->d.hashedscalararrayop.null_lhs_result = null_lhs_result;
        }
    }
 
    /*
     * When looking up an SQL NULL value with non-strict functions, we defer
     * to the value we cached when building the hash table.
     */
    if (scalar_isnull)
    {
        Assert(!strictfunc);
 
        *op->resnull = op->d.hashedscalararrayop.null_lhs_isnull;
        *op->resvalue = BoolGetDatum(op->d.hashedscalararrayop.null_lhs_result);
        return;
    }
 
 
    /* 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 = BoolGetDatum(!DatumGetBool(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_nominal_alignby, BoolGetDatum(), CurrentMemoryContext, DatumGetArrayTypeP, DatumGetBool(), ExprContext::ecxt_per_query_memory, element(), ExprEvalStep::elements_tab, ExecEvalArrayCompareInternal(), fb(), fetch_att(), fmgr_info(), fmgr_info_set_expr, get_typlenbyvalalign(), ExprEvalStep::has_nulls, ScalarArrayOpExprHashTable::hash_fcinfo_data, ScalarArrayOpExprHashTable::hash_finfo, ScalarArrayOpExprHashTable::hashtab, i, ExprEvalStep::inclause, InitFunctionCallInfoData, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, MemoryContextSwitchTo(), nitems, ExprEvalStep::null_lhs_result, ScalarArrayOpExprHashTable::op, ExprEvalStep::op, palloc0(), result, ExprEvalStep::saop, SizeForFunctionCallInfo, typalign, typalign_to_alignby(), ExprEvalStep::typbyval, ExprEvalStep::typlen, and NullableDatum::value.

Referenced by ExecInterpExpr().

ExecEvalJsonCoercion()

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

Definition at line 5186 of file execExprInterp.c.

{
    ErrorSaveContext *escontext = op->d.jsonexpr_coercion.escontext;
 
    /*
     * Prepare to call json_populate_type() to coerce the boolean result of
     * JSON_EXISTS_OP to the target type.  If the target type is integer or a
     * domain over integer, call the boolean-to-integer cast function instead,
     * because the integer's input function (which is what
     * json_populate_type() calls to coerce to scalar target types) doesn't
     * accept boolean literals as valid input.  We only have a special case
     * for integer and domains thereof as it seems common to use those types
     * for EXISTS columns in JSON_TABLE().
     */
    if (op->d.jsonexpr_coercion.exists_coerce)
    {
        if (op->d.jsonexpr_coercion.exists_cast_to_int)
        {
            /* Check domain constraints if any. */
            if (op->d.jsonexpr_coercion.exists_check_domain &&
                !domain_check_safe(*op->resvalue, *op->resnull,
                                   op->d.jsonexpr_coercion.targettype,
                                   &op->d.jsonexpr_coercion.json_coercion_cache,
                                   econtext->ecxt_per_query_memory,
                                   (Node *) escontext))
            {
                *op->resnull = true;
                *op->resvalue = (Datum) 0;
            }
            else
                *op->resvalue = DirectFunctionCall1(bool_int4, *op->resvalue);
            return;
        }
 
        *op->resvalue = DirectFunctionCall1(jsonb_in,
                                            DatumGetBool(*op->resvalue) ?
                                            CStringGetDatum("true") :
                                            CStringGetDatum("false"));
    }
 
    *op->resvalue = json_populate_type(*op->resvalue, JSONBOID,
                                       op->d.jsonexpr_coercion.targettype,
                                       op->d.jsonexpr_coercion.targettypmod,
                                       &op->d.jsonexpr_coercion.json_coercion_cache,
                                       econtext->ecxt_per_query_memory,
                                       op->resnull,
                                       op->d.jsonexpr_coercion.omit_quotes,
                                       (Node *) escontext);
}

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

Referenced by ExecInterpExpr().

ExecEvalJsonCoercionFinish()

void ExecEvalJsonCoercionFinish	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 5266 of file execExprInterp.c.

{
    JsonExprState *jsestate = op->d.jsonexpr.jsestate;
 
    if (SOFT_ERROR_OCCURRED(&jsestate->escontext))
    {
        /*
         * jsestate->error or jsestate->empty being set means that the error
         * occurred when coercing the JsonBehavior value.  Throw the error in
         * that case with the actual coercion error message shown in the
         * DETAIL part.
         */
        if (DatumGetBool(jsestate->error.value))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
            /*- translator: first %s is a SQL/JSON clause (e.g. ON ERROR) */
                     errmsg("could not coerce %s expression (%s) to the RETURNING type",
                            "ON ERROR",
                            GetJsonBehaviorValueString(jsestate->jsexpr->on_error)),
                     errdetail("%s", jsestate->escontext.error_data->message)));
        else if (DatumGetBool(jsestate->empty.value))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
            /*- translator: first %s is a SQL/JSON clause (e.g. ON ERROR) */
                     errmsg("could not coerce %s expression (%s) to the RETURNING type",
                            "ON EMPTY",
                            GetJsonBehaviorValueString(jsestate->jsexpr->on_empty)),
                     errdetail("%s", jsestate->escontext.error_data->message)));
 
        *op->resvalue = (Datum) 0;
        *op->resnull = true;
 
        jsestate->error.value = BoolGetDatum(true);
 
        /*
         * Reset for next use such as for catching errors when coercing a
         * JsonBehavior expression.
         */
        jsestate->escontext.error_occurred = false;
        jsestate->escontext.details_wanted = true;
    }
}

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

Referenced by ExecInterpExpr().

ExecEvalJsonConstructor()

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

Definition at line 4733 of file execExprInterp.c.

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

References JsonConstructorExpr::absent_on_null, JsonConstructorExprState::arg_nulls, JsonConstructorExprState::arg_type_cache, JsonConstructorExprState::arg_types, JsonConstructorExprState::arg_values, JsonConstructorExprState::category, JsonConstructorExprState::constructor, datum_to_json(), datum_to_jsonb(), DatumGetTextP, elog, ERROR, fb(), JsonReturning::format, JsonFormat::format_type, ExprEvalStep::isnull, ExprEvalStep::jcstate, JS_FORMAT_JSONB, JSCTOR_JSON_ARRAY, JSCTOR_JSON_OBJECT, JSCTOR_JSON_PARSE, JSCTOR_JSON_SCALAR, json_build_array_worker(), json_build_object_worker(), json_validate(), jsonb_build_array_worker(), jsonb_build_object_worker(), jsonb_from_text(), JsonConstructorExprState::nargs, ExprEvalStep::op, JsonConstructorExprState::outfuncid, JsonConstructorExpr::returning, JsonConstructorExpr::unique, and value.

Referenced by ExecInterpExpr().

ExecEvalJsonExprPath()

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

Definition at line 4909 of file execExprInterp.c.

{
    JsonExprState *jsestate = op->d.jsonexpr.jsestate;
    JsonExpr   *jsexpr = jsestate->jsexpr;
    Datum       item;
    JsonPath   *path;
    bool        throw_error = jsexpr->on_error->btype == JSON_BEHAVIOR_ERROR;
    bool        error = false,
                empty = false;
    int         jump_eval_coercion = jsestate->jump_eval_coercion;
    char       *val_string = NULL;
 
    item = jsestate->formatted_expr.value;
    path = DatumGetJsonPathP(jsestate->pathspec.value);
 
    /* Set error/empty to false. */
    memset(&jsestate->error, 0, sizeof(NullableDatum));
    memset(&jsestate->empty, 0, sizeof(NullableDatum));
 
    /* Also reset ErrorSaveContext contents for the next row. */
    if (jsestate->escontext.details_wanted)
    {
        jsestate->escontext.error_data = NULL;
        jsestate->escontext.details_wanted = false;
    }
    jsestate->escontext.error_occurred = false;
 
    switch (jsexpr->op)
    {
        case JSON_EXISTS_OP:
            {
                bool        exists = JsonPathExists(item, path,
                                                    !throw_error ? &error : NULL,
                                                    jsestate->args);
 
                if (!error)
                {
                    *op->resnull = false;
                    *op->resvalue = BoolGetDatum(exists);
                }
            }
            break;
 
        case JSON_QUERY_OP:
            *op->resvalue = JsonPathQuery(item, path, jsexpr->wrapper, &empty,
                                          !throw_error ? &error : NULL,
                                          jsestate->args,
                                          jsexpr->column_name);
 
            *op->resnull = (DatumGetPointer(*op->resvalue) == NULL);
            break;
 
        case JSON_VALUE_OP:
            {
                JsonbValue *jbv = JsonPathValue(item, path, &empty,
                                                !throw_error ? &error : NULL,
                                                jsestate->args,
                                                jsexpr->column_name);
 
                if (jbv == NULL)
                {
                    /* Will be coerced with json_populate_type(), if needed. */
                    *op->resvalue = (Datum) 0;
                    *op->resnull = true;
                }
                else if (!error && !empty)
                {
                    if (jsexpr->returning->typid == JSONOID ||
                        jsexpr->returning->typid == JSONBOID)
                    {
                        val_string = DatumGetCString(DirectFunctionCall1(jsonb_out,
                                                                         JsonbPGetDatum(JsonbValueToJsonb(jbv))));
                    }
                    else if (jsexpr->use_json_coercion)
                    {
                        *op->resvalue = JsonbPGetDatum(JsonbValueToJsonb(jbv));
                        *op->resnull = false;
                    }
                    else
                    {
                        val_string = ExecGetJsonValueItemString(jbv, op->resnull);
 
                        /*
                         * Simply convert to the default RETURNING type (text)
                         * if no coercion needed.
                         */
                        if (!jsexpr->use_io_coercion)
                            *op->resvalue = DirectFunctionCall1(textin,
                                                                CStringGetDatum(val_string));
                    }
                }
                break;
            }
 
            /* JSON_TABLE_OP can't happen here */
 
        default:
            elog(ERROR, "unrecognized SQL/JSON expression op %d",
                 (int) jsexpr->op);
            return false;
    }
 
    /*
     * Coerce the result value to the RETURNING type by calling its input
     * function.
     */
    if (!*op->resnull && jsexpr->use_io_coercion)
    {
        FunctionCallInfo fcinfo;
 
        Assert(jump_eval_coercion == -1);
        fcinfo = jsestate->input_fcinfo;
        Assert(fcinfo != NULL);
        Assert(val_string != NULL);
        fcinfo->args[0].value = PointerGetDatum(val_string);
        fcinfo->args[0].isnull = *op->resnull;
 
        /*
         * Second and third arguments are already set up in
         * ExecInitJsonExpr().
         */
 
        fcinfo->isnull = false;
        *op->resvalue = FunctionCallInvoke(fcinfo);
        if (SOFT_ERROR_OCCURRED(&jsestate->escontext))
            error = true;
    }
 
    /*
     * When setting up the ErrorSaveContext (if needed) for capturing the
     * errors that occur when coercing the JsonBehavior expression, set
     * details_wanted to be able to show the actual error message as the
     * DETAIL of the error message that tells that it is the JsonBehavior
     * expression that caused the error; see ExecEvalJsonCoercionFinish().
     */
 
    /* Handle ON EMPTY. */
    if (empty)
    {
        *op->resvalue = (Datum) 0;
        *op->resnull = true;
        if (jsexpr->on_empty)
        {
            if (jsexpr->on_empty->btype != JSON_BEHAVIOR_ERROR)
            {
                jsestate->empty.value = BoolGetDatum(true);
                /* Set up to catch coercion errors of the ON EMPTY value. */
                jsestate->escontext.error_occurred = false;
                jsestate->escontext.details_wanted = true;
                /* Jump to end if the ON EMPTY behavior is to return NULL */
                return jsestate->jump_empty >= 0 ? jsestate->jump_empty : jsestate->jump_end;
            }
        }
        else if (jsexpr->on_error->btype != JSON_BEHAVIOR_ERROR)
        {
            jsestate->error.value = BoolGetDatum(true);
            /* Set up to catch coercion errors of the ON ERROR value. */
            jsestate->escontext.error_occurred = false;
            jsestate->escontext.details_wanted = true;
            Assert(!throw_error);
            /* Jump to end if the ON ERROR behavior is to return NULL */
            return jsestate->jump_error >= 0 ? jsestate->jump_error : jsestate->jump_end;
        }
 
        if (jsexpr->column_name)
            ereport(ERROR,
                    errcode(ERRCODE_NO_SQL_JSON_ITEM),
                    errmsg("no SQL/JSON item found for specified path of column \"%s\"",
                           jsexpr->column_name));
        else
            ereport(ERROR,
                    errcode(ERRCODE_NO_SQL_JSON_ITEM),
                    errmsg("no SQL/JSON item found for specified path"));
    }
 
    /*
     * ON ERROR. Wouldn't get here if the behavior is ERROR, because they
     * would have already been thrown.
     */
    if (error)
    {
        Assert(!throw_error);
        *op->resvalue = (Datum) 0;
        *op->resnull = true;
        jsestate->error.value = BoolGetDatum(true);
        /* Set up to catch coercion errors of the ON ERROR value. */
        jsestate->escontext.error_occurred = false;
        jsestate->escontext.details_wanted = true;
        /* Jump to end if the ON ERROR behavior is to return NULL */
        return jsestate->jump_error >= 0 ? jsestate->jump_error : jsestate->jump_end;
    }
 
    return jump_eval_coercion >= 0 ? jump_eval_coercion : jsestate->jump_end;
}

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

Referenced by ExecInterpExpr().

ExecEvalJsonIsPredicate()

void ExecEvalJsonIsPredicate	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4811 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalMergeSupportFunc()

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

Definition at line 5346 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalMinMax()

void ExecEvalMinMax	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3686 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(), fb(), 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 3283 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(newval);
            break;
        default:
            elog(ERROR, "unsupported sequence type %u",
                 op->d.nextvalueexpr.seqtypid);
    }
    *op->resnull = false;
}

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

Referenced by ExecInterpExpr().

ExecEvalParamExec()

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

Definition at line 3058 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, ExecSetParamPlan(), fb(), ExprEvalStep::op, and unlikely.

Referenced by ExecInterpExpr().

ExecEvalParamExtern()

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

Definition at line 3080 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, fb(), format_type_be(), likely, OidIsValid, ExprEvalStep::op, and unlikely.

Referenced by ExecInterpExpr().

ExecEvalParamSet()

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

Definition at line 3123 of file execExprInterp.c.

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

References Assert, ExprContext::ecxt_param_exec_vals, fb(), and ExprEvalStep::op.

Referenced by ExecInterpExpr().

ExecEvalPreOrderedDistinctMulti()

bool ExecEvalPreOrderedDistinctMulti	(	AggState *	aggstate,
		AggStatePerTrans	pertrans
	)

Definition at line 5835 of file execExprInterp.c.

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

References FunctionCallInfoBaseData::args, ExprContext::ecxt_innertuple, ExprContext::ecxt_outertuple, AggStatePerTransData::equalfnMulti, ExecClearTuple(), ExecCopySlot(), ExecQual(), ExecStoreVirtualTuple(), fb(), AggStatePerTransData::haslast, i, NullableDatum::isnull, AggStatePerTransData::numInputs, AggStatePerTransData::numTransInputs, ExprEvalStep::pertrans, AggStatePerTransData::sortslot, 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 5792 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalRow()

void ExecEvalRow	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3666 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 3318 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 3309 of file execExprInterp.c.

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

References ExecEvalRowNullInt(), and ExprEvalStep::op.

Referenced by ExecInterpExpr().

ExecEvalRowNullInt()

static void ExecEvalRowNullInt ( ExprState *  state, ExprEvalStep *  op, ExprContext *  econtext, bool  checkisnull  )

static

Definition at line 3325 of file execExprInterp.c.

{
    Datum       value = *op->resvalue;
    bool        isnull = *op->resnull;
    HeapTupleHeader tuple;
    Oid         tupType;
    int32       tupTypmod;
    TupleDesc   tupDesc;
    HeapTupleData tmptup;
 
    *op->resnull = false;
 
    /* NULL row variables are treated just as NULL scalar columns */
    if (isnull)
    {
        *op->resvalue = BoolGetDatum(checkisnull);
        return;
    }
 
    /*
     * The SQL standard defines IS [NOT] NULL for a non-null rowtype argument
     * as:
     *
     * "R IS NULL" is true if every field is the null value.
     *
     * "R IS NOT NULL" is true if no field is the null value.
     *
     * This definition is (apparently intentionally) not recursive; so our
     * tests on the fields are primitive attisnull tests, not recursive checks
     * to see if they are all-nulls or no-nulls rowtypes.
     *
     * The standard does not consider the possibility of zero-field rows, but
     * here we consider them to vacuously satisfy both predicates.
     */
 
    tuple = DatumGetHeapTupleHeader(value);
 
    tupType = HeapTupleHeaderGetTypeId(tuple);
    tupTypmod = HeapTupleHeaderGetTypMod(tuple);
 
    /* Lookup tupdesc if first time through or if type changes */
    tupDesc = get_cached_rowtype(tupType, tupTypmod,
                                 &op->d.nulltest_row.rowcache, NULL);
 
    /*
     * heap_attisnull needs a HeapTuple not a bare HeapTupleHeader.
     */
    tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
    tmptup.t_data = tuple;
 
    for (int att = 1; att <= tupDesc->natts; att++)
    {
        /* ignore dropped columns */
        if (TupleDescCompactAttr(tupDesc, att - 1)->attisdropped)
            continue;
        if (heap_attisnull(&tmptup, att, tupDesc))
        {
            /* null field disproves IS NOT NULL */
            if (!checkisnull)
            {
                *op->resvalue = BoolGetDatum(false);
                return;
            }
        }
        else
        {
            /* non-null field disproves IS NULL */
            if (checkisnull)
            {
                *op->resvalue = BoolGetDatum(false);
                return;
            }
        }
    }
 
    *op->resvalue = BoolGetDatum(true);
}

References BoolGetDatum(), DatumGetHeapTupleHeader, fb(), get_cached_rowtype(), heap_attisnull(), HeapTupleHeaderGetDatumLength(), HeapTupleHeaderGetTypeId(), HeapTupleHeaderGetTypMod(), ExprEvalStep::isnull, TupleDescData::natts, ExprEvalStep::op, TupleDescCompactAttr(), and value.

Referenced by ExecEvalRowNotNull(), and ExecEvalRowNull().

ExecEvalScalarArrayOp()

void ExecEvalScalarArrayOp	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4033 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;
 
    /*
     * 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);
    }
 
    ExecEvalArrayCompareInternal(fcinfo,
                                 arr,
                                 op->d.scalararrayop.typlen,
                                 op->d.scalararrayop.typbyval,
                                 op->d.scalararrayop.typalign,
                                 useOr,
                                 &result,
                                 &resultnull);
 
    *op->resvalue = result;
    *op->resnull = resultnull;
}

References FunctionCallInfoBaseData::args, ARR_DIMS, ARR_ELEMTYPE, ARR_NDIM, ArrayGetNItems(), BoolGetDatum(), DatumGetArrayTypeP, ExecEvalArrayCompareInternal(), fb(), get_typlenbyvalalign(), NullableDatum::isnull, nitems, ExprEvalStep::op, result, and ExprEvalStep::useOr.

Referenced by ExecInterpExpr().

ExecEvalSQLValueFunction()

void ExecEvalSQLValueFunction	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3205 of file execExprInterp.c.

{
    LOCAL_FCINFO(fcinfo, 0);
    SQLValueFunction *svf = op->d.sqlvaluefunction.svf;
 
    *op->resnull = false;
 
    /*
     * Note: current_schema() can return NULL.  current_user() etc currently
     * cannot, but might as well code those cases the same way for safety.
     */
    switch (svf->op)
    {
        case SVFOP_CURRENT_DATE:
            *op->resvalue = DateADTGetDatum(GetSQLCurrentDate());
            break;
        case SVFOP_CURRENT_TIME:
        case SVFOP_CURRENT_TIME_N:
            *op->resvalue = TimeTzADTPGetDatum(GetSQLCurrentTime(svf->typmod));
            break;
        case SVFOP_CURRENT_TIMESTAMP:
        case SVFOP_CURRENT_TIMESTAMP_N:
            *op->resvalue = TimestampTzGetDatum(GetSQLCurrentTimestamp(svf->typmod));
            break;
        case SVFOP_LOCALTIME:
        case SVFOP_LOCALTIME_N:
            *op->resvalue = TimeADTGetDatum(GetSQLLocalTime(svf->typmod));
            break;
        case SVFOP_LOCALTIMESTAMP:
        case SVFOP_LOCALTIMESTAMP_N:
            *op->resvalue = TimestampGetDatum(GetSQLLocalTimestamp(svf->typmod));
            break;
        case SVFOP_CURRENT_ROLE:
        case SVFOP_CURRENT_USER:
        case SVFOP_USER:
            InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
            *op->resvalue = current_user(fcinfo);
            *op->resnull = fcinfo->isnull;
            break;
        case SVFOP_SESSION_USER:
            InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
            *op->resvalue = session_user(fcinfo);
            *op->resnull = fcinfo->isnull;
            break;
        case SVFOP_CURRENT_CATALOG:
            InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
            *op->resvalue = current_database(fcinfo);
            *op->resnull = fcinfo->isnull;
            break;
        case SVFOP_CURRENT_SCHEMA:
            InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
            *op->resvalue = current_schema(fcinfo);
            *op->resnull = fcinfo->isnull;
            break;
    }
}

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

Referenced by ExecInterpExpr().

ExecEvalStepOp()

ExprEvalOp ExecEvalStepOp	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 2970 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, fb(), and ExprEvalStep::op.

Referenced by CheckExprStillValid(), and llvm_compile_expr().

ExecEvalSubPlan()

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

Definition at line 5383 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, ExprEvalStep::sstate, and SubPlanState::subplan.

Referenced by ExecInterpExpr().

ExecEvalSysVar()

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

Definition at line 5659 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalWholeRowVar()

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

Definition at line 5400 of file execExprInterp.c.

{
    Var        *variable = op->d.wholerow.var;
    TupleTableSlot *slot = NULL;
    TupleDesc   output_tupdesc;
    MemoryContext oldcontext;
    HeapTupleHeader dtuple;
    HeapTuple   tuple;
 
    /* This was checked by ExecInitExpr */
    Assert(variable->varattno == InvalidAttrNumber);
 
    /* Get the input slot we want */
    switch (variable->varno)
    {
        case INNER_VAR:
            /* get the tuple from the inner node */
            slot = econtext->ecxt_innertuple;
            break;
 
        case OUTER_VAR:
            /* get the tuple from the outer node */
            slot = econtext->ecxt_outertuple;
            break;
 
            /* INDEX_VAR is handled by default case */
 
        default:
 
            /*
             * Get the tuple from the relation being scanned.
             *
             * By default, this uses the "scan" tuple slot, but a wholerow Var
             * in the RETURNING list may explicitly refer to OLD/NEW.  If the
             * OLD/NEW row doesn't exist, we just return NULL.
             */
            switch (variable->varreturningtype)
            {
                case VAR_RETURNING_DEFAULT:
                    slot = econtext->ecxt_scantuple;
                    break;
 
                case VAR_RETURNING_OLD:
                    if (state->flags & EEO_FLAG_OLD_IS_NULL)
                    {
                        *op->resvalue = (Datum) 0;
                        *op->resnull = true;
                        return;
                    }
                    slot = econtext->ecxt_oldtuple;
                    break;
 
                case VAR_RETURNING_NEW:
                    if (state->flags & EEO_FLAG_NEW_IS_NULL)
                    {
                        *op->resvalue = (Datum) 0;
                        *op->resnull = true;
                        return;
                    }
                    slot = econtext->ecxt_newtuple;
                    break;
            }
            break;
    }
 
    /* Apply the junkfilter if any */
    if (op->d.wholerow.junkFilter != NULL)
        slot = ExecFilterJunk(op->d.wholerow.junkFilter, slot);
 
    /*
     * If first time through, obtain tuple descriptor and check compatibility.
     *
     * XXX: It'd be great if this could be moved to the expression
     * initialization phase, but due to using slots that's currently not
     * feasible.
     */
    if (op->d.wholerow.first)
    {
        /* optimistically assume we don't need slow path */
        op->d.wholerow.slow = false;
 
        /*
         * If the Var identifies a named composite type, we must check that
         * the actual tuple type is compatible with it.
         */
        if (variable->vartype != RECORDOID)
        {
            TupleDesc   var_tupdesc;
            TupleDesc   slot_tupdesc;
 
            /*
             * We really only care about numbers of attributes and data types.
             * Also, we can ignore type mismatch on columns that are dropped
             * in the destination type, so long as (1) the physical storage
             * matches or (2) the actual column value is NULL.  Case (1) is
             * helpful in some cases involving out-of-date cached plans, while
             * case (2) is expected behavior in situations such as an INSERT
             * into a table with dropped columns (the planner typically
             * generates an INT4 NULL regardless of the dropped column type).
             * If we find a dropped column and cannot verify that case (1)
             * holds, we have to use the slow path to check (2) for each row.
             *
             * If vartype is a domain over composite, just look through that
             * to the base composite type.
             */
            var_tupdesc = lookup_rowtype_tupdesc_domain(variable->vartype,
                                                        -1, false);
 
            slot_tupdesc = slot->tts_tupleDescriptor;
 
            if (var_tupdesc->natts != slot_tupdesc->natts)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("table row type and query-specified row type do not match"),
                         errdetail_plural("Table row contains %d attribute, but query expects %d.",
                                          "Table row contains %d attributes, but query expects %d.",
                                          slot_tupdesc->natts,
                                          slot_tupdesc->natts,
                                          var_tupdesc->natts)));
 
            for (int i = 0; i < var_tupdesc->natts; i++)
            {
                Form_pg_attribute vattr = TupleDescAttr(var_tupdesc, i);
                Form_pg_attribute sattr = TupleDescAttr(slot_tupdesc, i);
 
                if (vattr->atttypid == sattr->atttypid)
                    continue;   /* no worries */
                if (!vattr->attisdropped)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("table row type and query-specified row type do not match"),
                             errdetail("Table has type %s at ordinal position %d, but query expects %s.",
                                       format_type_be(sattr->atttypid),
                                       i + 1,
                                       format_type_be(vattr->atttypid))));
 
                if (vattr->attlen != sattr->attlen ||
                    vattr->attalign != sattr->attalign)
                    op->d.wholerow.slow = true; /* need to check for nulls */
            }
 
            /*
             * Use the variable's declared rowtype as the descriptor for the
             * output values.  In particular, we *must* absorb any
             * attisdropped markings.
             */
            oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
            output_tupdesc = CreateTupleDescCopy(var_tupdesc);
            MemoryContextSwitchTo(oldcontext);
 
            ReleaseTupleDesc(var_tupdesc);
        }
        else
        {
            /*
             * In the RECORD case, we use the input slot's rowtype as the
             * descriptor for the output values, modulo possibly assigning new
             * column names below.
             */
            oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
            output_tupdesc = CreateTupleDescCopy(slot->tts_tupleDescriptor);
            MemoryContextSwitchTo(oldcontext);
 
            /*
             * It's possible that the input slot is a relation scan slot and
             * so is marked with that relation's rowtype.  But we're supposed
             * to be returning RECORD, so reset to that.
             */
            output_tupdesc->tdtypeid = RECORDOID;
            output_tupdesc->tdtypmod = -1;
 
            /*
             * We already got the correct physical datatype info above, but
             * now we should try to find the source RTE and adopt its column
             * aliases, since it's unlikely that the input slot has the
             * desired names.
             *
             * If we can't locate the RTE, assume the column names we've got
             * are OK.  (As of this writing, the only cases where we can't
             * locate the RTE are in execution of trigger WHEN clauses, and
             * then the Var will have the trigger's relation's rowtype, so its
             * names are fine.)  Also, if the creator of the RTE didn't bother
             * to fill in an eref field, assume our column names are OK. (This
             * happens in COPY, and perhaps other places.)
             */
            if (econtext->ecxt_estate &&
                variable->varno <= econtext->ecxt_estate->es_range_table_size)
            {
                RangeTblEntry *rte = exec_rt_fetch(variable->varno,
                                                   econtext->ecxt_estate);
 
                if (rte->eref)
                    ExecTypeSetColNames(output_tupdesc, rte->eref->colnames);
            }
        }
 
        /* Bless the tupdesc if needed, and save it in the execution state */
        op->d.wholerow.tupdesc = BlessTupleDesc(output_tupdesc);
 
        op->d.wholerow.first = false;
    }
 
    /*
     * Make sure all columns of the slot are accessible in the slot's
     * Datum/isnull arrays.
     */
    slot_getallattrs(slot);
 
    if (op->d.wholerow.slow)
    {
        /* Check to see if any dropped attributes are non-null */
        TupleDesc   tupleDesc = slot->tts_tupleDescriptor;
        TupleDesc   var_tupdesc = op->d.wholerow.tupdesc;
 
        Assert(var_tupdesc->natts == tupleDesc->natts);
 
        for (int i = 0; i < var_tupdesc->natts; i++)
        {
            CompactAttribute *vattr = TupleDescCompactAttr(var_tupdesc, i);
            CompactAttribute *sattr = TupleDescCompactAttr(tupleDesc, i);
 
            if (!vattr->attisdropped)
                continue;       /* already checked non-dropped cols */
            if (slot->tts_isnull[i])
                continue;       /* null is always okay */
            if (vattr->attlen != sattr->attlen ||
                vattr->attalignby != sattr->attalignby)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("table row type and query-specified row type do not match"),
                         errdetail("Physical storage mismatch on dropped attribute at ordinal position %d.",
                                   i + 1)));
        }
    }
 
    /*
     * Build a composite datum, making sure any toasted fields get detoasted.
     *
     * (Note: it is critical that we not change the slot's state here.)
     */
    tuple = toast_build_flattened_tuple(slot->tts_tupleDescriptor,
                                        slot->tts_values,
                                        slot->tts_isnull);
    dtuple = tuple->t_data;
 
    /*
     * Label the datum with the composite type info we identified before.
     *
     * (Note: we could skip doing this by passing op->d.wholerow.tupdesc to
     * the tuple build step; but that seems a tad risky so let's not.)
     */
    HeapTupleHeaderSetTypeId(dtuple, op->d.wholerow.tupdesc->tdtypeid);
    HeapTupleHeaderSetTypMod(dtuple, op->d.wholerow.tupdesc->tdtypmod);
 
    *op->resvalue = PointerGetDatum(dtuple);
    *op->resnull = false;
}

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

Referenced by ExecInterpExpr().

ExecEvalXmlExpr()

void ExecEvalXmlExpr	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4518 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, NULL));
                *op->resnull = false;
            }
            break;
 
        case IS_XMLPI:
            {
                text       *arg;
                bool        isnull;
 
                /* optional argument is known to be text */
                Assert(list_length(xexpr->args) <= 1);
 
                if (xexpr->args)
                {
                    isnull = op->d.xmlexpr.argnull[0];
                    if (isnull)
                        arg = NULL;
                    else
                        arg = DatumGetTextPP(op->d.xmlexpr.argvalue[0]);
                }
                else
                {
                    arg = NULL;
                    isnull = false;
                }
 
                *op->resvalue = PointerGetDatum(xmlpi(xexpr->name,
                                                      arg,
                                                      isnull,
                                                      op->resnull));
            }
            break;
 
        case IS_XMLROOT:
            {
                Datum      *argvalue = op->d.xmlexpr.argvalue;
                bool       *argnull = op->d.xmlexpr.argnull;
                xmltype    *data;
                text       *version;
                int         standalone;
 
                /* arguments are known to be xml, text, int */
                Assert(list_length(xexpr->args) == 3);
 
                if (argnull[0])
                    return;
                data = DatumGetXmlP(argvalue[0]);
 
                if (argnull[1])
                    version = NULL;
                else
                    version = DatumGetTextPP(argvalue[1]);
 
                Assert(!argnull[2]);    /* always present */
                standalone = DatumGetInt32(argvalue[2]);
 
                *op->resvalue = PointerGetDatum(xmlroot(data,
                                                        version,
                                                        standalone));
                *op->resnull = false;
            }
            break;
 
        case IS_XMLSERIALIZE:
            {
                Datum      *argvalue = op->d.xmlexpr.argvalue;
                bool       *argnull = op->d.xmlexpr.argnull;
 
                /* argument type is known to be xml */
                Assert(list_length(xexpr->args) == 1);
 
                if (argnull[0])
                    return;
                value = argvalue[0];
 
                *op->resvalue =
                    PointerGetDatum(xmltotext_with_options(DatumGetXmlP(value),
                                                           xexpr->xmloption,
                                                           xexpr->indent));
                *op->resnull = false;
            }
            break;
 
        case IS_DOCUMENT:
            {
                Datum      *argvalue = op->d.xmlexpr.argvalue;
                bool       *argnull = op->d.xmlexpr.argnull;
 
                /* optional argument is known to be xml */
                Assert(list_length(xexpr->args) == 1);
 
                if (argnull[0])
                    return;
                value = argvalue[0];
 
                *op->resvalue =
                    BoolGetDatum(xml_is_document(DatumGetXmlP(value)));
                *op->resnull = false;
            }
            break;
 
        default:
            elog(ERROR, "unrecognized XML operation");
            break;
    }
}

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

Referenced by ExecInterpExpr().

ExecGetJsonValueItemString()

static char * ExecGetJsonValueItemString ( JsonbValue *  item, bool *  resnull  )

static

Definition at line 5111 of file execExprInterp.c.

{
    *resnull = false;
 
    /* get coercion state reference and datum of the corresponding SQL type */
    switch (item->type)
    {
        case jbvNull:
            *resnull = true;
            return NULL;
 
        case jbvString:
            {
                char       *str = palloc(item->val.string.len + 1);
 
                memcpy(str, item->val.string.val, item->val.string.len);
                str[item->val.string.len] = '\0';
                return str;
            }
 
        case jbvNumeric:
            return DatumGetCString(DirectFunctionCall1(numeric_out,
                                                       NumericGetDatum(item->val.numeric)));
 
        case jbvBool:
            return DatumGetCString(DirectFunctionCall1(boolout,
                                                       BoolGetDatum(item->val.boolean)));
 
        case jbvDatetime:
            switch (item->val.datetime.typid)
            {
                case DATEOID:
                    return DatumGetCString(DirectFunctionCall1(date_out,
                                                               item->val.datetime.value));
                case TIMEOID:
                    return DatumGetCString(DirectFunctionCall1(time_out,
                                                               item->val.datetime.value));
                case TIMETZOID:
                    return DatumGetCString(DirectFunctionCall1(timetz_out,
                                                               item->val.datetime.value));
                case TIMESTAMPOID:
                    return DatumGetCString(DirectFunctionCall1(timestamp_out,
                                                               item->val.datetime.value));
                case TIMESTAMPTZOID:
                    return DatumGetCString(DirectFunctionCall1(timestamptz_out,
                                                               item->val.datetime.value));
                default:
                    elog(ERROR, "unexpected jsonb datetime type oid %u",
                         item->val.datetime.typid);
            }
            break;
 
        case jbvArray:
        case jbvObject:
        case jbvBinary:
            return DatumGetCString(DirectFunctionCall1(jsonb_out,
                                                       JsonbPGetDatum(JsonbValueToJsonb(item))));
 
        default:
            elog(ERROR, "unexpected jsonb value type %d", item->type);
    }
 
    Assert(false);
    *resnull = true;
    return NULL;
}

References Assert, BoolGetDatum(), boolout(), date_out(), DatumGetCString(), DirectFunctionCall1, elog, ERROR, fb(), jbvArray, jbvBinary, jbvBool, jbvDatetime, jbvNull, jbvNumeric, jbvObject, jbvString, jsonb_out(), JsonbPGetDatum(), JsonbValueToJsonb(), memcpy(), numeric_out(), NumericGetDatum(), palloc(), ExprEvalStep::resnull, str, time_out(), timestamp_out(), timestamptz_out(), timetz_out(), JsonbValue::type, and JsonbValue::val.

Referenced by ExecEvalJsonExprPath().

ExecInitInterpreter()

static void ExecInitInterpreter ( void  )

static

Definition at line 2938 of file execExprInterp.c.

{
#if defined(EEO_USE_COMPUTED_GOTO)
    /* Set up externally-visible pointer to dispatch table */
    if (dispatch_table == NULL)
    {
        dispatch_table = (const void **)
            DatumGetPointer(ExecInterpExpr(NULL, NULL, NULL));
 
        /* build reverse lookup table */
        for (int i = 0; i < EEOP_LAST; i++)
        {
            reverse_dispatch_table[i].opcode = dispatch_table[i];
            reverse_dispatch_table[i].op = (ExprEvalOp) i;
        }
 
        /* make it bsearch()able */
        qsort(reverse_dispatch_table,
              EEOP_LAST /* nmembers */ ,
              sizeof(ExprEvalOpLookup),
              dispatch_compare_ptr);
    }
#endif
}

References DatumGetPointer(), EEOP_LAST, ExecInterpExpr(), fb(), i, and qsort.

Referenced by ExecReadyInterpretedExpr().

ExecInterpExpr()

static Datum ExecInterpExpr ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 470 of file execExprInterp.c.

{
    ExprEvalStep *op;
    TupleTableSlot *resultslot;
    TupleTableSlot *innerslot;
    TupleTableSlot *outerslot;
    TupleTableSlot *scanslot;
    TupleTableSlot *oldslot;
    TupleTableSlot *newslot;
 
    /*
     * This array has to be in the same order as enum ExprEvalOp.
     */
#if defined(EEO_USE_COMPUTED_GOTO)
    static const void *const dispatch_table[] = {
        &&CASE_EEOP_DONE_RETURN,
        &&CASE_EEOP_DONE_NO_RETURN,
        &&CASE_EEOP_INNER_FETCHSOME,
        &&CASE_EEOP_OUTER_FETCHSOME,
        &&CASE_EEOP_SCAN_FETCHSOME,
        &&CASE_EEOP_OLD_FETCHSOME,
        &&CASE_EEOP_NEW_FETCHSOME,
        &&CASE_EEOP_INNER_VAR,
        &&CASE_EEOP_OUTER_VAR,
        &&CASE_EEOP_SCAN_VAR,
        &&CASE_EEOP_OLD_VAR,
        &&CASE_EEOP_NEW_VAR,
        &&CASE_EEOP_INNER_SYSVAR,
        &&CASE_EEOP_OUTER_SYSVAR,
        &&CASE_EEOP_SCAN_SYSVAR,
        &&CASE_EEOP_OLD_SYSVAR,
        &&CASE_EEOP_NEW_SYSVAR,
        &&CASE_EEOP_WHOLEROW,
        &&CASE_EEOP_ASSIGN_INNER_VAR,
        &&CASE_EEOP_ASSIGN_OUTER_VAR,
        &&CASE_EEOP_ASSIGN_SCAN_VAR,
        &&CASE_EEOP_ASSIGN_OLD_VAR,
        &&CASE_EEOP_ASSIGN_NEW_VAR,
        &&CASE_EEOP_ASSIGN_TMP,
        &&CASE_EEOP_ASSIGN_TMP_MAKE_RO,
        &&CASE_EEOP_CONST,
        &&CASE_EEOP_FUNCEXPR,
        &&CASE_EEOP_FUNCEXPR_STRICT,
        &&CASE_EEOP_FUNCEXPR_STRICT_1,
        &&CASE_EEOP_FUNCEXPR_STRICT_2,
        &&CASE_EEOP_FUNCEXPR_FUSAGE,
        &&CASE_EEOP_FUNCEXPR_STRICT_FUSAGE,
        &&CASE_EEOP_BOOL_AND_STEP_FIRST,
        &&CASE_EEOP_BOOL_AND_STEP,
        &&CASE_EEOP_BOOL_AND_STEP_LAST,
        &&CASE_EEOP_BOOL_OR_STEP_FIRST,
        &&CASE_EEOP_BOOL_OR_STEP,
        &&CASE_EEOP_BOOL_OR_STEP_LAST,
        &&CASE_EEOP_BOOL_NOT_STEP,
        &&CASE_EEOP_QUAL,
        &&CASE_EEOP_JUMP,
        &&CASE_EEOP_JUMP_IF_NULL,
        &&CASE_EEOP_JUMP_IF_NOT_NULL,
        &&CASE_EEOP_JUMP_IF_NOT_TRUE,
        &&CASE_EEOP_NULLTEST_ISNULL,
        &&CASE_EEOP_NULLTEST_ISNOTNULL,
        &&CASE_EEOP_NULLTEST_ROWISNULL,
        &&CASE_EEOP_NULLTEST_ROWISNOTNULL,
        &&CASE_EEOP_BOOLTEST_IS_TRUE,
        &&CASE_EEOP_BOOLTEST_IS_NOT_TRUE,
        &&CASE_EEOP_BOOLTEST_IS_FALSE,
        &&CASE_EEOP_BOOLTEST_IS_NOT_FALSE,
        &&CASE_EEOP_PARAM_EXEC,
        &&CASE_EEOP_PARAM_EXTERN,
        &&CASE_EEOP_PARAM_CALLBACK,
        &&CASE_EEOP_PARAM_SET,
        &&CASE_EEOP_CASE_TESTVAL,
        &&CASE_EEOP_CASE_TESTVAL_EXT,
        &&CASE_EEOP_MAKE_READONLY,
        &&CASE_EEOP_IOCOERCE,
        &&CASE_EEOP_IOCOERCE_SAFE,
        &&CASE_EEOP_DISTINCT,
        &&CASE_EEOP_NOT_DISTINCT,
        &&CASE_EEOP_NULLIF,
        &&CASE_EEOP_SQLVALUEFUNCTION,
        &&CASE_EEOP_CURRENTOFEXPR,
        &&CASE_EEOP_NEXTVALUEEXPR,
        &&CASE_EEOP_RETURNINGEXPR,
        &&CASE_EEOP_ARRAYEXPR,
        &&CASE_EEOP_ARRAYCOERCE,
        &&CASE_EEOP_ROW,
        &&CASE_EEOP_ROWCOMPARE_STEP,
        &&CASE_EEOP_ROWCOMPARE_FINAL,
        &&CASE_EEOP_MINMAX,
        &&CASE_EEOP_FIELDSELECT,
        &&CASE_EEOP_FIELDSTORE_DEFORM,
        &&CASE_EEOP_FIELDSTORE_FORM,
        &&CASE_EEOP_SBSREF_SUBSCRIPTS,
        &&CASE_EEOP_SBSREF_OLD,
        &&CASE_EEOP_SBSREF_ASSIGN,
        &&CASE_EEOP_SBSREF_FETCH,
        &&CASE_EEOP_DOMAIN_TESTVAL,
        &&CASE_EEOP_DOMAIN_TESTVAL_EXT,
        &&CASE_EEOP_DOMAIN_NOTNULL,
        &&CASE_EEOP_DOMAIN_CHECK,
        &&CASE_EEOP_HASHDATUM_SET_INITVAL,
        &&CASE_EEOP_HASHDATUM_FIRST,
        &&CASE_EEOP_HASHDATUM_FIRST_STRICT,
        &&CASE_EEOP_HASHDATUM_NEXT32,
        &&CASE_EEOP_HASHDATUM_NEXT32_STRICT,
        &&CASE_EEOP_CONVERT_ROWTYPE,
        &&CASE_EEOP_SCALARARRAYOP,
        &&CASE_EEOP_HASHED_SCALARARRAYOP,
        &&CASE_EEOP_XMLEXPR,
        &&CASE_EEOP_JSON_CONSTRUCTOR,
        &&CASE_EEOP_IS_JSON,
        &&CASE_EEOP_JSONEXPR_PATH,
        &&CASE_EEOP_JSONEXPR_COERCION,
        &&CASE_EEOP_JSONEXPR_COERCION_FINISH,
        &&CASE_EEOP_AGGREF,
        &&CASE_EEOP_GROUPING_FUNC,
        &&CASE_EEOP_WINDOW_FUNC,
        &&CASE_EEOP_MERGE_SUPPORT_FUNC,
        &&CASE_EEOP_SUBPLAN,
        &&CASE_EEOP_AGG_STRICT_DESERIALIZE,
        &&CASE_EEOP_AGG_DESERIALIZE,
        &&CASE_EEOP_AGG_STRICT_INPUT_CHECK_ARGS,
        &&CASE_EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1,
        &&CASE_EEOP_AGG_STRICT_INPUT_CHECK_NULLS,
        &&CASE_EEOP_AGG_PLAIN_PERGROUP_NULLCHECK,
        &&CASE_EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL,
        &&CASE_EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL,
        &&CASE_EEOP_AGG_PLAIN_TRANS_BYVAL,
        &&CASE_EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF,
        &&CASE_EEOP_AGG_PLAIN_TRANS_STRICT_BYREF,
        &&CASE_EEOP_AGG_PLAIN_TRANS_BYREF,
        &&CASE_EEOP_AGG_PRESORTED_DISTINCT_SINGLE,
        &&CASE_EEOP_AGG_PRESORTED_DISTINCT_MULTI,
        &&CASE_EEOP_AGG_ORDERED_TRANS_DATUM,
        &&CASE_EEOP_AGG_ORDERED_TRANS_TUPLE,
        &&CASE_EEOP_LAST
    };
 
    StaticAssertDecl(lengthof(dispatch_table) == EEOP_LAST + 1,
                     "dispatch_table out of whack with ExprEvalOp");
 
    if (unlikely(state == NULL))
        return PointerGetDatum(dispatch_table);
#else
    Assert(state != NULL);
#endif                          /* EEO_USE_COMPUTED_GOTO */
 
    /* setup state */
    op = state->steps;
    resultslot = state->resultslot;
    innerslot = econtext->ecxt_innertuple;
    outerslot = econtext->ecxt_outertuple;
    scanslot = econtext->ecxt_scantuple;
    oldslot = econtext->ecxt_oldtuple;
    newslot = econtext->ecxt_newtuple;
 
#if defined(EEO_USE_COMPUTED_GOTO)
    EEO_DISPATCH();
#endif
 
    EEO_SWITCH()
    {
        EEO_CASE(EEOP_DONE_RETURN)
        {
            *isnull = state->resnull;
            return state->resvalue;
        }
 
        EEO_CASE(EEOP_DONE_NO_RETURN)
        {
            Assert(isnull == NULL);
            return (Datum) 0;
        }
 
        EEO_CASE(EEOP_INNER_FETCHSOME)
        {
            CheckOpSlotCompatibility(op, innerslot);
 
            slot_getsomeattrs(innerslot, op->d.fetch.last_var);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_OUTER_FETCHSOME)
        {
            CheckOpSlotCompatibility(op, outerslot);
 
            slot_getsomeattrs(outerslot, op->d.fetch.last_var);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_SCAN_FETCHSOME)
        {
            CheckOpSlotCompatibility(op, scanslot);
 
            slot_getsomeattrs(scanslot, op->d.fetch.last_var);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_OLD_FETCHSOME)
        {
            CheckOpSlotCompatibility(op, oldslot);
 
            slot_getsomeattrs(oldslot, op->d.fetch.last_var);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_NEW_FETCHSOME)
        {
            CheckOpSlotCompatibility(op, newslot);
 
            slot_getsomeattrs(newslot, op->d.fetch.last_var);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_INNER_VAR)
        {
            int         attnum = op->d.var.attnum;
 
            /*
             * Since we already extracted all referenced columns from the
             * tuple with a FETCHSOME step, we can just grab the value
             * directly out of the slot's decomposed-data arrays.  But let's
             * have an Assert to check that that did happen.
             */
            Assert(attnum >= 0 && attnum < innerslot->tts_nvalid);
            *op->resvalue = innerslot->tts_values[attnum];
            *op->resnull = innerslot->tts_isnull[attnum];
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_OUTER_VAR)
        {
            int         attnum = op->d.var.attnum;
 
            /* See EEOP_INNER_VAR comments */
 
            Assert(attnum >= 0 && attnum < outerslot->tts_nvalid);
            *op->resvalue = outerslot->tts_values[attnum];
            *op->resnull = outerslot->tts_isnull[attnum];
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_SCAN_VAR)
        {
            int         attnum = op->d.var.attnum;
 
            /* See EEOP_INNER_VAR comments */
 
            Assert(attnum >= 0 && attnum < scanslot->tts_nvalid);
            *op->resvalue = scanslot->tts_values[attnum];
            *op->resnull = scanslot->tts_isnull[attnum];
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_OLD_VAR)
        {
            int         attnum = op->d.var.attnum;
 
            /* See EEOP_INNER_VAR comments */
 
            Assert(attnum >= 0 && attnum < oldslot->tts_nvalid);
            *op->resvalue = oldslot->tts_values[attnum];
            *op->resnull = oldslot->tts_isnull[attnum];
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_NEW_VAR)
        {
            int         attnum = op->d.var.attnum;
 
            /* See EEOP_INNER_VAR comments */
 
            Assert(attnum >= 0 && attnum < newslot->tts_nvalid);
            *op->resvalue = newslot->tts_values[attnum];
            *op->resnull = newslot->tts_isnull[attnum];
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_INNER_SYSVAR)
        {
            ExecEvalSysVar(state, op, econtext, innerslot);
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_OUTER_SYSVAR)
        {
            ExecEvalSysVar(state, op, econtext, outerslot);
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_SCAN_SYSVAR)
        {
            ExecEvalSysVar(state, op, econtext, scanslot);
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_OLD_SYSVAR)
        {
            ExecEvalSysVar(state, op, econtext, oldslot);
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_NEW_SYSVAR)
        {
            ExecEvalSysVar(state, op, econtext, newslot);
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_WHOLEROW)
        {
            /* too complex for an inline implementation */
            ExecEvalWholeRowVar(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_ASSIGN_INNER_VAR)
        {
            int         resultnum = op->d.assign_var.resultnum;
            int         attnum = op->d.assign_var.attnum;
 
            /*
             * We do not need CheckVarSlotCompatibility here; that was taken
             * care of at compilation time.  But see EEOP_INNER_VAR comments.
             */
            Assert(attnum >= 0 && attnum < innerslot->tts_nvalid);
            Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
            resultslot->tts_values[resultnum] = innerslot->tts_values[attnum];
            resultslot->tts_isnull[resultnum] = innerslot->tts_isnull[attnum];
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_ASSIGN_OUTER_VAR)
        {
            int         resultnum = op->d.assign_var.resultnum;
            int         attnum = op->d.assign_var.attnum;
 
            /*
             * We do not need CheckVarSlotCompatibility here; that was taken
             * care of at compilation time.  But see EEOP_INNER_VAR comments.
             */
            Assert(attnum >= 0 && attnum < outerslot->tts_nvalid);
            Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
            resultslot->tts_values[resultnum] = outerslot->tts_values[attnum];
            resultslot->tts_isnull[resultnum] = outerslot->tts_isnull[attnum];
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_ASSIGN_SCAN_VAR)
        {
            int         resultnum = op->d.assign_var.resultnum;
            int         attnum = op->d.assign_var.attnum;
 
            /*
             * We do not need CheckVarSlotCompatibility here; that was taken
             * care of at compilation time.  But see EEOP_INNER_VAR comments.
             */
            Assert(attnum >= 0 && attnum < scanslot->tts_nvalid);
            Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
            resultslot->tts_values[resultnum] = scanslot->tts_values[attnum];
            resultslot->tts_isnull[resultnum] = scanslot->tts_isnull[attnum];
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_ASSIGN_OLD_VAR)
        {
            int         resultnum = op->d.assign_var.resultnum;
            int         attnum = op->d.assign_var.attnum;
 
            /*
             * We do not need CheckVarSlotCompatibility here; that was taken
             * care of at compilation time.  But see EEOP_INNER_VAR comments.
             */
            Assert(attnum >= 0 && attnum < oldslot->tts_nvalid);
            Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
            resultslot->tts_values[resultnum] = oldslot->tts_values[attnum];
            resultslot->tts_isnull[resultnum] = oldslot->tts_isnull[attnum];
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_ASSIGN_NEW_VAR)
        {
            int         resultnum = op->d.assign_var.resultnum;
            int         attnum = op->d.assign_var.attnum;
 
            /*
             * We do not need CheckVarSlotCompatibility here; that was taken
             * care of at compilation time.  But see EEOP_INNER_VAR comments.
             */
            Assert(attnum >= 0 && attnum < newslot->tts_nvalid);
            Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
            resultslot->tts_values[resultnum] = newslot->tts_values[attnum];
            resultslot->tts_isnull[resultnum] = newslot->tts_isnull[attnum];
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_ASSIGN_TMP)
        {
            int         resultnum = op->d.assign_tmp.resultnum;
 
            Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
            resultslot->tts_values[resultnum] = state->resvalue;
            resultslot->tts_isnull[resultnum] = state->resnull;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_ASSIGN_TMP_MAKE_RO)
        {
            int         resultnum = op->d.assign_tmp.resultnum;
 
            Assert(resultnum >= 0 && resultnum < resultslot->tts_tupleDescriptor->natts);
            resultslot->tts_isnull[resultnum] = state->resnull;
            if (!resultslot->tts_isnull[resultnum])
                resultslot->tts_values[resultnum] =
                    MakeExpandedObjectReadOnlyInternal(state->resvalue);
            else
                resultslot->tts_values[resultnum] = state->resvalue;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_CONST)
        {
            *op->resnull = op->d.constval.isnull;
            *op->resvalue = op->d.constval.value;
 
            EEO_NEXT();
        }
 
        /*
         * Function-call implementations. Arguments have previously been
         * evaluated directly into fcinfo->args.
         *
         * As both STRICT checks and function-usage are noticeable performance
         * wise, and function calls are a very hot-path (they also back
         * operators!), it's worth having so many separate opcodes.
         *
         * Note: the reason for using a temporary variable "d", here and in
         * other places, is that some compilers think "*op->resvalue = f();"
         * requires them to evaluate op->resvalue into a register before
         * calling f(), just in case f() is able to modify op->resvalue
         * somehow.  The extra line of code can save a useless register spill
         * and reload across the function call.
         */
        EEO_CASE(EEOP_FUNCEXPR)
        {
            FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
            Datum       d;
 
            fcinfo->isnull = false;
            d = op->d.func.fn_addr(fcinfo);
            *op->resvalue = d;
            *op->resnull = fcinfo->isnull;
 
            EEO_NEXT();
        }
 
        /* strict function call with more than two arguments */
        EEO_CASE(EEOP_FUNCEXPR_STRICT)
        {
            FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
            NullableDatum *args = fcinfo->args;
            int         nargs = op->d.func.nargs;
            Datum       d;
 
            Assert(nargs > 2);
 
            /* strict function, so check for NULL args */
            for (int argno = 0; argno < nargs; argno++)
            {
                if (args[argno].isnull)
                {
                    *op->resnull = true;
                    goto strictfail;
                }
            }
            fcinfo->isnull = false;
            d = op->d.func.fn_addr(fcinfo);
            *op->resvalue = d;
            *op->resnull = fcinfo->isnull;
 
    strictfail:
            EEO_NEXT();
        }
 
        /* strict function call with one argument */
        EEO_CASE(EEOP_FUNCEXPR_STRICT_1)
        {
            FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
            NullableDatum *args = fcinfo->args;
 
            Assert(op->d.func.nargs == 1);
 
            /* strict function, so check for NULL args */
            if (args[0].isnull)
                *op->resnull = true;
            else
            {
                Datum       d;
 
                fcinfo->isnull = false;
                d = op->d.func.fn_addr(fcinfo);
                *op->resvalue = d;
                *op->resnull = fcinfo->isnull;
            }
 
            EEO_NEXT();
        }
 
        /* strict function call with two arguments */
        EEO_CASE(EEOP_FUNCEXPR_STRICT_2)
        {
            FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
            NullableDatum *args = fcinfo->args;
 
            Assert(op->d.func.nargs == 2);
 
            /* strict function, so check for NULL args */
            if (args[0].isnull || args[1].isnull)
                *op->resnull = true;
            else
            {
                Datum       d;
 
                fcinfo->isnull = false;
                d = op->d.func.fn_addr(fcinfo);
                *op->resvalue = d;
                *op->resnull = fcinfo->isnull;
            }
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_FUNCEXPR_FUSAGE)
        {
            /* not common enough to inline */
            ExecEvalFuncExprFusage(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_FUNCEXPR_STRICT_FUSAGE)
        {
            /* not common enough to inline */
            ExecEvalFuncExprStrictFusage(state, op, econtext);
 
            EEO_NEXT();
        }
 
        /*
         * If any of its clauses is FALSE, an AND's result is FALSE regardless
         * of the states of the rest of the clauses, so we can stop evaluating
         * and return FALSE immediately.  If none are FALSE and one or more is
         * NULL, we return NULL; otherwise we return TRUE.  This makes sense
         * when you interpret NULL as "don't know": perhaps one of the "don't
         * knows" would have been FALSE if we'd known its value.  Only when
         * all the inputs are known to be TRUE can we state confidently that
         * the AND's result is TRUE.
         */
        EEO_CASE(EEOP_BOOL_AND_STEP_FIRST)
        {
            *op->d.boolexpr.anynull = false;
 
            /*
             * EEOP_BOOL_AND_STEP_FIRST resets anynull, otherwise it's the
             * same as EEOP_BOOL_AND_STEP - so fall through to that.
             */
 
            /* FALL THROUGH */
        }
 
        EEO_CASE(EEOP_BOOL_AND_STEP)
        {
            if (*op->resnull)
            {
                *op->d.boolexpr.anynull = true;
            }
            else if (!DatumGetBool(*op->resvalue))
            {
                /* result is already set to FALSE, need not change it */
                /* bail out early */
                EEO_JUMP(op->d.boolexpr.jumpdone);
            }
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_BOOL_AND_STEP_LAST)
        {
            if (*op->resnull)
            {
                /* result is already set to NULL, need not change it */
            }
            else if (!DatumGetBool(*op->resvalue))
            {
                /* result is already set to FALSE, need not change it */
 
                /*
                 * No point jumping early to jumpdone - would be same target
                 * (as this is the last argument to the AND expression),
                 * except more expensive.
                 */
            }
            else if (*op->d.boolexpr.anynull)
            {
                *op->resvalue = (Datum) 0;
                *op->resnull = true;
            }
            else
            {
                /* result is already set to TRUE, need not change it */
            }
 
            EEO_NEXT();
        }
 
        /*
         * If any of its clauses is TRUE, an OR's result is TRUE regardless of
         * the states of the rest of the clauses, so we can stop evaluating
         * and return TRUE immediately.  If none are TRUE and one or more is
         * NULL, we return NULL; otherwise we return FALSE.  This makes sense
         * when you interpret NULL as "don't know": perhaps one of the "don't
         * knows" would have been TRUE if we'd known its value.  Only when all
         * the inputs are known to be FALSE can we state confidently that the
         * OR's result is FALSE.
         */
        EEO_CASE(EEOP_BOOL_OR_STEP_FIRST)
        {
            *op->d.boolexpr.anynull = false;
 
            /*
             * EEOP_BOOL_OR_STEP_FIRST resets anynull, otherwise it's the same
             * as EEOP_BOOL_OR_STEP - so fall through to that.
             */
 
            /* FALL THROUGH */
        }
 
        EEO_CASE(EEOP_BOOL_OR_STEP)
        {
            if (*op->resnull)
            {
                *op->d.boolexpr.anynull = true;
            }
            else if (DatumGetBool(*op->resvalue))
            {
                /* result is already set to TRUE, need not change it */
                /* bail out early */
                EEO_JUMP(op->d.boolexpr.jumpdone);
            }
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_BOOL_OR_STEP_LAST)
        {
            if (*op->resnull)
            {
                /* result is already set to NULL, need not change it */
            }
            else if (DatumGetBool(*op->resvalue))
            {
                /* result is already set to TRUE, need not change it */
 
                /*
                 * No point jumping to jumpdone - would be same target (as
                 * this is the last argument to the AND expression), except
                 * more expensive.
                 */
            }
            else if (*op->d.boolexpr.anynull)
            {
                *op->resvalue = (Datum) 0;
                *op->resnull = true;
            }
            else
            {
                /* result is already set to FALSE, need not change it */
            }
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_BOOL_NOT_STEP)
        {
            /*
             * Evaluation of 'not' is simple... if expr is false, then return
             * 'true' and vice versa.  It's safe to do this even on a
             * nominally null value, so we ignore resnull; that means that
             * NULL in produces NULL out, which is what we want.
             */
            *op->resvalue = BoolGetDatum(!DatumGetBool(*op->resvalue));
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_QUAL)
        {
            /* simplified version of BOOL_AND_STEP for use by ExecQual() */
 
            /* If argument (also result) is false or null ... */
            if (*op->resnull ||
                !DatumGetBool(*op->resvalue))
            {
                /* ... bail out early, returning FALSE */
                *op->resnull = false;
                *op->resvalue = BoolGetDatum(false);
                EEO_JUMP(op->d.qualexpr.jumpdone);
            }
 
            /*
             * Otherwise, leave the TRUE value in place, in case this is the
             * last qual.  Then, TRUE is the correct answer.
             */
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_JUMP)
        {
            /* Unconditionally jump to target step */
            EEO_JUMP(op->d.jump.jumpdone);
        }
 
        EEO_CASE(EEOP_JUMP_IF_NULL)
        {
            /* Transfer control if current result is null */
            if (*op->resnull)
                EEO_JUMP(op->d.jump.jumpdone);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_JUMP_IF_NOT_NULL)
        {
            /* Transfer control if current result is non-null */
            if (!*op->resnull)
                EEO_JUMP(op->d.jump.jumpdone);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_JUMP_IF_NOT_TRUE)
        {
            /* Transfer control if current result is null or false */
            if (*op->resnull || !DatumGetBool(*op->resvalue))
                EEO_JUMP(op->d.jump.jumpdone);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_NULLTEST_ISNULL)
        {
            *op->resvalue = BoolGetDatum(*op->resnull);
            *op->resnull = false;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_NULLTEST_ISNOTNULL)
        {
            *op->resvalue = BoolGetDatum(!*op->resnull);
            *op->resnull = false;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_NULLTEST_ROWISNULL)
        {
            /* out of line implementation: too large */
            ExecEvalRowNull(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_NULLTEST_ROWISNOTNULL)
        {
            /* out of line implementation: too large */
            ExecEvalRowNotNull(state, op, econtext);
 
            EEO_NEXT();
        }
 
        /* BooleanTest implementations for all booltesttypes */
 
        EEO_CASE(EEOP_BOOLTEST_IS_TRUE)
        {
            if (*op->resnull)
            {
                *op->resvalue = BoolGetDatum(false);
                *op->resnull = false;
            }
            /* else, input value is the correct output as well */
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_BOOLTEST_IS_NOT_TRUE)
        {
            if (*op->resnull)
            {
                *op->resvalue = BoolGetDatum(true);
                *op->resnull = false;
            }
            else
                *op->resvalue = BoolGetDatum(!DatumGetBool(*op->resvalue));
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_BOOLTEST_IS_FALSE)
        {
            if (*op->resnull)
            {
                *op->resvalue = BoolGetDatum(false);
                *op->resnull = false;
            }
            else
                *op->resvalue = BoolGetDatum(!DatumGetBool(*op->resvalue));
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_BOOLTEST_IS_NOT_FALSE)
        {
            if (*op->resnull)
            {
                *op->resvalue = BoolGetDatum(true);
                *op->resnull = false;
            }
            /* else, input value is the correct output as well */
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_PARAM_EXEC)
        {
            /* out of line implementation: too large */
            ExecEvalParamExec(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_PARAM_EXTERN)
        {
            /* out of line implementation: too large */
            ExecEvalParamExtern(state, op, econtext);
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_PARAM_CALLBACK)
        {
            /* allow an extension module to supply a PARAM_EXTERN value */
            op->d.cparam.paramfunc(state, op, econtext);
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_PARAM_SET)
        {
            /* out of line, unlikely to matter performance-wise */
            ExecEvalParamSet(state, op, econtext);
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_CASE_TESTVAL)
        {
            *op->resvalue = *op->d.casetest.value;
            *op->resnull = *op->d.casetest.isnull;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_CASE_TESTVAL_EXT)
        {
            *op->resvalue = econtext->caseValue_datum;
            *op->resnull = econtext->caseValue_isNull;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_MAKE_READONLY)
        {
            /*
             * Force a varlena value that might be read multiple times to R/O
             */
            if (!*op->d.make_readonly.isnull)
                *op->resvalue =
                    MakeExpandedObjectReadOnlyInternal(*op->d.make_readonly.value);
            *op->resnull = *op->d.make_readonly.isnull;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_IOCOERCE)
        {
            /*
             * Evaluate a CoerceViaIO node.  This can be quite a hot path, so
             * inline as much work as possible.  The source value is in our
             * result variable.
             *
             * Also look at ExecEvalCoerceViaIOSafe() if you change anything
             * here.
             */
            char       *str;
 
            /* call output function (similar to OutputFunctionCall) */
            if (*op->resnull)
            {
                /* output functions are not called on nulls */
                str = NULL;
            }
            else
            {
                FunctionCallInfo fcinfo_out;
 
                fcinfo_out = op->d.iocoerce.fcinfo_data_out;
                fcinfo_out->args[0].value = *op->resvalue;
                fcinfo_out->args[0].isnull = false;
 
                fcinfo_out->isnull = false;
                str = DatumGetCString(FunctionCallInvoke(fcinfo_out));
 
                /* OutputFunctionCall assumes result isn't null */
                Assert(!fcinfo_out->isnull);
            }
 
            /* call input function (similar to InputFunctionCall) */
            if (!op->d.iocoerce.finfo_in->fn_strict || str != NULL)
            {
                FunctionCallInfo fcinfo_in;
                Datum       d;
 
                fcinfo_in = op->d.iocoerce.fcinfo_data_in;
                fcinfo_in->args[0].value = PointerGetDatum(str);
                fcinfo_in->args[0].isnull = *op->resnull;
                /* second and third arguments are already set up */
 
                fcinfo_in->isnull = false;
                d = FunctionCallInvoke(fcinfo_in);
                *op->resvalue = d;
 
                /* Should get null result if and only if str is NULL */
                if (str == NULL)
                {
                    Assert(*op->resnull);
                    Assert(fcinfo_in->isnull);
                }
                else
                {
                    Assert(!*op->resnull);
                    Assert(!fcinfo_in->isnull);
                }
            }
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_IOCOERCE_SAFE)
        {
            ExecEvalCoerceViaIOSafe(state, op);
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_DISTINCT)
        {
            /*
             * IS DISTINCT FROM must evaluate arguments (already done into
             * fcinfo->args) to determine whether they are NULL; if either is
             * NULL then the result is determined.  If neither is NULL, then
             * proceed to evaluate the comparison function, which is just the
             * type's standard equality operator.  We need not care whether
             * that function is strict.  Because the handling of nulls is
             * different, we can't just reuse EEOP_FUNCEXPR.
             */
            FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
 
            /* check function arguments for NULLness */
            if (fcinfo->args[0].isnull && fcinfo->args[1].isnull)
            {
                /* Both NULL? Then is not distinct... */
                *op->resvalue = BoolGetDatum(false);
                *op->resnull = false;
            }
            else if (fcinfo->args[0].isnull || fcinfo->args[1].isnull)
            {
                /* Only one is NULL? Then is distinct... */
                *op->resvalue = BoolGetDatum(true);
                *op->resnull = false;
            }
            else
            {
                /* Neither null, so apply the equality function */
                Datum       eqresult;
 
                fcinfo->isnull = false;
                eqresult = op->d.func.fn_addr(fcinfo);
                /* Must invert result of "="; safe to do even if null */
                *op->resvalue = BoolGetDatum(!DatumGetBool(eqresult));
                *op->resnull = fcinfo->isnull;
            }
 
            EEO_NEXT();
        }
 
        /* see EEOP_DISTINCT for comments, this is just inverted */
        EEO_CASE(EEOP_NOT_DISTINCT)
        {
            FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
 
            if (fcinfo->args[0].isnull && fcinfo->args[1].isnull)
            {
                *op->resvalue = BoolGetDatum(true);
                *op->resnull = false;
            }
            else if (fcinfo->args[0].isnull || fcinfo->args[1].isnull)
            {
                *op->resvalue = BoolGetDatum(false);
                *op->resnull = false;
            }
            else
            {
                Datum       eqresult;
 
                fcinfo->isnull = false;
                eqresult = op->d.func.fn_addr(fcinfo);
                *op->resvalue = eqresult;
                *op->resnull = fcinfo->isnull;
            }
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_NULLIF)
        {
            /*
             * The arguments are already evaluated into fcinfo->args.
             */
            FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
            Datum       save_arg0 = fcinfo->args[0].value;
 
            /* if either argument is NULL they can't be equal */
            if (!fcinfo->args[0].isnull && !fcinfo->args[1].isnull)
            {
                Datum       result;
 
                /*
                 * If first argument is of varlena type, it might be an
                 * expanded datum.  We need to ensure that the value passed to
                 * the comparison function is a read-only pointer.  However,
                 * if we end by returning the first argument, that will be the
                 * original read-write pointer if it was read-write.
                 */
                if (op->d.func.make_ro)
                    fcinfo->args[0].value =
                        MakeExpandedObjectReadOnlyInternal(save_arg0);
 
                fcinfo->isnull = false;
                result = op->d.func.fn_addr(fcinfo);
 
                /* if the arguments are equal return null */
                if (!fcinfo->isnull && DatumGetBool(result))
                {
                    *op->resvalue = (Datum) 0;
                    *op->resnull = true;
 
                    EEO_NEXT();
                }
            }
 
            /* Arguments aren't equal, so return the first one */
            *op->resvalue = save_arg0;
            *op->resnull = fcinfo->args[0].isnull;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_SQLVALUEFUNCTION)
        {
            /*
             * Doesn't seem worthwhile to have an inline implementation
             * efficiency-wise.
             */
            ExecEvalSQLValueFunction(state, op);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_CURRENTOFEXPR)
        {
            /* error invocation uses space, and shouldn't ever occur */
            ExecEvalCurrentOfExpr(state, op);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_NEXTVALUEEXPR)
        {
            /*
             * Doesn't seem worthwhile to have an inline implementation
             * efficiency-wise.
             */
            ExecEvalNextValueExpr(state, op);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_RETURNINGEXPR)
        {
            /*
             * The next op actually evaluates the expression.  If the OLD/NEW
             * row doesn't exist, skip that and return NULL.
             */
            if (state->flags & op->d.returningexpr.nullflag)
            {
                *op->resvalue = (Datum) 0;
                *op->resnull = true;
 
                EEO_JUMP(op->d.returningexpr.jumpdone);
            }
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_ARRAYEXPR)
        {
            /* too complex for an inline implementation */
            ExecEvalArrayExpr(state, op);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_ARRAYCOERCE)
        {
            /* too complex for an inline implementation */
            ExecEvalArrayCoerce(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_ROW)
        {
            /* too complex for an inline implementation */
            ExecEvalRow(state, op);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_ROWCOMPARE_STEP)
        {
            FunctionCallInfo fcinfo = op->d.rowcompare_step.fcinfo_data;
            Datum       d;
 
            /* force NULL result if strict fn and NULL input */
            if (op->d.rowcompare_step.finfo->fn_strict &&
                (fcinfo->args[0].isnull || fcinfo->args[1].isnull))
            {
                *op->resnull = true;
                EEO_JUMP(op->d.rowcompare_step.jumpnull);
            }
 
            /* Apply comparison function */
            fcinfo->isnull = false;
            d = op->d.rowcompare_step.fn_addr(fcinfo);
            *op->resvalue = d;
 
            /* force NULL result if NULL function result */
            if (fcinfo->isnull)
            {
                *op->resnull = true;
                EEO_JUMP(op->d.rowcompare_step.jumpnull);
            }
            *op->resnull = false;
 
            /* If unequal, no need to compare remaining columns */
            if (DatumGetInt32(*op->resvalue) != 0)
            {
                EEO_JUMP(op->d.rowcompare_step.jumpdone);
            }
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_ROWCOMPARE_FINAL)
        {
            int32       cmpresult = DatumGetInt32(*op->resvalue);
            CompareType cmptype = op->d.rowcompare_final.cmptype;
 
            *op->resnull = false;
            switch (cmptype)
            {
                    /* EQ and NE cases aren't allowed here */
                case COMPARE_LT:
                    *op->resvalue = BoolGetDatum(cmpresult < 0);
                    break;
                case COMPARE_LE:
                    *op->resvalue = BoolGetDatum(cmpresult <= 0);
                    break;
                case COMPARE_GE:
                    *op->resvalue = BoolGetDatum(cmpresult >= 0);
                    break;
                case COMPARE_GT:
                    *op->resvalue = BoolGetDatum(cmpresult > 0);
                    break;
                default:
                    Assert(false);
                    break;
            }
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_MINMAX)
        {
            /* too complex for an inline implementation */
            ExecEvalMinMax(state, op);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_FIELDSELECT)
        {
            /* too complex for an inline implementation */
            ExecEvalFieldSelect(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_FIELDSTORE_DEFORM)
        {
            /* too complex for an inline implementation */
            ExecEvalFieldStoreDeForm(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_FIELDSTORE_FORM)
        {
            /* too complex for an inline implementation */
            ExecEvalFieldStoreForm(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_SBSREF_SUBSCRIPTS)
        {
            /* Precheck SubscriptingRef subscript(s) */
            if (op->d.sbsref_subscript.subscriptfunc(state, op, econtext))
            {
                EEO_NEXT();
            }
            else
            {
                /* Subscript is null, short-circuit SubscriptingRef to NULL */
                EEO_JUMP(op->d.sbsref_subscript.jumpdone);
            }
        }
 
        EEO_CASE(EEOP_SBSREF_OLD)
            EEO_CASE(EEOP_SBSREF_ASSIGN)
            EEO_CASE(EEOP_SBSREF_FETCH)
        {
            /* Perform a SubscriptingRef fetch or assignment */
            op->d.sbsref.subscriptfunc(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_CONVERT_ROWTYPE)
        {
            /* too complex for an inline implementation */
            ExecEvalConvertRowtype(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_SCALARARRAYOP)
        {
            /* too complex for an inline implementation */
            ExecEvalScalarArrayOp(state, op);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_HASHED_SCALARARRAYOP)
        {
            /* too complex for an inline implementation */
            ExecEvalHashedScalarArrayOp(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_DOMAIN_TESTVAL)
        {
            *op->resvalue = *op->d.casetest.value;
            *op->resnull = *op->d.casetest.isnull;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_DOMAIN_TESTVAL_EXT)
        {
            *op->resvalue = econtext->domainValue_datum;
            *op->resnull = econtext->domainValue_isNull;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_DOMAIN_NOTNULL)
        {
            /* too complex for an inline implementation */
            ExecEvalConstraintNotNull(state, op);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_DOMAIN_CHECK)
        {
            /* too complex for an inline implementation */
            ExecEvalConstraintCheck(state, op);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_HASHDATUM_SET_INITVAL)
        {
            *op->resvalue = op->d.hashdatum_initvalue.init_value;
            *op->resnull = false;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_HASHDATUM_FIRST)
        {
            FunctionCallInfo fcinfo = op->d.hashdatum.fcinfo_data;
 
            /*
             * Save the Datum on non-null inputs, otherwise store 0 so that
             * subsequent NEXT32 operations combine with an initialized value.
             */
            if (!fcinfo->args[0].isnull)
                *op->resvalue = op->d.hashdatum.fn_addr(fcinfo);
            else
                *op->resvalue = (Datum) 0;
 
            *op->resnull = false;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_HASHDATUM_FIRST_STRICT)
        {
            FunctionCallInfo fcinfo = op->d.hashdatum.fcinfo_data;
 
            if (fcinfo->args[0].isnull)
            {
                /*
                 * With strict we have the expression return NULL instead of
                 * ignoring NULL input values.  We've nothing more to do after
                 * finding a NULL.
                 */
                *op->resnull = true;
                *op->resvalue = (Datum) 0;
                EEO_JUMP(op->d.hashdatum.jumpdone);
            }
 
            /* execute the hash function and save the resulting value */
            *op->resvalue = op->d.hashdatum.fn_addr(fcinfo);
            *op->resnull = false;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_HASHDATUM_NEXT32)
        {
            FunctionCallInfo fcinfo = op->d.hashdatum.fcinfo_data;
            uint32      existinghash;
 
            existinghash = DatumGetUInt32(op->d.hashdatum.iresult->value);
            /* combine successive hash values by rotating */
            existinghash = pg_rotate_left32(existinghash, 1);
 
            /* leave the hash value alone on NULL inputs */
            if (!fcinfo->args[0].isnull)
            {
                uint32      hashvalue;
 
                /* execute hash func and combine with previous hash value */
                hashvalue = DatumGetUInt32(op->d.hashdatum.fn_addr(fcinfo));
                existinghash = existinghash ^ hashvalue;
            }
 
            *op->resvalue = UInt32GetDatum(existinghash);
            *op->resnull = false;
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_HASHDATUM_NEXT32_STRICT)
        {
            FunctionCallInfo fcinfo = op->d.hashdatum.fcinfo_data;
 
            if (fcinfo->args[0].isnull)
            {
                /*
                 * With strict we have the expression return NULL instead of
                 * ignoring NULL input values.  We've nothing more to do after
                 * finding a NULL.
                 */
                *op->resnull = true;
                *op->resvalue = (Datum) 0;
                EEO_JUMP(op->d.hashdatum.jumpdone);
            }
            else
            {
                uint32      existinghash;
                uint32      hashvalue;
 
                existinghash = DatumGetUInt32(op->d.hashdatum.iresult->value);
                /* combine successive hash values by rotating */
                existinghash = pg_rotate_left32(existinghash, 1);
 
                /* execute hash func and combine with previous hash value */
                hashvalue = DatumGetUInt32(op->d.hashdatum.fn_addr(fcinfo));
                *op->resvalue = UInt32GetDatum(existinghash ^ hashvalue);
                *op->resnull = false;
            }
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_XMLEXPR)
        {
            /* too complex for an inline implementation */
            ExecEvalXmlExpr(state, op);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_JSON_CONSTRUCTOR)
        {
            /* too complex for an inline implementation */
            ExecEvalJsonConstructor(state, op, econtext);
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_IS_JSON)
        {
            /* too complex for an inline implementation */
            ExecEvalJsonIsPredicate(state, op);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_JSONEXPR_PATH)
        {
            /* too complex for an inline implementation */
            EEO_JUMP(ExecEvalJsonExprPath(state, op, econtext));
        }
 
        EEO_CASE(EEOP_JSONEXPR_COERCION)
        {
            /* too complex for an inline implementation */
            ExecEvalJsonCoercion(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_JSONEXPR_COERCION_FINISH)
        {
            /* too complex for an inline implementation */
            ExecEvalJsonCoercionFinish(state, op);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_AGGREF)
        {
            /*
             * Returns a Datum whose value is the precomputed aggregate value
             * found in the given expression context.
             */
            int         aggno = op->d.aggref.aggno;
 
            Assert(econtext->ecxt_aggvalues != NULL);
 
            *op->resvalue = econtext->ecxt_aggvalues[aggno];
            *op->resnull = econtext->ecxt_aggnulls[aggno];
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_GROUPING_FUNC)
        {
            /* too complex/uncommon for an inline implementation */
            ExecEvalGroupingFunc(state, op);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_WINDOW_FUNC)
        {
            /*
             * Like Aggref, just return a precomputed value from the econtext.
             */
            WindowFuncExprState *wfunc = op->d.window_func.wfstate;
 
            Assert(econtext->ecxt_aggvalues != NULL);
 
            *op->resvalue = econtext->ecxt_aggvalues[wfunc->wfuncno];
            *op->resnull = econtext->ecxt_aggnulls[wfunc->wfuncno];
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_MERGE_SUPPORT_FUNC)
        {
            /* too complex/uncommon for an inline implementation */
            ExecEvalMergeSupportFunc(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_SUBPLAN)
        {
            /* too complex for an inline implementation */
            ExecEvalSubPlan(state, op, econtext);
 
            EEO_NEXT();
        }
 
        /* evaluate a strict aggregate deserialization function */
        EEO_CASE(EEOP_AGG_STRICT_DESERIALIZE)
        {
            /* Don't call a strict deserialization function with NULL input */
            if (op->d.agg_deserialize.fcinfo_data->args[0].isnull)
                EEO_JUMP(op->d.agg_deserialize.jumpnull);
 
            /* fallthrough */
        }
 
        /* evaluate aggregate deserialization function (non-strict portion) */
        EEO_CASE(EEOP_AGG_DESERIALIZE)
        {
            FunctionCallInfo fcinfo = op->d.agg_deserialize.fcinfo_data;
            AggState   *aggstate = castNode(AggState, state->parent);
            MemoryContext oldContext;
 
            /*
             * We run the deserialization functions in per-input-tuple memory
             * context.
             */
            oldContext = MemoryContextSwitchTo(aggstate->tmpcontext->ecxt_per_tuple_memory);
            fcinfo->isnull = false;
            *op->resvalue = FunctionCallInvoke(fcinfo);
            *op->resnull = fcinfo->isnull;
            MemoryContextSwitchTo(oldContext);
 
            EEO_NEXT();
        }
 
        /*
         * Check that a strict aggregate transition / combination function's
         * input is not NULL.
         */
 
        /* when checking more than one argument */
        EEO_CASE(EEOP_AGG_STRICT_INPUT_CHECK_ARGS)
        {
            NullableDatum *args = op->d.agg_strict_input_check.args;
            int         nargs = op->d.agg_strict_input_check.nargs;
 
            Assert(nargs > 1);
 
            for (int argno = 0; argno < nargs; argno++)
            {
                if (args[argno].isnull)
                    EEO_JUMP(op->d.agg_strict_input_check.jumpnull);
            }
            EEO_NEXT();
        }
 
        /* special case for just one argument */
        EEO_CASE(EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1)
        {
            NullableDatum *args = op->d.agg_strict_input_check.args;
            PG_USED_FOR_ASSERTS_ONLY int nargs = op->d.agg_strict_input_check.nargs;
 
            Assert(nargs == 1);
 
            if (args[0].isnull)
                EEO_JUMP(op->d.agg_strict_input_check.jumpnull);
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_AGG_STRICT_INPUT_CHECK_NULLS)
        {
            bool       *nulls = op->d.agg_strict_input_check.nulls;
            int         nargs = op->d.agg_strict_input_check.nargs;
 
            for (int argno = 0; argno < nargs; argno++)
            {
                if (nulls[argno])
                    EEO_JUMP(op->d.agg_strict_input_check.jumpnull);
            }
            EEO_NEXT();
        }
 
        /*
         * Check for a NULL pointer to the per-group states.
         */
 
        EEO_CASE(EEOP_AGG_PLAIN_PERGROUP_NULLCHECK)
        {
            AggState   *aggstate = castNode(AggState, state->parent);
            AggStatePerGroup pergroup_allaggs =
                aggstate->all_pergroups[op->d.agg_plain_pergroup_nullcheck.setoff];
 
            if (pergroup_allaggs == NULL)
                EEO_JUMP(op->d.agg_plain_pergroup_nullcheck.jumpnull);
 
            EEO_NEXT();
        }
 
        /*
         * Different types of aggregate transition functions are implemented
         * as different types of steps, to avoid incurring unnecessary
         * overhead.  There's a step type for each valid combination of having
         * a by value / by reference transition type, [not] needing to the
         * initialize the transition value for the first row in a group from
         * input, and [not] strict transition function.
         *
         * Could optimize further by splitting off by-reference for
         * fixed-length types, but currently that doesn't seem worth it.
         */
 
        EEO_CASE(EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL)
        {
            AggState   *aggstate = castNode(AggState, state->parent);
            AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
            AggStatePerGroup pergroup =
                &aggstate->all_pergroups[op->d.agg_trans.setoff][op->d.agg_trans.transno];
 
            Assert(pertrans->transtypeByVal);
 
            if (pergroup->noTransValue)
            {
                /* If transValue has not yet been initialized, do so now. */
                ExecAggInitGroup(aggstate, pertrans, pergroup,
                                 op->d.agg_trans.aggcontext);
                /* copied trans value from input, done this round */
            }
            else if (likely(!pergroup->transValueIsNull))
            {
                /* invoke transition function, unless prevented by strictness */
                ExecAggPlainTransByVal(aggstate, pertrans, pergroup,
                                       op->d.agg_trans.aggcontext,
                                       op->d.agg_trans.setno);
            }
 
            EEO_NEXT();
        }
 
        /* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */
        EEO_CASE(EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL)
        {
            AggState   *aggstate = castNode(AggState, state->parent);
            AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
            AggStatePerGroup pergroup =
                &aggstate->all_pergroups[op->d.agg_trans.setoff][op->d.agg_trans.transno];
 
            Assert(pertrans->transtypeByVal);
 
            if (likely(!pergroup->transValueIsNull))
                ExecAggPlainTransByVal(aggstate, pertrans, pergroup,
                                       op->d.agg_trans.aggcontext,
                                       op->d.agg_trans.setno);
 
            EEO_NEXT();
        }
 
        /* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */
        EEO_CASE(EEOP_AGG_PLAIN_TRANS_BYVAL)
        {
            AggState   *aggstate = castNode(AggState, state->parent);
            AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
            AggStatePerGroup pergroup =
                &aggstate->all_pergroups[op->d.agg_trans.setoff][op->d.agg_trans.transno];
 
            Assert(pertrans->transtypeByVal);
 
            ExecAggPlainTransByVal(aggstate, pertrans, pergroup,
                                   op->d.agg_trans.aggcontext,
                                   op->d.agg_trans.setno);
 
            EEO_NEXT();
        }
 
        /* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */
        EEO_CASE(EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF)
        {
            AggState   *aggstate = castNode(AggState, state->parent);
            AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
            AggStatePerGroup pergroup =
                &aggstate->all_pergroups[op->d.agg_trans.setoff][op->d.agg_trans.transno];
 
            Assert(!pertrans->transtypeByVal);
 
            if (pergroup->noTransValue)
                ExecAggInitGroup(aggstate, pertrans, pergroup,
                                 op->d.agg_trans.aggcontext);
            else if (likely(!pergroup->transValueIsNull))
                ExecAggPlainTransByRef(aggstate, pertrans, pergroup,
                                       op->d.agg_trans.aggcontext,
                                       op->d.agg_trans.setno);
 
            EEO_NEXT();
        }
 
        /* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */
        EEO_CASE(EEOP_AGG_PLAIN_TRANS_STRICT_BYREF)
        {
            AggState   *aggstate = castNode(AggState, state->parent);
            AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
            AggStatePerGroup pergroup =
                &aggstate->all_pergroups[op->d.agg_trans.setoff][op->d.agg_trans.transno];
 
            Assert(!pertrans->transtypeByVal);
 
            if (likely(!pergroup->transValueIsNull))
                ExecAggPlainTransByRef(aggstate, pertrans, pergroup,
                                       op->d.agg_trans.aggcontext,
                                       op->d.agg_trans.setno);
            EEO_NEXT();
        }
 
        /* see comments above EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL */
        EEO_CASE(EEOP_AGG_PLAIN_TRANS_BYREF)
        {
            AggState   *aggstate = castNode(AggState, state->parent);
            AggStatePerTrans pertrans = op->d.agg_trans.pertrans;
            AggStatePerGroup pergroup =
                &aggstate->all_pergroups[op->d.agg_trans.setoff][op->d.agg_trans.transno];
 
            Assert(!pertrans->transtypeByVal);
 
            ExecAggPlainTransByRef(aggstate, pertrans, pergroup,
                                   op->d.agg_trans.aggcontext,
                                   op->d.agg_trans.setno);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_AGG_PRESORTED_DISTINCT_SINGLE)
        {
            AggStatePerTrans pertrans = op->d.agg_presorted_distinctcheck.pertrans;
            AggState   *aggstate = castNode(AggState, state->parent);
 
            if (ExecEvalPreOrderedDistinctSingle(aggstate, pertrans))
                EEO_NEXT();
            else
                EEO_JUMP(op->d.agg_presorted_distinctcheck.jumpdistinct);
        }
 
        EEO_CASE(EEOP_AGG_PRESORTED_DISTINCT_MULTI)
        {
            AggState   *aggstate = castNode(AggState, state->parent);
            AggStatePerTrans pertrans = op->d.agg_presorted_distinctcheck.pertrans;
 
            if (ExecEvalPreOrderedDistinctMulti(aggstate, pertrans))
                EEO_NEXT();
            else
                EEO_JUMP(op->d.agg_presorted_distinctcheck.jumpdistinct);
        }
 
        /* process single-column ordered aggregate datum */
        EEO_CASE(EEOP_AGG_ORDERED_TRANS_DATUM)
        {
            /* too complex for an inline implementation */
            ExecEvalAggOrderedTransDatum(state, op, econtext);
 
            EEO_NEXT();
        }
 
        /* process multi-column ordered aggregate tuple */
        EEO_CASE(EEOP_AGG_ORDERED_TRANS_TUPLE)
        {
            /* too complex for an inline implementation */
            ExecEvalAggOrderedTransTuple(state, op, econtext);
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_LAST)
        {
            /* unreachable */
            Assert(false);
            goto out_error;
        }
    }
 
out_error:
    pg_unreachable();
    return (Datum) 0;
}

References ExprEvalStep::aggno, ExprEvalStep::args, FunctionCallInfoBaseData::args, Assert, attnum, BoolGetDatum(), ExprContext::caseValue_datum, ExprContext::caseValue_isNull, castNode, CheckOpSlotCompatibility(), ExprEvalStep::cmptype, COMPARE_GE, COMPARE_GT, COMPARE_LE, COMPARE_LT, ExprEvalStep::d, DatumGetBool(), DatumGetCString(), DatumGetInt32(), DatumGetUInt32(), ExprContext::domainValue_datum, ExprContext::domainValue_isNull, ExprContext::ecxt_aggnulls, ExprContext::ecxt_aggvalues, ExprContext::ecxt_innertuple, ExprContext::ecxt_newtuple, ExprContext::ecxt_oldtuple, ExprContext::ecxt_outertuple, ExprContext::ecxt_scantuple, EEO_CASE, EEO_DISPATCH, EEO_JUMP, EEO_NEXT, EEO_SWITCH, EEOP_AGG_DESERIALIZE, EEOP_AGG_ORDERED_TRANS_DATUM, EEOP_AGG_ORDERED_TRANS_TUPLE, EEOP_AGG_PLAIN_PERGROUP_NULLCHECK, EEOP_AGG_PLAIN_TRANS_BYREF, EEOP_AGG_PLAIN_TRANS_BYVAL, EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF, EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL, EEOP_AGG_PLAIN_TRANS_STRICT_BYREF, EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL, EEOP_AGG_PRESORTED_DISTINCT_MULTI, EEOP_AGG_PRESORTED_DISTINCT_SINGLE, EEOP_AGG_STRICT_DESERIALIZE, EEOP_AGG_STRICT_INPUT_CHECK_ARGS, EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1, EEOP_AGG_STRICT_INPUT_CHECK_NULLS, EEOP_AGGREF, EEOP_ARRAYCOERCE, EEOP_ARRAYEXPR, EEOP_ASSIGN_INNER_VAR, EEOP_ASSIGN_NEW_VAR, EEOP_ASSIGN_OLD_VAR, EEOP_ASSIGN_OUTER_VAR, EEOP_ASSIGN_SCAN_VAR, EEOP_ASSIGN_TMP, EEOP_ASSIGN_TMP_MAKE_RO, EEOP_BOOL_AND_STEP, EEOP_BOOL_AND_STEP_FIRST, EEOP_BOOL_AND_STEP_LAST, EEOP_BOOL_NOT_STEP, EEOP_BOOL_OR_STEP, EEOP_BOOL_OR_STEP_FIRST, EEOP_BOOL_OR_STEP_LAST, EEOP_BOOLTEST_IS_FALSE, EEOP_BOOLTEST_IS_NOT_FALSE, EEOP_BOOLTEST_IS_NOT_TRUE, EEOP_BOOLTEST_IS_TRUE, EEOP_CASE_TESTVAL, EEOP_CASE_TESTVAL_EXT, EEOP_CONST, EEOP_CONVERT_ROWTYPE, EEOP_CURRENTOFEXPR, EEOP_DISTINCT, EEOP_DOMAIN_CHECK, EEOP_DOMAIN_NOTNULL, EEOP_DOMAIN_TESTVAL, EEOP_DOMAIN_TESTVAL_EXT, EEOP_DONE_NO_RETURN, EEOP_DONE_RETURN, EEOP_FIELDSELECT, EEOP_FIELDSTORE_DEFORM, EEOP_FIELDSTORE_FORM, EEOP_FUNCEXPR, EEOP_FUNCEXPR_FUSAGE, EEOP_FUNCEXPR_STRICT, EEOP_FUNCEXPR_STRICT_1, EEOP_FUNCEXPR_STRICT_2, EEOP_FUNCEXPR_STRICT_FUSAGE, EEOP_GROUPING_FUNC, EEOP_HASHDATUM_FIRST, EEOP_HASHDATUM_FIRST_STRICT, EEOP_HASHDATUM_NEXT32, EEOP_HASHDATUM_NEXT32_STRICT, EEOP_HASHDATUM_SET_INITVAL, EEOP_HASHED_SCALARARRAYOP, EEOP_INNER_FETCHSOME, EEOP_INNER_SYSVAR, EEOP_INNER_VAR, EEOP_IOCOERCE, EEOP_IOCOERCE_SAFE, EEOP_IS_JSON, EEOP_JSON_CONSTRUCTOR, EEOP_JSONEXPR_COERCION, EEOP_JSONEXPR_COERCION_FINISH, EEOP_JSONEXPR_PATH, EEOP_JUMP, EEOP_JUMP_IF_NOT_NULL, EEOP_JUMP_IF_NOT_TRUE, EEOP_JUMP_IF_NULL, EEOP_LAST, EEOP_MAKE_READONLY, EEOP_MERGE_SUPPORT_FUNC, EEOP_MINMAX, EEOP_NEW_FETCHSOME, EEOP_NEW_SYSVAR, EEOP_NEW_VAR, EEOP_NEXTVALUEEXPR, EEOP_NOT_DISTINCT, EEOP_NULLIF, EEOP_NULLTEST_ISNOTNULL, EEOP_NULLTEST_ISNULL, EEOP_NULLTEST_ROWISNOTNULL, EEOP_NULLTEST_ROWISNULL, EEOP_OLD_FETCHSOME, EEOP_OLD_SYSVAR, EEOP_OLD_VAR, EEOP_OUTER_FETCHSOME, EEOP_OUTER_SYSVAR, EEOP_OUTER_VAR, EEOP_PARAM_CALLBACK, EEOP_PARAM_EXEC, EEOP_PARAM_EXTERN, EEOP_PARAM_SET, EEOP_QUAL, EEOP_RETURNINGEXPR, EEOP_ROW, EEOP_ROWCOMPARE_FINAL, EEOP_ROWCOMPARE_STEP, EEOP_SBSREF_ASSIGN, EEOP_SBSREF_FETCH, EEOP_SBSREF_OLD, EEOP_SBSREF_SUBSCRIPTS, EEOP_SCALARARRAYOP, EEOP_SCAN_FETCHSOME, EEOP_SCAN_SYSVAR, EEOP_SCAN_VAR, EEOP_SQLVALUEFUNCTION, EEOP_SUBPLAN, EEOP_WHOLEROW, EEOP_WINDOW_FUNC, EEOP_XMLEXPR, ExecAggInitGroup(), ExecAggPlainTransByRef(), ExecAggPlainTransByVal(), ExecEvalAggOrderedTransDatum(), ExecEvalAggOrderedTransTuple(), ExecEvalArrayCoerce(), ExecEvalArrayExpr(), ExecEvalCoerceViaIOSafe(), ExecEvalConstraintCheck(), ExecEvalConstraintNotNull(), ExecEvalConvertRowtype(), ExecEvalCurrentOfExpr(), ExecEvalFieldSelect(), ExecEvalFieldStoreDeForm(), ExecEvalFieldStoreForm(), ExecEvalFuncExprFusage(), ExecEvalFuncExprStrictFusage(), ExecEvalGroupingFunc(), ExecEvalHashedScalarArrayOp(), ExecEvalJsonCoercion(), ExecEvalJsonCoercionFinish(), ExecEvalJsonConstructor(), ExecEvalJsonExprPath(), ExecEvalJsonIsPredicate(), ExecEvalMergeSupportFunc(), ExecEvalMinMax(), ExecEvalNextValueExpr(), ExecEvalParamExec(), ExecEvalParamExtern(), ExecEvalParamSet(), ExecEvalPreOrderedDistinctMulti(), ExecEvalPreOrderedDistinctSingle(), ExecEvalRow(), ExecEvalRowNotNull(), ExecEvalRowNull(), ExecEvalScalarArrayOp(), ExecEvalSQLValueFunction(), ExecEvalSubPlan(), ExecEvalSysVar(), ExecEvalWholeRowVar(), ExecEvalXmlExpr(), fb(), FunctionCallInvoke, ExprEvalStep::isnull, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, lengthof, likely, MakeExpandedObjectReadOnlyInternal(), MemoryContextSwitchTo(), ExprEvalStep::nargs, ExprEvalStep::nulls, ExprEvalStep::op, ExprEvalStep::pertrans, pg_rotate_left32(), pg_unreachable, PG_USED_FOR_ASSERTS_ONLY, PointerGetDatum, result, ExprEvalStep::resultnum, slot_getsomeattrs(), StaticAssertDecl, str, AggStatePerTransData::transtypeByVal, TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, UInt32GetDatum(), unlikely, NullableDatum::value, and WindowFuncExprState::wfuncno.

Referenced by ExecInitInterpreter(), and ExecReadyInterpretedExpr().

ExecInterpExprStillValid()

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

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

ExecJustApplyFuncToCase()

static Datum ExecJustApplyFuncToCase ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2641 of file execExprInterp.c.

{
    ExprEvalStep *op = &state->steps[0];
    FunctionCallInfo fcinfo;
    NullableDatum *args;
    int         nargs;
    Datum       d;
 
    /*
     * XXX with some redesign of the CaseTestExpr mechanism, maybe we could
     * get rid of this data shuffling?
     */
    *op->resvalue = *op->d.casetest.value;
    *op->resnull = *op->d.casetest.isnull;
 
    op++;
 
    nargs = op->d.func.nargs;
    fcinfo = op->d.func.fcinfo_data;
    args = fcinfo->args;
 
    /* strict function, so check for NULL args */
    for (int argno = 0; argno < nargs; argno++)
    {
        if (args[argno].isnull)
        {
            *isnull = true;
            return (Datum) 0;
        }
    }
    fcinfo->isnull = false;
    d = op->d.func.fn_addr(fcinfo);
    *isnull = fcinfo->isnull;
    return d;
}

References ExprEvalStep::args, FunctionCallInfoBaseData::args, ExprEvalStep::d, fb(), ExprEvalStep::isnull, FunctionCallInfoBaseData::isnull, ExprEvalStep::nargs, ExprEvalStep::op, and NullableDatum::value.

Referenced by ExecReadyInterpretedExpr().

ExecJustAssignInnerVar()

static Datum ExecJustAssignInnerVar ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2620 of file execExprInterp.c.

{
    return ExecJustAssignVarImpl(state, econtext->ecxt_innertuple, isnull);
}

References ExprContext::ecxt_innertuple, ExecJustAssignVarImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustAssignInnerVarVirt()

static Datum ExecJustAssignInnerVarVirt ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2754 of file execExprInterp.c.

{
    return ExecJustAssignVarVirtImpl(state, econtext->ecxt_innertuple, isnull);
}

References ExprContext::ecxt_innertuple, ExecJustAssignVarVirtImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustAssignOuterVar()

static Datum ExecJustAssignOuterVar ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2627 of file execExprInterp.c.

{
    return ExecJustAssignVarImpl(state, econtext->ecxt_outertuple, isnull);
}

References ExprContext::ecxt_outertuple, ExecJustAssignVarImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustAssignOuterVarVirt()

static Datum ExecJustAssignOuterVarVirt ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2761 of file execExprInterp.c.

{
    return ExecJustAssignVarVirtImpl(state, econtext->ecxt_outertuple, isnull);
}

References ExprContext::ecxt_outertuple, ExecJustAssignVarVirtImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustAssignScanVar()

static Datum ExecJustAssignScanVar ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2634 of file execExprInterp.c.

{
    return ExecJustAssignVarImpl(state, econtext->ecxt_scantuple, isnull);
}

References ExprContext::ecxt_scantuple, ExecJustAssignVarImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustAssignScanVarVirt()

static Datum ExecJustAssignScanVarVirt ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2768 of file execExprInterp.c.

{
    return ExecJustAssignVarVirtImpl(state, econtext->ecxt_scantuple, isnull);
}

References ExprContext::ecxt_scantuple, ExecJustAssignVarVirtImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustAssignVarImpl()

static pg_attribute_always_inline Datum ExecJustAssignVarImpl ( ExprState *  state, TupleTableSlot *  inslot, bool *  isnull  )

static

Definition at line 2594 of file execExprInterp.c.

{
    ExprEvalStep *op = &state->steps[1];
    int         attnum = op->d.assign_var.attnum + 1;
    int         resultnum = op->d.assign_var.resultnum;
    TupleTableSlot *outslot = state->resultslot;
 
    CheckOpSlotCompatibility(&state->steps[0], inslot);
 
    /*
     * We do not need CheckVarSlotCompatibility here; that was taken care of
     * at compilation time.
     *
     * Since we use slot_getattr(), we don't need to implement the FETCHSOME
     * step explicitly, and we also needn't Assert that the attnum is in range
     * --- slot_getattr() will take care of any problems.  Nonetheless, check
     * that resultnum is in range.
     */
    Assert(resultnum >= 0 && resultnum < outslot->tts_tupleDescriptor->natts);
    outslot->tts_values[resultnum] =
        slot_getattr(inslot, attnum, &outslot->tts_isnull[resultnum]);
    return 0;
}

References Assert, attnum, CheckOpSlotCompatibility(), fb(), ExprEvalStep::op, ExprEvalStep::resultnum, and slot_getattr().

Referenced by ExecJustAssignInnerVar(), ExecJustAssignOuterVar(), and ExecJustAssignScanVar().

ExecJustAssignVarVirtImpl()

static pg_attribute_always_inline Datum ExecJustAssignVarVirtImpl ( ExprState *  state, TupleTableSlot *  inslot, bool *  isnull  )

static

Definition at line 2732 of file execExprInterp.c.

{
    ExprEvalStep *op = &state->steps[0];
    int         attnum = op->d.assign_var.attnum;
    int         resultnum = op->d.assign_var.resultnum;
    TupleTableSlot *outslot = state->resultslot;
 
    /* see ExecJustVarVirtImpl for comments */
 
    Assert(TTS_IS_VIRTUAL(inslot));
    Assert(TTS_FIXED(inslot));
    Assert(attnum >= 0 && attnum < inslot->tts_nvalid);
    Assert(resultnum >= 0 && resultnum < outslot->tts_tupleDescriptor->natts);
 
    outslot->tts_values[resultnum] = inslot->tts_values[attnum];
    outslot->tts_isnull[resultnum] = inslot->tts_isnull[attnum];
 
    return 0;
}

References Assert, attnum, fb(), ExprEvalStep::op, ExprEvalStep::resultnum, TTS_FIXED, and TTS_IS_VIRTUAL.

Referenced by ExecJustAssignInnerVarVirt(), ExecJustAssignOuterVarVirt(), and ExecJustAssignScanVarVirt().

ExecJustConst()

static Datum ExecJustConst ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2679 of file execExprInterp.c.

{
    ExprEvalStep *op = &state->steps[0];
 
    *isnull = op->d.constval.isnull;
    return op->d.constval.value;
}

References ExprEvalStep::isnull, and ExprEvalStep::op.

Referenced by ExecReadyInterpretedExpr().

ExecJustHashInnerVar()

static Datum ExecJustHashInnerVar ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2842 of file execExprInterp.c.

{
    return ExecJustHashVarImpl(state, econtext->ecxt_innertuple, isnull);
}

References ExprContext::ecxt_innertuple, ExecJustHashVarImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustHashInnerVarVirt()

static Datum ExecJustHashInnerVarVirt ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2869 of file execExprInterp.c.

{
    return ExecJustHashVarVirtImpl(state, econtext->ecxt_innertuple, isnull);
}

References ExprContext::ecxt_innertuple, ExecJustHashVarVirtImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustHashInnerVarWithIV()

static Datum ExecJustHashInnerVarWithIV ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2777 of file execExprInterp.c.

{
    ExprEvalStep *fetchop = &state->steps[0];
    ExprEvalStep *setivop = &state->steps[1];
    ExprEvalStep *innervar = &state->steps[2];
    ExprEvalStep *hashop = &state->steps[3];
    FunctionCallInfo fcinfo = hashop->d.hashdatum.fcinfo_data;
    int         attnum = innervar->d.var.attnum;
    uint32      hashkey;
 
    CheckOpSlotCompatibility(fetchop, econtext->ecxt_innertuple);
    slot_getsomeattrs(econtext->ecxt_innertuple, fetchop->d.fetch.last_var);
 
    fcinfo->args[0].value = econtext->ecxt_innertuple->tts_values[attnum];
    fcinfo->args[0].isnull = econtext->ecxt_innertuple->tts_isnull[attnum];
 
    hashkey = DatumGetUInt32(setivop->d.hashdatum_initvalue.init_value);
    hashkey = pg_rotate_left32(hashkey, 1);
 
    if (!fcinfo->args[0].isnull)
    {
        uint32      hashvalue;
 
        hashvalue = DatumGetUInt32(hashop->d.hashdatum.fn_addr(fcinfo));
        hashkey = hashkey ^ hashvalue;
    }
 
    *isnull = false;
    return UInt32GetDatum(hashkey);
}

References FunctionCallInfoBaseData::args, attnum, CheckOpSlotCompatibility(), DatumGetUInt32(), ExprContext::ecxt_innertuple, fb(), ExprEvalStep::isnull, NullableDatum::isnull, pg_rotate_left32(), slot_getsomeattrs(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, UInt32GetDatum(), and NullableDatum::value.

Referenced by ExecReadyInterpretedExpr().

ExecJustHashOuterVar()

static Datum ExecJustHashOuterVar ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2835 of file execExprInterp.c.

{
    return ExecJustHashVarImpl(state, econtext->ecxt_outertuple, isnull);
}

References ExprContext::ecxt_outertuple, ExecJustHashVarImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustHashOuterVarStrict()

static Datum ExecJustHashOuterVarStrict ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2887 of file execExprInterp.c.

{
    ExprEvalStep *fetchop = &state->steps[0];
    ExprEvalStep *var = &state->steps[1];
    ExprEvalStep *hashop = &state->steps[2];
    FunctionCallInfo fcinfo = hashop->d.hashdatum.fcinfo_data;
    int         attnum = var->d.var.attnum;
 
    CheckOpSlotCompatibility(fetchop, econtext->ecxt_outertuple);
    slot_getsomeattrs(econtext->ecxt_outertuple, fetchop->d.fetch.last_var);
 
    fcinfo->args[0].value = econtext->ecxt_outertuple->tts_values[attnum];
    fcinfo->args[0].isnull = econtext->ecxt_outertuple->tts_isnull[attnum];
 
    if (!fcinfo->args[0].isnull)
    {
        *isnull = false;
        return hashop->d.hashdatum.fn_addr(fcinfo);
    }
    else
    {
        /* return NULL on NULL input */
        *isnull = true;
        return (Datum) 0;
    }
}

References FunctionCallInfoBaseData::args, attnum, CheckOpSlotCompatibility(), ExprContext::ecxt_outertuple, fb(), ExprEvalStep::isnull, NullableDatum::isnull, slot_getsomeattrs(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, NullableDatum::value, and ExprEvalStep::var.

Referenced by ExecReadyInterpretedExpr().

ExecJustHashOuterVarVirt()

static Datum ExecJustHashOuterVarVirt ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2877 of file execExprInterp.c.

{
    return ExecJustHashVarVirtImpl(state, econtext->ecxt_outertuple, isnull);
}

References ExprContext::ecxt_outertuple, ExecJustHashVarVirtImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustHashVarImpl()

static pg_attribute_always_inline Datum ExecJustHashVarImpl ( ExprState *  state, TupleTableSlot *  slot, bool *  isnull  )

static

Definition at line 2811 of file execExprInterp.c.

{
    ExprEvalStep *fetchop = &state->steps[0];
    ExprEvalStep *var = &state->steps[1];
    ExprEvalStep *hashop = &state->steps[2];
    FunctionCallInfo fcinfo = hashop->d.hashdatum.fcinfo_data;
    int         attnum = var->d.var.attnum;
 
    CheckOpSlotCompatibility(fetchop, slot);
    slot_getsomeattrs(slot, fetchop->d.fetch.last_var);
 
    fcinfo->args[0].value = slot->tts_values[attnum];
    fcinfo->args[0].isnull = slot->tts_isnull[attnum];
 
    *isnull = false;
 
    if (!fcinfo->args[0].isnull)
        return hashop->d.hashdatum.fn_addr(fcinfo);
    else
        return (Datum) 0;
}

References FunctionCallInfoBaseData::args, attnum, CheckOpSlotCompatibility(), fb(), ExprEvalStep::isnull, NullableDatum::isnull, slot_getsomeattrs(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, NullableDatum::value, and ExprEvalStep::var.

Referenced by ExecJustHashInnerVar(), and ExecJustHashOuterVar().

ExecJustHashVarVirtImpl()

static pg_attribute_always_inline Datum ExecJustHashVarVirtImpl ( ExprState *  state, TupleTableSlot *  slot, bool *  isnull  )

static

Definition at line 2849 of file execExprInterp.c.

{
    ExprEvalStep *var = &state->steps[0];
    ExprEvalStep *hashop = &state->steps[1];
    FunctionCallInfo fcinfo = hashop->d.hashdatum.fcinfo_data;
    int         attnum = var->d.var.attnum;
 
    fcinfo->args[0].value = slot->tts_values[attnum];
    fcinfo->args[0].isnull = slot->tts_isnull[attnum];
 
    *isnull = false;
 
    if (!fcinfo->args[0].isnull)
        return hashop->d.hashdatum.fn_addr(fcinfo);
    else
        return (Datum) 0;
}

References FunctionCallInfoBaseData::args, attnum, fb(), ExprEvalStep::isnull, NullableDatum::isnull, TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, NullableDatum::value, and ExprEvalStep::var.

Referenced by ExecJustHashInnerVarVirt(), and ExecJustHashOuterVarVirt().

ExecJustInnerVar()

static Datum ExecJustInnerVar ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2573 of file execExprInterp.c.

{
    return ExecJustVarImpl(state, econtext->ecxt_innertuple, isnull);
}

References ExprContext::ecxt_innertuple, ExecJustVarImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustInnerVarVirt()

static Datum ExecJustInnerVarVirt ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2711 of file execExprInterp.c.

{
    return ExecJustVarVirtImpl(state, econtext->ecxt_innertuple, isnull);
}

References ExprContext::ecxt_innertuple, ExecJustVarVirtImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustOuterVar()

static Datum ExecJustOuterVar ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2580 of file execExprInterp.c.

{
    return ExecJustVarImpl(state, econtext->ecxt_outertuple, isnull);
}

References ExprContext::ecxt_outertuple, ExecJustVarImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustOuterVarVirt()

static Datum ExecJustOuterVarVirt ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2718 of file execExprInterp.c.

{
    return ExecJustVarVirtImpl(state, econtext->ecxt_outertuple, isnull);
}

References ExprContext::ecxt_outertuple, ExecJustVarVirtImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustScanVar()

static Datum ExecJustScanVar ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2587 of file execExprInterp.c.

{
    return ExecJustVarImpl(state, econtext->ecxt_scantuple, isnull);
}

References ExprContext::ecxt_scantuple, ExecJustVarImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustScanVarVirt()

static Datum ExecJustScanVarVirt ( ExprState *  state, ExprContext *  econtext, bool *  isnull  )

static

Definition at line 2725 of file execExprInterp.c.

{
    return ExecJustVarVirtImpl(state, econtext->ecxt_scantuple, isnull);
}

References ExprContext::ecxt_scantuple, ExecJustVarVirtImpl(), and ExprEvalStep::isnull.

Referenced by ExecReadyInterpretedExpr().

ExecJustVarImpl()

static pg_attribute_always_inline Datum ExecJustVarImpl ( ExprState *  state, TupleTableSlot *  slot, bool *  isnull  )

static

Definition at line 2556 of file execExprInterp.c.

{
    ExprEvalStep *op = &state->steps[1];
    int         attnum = op->d.var.attnum + 1;
 
    CheckOpSlotCompatibility(&state->steps[0], slot);
 
    /*
     * Since we use slot_getattr(), we don't need to implement the FETCHSOME
     * step explicitly, and we also needn't Assert that the attnum is in range
     * --- slot_getattr() will take care of any problems.
     */
    return slot_getattr(slot, attnum, isnull);
}

References attnum, CheckOpSlotCompatibility(), ExprEvalStep::isnull, ExprEvalStep::op, and slot_getattr().

Referenced by ExecJustInnerVar(), ExecJustOuterVar(), and ExecJustScanVar().

ExecJustVarVirtImpl()

static pg_attribute_always_inline Datum ExecJustVarVirtImpl ( ExprState *  state, TupleTableSlot *  slot, bool *  isnull  )

static

Definition at line 2689 of file execExprInterp.c.

{
    ExprEvalStep *op = &state->steps[0];
    int         attnum = op->d.var.attnum;
 
    /*
     * As it is guaranteed that a virtual slot is used, there never is a need
     * to perform tuple deforming (nor would it be possible). Therefore
     * execExpr.c has not emitted an EEOP_*_FETCHSOME step. Verify, as much as
     * possible, that that determination was accurate.
     */
    Assert(TTS_IS_VIRTUAL(slot));
    Assert(TTS_FIXED(slot));
    Assert(attnum >= 0 && attnum < slot->tts_nvalid);
 
    *isnull = slot->tts_isnull[attnum];
 
    return slot->tts_values[attnum];
}

References Assert, attnum, fb(), ExprEvalStep::isnull, ExprEvalStep::op, TTS_FIXED, TTS_IS_VIRTUAL, TupleTableSlot::tts_isnull, and TupleTableSlot::tts_values.

Referenced by ExecJustInnerVarVirt(), ExecJustOuterVarVirt(), and ExecJustScanVarVirt().

ExecReadyInterpretedExpr()

void ExecReadyInterpretedExpr

(

ExprState *

state

)

Definition at line 252 of file execExprInterp.c.

{
    /* Ensure one-time interpreter setup has been done */
    ExecInitInterpreter();
 
    /* Simple validity checks on expression */
    Assert(state->steps_len >= 1);
    Assert(state->steps[state->steps_len - 1].opcode == EEOP_DONE_RETURN ||
           state->steps[state->steps_len - 1].opcode == EEOP_DONE_NO_RETURN);
 
    /*
     * Don't perform redundant initialization. This is unreachable in current
     * cases, but might be hit if there's additional expression evaluation
     * methods that rely on interpreted execution to work.
     */
    if (state->flags & EEO_FLAG_INTERPRETER_INITIALIZED)
        return;
 
    /*
     * First time through, check whether attribute matches Var.  Might not be
     * ok anymore, due to schema changes. We do that by setting up a callback
     * that does checking on the first call, which then sets the evalfunc
     * callback to the actual method of execution.
     */
    state->evalfunc = ExecInterpExprStillValid;
 
    /* DIRECT_THREADED should not already be set */
    Assert((state->flags & EEO_FLAG_DIRECT_THREADED) == 0);
 
    /*
     * There shouldn't be any errors before the expression is fully
     * initialized, and even if so, it'd lead to the expression being
     * abandoned.  So we can set the flag now and save some code.
     */
    state->flags |= EEO_FLAG_INTERPRETER_INITIALIZED;
 
    /*
     * Select fast-path evalfuncs for very simple expressions.  "Starting up"
     * the full interpreter is a measurable overhead for these, and these
     * patterns occur often enough to be worth optimizing.
     */
    if (state->steps_len == 5)
    {
        ExprEvalOp  step0 = state->steps[0].opcode;
        ExprEvalOp  step1 = state->steps[1].opcode;
        ExprEvalOp  step2 = state->steps[2].opcode;
        ExprEvalOp  step3 = state->steps[3].opcode;
 
        if (step0 == EEOP_INNER_FETCHSOME &&
            step1 == EEOP_HASHDATUM_SET_INITVAL &&
            step2 == EEOP_INNER_VAR &&
            step3 == EEOP_HASHDATUM_NEXT32)
        {
            state->evalfunc_private = (void *) ExecJustHashInnerVarWithIV;
            return;
        }
    }
    else if (state->steps_len == 4)
    {
        ExprEvalOp  step0 = state->steps[0].opcode;
        ExprEvalOp  step1 = state->steps[1].opcode;
        ExprEvalOp  step2 = state->steps[2].opcode;
 
        if (step0 == EEOP_OUTER_FETCHSOME &&
            step1 == EEOP_OUTER_VAR &&
            step2 == EEOP_HASHDATUM_FIRST)
        {
            state->evalfunc_private = (void *) ExecJustHashOuterVar;
            return;
        }
        else if (step0 == EEOP_INNER_FETCHSOME &&
                 step1 == EEOP_INNER_VAR &&
                 step2 == EEOP_HASHDATUM_FIRST)
        {
            state->evalfunc_private = (void *) ExecJustHashInnerVar;
            return;
        }
        else if (step0 == EEOP_OUTER_FETCHSOME &&
                 step1 == EEOP_OUTER_VAR &&
                 step2 == EEOP_HASHDATUM_FIRST_STRICT)
        {
            state->evalfunc_private = (void *) ExecJustHashOuterVarStrict;
            return;
        }
    }
    else if (state->steps_len == 3)
    {
        ExprEvalOp  step0 = state->steps[0].opcode;
        ExprEvalOp  step1 = state->steps[1].opcode;
 
        if (step0 == EEOP_INNER_FETCHSOME &&
            step1 == EEOP_INNER_VAR)
        {
            state->evalfunc_private = ExecJustInnerVar;
            return;
        }
        else if (step0 == EEOP_OUTER_FETCHSOME &&
                 step1 == EEOP_OUTER_VAR)
        {
            state->evalfunc_private = ExecJustOuterVar;
            return;
        }
        else if (step0 == EEOP_SCAN_FETCHSOME &&
                 step1 == EEOP_SCAN_VAR)
        {
            state->evalfunc_private = ExecJustScanVar;
            return;
        }
        else if (step0 == EEOP_INNER_FETCHSOME &&
                 step1 == EEOP_ASSIGN_INNER_VAR)
        {
            state->evalfunc_private = ExecJustAssignInnerVar;
            return;
        }
        else if (step0 == EEOP_OUTER_FETCHSOME &&
                 step1 == EEOP_ASSIGN_OUTER_VAR)
        {
            state->evalfunc_private = ExecJustAssignOuterVar;
            return;
        }
        else if (step0 == EEOP_SCAN_FETCHSOME &&
                 step1 == EEOP_ASSIGN_SCAN_VAR)
        {
            state->evalfunc_private = ExecJustAssignScanVar;
            return;
        }
        else if (step0 == EEOP_CASE_TESTVAL &&
                 (step1 == EEOP_FUNCEXPR_STRICT ||
                  step1 == EEOP_FUNCEXPR_STRICT_1 ||
                  step1 == EEOP_FUNCEXPR_STRICT_2))
        {
            state->evalfunc_private = ExecJustApplyFuncToCase;
            return;
        }
        else if (step0 == EEOP_INNER_VAR &&
                 step1 == EEOP_HASHDATUM_FIRST)
        {
            state->evalfunc_private = (void *) ExecJustHashInnerVarVirt;
            return;
        }
        else if (step0 == EEOP_OUTER_VAR &&
                 step1 == EEOP_HASHDATUM_FIRST)
        {
            state->evalfunc_private = (void *) ExecJustHashOuterVarVirt;
            return;
        }
    }
    else if (state->steps_len == 2)
    {
        ExprEvalOp  step0 = state->steps[0].opcode;
 
        if (step0 == EEOP_CONST)
        {
            state->evalfunc_private = ExecJustConst;
            return;
        }
        else if (step0 == EEOP_INNER_VAR)
        {
            state->evalfunc_private = ExecJustInnerVarVirt;
            return;
        }
        else if (step0 == EEOP_OUTER_VAR)
        {
            state->evalfunc_private = ExecJustOuterVarVirt;
            return;
        }
        else if (step0 == EEOP_SCAN_VAR)
        {
            state->evalfunc_private = ExecJustScanVarVirt;
            return;
        }
        else if (step0 == EEOP_ASSIGN_INNER_VAR)
        {
            state->evalfunc_private = ExecJustAssignInnerVarVirt;
            return;
        }
        else if (step0 == EEOP_ASSIGN_OUTER_VAR)
        {
            state->evalfunc_private = ExecJustAssignOuterVarVirt;
            return;
        }
        else if (step0 == EEOP_ASSIGN_SCAN_VAR)
        {
            state->evalfunc_private = ExecJustAssignScanVarVirt;
            return;
        }
    }
 
#if defined(EEO_USE_COMPUTED_GOTO)
 
    /*
     * In the direct-threaded implementation, replace each opcode with the
     * address to jump to.  (Use ExecEvalStepOp() to get back the opcode.)
     */
    for (int off = 0; off < state->steps_len; off++)
    {
        ExprEvalStep *op = &state->steps[off];
 
        op->opcode = EEO_OPCODE(op->opcode);
    }
 
    state->flags |= EEO_FLAG_DIRECT_THREADED;
#endif                          /* EEO_USE_COMPUTED_GOTO */
 
    state->evalfunc_private = ExecInterpExpr;
}

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

Referenced by ExecReadyExpr().

get_cached_rowtype()

static TupleDesc get_cached_rowtype ( Oid  type_id, int32  typmod, ExprEvalRowtypeCache *  rowcache, bool *  changed  )

static

Definition at line 2490 of file execExprInterp.c.

{
    if (type_id != RECORDOID)
    {
        /*
         * It's a named composite type, so use the regular typcache.  Do a
         * lookup first time through, or if the composite type changed.  Note:
         * "tupdesc_id == 0" may look redundant, but it protects against the
         * admittedly-theoretical possibility that type_id was RECORDOID the
         * last time through, so that the cacheptr isn't TypeCacheEntry *.
         */
        TypeCacheEntry *typentry = (TypeCacheEntry *) rowcache->cacheptr;
 
        if (unlikely(typentry == NULL ||
                     rowcache->tupdesc_id == 0 ||
                     typentry->tupDesc_identifier != rowcache->tupdesc_id))
        {
            typentry = lookup_type_cache(type_id, TYPECACHE_TUPDESC);
            if (typentry->tupDesc == NULL)
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("type %s is not composite",
                                format_type_be(type_id))));
            rowcache->cacheptr = typentry;
            rowcache->tupdesc_id = typentry->tupDesc_identifier;
            if (changed)
                *changed = true;
        }
        return typentry->tupDesc;
    }
    else
    {
        /*
         * A RECORD type, once registered, doesn't change for the life of the
         * backend.  So we don't need a typcache entry as such, which is good
         * because there isn't one.  It's possible that the caller is asking
         * about a different type than before, though.
         */
        TupleDesc   tupDesc = (TupleDesc) rowcache->cacheptr;
 
        if (unlikely(tupDesc == NULL ||
                     rowcache->tupdesc_id != 0 ||
                     type_id != tupDesc->tdtypeid ||
                     typmod != tupDesc->tdtypmod))
        {
            tupDesc = lookup_rowtype_tupdesc(type_id, typmod);
            /* Drop pin acquired by lookup_rowtype_tupdesc */
            ReleaseTupleDesc(tupDesc);
            rowcache->cacheptr = tupDesc;
            rowcache->tupdesc_id = 0;   /* not a valid value for non-RECORD */
            if (changed)
                *changed = true;
        }
        return tupDesc;
    }
}

References ExprEvalRowtypeCache::cacheptr, ereport, errcode(), errmsg, ERROR, fb(), format_type_be(), lookup_rowtype_tupdesc(), lookup_type_cache(), ReleaseTupleDesc, ExprEvalStep::rowcache, TupleDescData::tdtypeid, TupleDescData::tdtypmod, TypeCacheEntry::tupDesc, ExprEvalRowtypeCache::tupdesc_id, TypeCacheEntry::tupDesc_identifier, TYPECACHE_TUPDESC, and unlikely.

Referenced by ExecEvalConvertRowtype(), ExecEvalFieldSelect(), ExecEvalFieldStoreDeForm(), ExecEvalFieldStoreForm(), and ExecEvalRowNullInt().

GetJsonBehaviorValueString()

static char * GetJsonBehaviorValueString ( JsonBehavior *  behavior )

static

Definition at line 5238 of file execExprInterp.c.

{
    /*
     * The order of array elements must correspond to the order of
     * JsonBehaviorType members.
     */
    const char *behavior_names[] =
    {
        "NULL",
        "ERROR",
        "EMPTY",
        "TRUE",
        "FALSE",
        "UNKNOWN",
        "EMPTY ARRAY",
        "EMPTY OBJECT",
        "DEFAULT"
    };
 
    return pstrdup(behavior_names[behavior->btype]);
}

References JsonBehavior::btype, fb(), and pstrdup().

Referenced by ExecEvalJsonCoercionFinish().

saop_element_hash()

static uint32 saop_element_hash ( struct saophash_hash *  tb, Datum  key  )

static

Definition at line 4207 of file execExprInterp.c.

{
    ScalarArrayOpExprHashTable *elements_tab = (ScalarArrayOpExprHashTable *) tb->private_data;
    FunctionCallInfo fcinfo = &elements_tab->hash_fcinfo_data;
    Datum       hash;
 
    fcinfo->args[0].value = key;
    fcinfo->args[0].isnull = false;
 
    hash = elements_tab->hash_finfo.fn_addr(fcinfo);
 
    return DatumGetUInt32(hash);
}

References FunctionCallInfoBaseData::args, DatumGetUInt32(), ExprEvalStep::elements_tab, fb(), FmgrInfo::fn_addr, hash(), ScalarArrayOpExprHashTable::hash_fcinfo_data, ScalarArrayOpExprHashTable::hash_finfo, NullableDatum::isnull, and NullableDatum::value.

saop_hash_element_match()

static bool saop_hash_element_match ( struct saophash_hash *  tb, Datum  key1, Datum  key2  )

static

Definition at line 4226 of file execExprInterp.c.

{
    Datum       result;
 
    ScalarArrayOpExprHashTable *elements_tab = (ScalarArrayOpExprHashTable *) tb->private_data;
    FunctionCallInfo fcinfo = elements_tab->op->d.hashedscalararrayop.fcinfo_data;
 
    fcinfo->args[0].value = key1;
    fcinfo->args[0].isnull = false;
    fcinfo->args[1].value = key2;
    fcinfo->args[1].isnull = false;
 
    result = elements_tab->op->d.hashedscalararrayop.finfo->fn_addr(fcinfo);
 
    return DatumGetBool(result);
}

References FunctionCallInfoBaseData::args, ExprEvalStep::d, DatumGetBool(), ExprEvalStep::elements_tab, fb(), ExprEvalStep::fcinfo_data, ExprEvalStep::finfo, FmgrInfo::fn_addr, ExprEvalStep::hashedscalararrayop, NullableDatum::isnull, ScalarArrayOpExprHashTable::op, result, and NullableDatum::value.