execExprInterp.c File Reference

#include "postgres.h"
#include "access/heaptoast.h"
#include "catalog/pg_type.h"
#include "commands/sequence.h"
#include "executor/execExpr.h"
#include "executor/nodeSubplan.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "nodes/miscnodes.h"
#include "nodes/nodeFuncs.h"
#include "pgstat.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/date.h"
#include "utils/datum.h"
#include "utils/expandedrecord.h"
#include "utils/json.h"
#include "utils/jsonfuncs.h"
#include "utils/jsonpath.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/timestamp.h"
#include "utils/typcache.h"
#include "utils/xml.h"
#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 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)
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 125 of file execExprInterp.c.

EEO_DISPATCH

#define EEO_DISPATCH

(

)

goto starteval

Definition at line 126 of file execExprInterp.c.

EEO_JUMP

#define EEO_JUMP

(

stepno

)

Value:

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

Definition at line 137 of file execExprInterp.c.

EEO_NEXT

#define EEO_NEXT

(

)

Value:

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

Definition at line 131 of file execExprInterp.c.

EEO_OPCODE

#define EEO_OPCODE

(

opcode

)

(opcode)

Definition at line 127 of file execExprInterp.c.

EEO_SWITCH

#define EEO_SWITCH

(

)

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

Definition at line 124 of file execExprInterp.c.

SH_DECLARE

#define SH_DECLARE

Definition at line 200 of file execExprInterp.c.

SH_DEFINE

#define SH_DEFINE

Definition at line 229 of file execExprInterp.c.

SH_ELEMENT_TYPE [1/2]

#define SH_ELEMENT_TYPE   ScalarArrayOpExprHashEntry

Definition at line 221 of file execExprInterp.c.

SH_ELEMENT_TYPE [2/2]

#define SH_ELEMENT_TYPE   ScalarArrayOpExprHashEntry

Definition at line 221 of file execExprInterp.c.

SH_EQUAL

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

Definition at line 225 of file execExprInterp.c.

SH_GET_HASH

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

Definition at line 228 of file execExprInterp.c.

SH_HASH_KEY

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

Definition at line 224 of file execExprInterp.c.

SH_KEY

#define SH_KEY   key

Definition at line 223 of file execExprInterp.c.

SH_KEY_TYPE [1/2]

#define SH_KEY_TYPE   Datum

Definition at line 222 of file execExprInterp.c.

SH_KEY_TYPE [2/2]

#define SH_KEY_TYPE   Datum

Definition at line 222 of file execExprInterp.c.

SH_PREFIX [1/2]

#define SH_PREFIX   saophash

Definition at line 220 of file execExprInterp.c.

SH_PREFIX [2/2]

#define SH_PREFIX   saophash

Definition at line 220 of file execExprInterp.c.

SH_SCOPE [1/2]

#define SH_SCOPE   static inline

Definition at line 226 of file execExprInterp.c.

SH_SCOPE [2/2]

#define SH_SCOPE   static inline

Definition at line 226 of file execExprInterp.c.

SH_STORE_HASH

#define SH_STORE_HASH

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

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

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

Referenced by ExecInterpExprStillValid(), and ExecRunCompiledExpr().

CheckOpSlotCompatibility()

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

static

Definition at line 2143 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(), and ExecJustVarImpl().

CheckVarSlotCompatibility()

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

static

Definition at line 2092 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);
 
        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, format_type_be(), TupleDescData::natts, TupleDescData::tdtypeid, 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 5195 of file execExprInterp.c.

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

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

Referenced by advance_transition_function(), and ExecAggPlainTransByRef().

ExecAggInitGroup()

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

Definition at line 5142 of file execExprInterp.c.

{
    FunctionCallInfo fcinfo = pertrans->transfn_fcinfo;
    MemoryContext oldContext;
 
    /*
     * We must copy the datum into aggcontext if it is pass-by-ref. We do not
     * need to pfree the old transValue, since it's NULL.  (We already checked
     * that the agg's input type is binary-compatible with its transtype, so
     * straight copy here is OK.)
     */
    oldContext = MemoryContextSwitchTo(aggcontext->ecxt_per_tuple_memory);
    pergroup->transValue = datumCopy(fcinfo->args[1].value,
                                     pertrans->transtypeByVal,
                                     pertrans->transtypeLen);
    pergroup->transValueIsNull = false;
    pergroup->noTransValue = false;
    MemoryContextSwitchTo(oldContext);
}

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

Referenced by ExecInterpExpr().

ExecAggPlainTransByRef()

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

static

Definition at line 5394 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, AggState::curaggcontext, AggState::curpertrans, AggState::current_set, DatumGetPointer(), ExprContext::ecxt_per_tuple_memory, ExecAggCopyTransValue(), FunctionCallInvoke, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, MemoryContextSwitchTo(), ExprEvalStep::pertrans, ExprEvalStep::setno, AggState::tmpcontext, AggStatePerTransData::transfn_fcinfo, AggStatePerGroupData::transValue, AggStatePerGroupData::transValueIsNull, 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 5362 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, AggState::curaggcontext, AggState::curpertrans, AggState::current_set, ExprContext::ecxt_per_tuple_memory, FunctionCallInvoke, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, MemoryContextSwitchTo(), ExprEvalStep::pertrans, ExprEvalStep::setno, AggState::tmpcontext, AggStatePerTransData::transfn_fcinfo, AggStatePerGroupData::transValue, AggStatePerGroupData::transValueIsNull, and NullableDatum::value.

Referenced by ExecInterpExpr().

ExecEvalAggOrderedTransDatum()

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

Definition at line 5334 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 5348 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 3183 of file execExprInterp.c.

{
    Datum       arraydatum;
 
    /* NULL array -> NULL result */
    if (*op->resnull)
        return;
 
    arraydatum = *op->resvalue;
 
    /*
     * If it's binary-compatible, modify the element type in the array header,
     * but otherwise leave the array as we received it.
     */
    if (op->d.arraycoerce.elemexprstate == NULL)
    {
        /* Detoast input array if necessary, and copy in any case */
        ArrayType  *array = DatumGetArrayTypePCopy(arraydatum);
 
        ARR_ELEMTYPE(array) = op->d.arraycoerce.resultelemtype;
        *op->resvalue = PointerGetDatum(array);
        return;
    }
 
    /*
     * Use array_map to apply the sub-expression to each array element.
     */
    *op->resvalue = array_map(arraydatum,
                              op->d.arraycoerce.elemexprstate,
                              econtext,
                              op->d.arraycoerce.resultelemtype,
                              op->d.arraycoerce.amstate);
}

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

Referenced by ExecInterpExpr().

ExecEvalArrayExpr()

void ExecEvalArrayExpr	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 2969 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalCoerceViaIOSafe()

void ExecEvalCoerceViaIOSafe	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 2703 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalConstraintCheck()

void ExecEvalConstraintCheck	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3990 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalConstraintNotNull()

void ExecEvalConstraintNotNull	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3976 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalConvertRowtype()

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

Definition at line 3496 of file execExprInterp.c.

{
    HeapTuple   result;
    Datum       tupDatum;
    HeapTupleHeader tuple;
    HeapTupleData tmptup;
    TupleDesc   indesc,
                outdesc;
    bool        changed = false;
 
    /* NULL in -> NULL out */
    if (*op->resnull)
        return;
 
    tupDatum = *op->resvalue;
    tuple = DatumGetHeapTupleHeader(tupDatum);
 
    /*
     * Lookup tupdescs if first time through or if type changes.  We'd better
     * pin them since type conversion functions could do catalog lookups and
     * hence cause cache invalidation.
     */
    indesc = get_cached_rowtype(op->d.convert_rowtype.inputtype, -1,
                                op->d.convert_rowtype.incache,
                                &changed);
    IncrTupleDescRefCount(indesc);
    outdesc = get_cached_rowtype(op->d.convert_rowtype.outputtype, -1,
                                 op->d.convert_rowtype.outcache,
                                 &changed);
    IncrTupleDescRefCount(outdesc);
 
    /*
     * We used to be able to assert that incoming tuples are marked with
     * exactly the rowtype of indesc.  However, now that ExecEvalWholeRowVar
     * might change the tuples' marking to plain RECORD due to inserting
     * aliases, we can only make this weak test:
     */
    Assert(HeapTupleHeaderGetTypeId(tuple) == indesc->tdtypeid ||
           HeapTupleHeaderGetTypeId(tuple) == RECORDOID);
 
    /* if first time through, or after change, initialize conversion map */
    if (changed)
    {
        MemoryContext old_cxt;
 
        /* allocate map in long-lived memory context */
        old_cxt = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
        /* prepare map from old to new attribute numbers */
        op->d.convert_rowtype.map = convert_tuples_by_name(indesc, outdesc);
 
        MemoryContextSwitchTo(old_cxt);
    }
 
    /* Following steps need a HeapTuple not a bare HeapTupleHeader */
    tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
    tmptup.t_data = tuple;
 
    if (op->d.convert_rowtype.map != NULL)
    {
        /* Full conversion with attribute rearrangement needed */
        result = execute_attr_map_tuple(&tmptup, op->d.convert_rowtype.map);
        /* Result already has appropriate composite-datum header fields */
        *op->resvalue = HeapTupleGetDatum(result);
    }
    else
    {
        /*
         * The tuple is physically compatible as-is, but we need to insert the
         * destination rowtype OID in its composite-datum header field, so we
         * have to copy it anyway.  heap_copy_tuple_as_datum() is convenient
         * for this since it will both make the physical copy and insert the
         * correct composite header fields.  Note that we aren't expecting to
         * have to flatten any toasted fields: the input was a composite
         * datum, so it shouldn't contain any.  So heap_copy_tuple_as_datum()
         * is overkill here, but its check for external fields is cheap.
         */
        *op->resvalue = heap_copy_tuple_as_datum(&tmptup, outdesc);
    }
 
    DecrTupleDescRefCount(indesc);
    DecrTupleDescRefCount(outdesc);
}

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

Referenced by ExecInterpExpr().

ExecEvalCurrentOfExpr()

void ExecEvalCurrentOfExpr	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 2830 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalFieldSelect()

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

Definition at line 3297 of file execExprInterp.c.

{
    AttrNumber  fieldnum = op->d.fieldselect.fieldnum;
    Datum       tupDatum;
    HeapTupleHeader tuple;
    Oid         tupType;
    int32       tupTypmod;
    TupleDesc   tupDesc;
    Form_pg_attribute attr;
    HeapTupleData tmptup;
 
    /* NULL record -> NULL result */
    if (*op->resnull)
        return;
 
    tupDatum = *op->resvalue;
 
    /* We can special-case expanded records for speed */
    if (VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(tupDatum)))
    {
        ExpandedRecordHeader *erh = (ExpandedRecordHeader *) DatumGetEOHP(tupDatum);
 
        Assert(erh->er_magic == ER_MAGIC);
 
        /* Extract record's TupleDesc */
        tupDesc = expanded_record_get_tupdesc(erh);
 
        /*
         * Find field's attr record.  Note we don't support system columns
         * here: a datum tuple doesn't have valid values for most of the
         * interesting system columns anyway.
         */
        if (fieldnum <= 0)      /* should never happen */
            elog(ERROR, "unsupported reference to system column %d in FieldSelect",
                 fieldnum);
        if (fieldnum > tupDesc->natts)  /* should never happen */
            elog(ERROR, "attribute number %d exceeds number of columns %d",
                 fieldnum, tupDesc->natts);
        attr = TupleDescAttr(tupDesc, fieldnum - 1);
 
        /* Check for dropped column, and force a NULL result if so */
        if (attr->attisdropped)
        {
            *op->resnull = true;
            return;
        }
 
        /* Check for type mismatch --- possible after ALTER COLUMN TYPE? */
        /* As in CheckVarSlotCompatibility, we should but can't check typmod */
        if (op->d.fieldselect.resulttype != attr->atttypid)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("attribute %d has wrong type", fieldnum),
                     errdetail("Table has type %s, but query expects %s.",
                               format_type_be(attr->atttypid),
                               format_type_be(op->d.fieldselect.resulttype))));
 
        /* extract the field */
        *op->resvalue = expanded_record_get_field(erh, fieldnum,
                                                  op->resnull);
    }
    else
    {
        /* Get the composite datum and extract its type fields */
        tuple = DatumGetHeapTupleHeader(tupDatum);
 
        tupType = HeapTupleHeaderGetTypeId(tuple);
        tupTypmod = HeapTupleHeaderGetTypMod(tuple);
 
        /* Lookup tupdesc if first time through or if type changes */
        tupDesc = get_cached_rowtype(tupType, tupTypmod,
                                     &op->d.fieldselect.rowcache, NULL);
 
        /*
         * Find field's attr record.  Note we don't support system columns
         * here: a datum tuple doesn't have valid values for most of the
         * interesting system columns anyway.
         */
        if (fieldnum <= 0)      /* should never happen */
            elog(ERROR, "unsupported reference to system column %d in FieldSelect",
                 fieldnum);
        if (fieldnum > tupDesc->natts)  /* should never happen */
            elog(ERROR, "attribute number %d exceeds number of columns %d",
                 fieldnum, tupDesc->natts);
        attr = TupleDescAttr(tupDesc, fieldnum - 1);
 
        /* Check for dropped column, and force a NULL result if so */
        if (attr->attisdropped)
        {
            *op->resnull = true;
            return;
        }
 
        /* Check for type mismatch --- possible after ALTER COLUMN TYPE? */
        /* As in CheckVarSlotCompatibility, we should but can't check typmod */
        if (op->d.fieldselect.resulttype != attr->atttypid)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("attribute %d has wrong type", fieldnum),
                     errdetail("Table has type %s, but query expects %s.",
                               format_type_be(attr->atttypid),
                               format_type_be(op->d.fieldselect.resulttype))));
 
        /* heap_getattr needs a HeapTuple not a bare HeapTupleHeader */
        tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
        tmptup.t_data = tuple;
 
        /* extract the field */
        *op->resvalue = heap_getattr(&tmptup,
                                     fieldnum,
                                     tupDesc,
                                     op->resnull);
    }
}

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

Referenced by ExecInterpExpr().

ExecEvalFieldStoreDeForm()

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

Definition at line 3422 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalFieldStoreForm()

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

Definition at line 3472 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalFuncExprFusage()

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

Definition at line 2558 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalFuncExprStrictFusage()

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

Definition at line 2579 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalGroupingFunc()

void ExecEvalGroupingFunc	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4814 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalHashedScalarArrayOp()

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

Definition at line 3794 of file execExprInterp.c.

{
    ScalarArrayOpExprHashTable *elements_tab = op->d.hashedscalararrayop.elements_tab;
    FunctionCallInfo fcinfo = op->d.hashedscalararrayop.fcinfo_data;
    bool        inclause = op->d.hashedscalararrayop.inclause;
    bool        strictfunc = op->d.hashedscalararrayop.finfo->fn_strict;
    Datum       scalar = fcinfo->args[0].value;
    bool        scalar_isnull = fcinfo->args[0].isnull;
    Datum       result;
    bool        resultnull;
    bool        hashfound;
 
    /* We don't setup a hashed scalar array op if the array const is null. */
    Assert(!*op->resnull);
 
    /*
     * If the scalar is NULL, and the function is strict, return NULL; no
     * point in executing the search.
     */
    if (fcinfo->args[0].isnull && strictfunc)
    {
        *op->resnull = true;
        return;
    }
 
    /* Build the hash table on first evaluation */
    if (elements_tab == NULL)
    {
        ScalarArrayOpExpr *saop;
        int16       typlen;
        bool        typbyval;
        char        typalign;
        int         nitems;
        bool        has_nulls = false;
        char       *s;
        bits8      *bitmap;
        int         bitmask;
        MemoryContext oldcontext;
        ArrayType  *arr;
 
        saop = op->d.hashedscalararrayop.saop;
 
        arr = DatumGetArrayTypeP(*op->resvalue);
        nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr));
 
        get_typlenbyvalalign(ARR_ELEMTYPE(arr),
                             &typlen,
                             &typbyval,
                             &typalign);
 
        oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
        elements_tab = (ScalarArrayOpExprHashTable *)
            palloc0(offsetof(ScalarArrayOpExprHashTable, hash_fcinfo_data) +
                    SizeForFunctionCallInfo(1));
        op->d.hashedscalararrayop.elements_tab = elements_tab;
        elements_tab->op = op;
 
        fmgr_info(saop->hashfuncid, &elements_tab->hash_finfo);
        fmgr_info_set_expr((Node *) saop, &elements_tab->hash_finfo);
 
        InitFunctionCallInfoData(elements_tab->hash_fcinfo_data,
                                 &elements_tab->hash_finfo,
                                 1,
                                 saop->inputcollid,
                                 NULL,
                                 NULL);
 
        /*
         * Create the hash table sizing it according to the number of elements
         * in the array.  This does assume that the array has no duplicates.
         * If the array happens to contain many duplicate values then it'll
         * just mean that we sized the table a bit on the large side.
         */
        elements_tab->hashtab = saophash_create(CurrentMemoryContext, nitems,
                                                elements_tab);
 
        MemoryContextSwitchTo(oldcontext);
 
        s = (char *) ARR_DATA_PTR(arr);
        bitmap = ARR_NULLBITMAP(arr);
        bitmask = 1;
        for (int i = 0; i < nitems; i++)
        {
            /* Get array element, checking for NULL. */
            if (bitmap && (*bitmap & bitmask) == 0)
            {
                has_nulls = true;
            }
            else
            {
                Datum       element;
 
                element = fetch_att(s, typbyval, typlen);
                s = att_addlength_pointer(s, typlen, s);
                s = (char *) att_align_nominal(s, typalign);
 
                saophash_insert(elements_tab->hashtab, element, &hashfound);
            }
 
            /* Advance bitmap pointer if any. */
            if (bitmap)
            {
                bitmask <<= 1;
                if (bitmask == 0x100)
                {
                    bitmap++;
                    bitmask = 1;
                }
            }
        }
 
        /*
         * Remember if we had any nulls so that we know if we need to execute
         * non-strict functions with a null lhs value if no match is found.
         */
        op->d.hashedscalararrayop.has_nulls = has_nulls;
    }
 
    /* Check the hash to see if we have a match. */
    hashfound = NULL != saophash_lookup(elements_tab->hashtab, scalar);
 
    /* the result depends on if the clause is an IN or NOT IN clause */
    if (inclause)
        result = BoolGetDatum(hashfound);   /* IN */
    else
        result = BoolGetDatum(!hashfound);  /* NOT IN */
 
    resultnull = false;
 
    /*
     * If we didn't find a match in the array, we still might need to handle
     * the possibility of null values.  We didn't put any NULLs into the
     * hashtable, but instead marked if we found any when building the table
     * in has_nulls.
     */
    if (!hashfound && op->d.hashedscalararrayop.has_nulls)
    {
        if (strictfunc)
        {
 
            /*
             * We have nulls in the array so a non-null lhs and no match must
             * yield NULL.
             */
            result = (Datum) 0;
            resultnull = true;
        }
        else
        {
            /*
             * Execute function will null rhs just once.
             *
             * The hash lookup path will have scribbled on the lhs argument so
             * we need to set it up also (even though we entered this function
             * with it already set).
             */
            fcinfo->args[0].value = scalar;
            fcinfo->args[0].isnull = scalar_isnull;
            fcinfo->args[1].value = (Datum) 0;
            fcinfo->args[1].isnull = true;
 
            result = op->d.hashedscalararrayop.finfo->fn_addr(fcinfo);
            resultnull = fcinfo->isnull;
 
            /*
             * Reverse the result for NOT IN clauses since the above function
             * is the equality function and we need not-equals.
             */
            if (!inclause)
                result = !result;
        }
    }
 
    *op->resvalue = result;
    *op->resnull = resultnull;
}

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

Referenced by ExecInterpExpr().

ExecEvalJsonCoercion()

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

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

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

Referenced by ExecInterpExpr().

ExecEvalJsonCoercionFinish()

void ExecEvalJsonCoercionFinish	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4760 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalJsonConstructor()

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

Definition at line 4225 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, JsonReturning::format, JsonFormat::format_type, if(), 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, res, JsonConstructorExpr::returning, JsonConstructorExpr::type, JsonConstructorExpr::unique, and value.

Referenced by ExecInterpExpr().

ExecEvalJsonExprPath()

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

Definition at line 4403 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalJsonIsPredicate()

void ExecEvalJsonIsPredicate	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4303 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalMergeSupportFunc()

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

Definition at line 4841 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalMinMax()

void ExecEvalMinMax	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3244 of file execExprInterp.c.

{
    Datum      *values = op->d.minmax.values;
    bool       *nulls = op->d.minmax.nulls;
    FunctionCallInfo fcinfo = op->d.minmax.fcinfo_data;
    MinMaxOp    operator = op->d.minmax.op;
 
    /* set at initialization */
    Assert(fcinfo->args[0].isnull == false);
    Assert(fcinfo->args[1].isnull == false);
 
    /* default to null result */
    *op->resnull = true;
 
    for (int off = 0; off < op->d.minmax.nelems; off++)
    {
        /* ignore NULL inputs */
        if (nulls[off])
            continue;
 
        if (*op->resnull)
        {
            /* first nonnull input, adopt value */
            *op->resvalue = values[off];
            *op->resnull = false;
        }
        else
        {
            int         cmpresult;
 
            /* apply comparison function */
            fcinfo->args[0].value = *op->resvalue;
            fcinfo->args[1].value = values[off];
 
            fcinfo->isnull = false;
            cmpresult = DatumGetInt32(FunctionCallInvoke(fcinfo));
            if (fcinfo->isnull) /* probably should not happen */
                continue;
 
            if (cmpresult > 0 && operator == IS_LEAST)
                *op->resvalue = values[off];
            else if (cmpresult < 0 && operator == IS_GREATEST)
                *op->resvalue = values[off];
        }
    }
}

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

Referenced by ExecInterpExpr().

ExecEvalNextValueExpr()

void ExecEvalNextValueExpr	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 2841 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalParamExec()

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

Definition at line 2616 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalParamExtern()

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

Definition at line 2638 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalParamSet()

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

Definition at line 2681 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalPreOrderedDistinctMulti()

bool ExecEvalPreOrderedDistinctMulti	(	AggState *	aggstate,
		AggStatePerTrans	pertrans
	)

Definition at line 5287 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalPreOrderedDistinctSingle()

bool ExecEvalPreOrderedDistinctSingle	(	AggState *	aggstate,
		AggStatePerTrans	pertrans
	)

Definition at line 5244 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalRow()

void ExecEvalRow	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3224 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 2876 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 2867 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 2883 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 (TupleDescAttr(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, get_cached_rowtype(), heap_attisnull(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, ExprEvalStep::isnull, TupleDescData::natts, ExprEvalStep::op, HeapTupleData::t_data, HeapTupleData::t_len, TupleDescAttr, and value.

Referenced by ExecEvalRowNotNull(), and ExecEvalRowNull().

ExecEvalScalarArrayOp()

void ExecEvalScalarArrayOp	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 3591 of file execExprInterp.c.

{
    FunctionCallInfo fcinfo = op->d.scalararrayop.fcinfo_data;
    bool        useOr = op->d.scalararrayop.useOr;
    bool        strictfunc = op->d.scalararrayop.finfo->fn_strict;
    ArrayType  *arr;
    int         nitems;
    Datum       result;
    bool        resultnull;
    int16       typlen;
    bool        typbyval;
    char        typalign;
    char       *s;
    bits8      *bitmap;
    int         bitmask;
 
    /*
     * If the array is NULL then we return NULL --- it's not very meaningful
     * to do anything else, even if the operator isn't strict.
     */
    if (*op->resnull)
        return;
 
    /* Else okay to fetch and detoast the array */
    arr = DatumGetArrayTypeP(*op->resvalue);
 
    /*
     * If the array is empty, we return either FALSE or TRUE per the useOr
     * flag.  This is correct even if the scalar is NULL; since we would
     * evaluate the operator zero times, it matters not whether it would want
     * to return NULL.
     */
    nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr));
    if (nitems <= 0)
    {
        *op->resvalue = BoolGetDatum(!useOr);
        *op->resnull = false;
        return;
    }
 
    /*
     * If the scalar is NULL, and the function is strict, return NULL; no
     * point in iterating the loop.
     */
    if (fcinfo->args[0].isnull && strictfunc)
    {
        *op->resnull = true;
        return;
    }
 
    /*
     * We arrange to look up info about the element type only once per series
     * of calls, assuming the element type doesn't change underneath us.
     */
    if (op->d.scalararrayop.element_type != ARR_ELEMTYPE(arr))
    {
        get_typlenbyvalalign(ARR_ELEMTYPE(arr),
                             &op->d.scalararrayop.typlen,
                             &op->d.scalararrayop.typbyval,
                             &op->d.scalararrayop.typalign);
        op->d.scalararrayop.element_type = ARR_ELEMTYPE(arr);
    }
 
    typlen = op->d.scalararrayop.typlen;
    typbyval = op->d.scalararrayop.typbyval;
    typalign = op->d.scalararrayop.typalign;
 
    /* Initialize result appropriately depending on useOr */
    result = BoolGetDatum(!useOr);
    resultnull = false;
 
    /* Loop over the array elements */
    s = (char *) ARR_DATA_PTR(arr);
    bitmap = ARR_NULLBITMAP(arr);
    bitmask = 1;
 
    for (int i = 0; i < nitems; i++)
    {
        Datum       elt;
        Datum       thisresult;
 
        /* Get array element, checking for NULL */
        if (bitmap && (*bitmap & bitmask) == 0)
        {
            fcinfo->args[1].value = (Datum) 0;
            fcinfo->args[1].isnull = true;
        }
        else
        {
            elt = fetch_att(s, typbyval, typlen);
            s = att_addlength_pointer(s, typlen, s);
            s = (char *) att_align_nominal(s, typalign);
            fcinfo->args[1].value = elt;
            fcinfo->args[1].isnull = false;
        }
 
        /* Call comparison function */
        if (fcinfo->args[1].isnull && strictfunc)
        {
            fcinfo->isnull = true;
            thisresult = (Datum) 0;
        }
        else
        {
            fcinfo->isnull = false;
            thisresult = op->d.scalararrayop.fn_addr(fcinfo);
        }
 
        /* Combine results per OR or AND semantics */
        if (fcinfo->isnull)
            resultnull = true;
        else if (useOr)
        {
            if (DatumGetBool(thisresult))
            {
                result = BoolGetDatum(true);
                resultnull = false;
                break;          /* needn't look at any more elements */
            }
        }
        else
        {
            if (!DatumGetBool(thisresult))
            {
                result = BoolGetDatum(false);
                resultnull = false;
                break;          /* needn't look at any more elements */
            }
        }
 
        /* advance bitmap pointer if any */
        if (bitmap)
        {
            bitmask <<= 1;
            if (bitmask == 0x100)
            {
                bitmap++;
                bitmask = 1;
            }
        }
    }
 
    *op->resvalue = result;
    *op->resnull = resultnull;
}

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

Referenced by ExecInterpExpr().

ExecEvalSQLValueFunction()

void ExecEvalSQLValueFunction	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 2763 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalStepOp()

ExprEvalOp ExecEvalStepOp	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 2528 of file execExprInterp.c.

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

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

Referenced by CheckExprStillValid().

ExecEvalSubPlan()

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

Definition at line 4878 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalSysVar()

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

Definition at line 5122 of file execExprInterp.c.

{
    Datum       d;
 
    /* slot_getsysattr has sufficient defenses against bad attnums */
    d = slot_getsysattr(slot,
                        op->d.var.attnum,
                        op->resnull);
    *op->resvalue = d;
    /* this ought to be unreachable, but it's cheap enough to check */
    if (unlikely(*op->resnull))
        elog(ERROR, "failed to fetch attribute from slot");
}

References ExprEvalStep::d, elog, ERROR, ExprEvalStep::op, slot_getsysattr(), and unlikely.

Referenced by ExecInterpExpr().

ExecEvalWholeRowVar()

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

Definition at line 4895 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecEvalXmlExpr()

void ExecEvalXmlExpr	(	ExprState *	state,
		ExprEvalStep *	op
	)

Definition at line 4010 of file execExprInterp.c.

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

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

Referenced by ExecInterpExpr().

ExecGetJsonValueItemString()

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

static

Definition at line 4605 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, jbvArray, jbvBinary, jbvBool, jbvDatetime, jbvNull, jbvNumeric, jbvObject, jbvString, jsonb_out(), JsonbPGetDatum(), JsonbValueToJsonb(), 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 2496 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(), i, and qsort.

Referenced by ExecReadyInterpretedExpr().

ExecInterpExpr()

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

static

Definition at line 396 of file execExprInterp.c.

{
    ExprEvalStep *op;
    TupleTableSlot *resultslot;
    TupleTableSlot *innerslot;
    TupleTableSlot *outerslot;
    TupleTableSlot *scanslot;
 
    /*
     * 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,
        &&CASE_EEOP_INNER_FETCHSOME,
        &&CASE_EEOP_OUTER_FETCHSOME,
        &&CASE_EEOP_SCAN_FETCHSOME,
        &&CASE_EEOP_INNER_VAR,
        &&CASE_EEOP_OUTER_VAR,
        &&CASE_EEOP_SCAN_VAR,
        &&CASE_EEOP_INNER_SYSVAR,
        &&CASE_EEOP_OUTER_SYSVAR,
        &&CASE_EEOP_SCAN_SYSVAR,
        &&CASE_EEOP_WHOLEROW,
        &&CASE_EEOP_ASSIGN_INNER_VAR,
        &&CASE_EEOP_ASSIGN_OUTER_VAR,
        &&CASE_EEOP_ASSIGN_SCAN_VAR,
        &&CASE_EEOP_ASSIGN_TMP,
        &&CASE_EEOP_ASSIGN_TMP_MAKE_RO,
        &&CASE_EEOP_CONST,
        &&CASE_EEOP_FUNCEXPR,
        &&CASE_EEOP_FUNCEXPR_STRICT,
        &&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_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_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_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_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;
 
#if defined(EEO_USE_COMPUTED_GOTO)
    EEO_DISPATCH();
#endif
 
    EEO_SWITCH()
    {
        EEO_CASE(EEOP_DONE)
        {
            goto out;
        }
 
        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_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_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_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_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();
        }
 
        EEO_CASE(EEOP_FUNCEXPR_STRICT)
        {
            FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
            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;
                    goto strictfail;
                }
            }
            fcinfo->isnull = false;
            d = op->d.func.fn_addr(fcinfo);
            *op->resvalue = d;
            *op->resnull = fcinfo->isnull;
 
    strictfail:
            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)
        {
            /*
             * Normally upper parts of the expression tree have setup the
             * values to be returned here, but some parts of the system
             * currently misuse {caseValue,domainValue}_{datum,isNull} to set
             * run-time data.  So if no values have been set-up, use
             * ExprContext's.  This isn't pretty, but also not *that* ugly,
             * and this is unlikely to be performance sensitive enough to
             * worry about an extra branch.
             */
            if (op->d.casetest.value)
            {
                *op->resvalue = *op->d.casetest.value;
                *op->resnull = *op->d.casetest.isnull;
            }
            else
            {
                *op->resvalue = econtext->caseValue_datum;
                *op->resnull = econtext->caseValue_isNull;
            }
 
            EEO_NEXT();
        }
 
        EEO_CASE(EEOP_DOMAIN_TESTVAL)
        {
            /*
             * See EEOP_CASE_TESTVAL comment.
             */
            if (op->d.casetest.value)
            {
                *op->resvalue = *op->d.casetest.value;
                *op->resnull = *op->d.casetest.isnull;
            }
            else
            {
                *op->resvalue = econtext->domainValue_datum;
                *op->resnull = econtext->domainValue_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();
        }