/src/postgres/src/backend/executor/execExpr.c

Source
/*-------------------------------------------------------------------------
 *
 * execExpr.c
 *    Expression evaluation infrastructure.
 *
 *  During executor startup, we compile each expression tree (which has
 *  previously been processed by the parser and planner) into an ExprState,
 *  using ExecInitExpr() et al.  This converts the tree into a flat array
 *  of ExprEvalSteps, which may be thought of as instructions in a program.
 *  At runtime, we'll execute steps, starting with the first, until we reach
 *  an EEOP_DONE_{RETURN|NO_RETURN} opcode.
 *
 *  This file contains the "compilation" logic.  It is independent of the
 *  specific execution technology we use (switch statement, computed goto,
 *  JIT compilation, etc).
 *
 *  See src/backend/executor/README for some background, specifically the
 *  "Expression Trees and ExprState nodes", "Expression Initialization",
 *  and "Expression Evaluation" sections.
 *
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    src/backend/executor/execExpr.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include "access/nbtree.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "executor/execExpr.h"
#include "executor/nodeSubplan.h"
#include "funcapi.h"
#include "jit/jit.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "nodes/subscripting.h"
#include "optimizer/optimizer.h"
#include "pgstat.h"
#include "utils/acl.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/jsonfuncs.h"
#include "utils/jsonpath.h"
#include "utils/lsyscache.h"
#include "utils/typcache.h"


typedef struct ExprSetupInfo
{
  /*
   * Highest attribute numbers fetched from inner/outer/scan/old/new tuple
   * slots:
   */
  AttrNumber  last_inner;
  AttrNumber  last_outer;
  AttrNumber  last_scan;
  AttrNumber  last_old;
  AttrNumber  last_new;
  /* MULTIEXPR SubPlan nodes appearing in the expression: */
  List     *multiexpr_subplans;
} ExprSetupInfo;

static void ExecReadyExpr(ExprState *state);
static void ExecInitExprRec(Expr *node, ExprState *state,
              Datum *resv, bool *resnull);
static void ExecInitFunc(ExprEvalStep *scratch, Expr *node, List *args,
             Oid funcid, Oid inputcollid,
             ExprState *state);
static void ExecInitSubPlanExpr(SubPlan *subplan,
                ExprState *state,
                Datum *resv, bool *resnull);
static void ExecCreateExprSetupSteps(ExprState *state, Node *node);
static void ExecPushExprSetupSteps(ExprState *state, ExprSetupInfo *info);
static bool expr_setup_walker(Node *node, ExprSetupInfo *info);
static bool ExecComputeSlotInfo(ExprState *state, ExprEvalStep *op);
static void ExecInitWholeRowVar(ExprEvalStep *scratch, Var *variable,
                ExprState *state);
static void ExecInitSubscriptingRef(ExprEvalStep *scratch,
                  SubscriptingRef *sbsref,
                  ExprState *state,
                  Datum *resv, bool *resnull);
static bool isAssignmentIndirectionExpr(Expr *expr);
static void ExecInitCoerceToDomain(ExprEvalStep *scratch, CoerceToDomain *ctest,
                   ExprState *state,
                   Datum *resv, bool *resnull);
static void ExecBuildAggTransCall(ExprState *state, AggState *aggstate,
                  ExprEvalStep *scratch,
                  FunctionCallInfo fcinfo, AggStatePerTrans pertrans,
                  int transno, int setno, int setoff, bool ishash,
                  bool nullcheck);
static void ExecInitJsonExpr(JsonExpr *jsexpr, ExprState *state,
               Datum *resv, bool *resnull,
               ExprEvalStep *scratch);
static void ExecInitJsonCoercion(ExprState *state, JsonReturning *returning,
                 ErrorSaveContext *escontext, bool omit_quotes,
                 bool exists_coerce,
                 Datum *resv, bool *resnull);


/*
 * ExecInitExpr: prepare an expression tree for execution
 *
 * This function builds and returns an ExprState implementing the given
 * Expr node tree.  The return ExprState can then be handed to ExecEvalExpr
 * for execution.  Because the Expr tree itself is read-only as far as
 * ExecInitExpr and ExecEvalExpr are concerned, several different executions
 * of the same plan tree can occur concurrently.  (But note that an ExprState
 * does mutate at runtime, so it can't be re-used concurrently.)
 *
 * This must be called in a memory context that will last as long as repeated
 * executions of the expression are needed.  Typically the context will be
 * the same as the per-query context of the associated ExprContext.
 *
 * Any Aggref, WindowFunc, or SubPlan nodes found in the tree are added to
 * the lists of such nodes held by the parent PlanState.
 *
 * Note: there is no ExecEndExpr function; we assume that any resource
 * cleanup needed will be handled by just releasing the memory context
 * in which the state tree is built.  Functions that require additional
 * cleanup work can register a shutdown callback in the ExprContext.
 *
 *  'node' is the root of the expression tree to compile.
 *  'parent' is the PlanState node that owns the expression.
 *
 * 'parent' may be NULL if we are preparing an expression that is not
 * associated with a plan tree.  (If so, it can't have aggs or subplans.)
 * Such cases should usually come through ExecPrepareExpr, not directly here.
 *
 * Also, if 'node' is NULL, we just return NULL.  This is convenient for some
 * callers that may or may not have an expression that needs to be compiled.
 * Note that a NULL ExprState pointer *cannot* be handed to ExecEvalExpr,
 * although ExecQual and ExecCheck will accept one (and treat it as "true").
 */
ExprState *
ExecInitExpr(Expr *node, PlanState *parent)
{
  ExprState  *state;
  ExprEvalStep scratch = {0};

  /* Special case: NULL expression produces a NULL ExprState pointer */
  if (node == NULL)
    return NULL;

  /* Initialize ExprState with empty step list */
  state = makeNode(ExprState);
  state->expr = node;
  state->parent = parent;
  state->ext_params = NULL;

  /* Insert setup steps as needed */
  ExecCreateExprSetupSteps(state, (Node *) node);

  /* Compile the expression proper */
  ExecInitExprRec(node, state, &state->resvalue, &state->resnull);

  /* Finally, append a DONE step */
  scratch.opcode = EEOP_DONE_RETURN;
  ExprEvalPushStep(state, &scratch);

  ExecReadyExpr(state);

  return state;
}

/*
 * ExecInitExprWithParams: prepare a standalone expression tree for execution
 *
 * This is the same as ExecInitExpr, except that there is no parent PlanState,
 * and instead we may have a ParamListInfo describing PARAM_EXTERN Params.
 */
ExprState *
ExecInitExprWithParams(Expr *node, ParamListInfo ext_params)
{
  ExprState  *state;
  ExprEvalStep scratch = {0};

  /* Special case: NULL expression produces a NULL ExprState pointer */
  if (node == NULL)
    return NULL;

  /* Initialize ExprState with empty step list */
  state = makeNode(ExprState);
  state->expr = node;
  state->parent = NULL;
  state->ext_params = ext_params;

  /* Insert setup steps as needed */
  ExecCreateExprSetupSteps(state, (Node *) node);

  /* Compile the expression proper */
  ExecInitExprRec(node, state, &state->resvalue, &state->resnull);

  /* Finally, append a DONE step */
  scratch.opcode = EEOP_DONE_RETURN;
  ExprEvalPushStep(state, &scratch);

  ExecReadyExpr(state);

  return state;
}

/*
 * ExecInitQual: prepare a qual for execution by ExecQual
 *
 * Prepares for the evaluation of a conjunctive boolean expression (qual list
 * with implicit AND semantics) that returns true if none of the
 * subexpressions are false.
 *
 * We must return true if the list is empty.  Since that's a very common case,
 * we optimize it a bit further by translating to a NULL ExprState pointer
 * rather than setting up an ExprState that computes constant TRUE.  (Some
 * especially hot-spot callers of ExecQual detect this and avoid calling
 * ExecQual at all.)
 *
 * If any of the subexpressions yield NULL, then the result of the conjunction
 * is false.  This makes ExecQual primarily useful for evaluating WHERE
 * clauses, since SQL specifies that tuples with null WHERE results do not
 * get selected.
 */
ExprState *
ExecInitQual(List *qual, PlanState *parent)
{
  ExprState  *state;
  ExprEvalStep scratch = {0};
  List     *adjust_jumps = NIL;

  /* short-circuit (here and in ExecQual) for empty restriction list */
  if (qual == NIL)
    return NULL;

  Assert(IsA(qual, List));

  state = makeNode(ExprState);
  state->expr = (Expr *) qual;
  state->parent = parent;
  state->ext_params = NULL;

  /* mark expression as to be used with ExecQual() */
  state->flags = EEO_FLAG_IS_QUAL;

  /* Insert setup steps as needed */
  ExecCreateExprSetupSteps(state, (Node *) qual);

  /*
   * ExecQual() needs to return false for an expression returning NULL. That
   * allows us to short-circuit the evaluation the first time a NULL is
   * encountered.  As qual evaluation is a hot-path this warrants using a
   * special opcode for qual evaluation that's simpler than BOOL_AND (which
   * has more complex NULL handling).
   */
  scratch.opcode = EEOP_QUAL;

  /*
   * We can use ExprState's resvalue/resnull as target for each qual expr.
   */
  scratch.resvalue = &state->resvalue;
  scratch.resnull = &state->resnull;

  foreach_ptr(Expr, node, qual)
  {
    /* first evaluate expression */
    ExecInitExprRec(node, state, &state->resvalue, &state->resnull);

    /* then emit EEOP_QUAL to detect if it's false (or null) */
    scratch.d.qualexpr.jumpdone = -1;
    ExprEvalPushStep(state, &scratch);
    adjust_jumps = lappend_int(adjust_jumps,
                   state->steps_len - 1);
  }

  /* adjust jump targets */
  foreach_int(jump, adjust_jumps)
  {
    ExprEvalStep *as = &state->steps[jump];

    Assert(as->opcode == EEOP_QUAL);
    Assert(as->d.qualexpr.jumpdone == -1);
    as->d.qualexpr.jumpdone = state->steps_len;
  }

  /*
   * At the end, we don't need to do anything more.  The last qual expr must
   * have yielded TRUE, and since its result is stored in the desired output
   * location, we're done.
   */
  scratch.opcode = EEOP_DONE_RETURN;
  ExprEvalPushStep(state, &scratch);

  ExecReadyExpr(state);

  return state;
}

/*
 * ExecInitCheck: prepare a check constraint for execution by ExecCheck
 *
 * This is much like ExecInitQual/ExecQual, except that a null result from
 * the conjunction is treated as TRUE.  This behavior is appropriate for
 * evaluating CHECK constraints, since SQL specifies that NULL constraint
 * conditions are not failures.
 *
 * Note that like ExecInitQual, this expects input in implicit-AND format.
 * Users of ExecCheck that have expressions in normal explicit-AND format
 * can just apply ExecInitExpr to produce suitable input for ExecCheck.
 */
ExprState *
ExecInitCheck(List *qual, PlanState *parent)
{
  /* short-circuit (here and in ExecCheck) for empty restriction list */
  if (qual == NIL)
    return NULL;

  Assert(IsA(qual, List));

  /*
   * Just convert the implicit-AND list to an explicit AND (if there's more
   * than one entry), and compile normally.  Unlike ExecQual, we can't
   * short-circuit on NULL results, so the regular AND behavior is needed.
   */
  return ExecInitExpr(make_ands_explicit(qual), parent);
}

/*
 * Call ExecInitExpr() on a list of expressions, return a list of ExprStates.
 */
List *
ExecInitExprList(List *nodes, PlanState *parent)
{
  List     *result = NIL;
  ListCell   *lc;

  foreach(lc, nodes)
  {
    Expr     *e = lfirst(lc);

    result = lappend(result, ExecInitExpr(e, parent));
  }

  return result;
}

/*
 *    ExecBuildProjectionInfo
 *
 * Build a ProjectionInfo node for evaluating the given tlist in the given
 * econtext, and storing the result into the tuple slot.  (Caller must have
 * ensured that tuple slot has a descriptor matching the tlist!)
 *
 * inputDesc can be NULL, but if it is not, we check to see whether simple
 * Vars in the tlist match the descriptor.  It is important to provide
 * inputDesc for relation-scan plan nodes, as a cross check that the relation
 * hasn't been changed since the plan was made.  At higher levels of a plan,
 * there is no need to recheck.
 *
 * This is implemented by internally building an ExprState that performs the
 * whole projection in one go.
 *
 * Caution: before PG v10, the targetList was a list of ExprStates; now it
 * should be the planner-created targetlist, since we do the compilation here.
 */
ProjectionInfo *
ExecBuildProjectionInfo(List *targetList,
            ExprContext *econtext,
            TupleTableSlot *slot,
            PlanState *parent,
            TupleDesc inputDesc)
{
  ProjectionInfo *projInfo = makeNode(ProjectionInfo);
  ExprState  *state;
  ExprEvalStep scratch = {0};
  ListCell   *lc;

  projInfo->pi_exprContext = econtext;
  /* We embed ExprState into ProjectionInfo instead of doing extra palloc */
  projInfo->pi_state.type = T_ExprState;
  state = &projInfo->pi_state;
  state->expr = (Expr *) targetList;
  state->parent = parent;
  state->ext_params = NULL;

  state->resultslot = slot;

  /* Insert setup steps as needed */
  ExecCreateExprSetupSteps(state, (Node *) targetList);

  /* Now compile each tlist column */
  foreach(lc, targetList)
  {
    TargetEntry *tle = lfirst_node(TargetEntry, lc);
    Var      *variable = NULL;
    AttrNumber  attnum = 0;
    bool    isSafeVar = false;

    /*
     * If tlist expression is a safe non-system Var, use the fast-path
     * ASSIGN_*_VAR opcodes.  "Safe" means that we don't need to apply
     * CheckVarSlotCompatibility() during plan startup.  If a source slot
     * was provided, we make the equivalent tests here; if a slot was not
     * provided, we assume that no check is needed because we're dealing
     * with a non-relation-scan-level expression.
     */
    if (tle->expr != NULL &&
      IsA(tle->expr, Var) &&
      ((Var *) tle->expr)->varattno > 0)
    {
      /* Non-system Var, but how safe is it? */
      variable = (Var *) tle->expr;
      attnum = variable->varattno;

      if (inputDesc == NULL)
        isSafeVar = true; /* can't check, just assume OK */
      else if (attnum <= inputDesc->natts)
      {
        Form_pg_attribute attr = TupleDescAttr(inputDesc, attnum - 1);

        /*
         * If user attribute is dropped or has a type mismatch, don't
         * use ASSIGN_*_VAR.  Instead let the normal expression
         * machinery handle it (which'll possibly error out).
         */
        if (!attr->attisdropped && variable->vartype == attr->atttypid)
        {
          isSafeVar = true;
        }
      }
    }

    if (isSafeVar)
    {
      /* Fast-path: just generate an EEOP_ASSIGN_*_VAR step */
      switch (variable->varno)
      {
        case INNER_VAR:
          /* get the tuple from the inner node */
          scratch.opcode = EEOP_ASSIGN_INNER_VAR;
          break;

        case OUTER_VAR:
          /* get the tuple from the outer node */
          scratch.opcode = EEOP_ASSIGN_OUTER_VAR;
          break;

          /* INDEX_VAR is handled by default case */

        default:

          /*
           * Get the tuple from the relation being scanned, or the
           * old/new tuple slot, if old/new values were requested.
           */
          switch (variable->varreturningtype)
          {
            case VAR_RETURNING_DEFAULT:
              scratch.opcode = EEOP_ASSIGN_SCAN_VAR;
              break;
            case VAR_RETURNING_OLD:
              scratch.opcode = EEOP_ASSIGN_OLD_VAR;
              state->flags |= EEO_FLAG_HAS_OLD;
              break;
            case VAR_RETURNING_NEW:
              scratch.opcode = EEOP_ASSIGN_NEW_VAR;
              state->flags |= EEO_FLAG_HAS_NEW;
              break;
          }
          break;
      }

      scratch.d.assign_var.attnum = attnum - 1;
      scratch.d.assign_var.resultnum = tle->resno - 1;
      ExprEvalPushStep(state, &scratch);
    }
    else
    {
      /*
       * Otherwise, compile the column expression normally.
       *
       * We can't tell the expression to evaluate directly into the
       * result slot, as the result slot (and the exprstate for that
       * matter) can change between executions.  We instead evaluate
       * into the ExprState's resvalue/resnull and then move.
       */
      ExecInitExprRec(tle->expr, state,
              &state->resvalue, &state->resnull);

      /*
       * Column might be referenced multiple times in upper nodes, so
       * force value to R/O - but only if it could be an expanded datum.
       */
      if (get_typlen(exprType((Node *) tle->expr)) == -1)
        scratch.opcode = EEOP_ASSIGN_TMP_MAKE_RO;
      else
        scratch.opcode = EEOP_ASSIGN_TMP;
      scratch.d.assign_tmp.resultnum = tle->resno - 1;
      ExprEvalPushStep(state, &scratch);
    }
  }

  scratch.opcode = EEOP_DONE_NO_RETURN;
  ExprEvalPushStep(state, &scratch);

  ExecReadyExpr(state);

  return projInfo;
}

/*
 *    ExecBuildUpdateProjection
 *
 * Build a ProjectionInfo node for constructing a new tuple during UPDATE.
 * The projection will be executed in the given econtext and the result will
 * be stored into the given tuple slot.  (Caller must have ensured that tuple
 * slot has a descriptor matching the target rel!)
 *
 * When evalTargetList is false, targetList contains the UPDATE ... SET
 * expressions that have already been computed by a subplan node; the values
 * from this tlist are assumed to be available in the "outer" tuple slot.
 * When evalTargetList is true, targetList contains the UPDATE ... SET
 * expressions that must be computed (which could contain references to
 * the outer, inner, or scan tuple slots).
 *
 * In either case, targetColnos contains a list of the target column numbers
 * corresponding to the non-resjunk entries of targetList.  The tlist values
 * are assigned into these columns of the result tuple slot.  Target columns
 * not listed in targetColnos are filled from the UPDATE's old tuple, which
 * is assumed to be available in the "scan" tuple slot.
 *
 * targetList can also contain resjunk columns.  These must be evaluated
 * if evalTargetList is true, but their values are discarded.
 *
 * relDesc must describe the relation we intend to update.
 *
 * This is basically a specialized variant of ExecBuildProjectionInfo.
 * However, it also performs sanity checks equivalent to ExecCheckPlanOutput.
 * Since we never make a normal tlist equivalent to the whole
 * tuple-to-be-assigned, there is no convenient way to apply
 * ExecCheckPlanOutput, so we must do our safety checks here.
 */
ProjectionInfo *
ExecBuildUpdateProjection(List *targetList,
              bool evalTargetList,
              List *targetColnos,
              TupleDesc relDesc,
              ExprContext *econtext,
              TupleTableSlot *slot,
              PlanState *parent)
{
  ProjectionInfo *projInfo = makeNode(ProjectionInfo);
  ExprState  *state;
  int     nAssignableCols;
  bool    sawJunk;
  Bitmapset  *assignedCols;
  ExprSetupInfo deform = {0, 0, 0, 0, 0, NIL};
  ExprEvalStep scratch = {0};
  int     outerattnum;
  ListCell   *lc,
         *lc2;

  projInfo->pi_exprContext = econtext;
  /* We embed ExprState into ProjectionInfo instead of doing extra palloc */
  projInfo->pi_state.type = T_ExprState;
  state = &projInfo->pi_state;
  if (evalTargetList)
    state->expr = (Expr *) targetList;
  else
    state->expr = NULL;   /* not used */
  state->parent = parent;
  state->ext_params = NULL;

  state->resultslot = slot;

  /*
   * Examine the targetList to see how many non-junk columns there are, and
   * to verify that the non-junk columns come before the junk ones.
   */
  nAssignableCols = 0;
  sawJunk = false;
  foreach(lc, targetList)
  {
    TargetEntry *tle = lfirst_node(TargetEntry, lc);

    if (tle->resjunk)
      sawJunk = true;
    else
    {
      if (sawJunk)
        elog(ERROR, "subplan target list is out of order");
      nAssignableCols++;
    }
  }

  /* We should have one targetColnos entry per non-junk column */
  if (nAssignableCols != list_length(targetColnos))
    elog(ERROR, "targetColnos does not match subplan target list");

  /*
   * Build a bitmapset of the columns in targetColnos.  (We could just use
   * list_member_int() tests, but that risks O(N^2) behavior with many
   * columns.)
   */
  assignedCols = NULL;
  foreach(lc, targetColnos)
  {
    AttrNumber  targetattnum = lfirst_int(lc);

    assignedCols = bms_add_member(assignedCols, targetattnum);
  }

  /*
   * We need to insert EEOP_*_FETCHSOME steps to ensure the input tuples are
   * sufficiently deconstructed.  The scan tuple must be deconstructed at
   * least as far as the last old column we need.
   */
  for (int attnum = relDesc->natts; attnum > 0; attnum--)
  {
    CompactAttribute *attr = TupleDescCompactAttr(relDesc, attnum - 1);

    if (attr->attisdropped)
      continue;
    if (bms_is_member(attnum, assignedCols))
      continue;
    deform.last_scan = attnum;
    break;
  }

  /*
   * If we're actually evaluating the tlist, incorporate its input
   * requirements too; otherwise, we'll just need to fetch the appropriate
   * number of columns of the "outer" tuple.
   */
  if (evalTargetList)
    expr_setup_walker((Node *) targetList, &deform);
  else
    deform.last_outer = nAssignableCols;

  ExecPushExprSetupSteps(state, &deform);

  /*
   * Now generate code to evaluate the tlist's assignable expressions or
   * fetch them from the outer tuple, incidentally validating that they'll
   * be of the right data type.  The checks above ensure that the forboth()
   * will iterate over exactly the non-junk columns.  Note that we don't
   * bother evaluating any remaining resjunk columns.
   */
  outerattnum = 0;
  forboth(lc, targetList, lc2, targetColnos)
  {
    TargetEntry *tle = lfirst_node(TargetEntry, lc);
    AttrNumber  targetattnum = lfirst_int(lc2);
    Form_pg_attribute attr;

    Assert(!tle->resjunk);

    /*
     * Apply sanity checks comparable to ExecCheckPlanOutput().
     */
    if (targetattnum <= 0 || targetattnum > relDesc->natts)
      ereport(ERROR,
          (errcode(ERRCODE_DATATYPE_MISMATCH),
           errmsg("table row type and query-specified row type do not match"),
           errdetail("Query has too many columns.")));
    attr = TupleDescAttr(relDesc, targetattnum - 1);

    if (attr->attisdropped)
      ereport(ERROR,
          (errcode(ERRCODE_DATATYPE_MISMATCH),
           errmsg("table row type and query-specified row type do not match"),
           errdetail("Query provides a value for a dropped column at ordinal position %d.",
                 targetattnum)));
    if (exprType((Node *) tle->expr) != attr->atttypid)
      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(attr->atttypid),
                 targetattnum,
                 format_type_be(exprType((Node *) tle->expr)))));

    /* OK, generate code to perform the assignment. */
    if (evalTargetList)
    {
      /*
       * We must evaluate the TLE's expression and assign it.  We do not
       * bother jumping through hoops for "safe" Vars like
       * ExecBuildProjectionInfo does; this is a relatively less-used
       * path and it doesn't seem worth expending code for that.
       */
      ExecInitExprRec(tle->expr, state,
              &state->resvalue, &state->resnull);
      /* Needn't worry about read-only-ness here, either. */
      scratch.opcode = EEOP_ASSIGN_TMP;
      scratch.d.assign_tmp.resultnum = targetattnum - 1;
      ExprEvalPushStep(state, &scratch);
    }
    else
    {
      /* Just assign from the outer tuple. */
      scratch.opcode = EEOP_ASSIGN_OUTER_VAR;
      scratch.d.assign_var.attnum = outerattnum;
      scratch.d.assign_var.resultnum = targetattnum - 1;
      ExprEvalPushStep(state, &scratch);
    }
    outerattnum++;
  }

  /*
   * Now generate code to copy over any old columns that were not assigned
   * to, and to ensure that dropped columns are set to NULL.
   */
  for (int attnum = 1; attnum <= relDesc->natts; attnum++)
  {
    CompactAttribute *attr = TupleDescCompactAttr(relDesc, attnum - 1);

    if (attr->attisdropped)
    {
      /* Put a null into the ExprState's resvalue/resnull ... */
      scratch.opcode = EEOP_CONST;
      scratch.resvalue = &state->resvalue;
      scratch.resnull = &state->resnull;
      scratch.d.constval.value = (Datum) 0;
      scratch.d.constval.isnull = true;
      ExprEvalPushStep(state, &scratch);
      /* ... then assign it to the result slot */
      scratch.opcode = EEOP_ASSIGN_TMP;
      scratch.d.assign_tmp.resultnum = attnum - 1;
      ExprEvalPushStep(state, &scratch);
    }
    else if (!bms_is_member(attnum, assignedCols))
    {
      /* Certainly the right type, so needn't check */
      scratch.opcode = EEOP_ASSIGN_SCAN_VAR;
      scratch.d.assign_var.attnum = attnum - 1;
      scratch.d.assign_var.resultnum = attnum - 1;
      ExprEvalPushStep(state, &scratch);
    }
  }

  scratch.opcode = EEOP_DONE_NO_RETURN;
  ExprEvalPushStep(state, &scratch);

  ExecReadyExpr(state);

  return projInfo;
}

/*
 * ExecPrepareExpr --- initialize for expression execution outside a normal
 * Plan tree context.
 *
 * This differs from ExecInitExpr in that we don't assume the caller is
 * already running in the EState's per-query context.  Also, we run the
 * passed expression tree through expression_planner() to prepare it for
 * execution.  (In ordinary Plan trees the regular planning process will have
 * made the appropriate transformations on expressions, but for standalone
 * expressions this won't have happened.)
 */
ExprState *
ExecPrepareExpr(Expr *node, EState *estate)
{
  ExprState  *result;
  MemoryContext oldcontext;

  oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);

  node = expression_planner(node);

  result = ExecInitExpr(node, NULL);

  MemoryContextSwitchTo(oldcontext);

  return result;
}

/*
 * ExecPrepareQual --- initialize for qual execution outside a normal
 * Plan tree context.
 *
 * This differs from ExecInitQual in that we don't assume the caller is
 * already running in the EState's per-query context.  Also, we run the
 * passed expression tree through expression_planner() to prepare it for
 * execution.  (In ordinary Plan trees the regular planning process will have
 * made the appropriate transformations on expressions, but for standalone
 * expressions this won't have happened.)
 */
ExprState *
ExecPrepareQual(List *qual, EState *estate)
{
  ExprState  *result;
  MemoryContext oldcontext;

  oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);

  qual = (List *) expression_planner((Expr *) qual);

  result = ExecInitQual(qual, NULL);

  MemoryContextSwitchTo(oldcontext);

  return result;
}

/*
 * ExecPrepareCheck -- initialize check constraint for execution outside a
 * normal Plan tree context.
 *
 * See ExecPrepareExpr() and ExecInitCheck() for details.
 */
ExprState *
ExecPrepareCheck(List *qual, EState *estate)
{
  ExprState  *result;
  MemoryContext oldcontext;

  oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);

  qual = (List *) expression_planner((Expr *) qual);

  result = ExecInitCheck(qual, NULL);

  MemoryContextSwitchTo(oldcontext);

  return result;
}

/*
 * Call ExecPrepareExpr() on each member of a list of Exprs, and return
 * a list of ExprStates.
 *
 * See ExecPrepareExpr() for details.
 */
List *
ExecPrepareExprList(List *nodes, EState *estate)
{
  List     *result = NIL;
  MemoryContext oldcontext;
  ListCell   *lc;

  /* Ensure that the list cell nodes are in the right context too */
  oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);

  foreach(lc, nodes)
  {
    Expr     *e = (Expr *) lfirst(lc);

    result = lappend(result, ExecPrepareExpr(e, estate));
  }

  MemoryContextSwitchTo(oldcontext);

  return result;
}

/*
 * ExecCheck - evaluate a check constraint
 *
 * For check constraints, a null result is taken as TRUE, ie the constraint
 * passes.
 *
 * The check constraint may have been prepared with ExecInitCheck
 * (possibly via ExecPrepareCheck) if the caller had it in implicit-AND
 * format, but a regular boolean expression prepared with ExecInitExpr or
 * ExecPrepareExpr works too.
 */
bool
ExecCheck(ExprState *state, ExprContext *econtext)
{
  Datum   ret;
  bool    isnull;

  /* short-circuit (here and in ExecInitCheck) for empty restriction list */
  if (state == NULL)
    return true;

  /* verify that expression was not compiled using ExecInitQual */
  Assert(!(state->flags & EEO_FLAG_IS_QUAL));

  ret = ExecEvalExprSwitchContext(state, econtext, &isnull);

  if (isnull)
    return true;

  return DatumGetBool(ret);
}

/*
 * Prepare a compiled expression for execution.  This has to be called for
 * every ExprState before it can be executed.
 *
 * NB: While this currently only calls ExecReadyInterpretedExpr(),
 * this will likely get extended to further expression evaluation methods.
 * Therefore this should be used instead of directly calling
 * ExecReadyInterpretedExpr().
 */
static void
ExecReadyExpr(ExprState *state)
{
  if (jit_compile_expr(state))
    return;

  ExecReadyInterpretedExpr(state);
}

/*
 * Append the steps necessary for the evaluation of node to ExprState->steps,
 * possibly recursing into sub-expressions of node.
 *
 * node - expression to evaluate
 * state - ExprState to whose ->steps to append the necessary operations
 * resv / resnull - where to store the result of the node into
 */
static void
ExecInitExprRec(Expr *node, ExprState *state,
        Datum *resv, bool *resnull)
{
  ExprEvalStep scratch = {0};

  /* Guard against stack overflow due to overly complex expressions */
  check_stack_depth();

  /* Step's output location is always what the caller gave us */
  Assert(resv != NULL && resnull != NULL);
  scratch.resvalue = resv;
  scratch.resnull = resnull;

  /* cases should be ordered as they are in enum NodeTag */
  switch (nodeTag(node))
  {
    case T_Var:
      {
        Var      *variable = (Var *) node;

        if (variable->varattno == InvalidAttrNumber)
        {
          /* whole-row Var */
          ExecInitWholeRowVar(&scratch, variable, state);
        }
        else if (variable->varattno <= 0)
        {
          /* system column */
          scratch.d.var.attnum = variable->varattno;
          scratch.d.var.vartype = variable->vartype;
          scratch.d.var.varreturningtype = variable->varreturningtype;
          switch (variable->varno)
          {
            case INNER_VAR:
              scratch.opcode = EEOP_INNER_SYSVAR;
              break;
            case OUTER_VAR:
              scratch.opcode = EEOP_OUTER_SYSVAR;
              break;

              /* INDEX_VAR is handled by default case */

            default:
              switch (variable->varreturningtype)
              {
                case VAR_RETURNING_DEFAULT:
                  scratch.opcode = EEOP_SCAN_SYSVAR;
                  break;
                case VAR_RETURNING_OLD:
                  scratch.opcode = EEOP_OLD_SYSVAR;
                  state->flags |= EEO_FLAG_HAS_OLD;
                  break;
                case VAR_RETURNING_NEW:
                  scratch.opcode = EEOP_NEW_SYSVAR;
                  state->flags |= EEO_FLAG_HAS_NEW;
                  break;
              }
              break;
          }
        }
        else
        {
          /* regular user column */
          scratch.d.var.attnum = variable->varattno - 1;
          scratch.d.var.vartype = variable->vartype;
          scratch.d.var.varreturningtype = variable->varreturningtype;
          switch (variable->varno)
          {
            case INNER_VAR:
              scratch.opcode = EEOP_INNER_VAR;
              break;
            case OUTER_VAR:
              scratch.opcode = EEOP_OUTER_VAR;
              break;

              /* INDEX_VAR is handled by default case */

            default:
              switch (variable->varreturningtype)
              {
                case VAR_RETURNING_DEFAULT:
                  scratch.opcode = EEOP_SCAN_VAR;
                  break;
                case VAR_RETURNING_OLD:
                  scratch.opcode = EEOP_OLD_VAR;
                  state->flags |= EEO_FLAG_HAS_OLD;
                  break;
                case VAR_RETURNING_NEW:
                  scratch.opcode = EEOP_NEW_VAR;
                  state->flags |= EEO_FLAG_HAS_NEW;
                  break;
              }
              break;
          }
        }

        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_Const:
      {
        Const    *con = (Const *) node;

        scratch.opcode = EEOP_CONST;
        scratch.d.constval.value = con->constvalue;
        scratch.d.constval.isnull = con->constisnull;

        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_Param:
      {
        Param    *param = (Param *) node;
        ParamListInfo params;

        switch (param->paramkind)
        {
          case PARAM_EXEC:
            scratch.opcode = EEOP_PARAM_EXEC;
            scratch.d.param.paramid = param->paramid;
            scratch.d.param.paramtype = param->paramtype;
            ExprEvalPushStep(state, &scratch);
            break;
          case PARAM_EXTERN:

            /*
             * If we have a relevant ParamCompileHook, use it;
             * otherwise compile a standard EEOP_PARAM_EXTERN
             * step.  ext_params, if supplied, takes precedence
             * over info from the parent node's EState (if any).
             */
            if (state->ext_params)
              params = state->ext_params;
            else if (state->parent &&
                 state->parent->state)
              params = state->parent->state->es_param_list_info;
            else
              params = NULL;
            if (params && params->paramCompile)
            {
              params->paramCompile(params, param, state,
                         resv, resnull);
            }
            else
            {
              scratch.opcode = EEOP_PARAM_EXTERN;
              scratch.d.param.paramid = param->paramid;
              scratch.d.param.paramtype = param->paramtype;
              ExprEvalPushStep(state, &scratch);
            }
            break;
          default:
            elog(ERROR, "unrecognized paramkind: %d",
               (int) param->paramkind);
            break;
        }
        break;
      }

    case T_Aggref:
      {
        Aggref     *aggref = (Aggref *) node;

        scratch.opcode = EEOP_AGGREF;
        scratch.d.aggref.aggno = aggref->aggno;

        if (state->parent && IsA(state->parent, AggState))
        {
          AggState   *aggstate = (AggState *) state->parent;

          aggstate->aggs = lappend(aggstate->aggs, aggref);
        }
        else
        {
          /* planner messed up */
          elog(ERROR, "Aggref found in non-Agg plan node");
        }

        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_GroupingFunc:
      {
        GroupingFunc *grp_node = (GroupingFunc *) node;
        Agg      *agg;

        if (!state->parent || !IsA(state->parent, AggState) ||
          !IsA(state->parent->plan, Agg))
          elog(ERROR, "GroupingFunc found in non-Agg plan node");

        scratch.opcode = EEOP_GROUPING_FUNC;

        agg = (Agg *) (state->parent->plan);

        if (agg->groupingSets)
          scratch.d.grouping_func.clauses = grp_node->cols;
        else
          scratch.d.grouping_func.clauses = NIL;

        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_WindowFunc:
      {
        WindowFunc *wfunc = (WindowFunc *) node;
        WindowFuncExprState *wfstate = makeNode(WindowFuncExprState);

        wfstate->wfunc = wfunc;

        if (state->parent && IsA(state->parent, WindowAggState))
        {
          WindowAggState *winstate = (WindowAggState *) state->parent;
          int     nfuncs;

          winstate->funcs = lappend(winstate->funcs, wfstate);
          nfuncs = ++winstate->numfuncs;
          if (wfunc->winagg)
            winstate->numaggs++;

          /* for now initialize agg using old style expressions */
          wfstate->args = ExecInitExprList(wfunc->args,
                           state->parent);
          wfstate->aggfilter = ExecInitExpr(wfunc->aggfilter,
                            state->parent);

          /*
           * Complain if the windowfunc's arguments contain any
           * windowfuncs; nested window functions are semantically
           * nonsensical.  (This should have been caught earlier,
           * but we defend against it here anyway.)
           */
          if (nfuncs != winstate->numfuncs)
            ereport(ERROR,
                (errcode(ERRCODE_WINDOWING_ERROR),
                 errmsg("window function calls cannot be nested")));
        }
        else
        {
          /* planner messed up */
          elog(ERROR, "WindowFunc found in non-WindowAgg plan node");
        }

        scratch.opcode = EEOP_WINDOW_FUNC;
        scratch.d.window_func.wfstate = wfstate;
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_MergeSupportFunc:
      {
        /* must be in a MERGE, else something messed up */
        if (!state->parent ||
          !IsA(state->parent, ModifyTableState) ||
          ((ModifyTableState *) state->parent)->operation != CMD_MERGE)
          elog(ERROR, "MergeSupportFunc found in non-merge plan node");

        scratch.opcode = EEOP_MERGE_SUPPORT_FUNC;
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_SubscriptingRef:
      {
        SubscriptingRef *sbsref = (SubscriptingRef *) node;

        ExecInitSubscriptingRef(&scratch, sbsref, state, resv, resnull);
        break;
      }

    case T_FuncExpr:
      {
        FuncExpr   *func = (FuncExpr *) node;

        ExecInitFunc(&scratch, node,
               func->args, func->funcid, func->inputcollid,
               state);
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_OpExpr:
      {
        OpExpr     *op = (OpExpr *) node;

        ExecInitFunc(&scratch, node,
               op->args, op->opfuncid, op->inputcollid,
               state);
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_DistinctExpr:
      {
        DistinctExpr *op = (DistinctExpr *) node;

        ExecInitFunc(&scratch, node,
               op->args, op->opfuncid, op->inputcollid,
               state);

        /*
         * Change opcode of call instruction to EEOP_DISTINCT.
         *
         * XXX: historically we've not called the function usage
         * pgstat infrastructure - that seems inconsistent given that
         * we do so for normal function *and* operator evaluation.  If
         * we decided to do that here, we'd probably want separate
         * opcodes for FUSAGE or not.
         */
        scratch.opcode = EEOP_DISTINCT;
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_NullIfExpr:
      {
        NullIfExpr *op = (NullIfExpr *) node;

        ExecInitFunc(&scratch, node,
               op->args, op->opfuncid, op->inputcollid,
               state);

        /*
         * If first argument is of varlena type, we'll need to ensure
         * that the value passed to the comparison function is a
         * read-only pointer.
         */
        scratch.d.func.make_ro =
          (get_typlen(exprType((Node *) linitial(op->args))) == -1);

        /*
         * Change opcode of call instruction to EEOP_NULLIF.
         *
         * XXX: historically we've not called the function usage
         * pgstat infrastructure - that seems inconsistent given that
         * we do so for normal function *and* operator evaluation.  If
         * we decided to do that here, we'd probably want separate
         * opcodes for FUSAGE or not.
         */
        scratch.opcode = EEOP_NULLIF;
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_ScalarArrayOpExpr:
      {
        ScalarArrayOpExpr *opexpr = (ScalarArrayOpExpr *) node;
        Expr     *scalararg;
        Expr     *arrayarg;
        FmgrInfo   *finfo;
        FunctionCallInfo fcinfo;
        AclResult aclresult;
        Oid     cmpfuncid;

        /*
         * Select the correct comparison function.  When we do hashed
         * NOT IN clauses, the opfuncid will be the inequality
         * comparison function and negfuncid will be set to equality.
         * We need to use the equality function for hash probes.
         */
        if (OidIsValid(opexpr->negfuncid))
        {
          Assert(OidIsValid(opexpr->hashfuncid));
          cmpfuncid = opexpr->negfuncid;
        }
        else
          cmpfuncid = opexpr->opfuncid;

        Assert(list_length(opexpr->args) == 2);
        scalararg = (Expr *) linitial(opexpr->args);
        arrayarg = (Expr *) lsecond(opexpr->args);

        /* Check permission to call function */
        aclresult = object_aclcheck(ProcedureRelationId, cmpfuncid,
                      GetUserId(),
                      ACL_EXECUTE);
        if (aclresult != ACLCHECK_OK)
          aclcheck_error(aclresult, OBJECT_FUNCTION,
                   get_func_name(cmpfuncid));
        InvokeFunctionExecuteHook(cmpfuncid);

        if (OidIsValid(opexpr->hashfuncid))
        {
          aclresult = object_aclcheck(ProcedureRelationId, opexpr->hashfuncid,
                        GetUserId(),
                        ACL_EXECUTE);
          if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_FUNCTION,
                     get_func_name(opexpr->hashfuncid));
          InvokeFunctionExecuteHook(opexpr->hashfuncid);
        }

        /* Set up the primary fmgr lookup information */
        finfo = palloc0(sizeof(FmgrInfo));
        fcinfo = palloc0(SizeForFunctionCallInfo(2));
        fmgr_info(cmpfuncid, finfo);
        fmgr_info_set_expr((Node *) node, finfo);
        InitFunctionCallInfoData(*fcinfo, finfo, 2,
                     opexpr->inputcollid, NULL, NULL);

        /*
         * If hashfuncid is set, we create a EEOP_HASHED_SCALARARRAYOP
         * step instead of a EEOP_SCALARARRAYOP.  This provides much
         * faster lookup performance than the normal linear search
         * when the number of items in the array is anything but very
         * small.
         */
        if (OidIsValid(opexpr->hashfuncid))
        {
          /* Evaluate scalar directly into left function argument */
          ExecInitExprRec(scalararg, state,
                  &fcinfo->args[0].value, &fcinfo->args[0].isnull);

          /*
           * Evaluate array argument into our return value.  There's
           * no danger in that, because the return value is
           * guaranteed to be overwritten by
           * EEOP_HASHED_SCALARARRAYOP, and will not be passed to
           * any other expression.
           */
          ExecInitExprRec(arrayarg, state, resv, resnull);

          /* And perform the operation */
          scratch.opcode = EEOP_HASHED_SCALARARRAYOP;
          scratch.d.hashedscalararrayop.inclause = opexpr->useOr;
          scratch.d.hashedscalararrayop.finfo = finfo;
          scratch.d.hashedscalararrayop.fcinfo_data = fcinfo;
          scratch.d.hashedscalararrayop.saop = opexpr;


          ExprEvalPushStep(state, &scratch);
        }
        else
        {
          /* Evaluate scalar directly into left function argument */
          ExecInitExprRec(scalararg, state,
                  &fcinfo->args[0].value,
                  &fcinfo->args[0].isnull);

          /*
           * Evaluate array argument into our return value.  There's
           * no danger in that, because the return value is
           * guaranteed to be overwritten by EEOP_SCALARARRAYOP, and
           * will not be passed to any other expression.
           */
          ExecInitExprRec(arrayarg, state, resv, resnull);

          /* And perform the operation */
          scratch.opcode = EEOP_SCALARARRAYOP;
          scratch.d.scalararrayop.element_type = InvalidOid;
          scratch.d.scalararrayop.useOr = opexpr->useOr;
          scratch.d.scalararrayop.finfo = finfo;
          scratch.d.scalararrayop.fcinfo_data = fcinfo;
          scratch.d.scalararrayop.fn_addr = finfo->fn_addr;
          ExprEvalPushStep(state, &scratch);
        }
        break;
      }

    case T_BoolExpr:
      {
        BoolExpr   *boolexpr = (BoolExpr *) node;
        int     nargs = list_length(boolexpr->args);
        List     *adjust_jumps = NIL;
        int     off;
        ListCell   *lc;

        /* allocate scratch memory used by all steps of AND/OR */
        if (boolexpr->boolop != NOT_EXPR)
          scratch.d.boolexpr.anynull = (bool *) palloc(sizeof(bool));

        /*
         * For each argument evaluate the argument itself, then
         * perform the bool operation's appropriate handling.
         *
         * We can evaluate each argument into our result area, since
         * the short-circuiting logic means we only need to remember
         * previous NULL values.
         *
         * AND/OR is split into separate STEP_FIRST (one) / STEP (zero
         * or more) / STEP_LAST (one) steps, as each of those has to
         * perform different work.  The FIRST/LAST split is valid
         * because AND/OR have at least two arguments.
         */
        off = 0;
        foreach(lc, boolexpr->args)
        {
          Expr     *arg = (Expr *) lfirst(lc);

          /* Evaluate argument into our output variable */
          ExecInitExprRec(arg, state, resv, resnull);

          /* Perform the appropriate step type */
          switch (boolexpr->boolop)
          {
            case AND_EXPR:
              Assert(nargs >= 2);

              if (off == 0)
                scratch.opcode = EEOP_BOOL_AND_STEP_FIRST;
              else if (off + 1 == nargs)
                scratch.opcode = EEOP_BOOL_AND_STEP_LAST;
              else
                scratch.opcode = EEOP_BOOL_AND_STEP;
              break;
            case OR_EXPR:
              Assert(nargs >= 2);

              if (off == 0)
                scratch.opcode = EEOP_BOOL_OR_STEP_FIRST;
              else if (off + 1 == nargs)
                scratch.opcode = EEOP_BOOL_OR_STEP_LAST;
              else
                scratch.opcode = EEOP_BOOL_OR_STEP;
              break;
            case NOT_EXPR:
              Assert(nargs == 1);

              scratch.opcode = EEOP_BOOL_NOT_STEP;
              break;
            default:
              elog(ERROR, "unrecognized boolop: %d",
                 (int) boolexpr->boolop);
              break;
          }

          scratch.d.boolexpr.jumpdone = -1;
          ExprEvalPushStep(state, &scratch);
          adjust_jumps = lappend_int(adjust_jumps,
                         state->steps_len - 1);
          off++;
        }

        /* adjust jump targets */
        foreach(lc, adjust_jumps)
        {
          ExprEvalStep *as = &state->steps[lfirst_int(lc)];

          Assert(as->d.boolexpr.jumpdone == -1);
          as->d.boolexpr.jumpdone = state->steps_len;
        }

        break;
      }

    case T_SubPlan:
      {
        SubPlan    *subplan = (SubPlan *) node;

        /*
         * Real execution of a MULTIEXPR SubPlan has already been
         * done. What we have to do here is return a dummy NULL record
         * value in case this targetlist element is assigned
         * someplace.
         */
        if (subplan->subLinkType == MULTIEXPR_SUBLINK)
        {
          scratch.opcode = EEOP_CONST;
          scratch.d.constval.value = (Datum) 0;
          scratch.d.constval.isnull = true;
          ExprEvalPushStep(state, &scratch);
          break;
        }

        ExecInitSubPlanExpr(subplan, state, resv, resnull);
        break;
      }

    case T_FieldSelect:
      {
        FieldSelect *fselect = (FieldSelect *) node;

        /* evaluate row/record argument into result area */
        ExecInitExprRec(fselect->arg, state, resv, resnull);

        /* and extract field */
        scratch.opcode = EEOP_FIELDSELECT;
        scratch.d.fieldselect.fieldnum = fselect->fieldnum;
        scratch.d.fieldselect.resulttype = fselect->resulttype;
        scratch.d.fieldselect.rowcache.cacheptr = NULL;

        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_FieldStore:
      {
        FieldStore *fstore = (FieldStore *) node;
        TupleDesc tupDesc;
        ExprEvalRowtypeCache *rowcachep;
        Datum    *values;
        bool     *nulls;
        int     ncolumns;
        ListCell   *l1,
               *l2;

        /* find out the number of columns in the composite type */
        tupDesc = lookup_rowtype_tupdesc(fstore->resulttype, -1);
        ncolumns = tupDesc->natts;
        ReleaseTupleDesc(tupDesc);

        /* create workspace for column values */
        values = (Datum *) palloc(sizeof(Datum) * ncolumns);
        nulls = (bool *) palloc(sizeof(bool) * ncolumns);

        /* create shared composite-type-lookup cache struct */
        rowcachep = palloc(sizeof(ExprEvalRowtypeCache));
        rowcachep->cacheptr = NULL;

        /* emit code to evaluate the composite input value */
        ExecInitExprRec(fstore->arg, state, resv, resnull);

        /* next, deform the input tuple into our workspace */
        scratch.opcode = EEOP_FIELDSTORE_DEFORM;
        scratch.d.fieldstore.fstore = fstore;
        scratch.d.fieldstore.rowcache = rowcachep;
        scratch.d.fieldstore.values = values;
        scratch.d.fieldstore.nulls = nulls;
        scratch.d.fieldstore.ncolumns = ncolumns;
        ExprEvalPushStep(state, &scratch);

        /* evaluate new field values, store in workspace columns */
        forboth(l1, fstore->newvals, l2, fstore->fieldnums)
        {
          Expr     *e = (Expr *) lfirst(l1);
          AttrNumber  fieldnum = lfirst_int(l2);
          Datum    *save_innermost_caseval;
          bool     *save_innermost_casenull;

          if (fieldnum <= 0 || fieldnum > ncolumns)
            elog(ERROR, "field number %d is out of range in FieldStore",
               fieldnum);

          /*
           * Use the CaseTestExpr mechanism to pass down the old
           * value of the field being replaced; this is needed in
           * case the newval is itself a FieldStore or
           * SubscriptingRef that has to obtain and modify the old
           * value.  It's safe to reuse the CASE mechanism because
           * there cannot be a CASE between here and where the value
           * would be needed, and a field assignment can't be within
           * a CASE either.  (So saving and restoring
           * innermost_caseval is just paranoia, but let's do it
           * anyway.)
           *
           * Another non-obvious point is that it's safe to use the
           * field's values[]/nulls[] entries as both the caseval
           * source and the result address for this subexpression.
           * That's okay only because (1) both FieldStore and
           * SubscriptingRef evaluate their arg or refexpr inputs
           * first, and (2) any such CaseTestExpr is directly the
           * arg or refexpr input.  So any read of the caseval will
           * occur before there's a chance to overwrite it.  Also,
           * if multiple entries in the newvals/fieldnums lists
           * target the same field, they'll effectively be applied
           * left-to-right which is what we want.
           */
          save_innermost_caseval = state->innermost_caseval;
          save_innermost_casenull = state->innermost_casenull;
          state->innermost_caseval = &values[fieldnum - 1];
          state->innermost_casenull = &nulls[fieldnum - 1];

          ExecInitExprRec(e, state,
                  &values[fieldnum - 1],
                  &nulls[fieldnum - 1]);

          state->innermost_caseval = save_innermost_caseval;
          state->innermost_casenull = save_innermost_casenull;
        }

        /* finally, form result tuple */
        scratch.opcode = EEOP_FIELDSTORE_FORM;
        scratch.d.fieldstore.fstore = fstore;
        scratch.d.fieldstore.rowcache = rowcachep;
        scratch.d.fieldstore.values = values;
        scratch.d.fieldstore.nulls = nulls;
        scratch.d.fieldstore.ncolumns = ncolumns;
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_RelabelType:
      {
        /* relabel doesn't need to do anything at runtime */
        RelabelType *relabel = (RelabelType *) node;

        ExecInitExprRec(relabel->arg, state, resv, resnull);
        break;
      }

    case T_CoerceViaIO:
      {
        CoerceViaIO *iocoerce = (CoerceViaIO *) node;
        Oid     iofunc;
        bool    typisvarlena;
        Oid     typioparam;
        FunctionCallInfo fcinfo_in;

        /* evaluate argument into step's result area */
        ExecInitExprRec(iocoerce->arg, state, resv, resnull);

        /*
         * Prepare both output and input function calls, to be
         * evaluated inside a single evaluation step for speed - this
         * can be a very common operation.
         *
         * We don't check permissions here as a type's input/output
         * function are assumed to be executable by everyone.
         */
        if (state->escontext == NULL)
          scratch.opcode = EEOP_IOCOERCE;
        else
          scratch.opcode = EEOP_IOCOERCE_SAFE;

        /* lookup the source type's output function */
        scratch.d.iocoerce.finfo_out = palloc0(sizeof(FmgrInfo));
        scratch.d.iocoerce.fcinfo_data_out = palloc0(SizeForFunctionCallInfo(1));

        getTypeOutputInfo(exprType((Node *) iocoerce->arg),
                  &iofunc, &typisvarlena);
        fmgr_info(iofunc, scratch.d.iocoerce.finfo_out);
        fmgr_info_set_expr((Node *) node, scratch.d.iocoerce.finfo_out);
        InitFunctionCallInfoData(*scratch.d.iocoerce.fcinfo_data_out,
                     scratch.d.iocoerce.finfo_out,
                     1, InvalidOid, NULL, NULL);

        /* lookup the result type's input function */
        scratch.d.iocoerce.finfo_in = palloc0(sizeof(FmgrInfo));
        scratch.d.iocoerce.fcinfo_data_in = palloc0(SizeForFunctionCallInfo(3));

        getTypeInputInfo(iocoerce->resulttype,
                 &iofunc, &typioparam);
        fmgr_info(iofunc, scratch.d.iocoerce.finfo_in);
        fmgr_info_set_expr((Node *) node, scratch.d.iocoerce.finfo_in);
        InitFunctionCallInfoData(*scratch.d.iocoerce.fcinfo_data_in,
                     scratch.d.iocoerce.finfo_in,
                     3, InvalidOid, NULL, NULL);

        /*
         * We can preload the second and third arguments for the input
         * function, since they're constants.
         */
        fcinfo_in = scratch.d.iocoerce.fcinfo_data_in;
        fcinfo_in->args[1].value = ObjectIdGetDatum(typioparam);
        fcinfo_in->args[1].isnull = false;
        fcinfo_in->args[2].value = Int32GetDatum(-1);
        fcinfo_in->args[2].isnull = false;

        fcinfo_in->context = (Node *) state->escontext;

        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_ArrayCoerceExpr:
      {
        ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
        Oid     resultelemtype;
        ExprState  *elemstate;

        /* evaluate argument into step's result area */
        ExecInitExprRec(acoerce->arg, state, resv, resnull);

        resultelemtype = get_element_type(acoerce->resulttype);
        if (!OidIsValid(resultelemtype))
          ereport(ERROR,
              (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
               errmsg("target type is not an array")));

        /*
         * Construct a sub-expression for the per-element expression;
         * but don't ready it until after we check it for triviality.
         * We assume it hasn't any Var references, but does have a
         * CaseTestExpr representing the source array element values.
         */
        elemstate = makeNode(ExprState);
        elemstate->expr = acoerce->elemexpr;
        elemstate->parent = state->parent;
        elemstate->ext_params = state->ext_params;

        elemstate->innermost_caseval = (Datum *) palloc(sizeof(Datum));
        elemstate->innermost_casenull = (bool *) palloc(sizeof(bool));

        ExecInitExprRec(acoerce->elemexpr, elemstate,
                &elemstate->resvalue, &elemstate->resnull);

        if (elemstate->steps_len == 1 &&
          elemstate->steps[0].opcode == EEOP_CASE_TESTVAL)
        {
          /* Trivial, so we need no per-element work at runtime */
          elemstate = NULL;
        }
        else
        {
          /* Not trivial, so append a DONE step */
          scratch.opcode = EEOP_DONE_RETURN;
          ExprEvalPushStep(elemstate, &scratch);
          /* and ready the subexpression */
          ExecReadyExpr(elemstate);
        }

        scratch.opcode = EEOP_ARRAYCOERCE;
        scratch.d.arraycoerce.elemexprstate = elemstate;
        scratch.d.arraycoerce.resultelemtype = resultelemtype;

        if (elemstate)
        {
          /* Set up workspace for array_map */
          scratch.d.arraycoerce.amstate =
            (ArrayMapState *) palloc0(sizeof(ArrayMapState));
        }
        else
        {
          /* Don't need workspace if there's no subexpression */
          scratch.d.arraycoerce.amstate = NULL;
        }

        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_ConvertRowtypeExpr:
      {
        ConvertRowtypeExpr *convert = (ConvertRowtypeExpr *) node;
        ExprEvalRowtypeCache *rowcachep;

        /* cache structs must be out-of-line for space reasons */
        rowcachep = palloc(2 * sizeof(ExprEvalRowtypeCache));
        rowcachep[0].cacheptr = NULL;
        rowcachep[1].cacheptr = NULL;

        /* evaluate argument into step's result area */
        ExecInitExprRec(convert->arg, state, resv, resnull);

        /* and push conversion step */
        scratch.opcode = EEOP_CONVERT_ROWTYPE;
        scratch.d.convert_rowtype.inputtype =
          exprType((Node *) convert->arg);
        scratch.d.convert_rowtype.outputtype = convert->resulttype;
        scratch.d.convert_rowtype.incache = &rowcachep[0];
        scratch.d.convert_rowtype.outcache = &rowcachep[1];
        scratch.d.convert_rowtype.map = NULL;

        ExprEvalPushStep(state, &scratch);
        break;
      }

      /* note that CaseWhen expressions are handled within this block */
    case T_CaseExpr:
      {
        CaseExpr   *caseExpr = (CaseExpr *) node;
        List     *adjust_jumps = NIL;
        Datum    *caseval = NULL;
        bool     *casenull = NULL;
        ListCell   *lc;

        /*
         * If there's a test expression, we have to evaluate it and
         * save the value where the CaseTestExpr placeholders can find
         * it.
         */
        if (caseExpr->arg != NULL)
        {
          /* Evaluate testexpr into caseval/casenull workspace */
          caseval = palloc(sizeof(Datum));
          casenull = palloc(sizeof(bool));

          ExecInitExprRec(caseExpr->arg, state,
                  caseval, casenull);

          /*
           * Since value might be read multiple times, force to R/O
           * - but only if it could be an expanded datum.
           */
          if (get_typlen(exprType((Node *) caseExpr->arg)) == -1)
          {
            /* change caseval in-place */
            scratch.opcode = EEOP_MAKE_READONLY;
            scratch.resvalue = caseval;
            scratch.resnull = casenull;
            scratch.d.make_readonly.value = caseval;
            scratch.d.make_readonly.isnull = casenull;
            ExprEvalPushStep(state, &scratch);
            /* restore normal settings of scratch fields */
            scratch.resvalue = resv;
            scratch.resnull = resnull;
          }
        }

        /*
         * Prepare to evaluate each of the WHEN clauses in turn; as
         * soon as one is true we return the value of the
         * corresponding THEN clause.  If none are true then we return
         * the value of the ELSE clause, or NULL if there is none.
         */
        foreach(lc, caseExpr->args)
        {
          CaseWhen   *when = (CaseWhen *) lfirst(lc);
          Datum    *save_innermost_caseval;
          bool     *save_innermost_casenull;
          int     whenstep;

          /*
           * Make testexpr result available to CaseTestExpr nodes
           * within the condition.  We must save and restore prior
           * setting of innermost_caseval fields, in case this node
           * is itself within a larger CASE.
           *
           * If there's no test expression, we don't actually need
           * to save and restore these fields; but it's less code to
           * just do so unconditionally.
           */
          save_innermost_caseval = state->innermost_caseval;
          save_innermost_casenull = state->innermost_casenull;
          state->innermost_caseval = caseval;
          state->innermost_casenull = casenull;

          /* evaluate condition into CASE's result variables */
          ExecInitExprRec(when->expr, state, resv, resnull);

          state->innermost_caseval = save_innermost_caseval;
          state->innermost_casenull = save_innermost_casenull;

          /* If WHEN result isn't true, jump to next CASE arm */
          scratch.opcode = EEOP_JUMP_IF_NOT_TRUE;
          scratch.d.jump.jumpdone = -1; /* computed later */
          ExprEvalPushStep(state, &scratch);
          whenstep = state->steps_len - 1;

          /*
           * If WHEN result is true, evaluate THEN result, storing
           * it into the CASE's result variables.
           */
          ExecInitExprRec(when->result, state, resv, resnull);

          /* Emit JUMP step to jump to end of CASE's code */
          scratch.opcode = EEOP_JUMP;
          scratch.d.jump.jumpdone = -1; /* computed later */
          ExprEvalPushStep(state, &scratch);

          /*
           * Don't know address for that jump yet, compute once the
           * whole CASE expression is built.
           */
          adjust_jumps = lappend_int(adjust_jumps,
                         state->steps_len - 1);

          /*
           * But we can set WHEN test's jump target now, to make it
           * jump to the next WHEN subexpression or the ELSE.
           */
          state->steps[whenstep].d.jump.jumpdone = state->steps_len;
        }

        /* transformCaseExpr always adds a default */
        Assert(caseExpr->defresult);

        /* evaluate ELSE expr into CASE's result variables */
        ExecInitExprRec(caseExpr->defresult, state,
                resv, resnull);

        /* adjust jump targets */
        foreach(lc, adjust_jumps)
        {
          ExprEvalStep *as = &state->steps[lfirst_int(lc)];

          Assert(as->opcode == EEOP_JUMP);
          Assert(as->d.jump.jumpdone == -1);
          as->d.jump.jumpdone = state->steps_len;
        }

        break;
      }

    case T_CaseTestExpr:
      {
        /*
         * Read from location identified by innermost_caseval.  Note
         * that innermost_caseval could be NULL, if this node isn't
         * actually within a CaseExpr, ArrayCoerceExpr, etc structure.
         * That can happen because some parts of the system abuse
         * CaseTestExpr to cause a read of a value externally supplied
         * in econtext->caseValue_datum.  We'll take care of that by
         * generating a specialized operation.
         */
        if (state->innermost_caseval == NULL)
          scratch.opcode = EEOP_CASE_TESTVAL_EXT;
        else
        {
          scratch.opcode = EEOP_CASE_TESTVAL;
          scratch.d.casetest.value = state->innermost_caseval;
          scratch.d.casetest.isnull = state->innermost_casenull;
        }
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_ArrayExpr:
      {
        ArrayExpr  *arrayexpr = (ArrayExpr *) node;
        int     nelems = list_length(arrayexpr->elements);
        ListCell   *lc;
        int     elemoff;

        /*
         * Evaluate by computing each element, and then forming the
         * array.  Elements are computed into scratch arrays
         * associated with the ARRAYEXPR step.
         */
        scratch.opcode = EEOP_ARRAYEXPR;
        scratch.d.arrayexpr.elemvalues =
          (Datum *) palloc(sizeof(Datum) * nelems);
        scratch.d.arrayexpr.elemnulls =
          (bool *) palloc(sizeof(bool) * nelems);
        scratch.d.arrayexpr.nelems = nelems;

        /* fill remaining fields of step */
        scratch.d.arrayexpr.multidims = arrayexpr->multidims;
        scratch.d.arrayexpr.elemtype = arrayexpr->element_typeid;

        /* do one-time catalog lookup for type info */
        get_typlenbyvalalign(arrayexpr->element_typeid,
                   &scratch.d.arrayexpr.elemlength,
                   &scratch.d.arrayexpr.elembyval,
                   &scratch.d.arrayexpr.elemalign);

        /* prepare to evaluate all arguments */
        elemoff = 0;
        foreach(lc, arrayexpr->elements)
        {
          Expr     *e = (Expr *) lfirst(lc);

          ExecInitExprRec(e, state,
                  &scratch.d.arrayexpr.elemvalues[elemoff],
                  &scratch.d.arrayexpr.elemnulls[elemoff]);
          elemoff++;
        }

        /* and then collect all into an array */
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_RowExpr:
      {
        RowExpr    *rowexpr = (RowExpr *) node;
        int     nelems = list_length(rowexpr->args);
        TupleDesc tupdesc;
        int     i;
        ListCell   *l;

        /* Build tupdesc to describe result tuples */
        if (rowexpr->row_typeid == RECORDOID)
        {
          /* generic record, use types of given expressions */
          tupdesc = ExecTypeFromExprList(rowexpr->args);
          /* ... but adopt RowExpr's column aliases */
          ExecTypeSetColNames(tupdesc, rowexpr->colnames);
          /* Bless the tupdesc so it can be looked up later */
          BlessTupleDesc(tupdesc);
        }
        else
        {
          /* it's been cast to a named type, use that */
          tupdesc = lookup_rowtype_tupdesc_copy(rowexpr->row_typeid, -1);
        }

        /*
         * In the named-type case, the tupdesc could have more columns
         * than are in the args list, since the type might have had
         * columns added since the ROW() was parsed.  We want those
         * extra columns to go to nulls, so we make sure that the
         * workspace arrays are large enough and then initialize any
         * extra columns to read as NULLs.
         */
        Assert(nelems <= tupdesc->natts);
        nelems = Max(nelems, tupdesc->natts);

        /*
         * Evaluate by first building datums for each field, and then
         * a final step forming the composite datum.
         */
        scratch.opcode = EEOP_ROW;
        scratch.d.row.tupdesc = tupdesc;

        /* space for the individual field datums */
        scratch.d.row.elemvalues =
          (Datum *) palloc(sizeof(Datum) * nelems);
        scratch.d.row.elemnulls =
          (bool *) palloc(sizeof(bool) * nelems);
        /* as explained above, make sure any extra columns are null */
        memset(scratch.d.row.elemnulls, true, sizeof(bool) * nelems);

        /* Set up evaluation, skipping any deleted columns */
        i = 0;
        foreach(l, rowexpr->args)
        {
          Form_pg_attribute att = TupleDescAttr(tupdesc, i);
          Expr     *e = (Expr *) lfirst(l);

          if (!att->attisdropped)
          {
            /*
             * Guard against ALTER COLUMN TYPE on rowtype since
             * the RowExpr was created.  XXX should we check
             * typmod too?  Not sure we can be sure it'll be the
             * same.
             */
            if (exprType((Node *) e) != att->atttypid)
              ereport(ERROR,
                  (errcode(ERRCODE_DATATYPE_MISMATCH),
                   errmsg("ROW() column has type %s instead of type %s",
                      format_type_be(exprType((Node *) e)),
                      format_type_be(att->atttypid))));
          }
          else
          {
            /*
             * Ignore original expression and insert a NULL. We
             * don't really care what type of NULL it is, so
             * always make an int4 NULL.
             */
            e = (Expr *) makeNullConst(INT4OID, -1, InvalidOid);
          }

          /* Evaluate column expr into appropriate workspace slot */
          ExecInitExprRec(e, state,
                  &scratch.d.row.elemvalues[i],
                  &scratch.d.row.elemnulls[i]);
          i++;
        }

        /* And finally build the row value */
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_RowCompareExpr:
      {
        RowCompareExpr *rcexpr = (RowCompareExpr *) node;
        int     nopers = list_length(rcexpr->opnos);
        List     *adjust_jumps = NIL;
        ListCell   *l_left_expr,
               *l_right_expr,
               *l_opno,
               *l_opfamily,
               *l_inputcollid;
        ListCell   *lc;

        /*
         * Iterate over each field, prepare comparisons.  To handle
         * NULL results, prepare jumps to after the expression.  If a
         * comparison yields a != 0 result, jump to the final step.
         */
        Assert(list_length(rcexpr->largs) == nopers);
        Assert(list_length(rcexpr->rargs) == nopers);
        Assert(list_length(rcexpr->opfamilies) == nopers);
        Assert(list_length(rcexpr->inputcollids) == nopers);

        forfive(l_left_expr, rcexpr->largs,
            l_right_expr, rcexpr->rargs,
            l_opno, rcexpr->opnos,
            l_opfamily, rcexpr->opfamilies,
            l_inputcollid, rcexpr->inputcollids)
        {
          Expr     *left_expr = (Expr *) lfirst(l_left_expr);
          Expr     *right_expr = (Expr *) lfirst(l_right_expr);
          Oid     opno = lfirst_oid(l_opno);
          Oid     opfamily = lfirst_oid(l_opfamily);
          Oid     inputcollid = lfirst_oid(l_inputcollid);
          int     strategy;
          Oid     lefttype;
          Oid     righttype;
          Oid     proc;
          FmgrInfo   *finfo;
          FunctionCallInfo fcinfo;

          get_op_opfamily_properties(opno, opfamily, false,
                         &strategy,
                         &lefttype,
                         &righttype);
          proc = get_opfamily_proc(opfamily,
                       lefttype,
                       righttype,
                       BTORDER_PROC);
          if (!OidIsValid(proc))
            elog(ERROR, "missing support function %d(%u,%u) in opfamily %u",
               BTORDER_PROC, lefttype, righttype, opfamily);

          /* Set up the primary fmgr lookup information */
          finfo = palloc0(sizeof(FmgrInfo));
          fcinfo = palloc0(SizeForFunctionCallInfo(2));
          fmgr_info(proc, finfo);
          fmgr_info_set_expr((Node *) node, finfo);
          InitFunctionCallInfoData(*fcinfo, finfo, 2,
                       inputcollid, NULL, NULL);

          /*
           * If we enforced permissions checks on index support
           * functions, we'd need to make a check here.  But the
           * index support machinery doesn't do that, and thus
           * neither does this code.
           */

          /* evaluate left and right args directly into fcinfo */
          ExecInitExprRec(left_expr, state,
                  &fcinfo->args[0].value, &fcinfo->args[0].isnull);
          ExecInitExprRec(right_expr, state,
                  &fcinfo->args[1].value, &fcinfo->args[1].isnull);

          scratch.opcode = EEOP_ROWCOMPARE_STEP;
          scratch.d.rowcompare_step.finfo = finfo;
          scratch.d.rowcompare_step.fcinfo_data = fcinfo;
          scratch.d.rowcompare_step.fn_addr = finfo->fn_addr;
          /* jump targets filled below */
          scratch.d.rowcompare_step.jumpnull = -1;
          scratch.d.rowcompare_step.jumpdone = -1;

          ExprEvalPushStep(state, &scratch);
          adjust_jumps = lappend_int(adjust_jumps,
                         state->steps_len - 1);
        }

        /*
         * We could have a zero-column rowtype, in which case the rows
         * necessarily compare equal.
         */
        if (nopers == 0)
        {
          scratch.opcode = EEOP_CONST;
          scratch.d.constval.value = Int32GetDatum(0);
          scratch.d.constval.isnull = false;
          ExprEvalPushStep(state, &scratch);
        }

        /* Finally, examine the last comparison result */
        scratch.opcode = EEOP_ROWCOMPARE_FINAL;
        scratch.d.rowcompare_final.cmptype = rcexpr->cmptype;
        ExprEvalPushStep(state, &scratch);

        /* adjust jump targets */
        foreach(lc, adjust_jumps)
        {
          ExprEvalStep *as = &state->steps[lfirst_int(lc)];

          Assert(as->opcode == EEOP_ROWCOMPARE_STEP);
          Assert(as->d.rowcompare_step.jumpdone == -1);
          Assert(as->d.rowcompare_step.jumpnull == -1);

          /* jump to comparison evaluation */
          as->d.rowcompare_step.jumpdone = state->steps_len - 1;
          /* jump to the following expression */
          as->d.rowcompare_step.jumpnull = state->steps_len;
        }

        break;
      }

    case T_CoalesceExpr:
      {
        CoalesceExpr *coalesce = (CoalesceExpr *) node;
        List     *adjust_jumps = NIL;
        ListCell   *lc;

        /* We assume there's at least one arg */
        Assert(coalesce->args != NIL);

        /*
         * Prepare evaluation of all coalesced arguments, after each
         * one push a step that short-circuits if not null.
         */
        foreach(lc, coalesce->args)
        {
          Expr     *e = (Expr *) lfirst(lc);

          /* evaluate argument, directly into result datum */
          ExecInitExprRec(e, state, resv, resnull);

          /* if it's not null, skip to end of COALESCE expr */
          scratch.opcode = EEOP_JUMP_IF_NOT_NULL;
          scratch.d.jump.jumpdone = -1; /* adjust later */
          ExprEvalPushStep(state, &scratch);

          adjust_jumps = lappend_int(adjust_jumps,
                         state->steps_len - 1);
        }

        /*
         * No need to add a constant NULL return - we only can get to
         * the end of the expression if a NULL already is being
         * returned.
         */

        /* adjust jump targets */
        foreach(lc, adjust_jumps)
        {
          ExprEvalStep *as = &state->steps[lfirst_int(lc)];

          Assert(as->opcode == EEOP_JUMP_IF_NOT_NULL);
          Assert(as->d.jump.jumpdone == -1);
          as->d.jump.jumpdone = state->steps_len;
        }

        break;
      }

    case T_MinMaxExpr:
      {
        MinMaxExpr *minmaxexpr = (MinMaxExpr *) node;
        int     nelems = list_length(minmaxexpr->args);
        TypeCacheEntry *typentry;
        FmgrInfo   *finfo;
        FunctionCallInfo fcinfo;
        ListCell   *lc;
        int     off;

        /* Look up the btree comparison function for the datatype */
        typentry = lookup_type_cache(minmaxexpr->minmaxtype,
                       TYPECACHE_CMP_PROC);
        if (!OidIsValid(typentry->cmp_proc))
          ereport(ERROR,
              (errcode(ERRCODE_UNDEFINED_FUNCTION),
               errmsg("could not identify a comparison function for type %s",
                  format_type_be(minmaxexpr->minmaxtype))));

        /*
         * If we enforced permissions checks on index support
         * functions, we'd need to make a check here.  But the index
         * support machinery doesn't do that, and thus neither does
         * this code.
         */

        /* Perform function lookup */
        finfo = palloc0(sizeof(FmgrInfo));
        fcinfo = palloc0(SizeForFunctionCallInfo(2));
        fmgr_info(typentry->cmp_proc, finfo);
        fmgr_info_set_expr((Node *) node, finfo);
        InitFunctionCallInfoData(*fcinfo, finfo, 2,
                     minmaxexpr->inputcollid, NULL, NULL);

        scratch.opcode = EEOP_MINMAX;
        /* allocate space to store arguments */
        scratch.d.minmax.values =
          (Datum *) palloc(sizeof(Datum) * nelems);
        scratch.d.minmax.nulls =
          (bool *) palloc(sizeof(bool) * nelems);
        scratch.d.minmax.nelems = nelems;

        scratch.d.minmax.op = minmaxexpr->op;
        scratch.d.minmax.finfo = finfo;
        scratch.d.minmax.fcinfo_data = fcinfo;

        /* evaluate expressions into minmax->values/nulls */
        off = 0;
        foreach(lc, minmaxexpr->args)
        {
          Expr     *e = (Expr *) lfirst(lc);

          ExecInitExprRec(e, state,
                  &scratch.d.minmax.values[off],
                  &scratch.d.minmax.nulls[off]);
          off++;
        }

        /* and push the final comparison */
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_SQLValueFunction:
      {
        SQLValueFunction *svf = (SQLValueFunction *) node;

        scratch.opcode = EEOP_SQLVALUEFUNCTION;
        scratch.d.sqlvaluefunction.svf = svf;

        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_XmlExpr:
      {
        XmlExpr    *xexpr = (XmlExpr *) node;
        int     nnamed = list_length(xexpr->named_args);
        int     nargs = list_length(xexpr->args);
        int     off;
        ListCell   *arg;

        scratch.opcode = EEOP_XMLEXPR;
        scratch.d.xmlexpr.xexpr = xexpr;

        /* allocate space for storing all the arguments */
        if (nnamed)
        {
          scratch.d.xmlexpr.named_argvalue =
            (Datum *) palloc(sizeof(Datum) * nnamed);
          scratch.d.xmlexpr.named_argnull =
            (bool *) palloc(sizeof(bool) * nnamed);
        }
        else
        {
          scratch.d.xmlexpr.named_argvalue = NULL;
          scratch.d.xmlexpr.named_argnull = NULL;
        }

        if (nargs)
        {
          scratch.d.xmlexpr.argvalue =
            (Datum *) palloc(sizeof(Datum) * nargs);
          scratch.d.xmlexpr.argnull =
            (bool *) palloc(sizeof(bool) * nargs);
        }
        else
        {
          scratch.d.xmlexpr.argvalue = NULL;
          scratch.d.xmlexpr.argnull = NULL;
        }

        /* prepare argument execution */
        off = 0;
        foreach(arg, xexpr->named_args)
        {
          Expr     *e = (Expr *) lfirst(arg);

          ExecInitExprRec(e, state,
                  &scratch.d.xmlexpr.named_argvalue[off],
                  &scratch.d.xmlexpr.named_argnull[off]);
          off++;
        }

        off = 0;
        foreach(arg, xexpr->args)
        {
          Expr     *e = (Expr *) lfirst(arg);

          ExecInitExprRec(e, state,
                  &scratch.d.xmlexpr.argvalue[off],
                  &scratch.d.xmlexpr.argnull[off]);
          off++;
        }

        /* and evaluate the actual XML expression */
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_JsonValueExpr:
      {
        JsonValueExpr *jve = (JsonValueExpr *) node;

        Assert(jve->raw_expr != NULL);
        ExecInitExprRec(jve->raw_expr, state, resv, resnull);
        Assert(jve->formatted_expr != NULL);
        ExecInitExprRec(jve->formatted_expr, state, resv, resnull);
        break;
      }

    case T_JsonConstructorExpr:
      {
        JsonConstructorExpr *ctor = (JsonConstructorExpr *) node;
        List     *args = ctor->args;
        ListCell   *lc;
        int     nargs = list_length(args);
        int     argno = 0;

        if (ctor->func)
        {
          ExecInitExprRec(ctor->func, state, resv, resnull);
        }
        else if ((ctor->type == JSCTOR_JSON_PARSE && !ctor->unique) ||
             ctor->type == JSCTOR_JSON_SERIALIZE)
        {
          /* Use the value of the first argument as result */
          ExecInitExprRec(linitial(args), state, resv, resnull);
        }
        else
        {
          JsonConstructorExprState *jcstate;

          jcstate = palloc0(sizeof(JsonConstructorExprState));

          scratch.opcode = EEOP_JSON_CONSTRUCTOR;
          scratch.d.json_constructor.jcstate = jcstate;

          jcstate->constructor = ctor;
          jcstate->arg_values = (Datum *) palloc(sizeof(Datum) * nargs);
          jcstate->arg_nulls = (bool *) palloc(sizeof(bool) * nargs);
          jcstate->arg_types = (Oid *) palloc(sizeof(Oid) * nargs);
          jcstate->nargs = nargs;

          foreach(lc, args)
          {
            Expr     *arg = (Expr *) lfirst(lc);

            jcstate->arg_types[argno] = exprType((Node *) arg);

            if (IsA(arg, Const))
            {
              /* Don't evaluate const arguments every round */
              Const    *con = (Const *) arg;

              jcstate->arg_values[argno] = con->constvalue;
              jcstate->arg_nulls[argno] = con->constisnull;
            }
            else
            {
              ExecInitExprRec(arg, state,
                      &jcstate->arg_values[argno],
                      &jcstate->arg_nulls[argno]);
            }
            argno++;
          }

          /* prepare type cache for datum_to_json[b]() */
          if (ctor->type == JSCTOR_JSON_SCALAR)
          {
            bool    is_jsonb =
              ctor->returning->format->format_type == JS_FORMAT_JSONB;

            jcstate->arg_type_cache =
              palloc(sizeof(*jcstate->arg_type_cache) * nargs);

            for (int i = 0; i < nargs; i++)
            {
              JsonTypeCategory category;
              Oid     outfuncid;
              Oid     typid = jcstate->arg_types[i];

              json_categorize_type(typid, is_jsonb,
                         &category, &outfuncid);

              jcstate->arg_type_cache[i].outfuncid = outfuncid;
              jcstate->arg_type_cache[i].category = (int) category;
            }
          }

          ExprEvalPushStep(state, &scratch);
        }

        if (ctor->coercion)
        {
          Datum    *innermost_caseval = state->innermost_caseval;
          bool     *innermost_isnull = state->innermost_casenull;

          state->innermost_caseval = resv;
          state->innermost_casenull = resnull;

          ExecInitExprRec(ctor->coercion, state, resv, resnull);

          state->innermost_caseval = innermost_caseval;
          state->innermost_casenull = innermost_isnull;
        }
      }
      break;

    case T_JsonIsPredicate:
      {
        JsonIsPredicate *pred = (JsonIsPredicate *) node;

        ExecInitExprRec((Expr *) pred->expr, state, resv, resnull);

        scratch.opcode = EEOP_IS_JSON;
        scratch.d.is_json.pred = pred;

        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_JsonExpr:
      {
        JsonExpr   *jsexpr = castNode(JsonExpr, node);

        /*
         * No need to initialize a full JsonExprState For
         * JSON_TABLE(), because the upstream caller tfuncFetchRows()
         * is only interested in the value of formatted_expr.
         */
        if (jsexpr->op == JSON_TABLE_OP)
          ExecInitExprRec((Expr *) jsexpr->formatted_expr, state,
                  resv, resnull);
        else
          ExecInitJsonExpr(jsexpr, state, resv, resnull, &scratch);
        break;
      }

    case T_NullTest:
      {
        NullTest   *ntest = (NullTest *) node;

        if (ntest->nulltesttype == IS_NULL)
        {
          if (ntest->argisrow)
            scratch.opcode = EEOP_NULLTEST_ROWISNULL;
          else
            scratch.opcode = EEOP_NULLTEST_ISNULL;
        }
        else if (ntest->nulltesttype == IS_NOT_NULL)
        {
          if (ntest->argisrow)
            scratch.opcode = EEOP_NULLTEST_ROWISNOTNULL;
          else
            scratch.opcode = EEOP_NULLTEST_ISNOTNULL;
        }
        else
        {
          elog(ERROR, "unrecognized nulltesttype: %d",
             (int) ntest->nulltesttype);
        }
        /* initialize cache in case it's a row test */
        scratch.d.nulltest_row.rowcache.cacheptr = NULL;

        /* first evaluate argument into result variable */
        ExecInitExprRec(ntest->arg, state,
                resv, resnull);

        /* then push the test of that argument */
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_BooleanTest:
      {
        BooleanTest *btest = (BooleanTest *) node;

        /*
         * Evaluate argument, directly into result datum.  That's ok,
         * because resv/resnull is definitely not used anywhere else,
         * and will get overwritten by the below EEOP_BOOLTEST_IS_*
         * step.
         */
        ExecInitExprRec(btest->arg, state, resv, resnull);

        switch (btest->booltesttype)
        {
          case IS_TRUE:
            scratch.opcode = EEOP_BOOLTEST_IS_TRUE;
            break;
          case IS_NOT_TRUE:
            scratch.opcode = EEOP_BOOLTEST_IS_NOT_TRUE;
            break;
          case IS_FALSE:
            scratch.opcode = EEOP_BOOLTEST_IS_FALSE;
            break;
          case IS_NOT_FALSE:
            scratch.opcode = EEOP_BOOLTEST_IS_NOT_FALSE;
            break;
          case IS_UNKNOWN:
            /* Same as scalar IS NULL test */
            scratch.opcode = EEOP_NULLTEST_ISNULL;
            break;
          case IS_NOT_UNKNOWN:
            /* Same as scalar IS NOT NULL test */
            scratch.opcode = EEOP_NULLTEST_ISNOTNULL;
            break;
          default:
            elog(ERROR, "unrecognized booltesttype: %d",
               (int) btest->booltesttype);
        }

        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_CoerceToDomain:
      {
        CoerceToDomain *ctest = (CoerceToDomain *) node;

        ExecInitCoerceToDomain(&scratch, ctest, state,
                     resv, resnull);
        break;
      }

    case T_CoerceToDomainValue:
      {
        /*
         * Read from location identified by innermost_domainval.  Note
         * that innermost_domainval could be NULL, if we're compiling
         * a standalone domain check rather than one embedded in a
         * larger expression.  In that case we must read from
         * econtext->domainValue_datum.  We'll take care of that by
         * generating a specialized operation.
         */
        if (state->innermost_domainval == NULL)
          scratch.opcode = EEOP_DOMAIN_TESTVAL_EXT;
        else
        {
          scratch.opcode = EEOP_DOMAIN_TESTVAL;
          /* we share instruction union variant with case testval */
          scratch.d.casetest.value = state->innermost_domainval;
          scratch.d.casetest.isnull = state->innermost_domainnull;
        }
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_CurrentOfExpr:
      {
        scratch.opcode = EEOP_CURRENTOFEXPR;
        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_NextValueExpr:
      {
        NextValueExpr *nve = (NextValueExpr *) node;

        scratch.opcode = EEOP_NEXTVALUEEXPR;
        scratch.d.nextvalueexpr.seqid = nve->seqid;
        scratch.d.nextvalueexpr.seqtypid = nve->typeId;

        ExprEvalPushStep(state, &scratch);
        break;
      }

    case T_ReturningExpr:
      {
        ReturningExpr *rexpr = (ReturningExpr *) node;
        int     retstep;

        /* Skip expression evaluation if OLD/NEW row doesn't exist */
        scratch.opcode = EEOP_RETURNINGEXPR;
        scratch.d.returningexpr.nullflag = rexpr->retold ?
          EEO_FLAG_OLD_IS_NULL : EEO_FLAG_NEW_IS_NULL;
        scratch.d.returningexpr.jumpdone = -1;  /* set below */
        ExprEvalPushStep(state, &scratch);
        retstep = state->steps_len - 1;

        /* Steps to evaluate expression to return */
        ExecInitExprRec(rexpr->retexpr, state, resv, resnull);

        /* Jump target used if OLD/NEW row doesn't exist */
        state->steps[retstep].d.returningexpr.jumpdone = state->steps_len;

        /* Update ExprState flags */
        if (rexpr->retold)
          state->flags |= EEO_FLAG_HAS_OLD;
        else
          state->flags |= EEO_FLAG_HAS_NEW;

        break;
      }

    default:
      elog(ERROR, "unrecognized node type: %d",
         (int) nodeTag(node));
      break;
  }
}

/*
 * Add another expression evaluation step to ExprState->steps.
 *
 * Note that this potentially re-allocates es->steps, therefore no pointer
 * into that array may be used while the expression is still being built.
 */
void
ExprEvalPushStep(ExprState *es, const ExprEvalStep *s)
{
  if (es->steps_alloc == 0)
  {
    es->steps_alloc = 16;
    es->steps = palloc(sizeof(ExprEvalStep) * es->steps_alloc);
  }
  else if (es->steps_alloc == es->steps_len)
  {
    es->steps_alloc *= 2;
    es->steps = repalloc(es->steps,
               sizeof(ExprEvalStep) * es->steps_alloc);
  }

  memcpy(&es->steps[es->steps_len++], s, sizeof(ExprEvalStep));
}

/*
 * Perform setup necessary for the evaluation of a function-like expression,
 * appending argument evaluation steps to the steps list in *state, and
 * setting up *scratch so it is ready to be pushed.
 *
 * *scratch is not pushed here, so that callers may override the opcode,
 * which is useful for function-like cases like DISTINCT.
 */
static void
ExecInitFunc(ExprEvalStep *scratch, Expr *node, List *args, Oid funcid,
       Oid inputcollid, ExprState *state)
{
  int     nargs = list_length(args);
  AclResult aclresult;
  FmgrInfo   *flinfo;
  FunctionCallInfo fcinfo;
  int     argno;
  ListCell   *lc;

  /* Check permission to call function */
  aclresult = object_aclcheck(ProcedureRelationId, funcid, GetUserId(), ACL_EXECUTE);
  if (aclresult != ACLCHECK_OK)
    aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(funcid));
  InvokeFunctionExecuteHook(funcid);

  /*
   * Safety check on nargs.  Under normal circumstances this should never
   * fail, as parser should check sooner.  But possibly it might fail if
   * server has been compiled with FUNC_MAX_ARGS smaller than some functions
   * declared in pg_proc?
   */
  if (nargs > FUNC_MAX_ARGS)
    ereport(ERROR,
        (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
         errmsg_plural("cannot pass more than %d argument to a function",
                 "cannot pass more than %d arguments to a function",
                 FUNC_MAX_ARGS,
                 FUNC_MAX_ARGS)));

  /* Allocate function lookup data and parameter workspace for this call */
  scratch->d.func.finfo = palloc0(sizeof(FmgrInfo));
  scratch->d.func.fcinfo_data = palloc0(SizeForFunctionCallInfo(nargs));
  flinfo = scratch->d.func.finfo;
  fcinfo = scratch->d.func.fcinfo_data;

  /* Set up the primary fmgr lookup information */
  fmgr_info(funcid, flinfo);
  fmgr_info_set_expr((Node *) node, flinfo);

  /* Initialize function call parameter structure too */
  InitFunctionCallInfoData(*fcinfo, flinfo,
               nargs, inputcollid, NULL, NULL);

  /* Keep extra copies of this info to save an indirection at runtime */
  scratch->d.func.fn_addr = flinfo->fn_addr;
  scratch->d.func.nargs = nargs;

  /* We only support non-set functions here */
  if (flinfo->fn_retset)
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
         errmsg("set-valued function called in context that cannot accept a set"),
         state->parent ?
         executor_errposition(state->parent->state,
                    exprLocation((Node *) node)) : 0));

  /* Build code to evaluate arguments directly into the fcinfo struct */
  argno = 0;
  foreach(lc, args)
  {
    Expr     *arg = (Expr *) lfirst(lc);

    if (IsA(arg, Const))
    {
      /*
       * Don't evaluate const arguments every round; especially
       * interesting for constants in comparisons.
       */
      Const    *con = (Const *) arg;

      fcinfo->args[argno].value = con->constvalue;
      fcinfo->args[argno].isnull = con->constisnull;
    }
    else
    {
      ExecInitExprRec(arg, state,
              &fcinfo->args[argno].value,
              &fcinfo->args[argno].isnull);
    }
    argno++;
  }

  /* Insert appropriate opcode depending on strictness and stats level */
  if (pgstat_track_functions <= flinfo->fn_stats)
  {
    if (flinfo->fn_strict && nargs > 0)
    {
      /* Choose nargs optimized implementation if available. */
      if (nargs == 1)
        scratch->opcode = EEOP_FUNCEXPR_STRICT_1;
      else if (nargs == 2)
        scratch->opcode = EEOP_FUNCEXPR_STRICT_2;
      else
        scratch->opcode = EEOP_FUNCEXPR_STRICT;
    }
    else
      scratch->opcode = EEOP_FUNCEXPR;
  }
  else
  {
    if (flinfo->fn_strict && nargs > 0)
      scratch->opcode = EEOP_FUNCEXPR_STRICT_FUSAGE;
    else
      scratch->opcode = EEOP_FUNCEXPR_FUSAGE;
  }
}

/*
 * Append the steps necessary for the evaluation of a SubPlan node to
 * ExprState->steps.
 *
 * subplan - SubPlan expression to evaluate
 * state - ExprState to whose ->steps to append the necessary operations
 * resv / resnull - where to store the result of the node into
 */
static void
ExecInitSubPlanExpr(SubPlan *subplan,
          ExprState *state,
          Datum *resv, bool *resnull)
{
  ExprEvalStep scratch = {0};
  SubPlanState *sstate;
  ListCell   *pvar;
  ListCell   *l;

  if (!state->parent)
    elog(ERROR, "SubPlan found with no parent plan");

  /*
   * Generate steps to evaluate input arguments for the subplan.
   *
   * We evaluate the argument expressions into ExprState's resvalue/resnull,
   * and then use PARAM_SET to update the parameter. We do that, instead of
   * evaluating directly into the param, to avoid depending on the pointer
   * value remaining stable / being included in the generated expression. No
   * danger of conflicts with other uses of resvalue/resnull as storing and
   * using the value always is in subsequent steps.
   *
   * Any calculation we have to do can be done in the parent econtext, since
   * the Param values don't need to have per-query lifetime.
   */
  Assert(list_length(subplan->parParam) == list_length(subplan->args));
  forboth(l, subplan->parParam, pvar, subplan->args)
  {
    int     paramid = lfirst_int(l);
    Expr     *arg = (Expr *) lfirst(pvar);

    ExecInitExprRec(arg, state,
            &state->resvalue, &state->resnull);

    scratch.opcode = EEOP_PARAM_SET;
    scratch.d.param.paramid = paramid;
    /* paramtype's not actually used, but we might as well fill it */
    scratch.d.param.paramtype = exprType((Node *) arg);
    ExprEvalPushStep(state, &scratch);
  }

  sstate = ExecInitSubPlan(subplan, state->parent);

  /* add SubPlanState nodes to state->parent->subPlan */
  state->parent->subPlan = lappend(state->parent->subPlan,
                   sstate);

  scratch.opcode = EEOP_SUBPLAN;
  scratch.resvalue = resv;
  scratch.resnull = resnull;
  scratch.d.subplan.sstate = sstate;

  ExprEvalPushStep(state, &scratch);
}

/*
 * Add expression steps performing setup that's needed before any of the
 * main execution of the expression.
 */
static void
ExecCreateExprSetupSteps(ExprState *state, Node *node)
{
  ExprSetupInfo info = {0, 0, 0, 0, 0, NIL};

  /* Prescan to find out what we need. */
  expr_setup_walker(node, &info);

  /* And generate those steps. */
  ExecPushExprSetupSteps(state, &info);
}

/*
 * Add steps performing expression setup as indicated by "info".
 * This is useful when building an ExprState covering more than one expression.
 */
static void
ExecPushExprSetupSteps(ExprState *state, ExprSetupInfo *info)
{
  ExprEvalStep scratch = {0};
  ListCell   *lc;

  scratch.resvalue = NULL;
  scratch.resnull = NULL;

  /*
   * Add steps deforming the ExprState's inner/outer/scan/old/new slots as
   * much as required by any Vars appearing in the expression.
   */
  if (info->last_inner > 0)
  {
    scratch.opcode = EEOP_INNER_FETCHSOME;
    scratch.d.fetch.last_var = info->last_inner;
    scratch.d.fetch.fixed = false;
    scratch.d.fetch.kind = NULL;
    scratch.d.fetch.known_desc = NULL;
    if (ExecComputeSlotInfo(state, &scratch))
      ExprEvalPushStep(state, &scratch);
  }
  if (info->last_outer > 0)
  {
    scratch.opcode = EEOP_OUTER_FETCHSOME;
    scratch.d.fetch.last_var = info->last_outer;
    scratch.d.fetch.fixed = false;
    scratch.d.fetch.kind = NULL;
    scratch.d.fetch.known_desc = NULL;
    if (ExecComputeSlotInfo(state, &scratch))
      ExprEvalPushStep(state, &scratch);
  }
  if (info->last_scan > 0)
  {
    scratch.opcode = EEOP_SCAN_FETCHSOME;
    scratch.d.fetch.last_var = info->last_scan;
    scratch.d.fetch.fixed = false;
    scratch.d.fetch.kind = NULL;
    scratch.d.fetch.known_desc = NULL;
    if (ExecComputeSlotInfo(state, &scratch))
      ExprEvalPushStep(state, &scratch);
  }
  if (info->last_old > 0)
  {
    scratch.opcode = EEOP_OLD_FETCHSOME;
    scratch.d.fetch.last_var = info->last_old;
    scratch.d.fetch.fixed = false;
    scratch.d.fetch.kind = NULL;
    scratch.d.fetch.known_desc = NULL;
    if (ExecComputeSlotInfo(state, &scratch))
      ExprEvalPushStep(state, &scratch);
  }
  if (info->last_new > 0)
  {
    scratch.opcode = EEOP_NEW_FETCHSOME;
    scratch.d.fetch.last_var = info->last_new;
    scratch.d.fetch.fixed = false;
    scratch.d.fetch.kind = NULL;
    scratch.d.fetch.known_desc = NULL;
    if (ExecComputeSlotInfo(state, &scratch))
      ExprEvalPushStep(state, &scratch);
  }

  /*
   * Add steps to execute any MULTIEXPR SubPlans appearing in the
   * expression.  We need to evaluate these before any of the Params
   * referencing their outputs are used, but after we've prepared for any
   * Var references they may contain.  (There cannot be cross-references
   * between MULTIEXPR SubPlans, so we needn't worry about their order.)
   */
  foreach(lc, info->multiexpr_subplans)
  {
    SubPlan    *subplan = (SubPlan *) lfirst(lc);

    Assert(subplan->subLinkType == MULTIEXPR_SUBLINK);

    /* The result can be ignored, but we better put it somewhere */
    ExecInitSubPlanExpr(subplan, state,
              &state->resvalue, &state->resnull);
  }
}

/*
 * expr_setup_walker: expression walker for ExecCreateExprSetupSteps
 */
static bool
expr_setup_walker(Node *node, ExprSetupInfo *info)
{
  if (node == NULL)
    return false;
  if (IsA(node, Var))
  {
    Var      *variable = (Var *) node;
    AttrNumber  attnum = variable->varattno;

    switch (variable->varno)
    {
      case INNER_VAR:
        info->last_inner = Max(info->last_inner, attnum);
        break;

      case OUTER_VAR:
        info->last_outer = Max(info->last_outer, attnum);
        break;

        /* INDEX_VAR is handled by default case */

      default:
        switch (variable->varreturningtype)
        {
          case VAR_RETURNING_DEFAULT:
            info->last_scan = Max(info->last_scan, attnum);
            break;
          case VAR_RETURNING_OLD:
            info->last_old = Max(info->last_old, attnum);
            break;
          case VAR_RETURNING_NEW:
            info->last_new = Max(info->last_new, attnum);
            break;
        }
        break;
    }
    return false;
  }

  /* Collect all MULTIEXPR SubPlans, too */
  if (IsA(node, SubPlan))
  {
    SubPlan    *subplan = (SubPlan *) node;

    if (subplan->subLinkType == MULTIEXPR_SUBLINK)
      info->multiexpr_subplans = lappend(info->multiexpr_subplans,
                         subplan);
  }

  /*
   * Don't examine the arguments or filters of Aggrefs or WindowFuncs,
   * because those do not represent expressions to be evaluated within the
   * calling expression's econtext.  GroupingFunc arguments are never
   * evaluated at all.
   */
  if (IsA(node, Aggref))
    return false;
  if (IsA(node, WindowFunc))
    return false;
  if (IsA(node, GroupingFunc))
    return false;
  return expression_tree_walker(node, expr_setup_walker, info);
}

/*
 * Compute additional information for EEOP_*_FETCHSOME ops.
 *
 * The goal is to determine whether a slot is 'fixed', that is, every
 * evaluation of the expression will have the same type of slot, with an
 * equivalent descriptor.
 *
 * EEOP_OLD_FETCHSOME and EEOP_NEW_FETCHSOME are used to process RETURNING, if
 * OLD/NEW columns are referred to explicitly.  In both cases, the tuple
 * descriptor comes from the parent scan node, so we treat them the same as
 * EEOP_SCAN_FETCHSOME.
 *
 * Returns true if the deforming step is required, false otherwise.
 */
static bool
ExecComputeSlotInfo(ExprState *state, ExprEvalStep *op)
{
  PlanState  *parent = state->parent;
  TupleDesc desc = NULL;
  const TupleTableSlotOps *tts_ops = NULL;
  bool    isfixed = false;
  ExprEvalOp  opcode = op->opcode;

  Assert(opcode == EEOP_INNER_FETCHSOME ||
       opcode == EEOP_OUTER_FETCHSOME ||
       opcode == EEOP_SCAN_FETCHSOME ||
       opcode == EEOP_OLD_FETCHSOME ||
       opcode == EEOP_NEW_FETCHSOME);

  if (op->d.fetch.known_desc != NULL)
  {
    desc = op->d.fetch.known_desc;
    tts_ops = op->d.fetch.kind;
    isfixed = op->d.fetch.kind != NULL;
  }
  else if (!parent)
  {
    isfixed = false;
  }
  else if (opcode == EEOP_INNER_FETCHSOME)
  {
    PlanState  *is = innerPlanState(parent);

    if (parent->inneropsset && !parent->inneropsfixed)
    {
      isfixed = false;
    }
    else if (parent->inneropsset && parent->innerops)
    {
      isfixed = true;
      tts_ops = parent->innerops;
      desc = ExecGetResultType(is);
    }
    else if (is)
    {
      tts_ops = ExecGetResultSlotOps(is, &isfixed);
      desc = ExecGetResultType(is);
    }
  }
  else if (opcode == EEOP_OUTER_FETCHSOME)
  {
    PlanState  *os = outerPlanState(parent);

    if (parent->outeropsset && !parent->outeropsfixed)
    {
      isfixed = false;
    }
    else if (parent->outeropsset && parent->outerops)
    {
      isfixed = true;
      tts_ops = parent->outerops;
      desc = ExecGetResultType(os);
    }
    else if (os)
    {
      tts_ops = ExecGetResultSlotOps(os, &isfixed);
      desc = ExecGetResultType(os);
    }
  }
  else if (opcode == EEOP_SCAN_FETCHSOME ||
       opcode == EEOP_OLD_FETCHSOME ||
       opcode == EEOP_NEW_FETCHSOME)
  {
    desc = parent->scandesc;

    if (parent->scanops)
      tts_ops = parent->scanops;

    if (parent->scanopsset)
      isfixed = parent->scanopsfixed;
  }

  if (isfixed && desc != NULL && tts_ops != NULL)
  {
    op->d.fetch.fixed = true;
    op->d.fetch.kind = tts_ops;
    op->d.fetch.known_desc = desc;
  }
  else
  {
    op->d.fetch.fixed = false;
    op->d.fetch.kind = NULL;
    op->d.fetch.known_desc = NULL;
  }

  /* if the slot is known to always virtual we never need to deform */
  if (op->d.fetch.fixed && op->d.fetch.kind == &TTSOpsVirtual)
    return false;

  return true;
}

/*
 * Prepare step for the evaluation of a whole-row variable.
 * The caller still has to push the step.
 */
static void
ExecInitWholeRowVar(ExprEvalStep *scratch, Var *variable, ExprState *state)
{
  PlanState  *parent = state->parent;

  /* fill in all but the target */
  scratch->opcode = EEOP_WHOLEROW;
  scratch->d.wholerow.var = variable;
  scratch->d.wholerow.first = true;
  scratch->d.wholerow.slow = false;
  scratch->d.wholerow.tupdesc = NULL; /* filled at runtime */
  scratch->d.wholerow.junkFilter = NULL;

  /* update ExprState flags if Var refers to OLD/NEW */
  if (variable->varreturningtype == VAR_RETURNING_OLD)
    state->flags |= EEO_FLAG_HAS_OLD;
  else if (variable->varreturningtype == VAR_RETURNING_NEW)
    state->flags |= EEO_FLAG_HAS_NEW;

  /*
   * If the input tuple came from a subquery, it might contain "resjunk"
   * columns (such as GROUP BY or ORDER BY columns), which we don't want to
   * keep in the whole-row result.  We can get rid of such columns by
   * passing the tuple through a JunkFilter --- but to make one, we have to
   * lay our hands on the subquery's targetlist.  Fortunately, there are not
   * very many cases where this can happen, and we can identify all of them
   * by examining our parent PlanState.  We assume this is not an issue in
   * standalone expressions that don't have parent plans.  (Whole-row Vars
   * can occur in such expressions, but they will always be referencing
   * table rows.)
   */
  if (parent)
  {
    PlanState  *subplan = NULL;

    switch (nodeTag(parent))
    {
      case T_SubqueryScanState:
        subplan = ((SubqueryScanState *) parent)->subplan;
        break;
      case T_CteScanState:
        subplan = ((CteScanState *) parent)->cteplanstate;
        break;
      default:
        break;
    }

    if (subplan)
    {
      bool    junk_filter_needed = false;
      ListCell   *tlist;

      /* Detect whether subplan tlist actually has any junk columns */
      foreach(tlist, subplan->plan->targetlist)
      {
        TargetEntry *tle = (TargetEntry *) lfirst(tlist);

        if (tle->resjunk)
        {
          junk_filter_needed = true;
          break;
        }
      }

      /* If so, build the junkfilter now */
      if (junk_filter_needed)
      {
        scratch->d.wholerow.junkFilter =
          ExecInitJunkFilter(subplan->plan->targetlist,
                     ExecInitExtraTupleSlot(parent->state, NULL,
                                &TTSOpsVirtual));
      }
    }
  }
}

/*
 * Prepare evaluation of a SubscriptingRef expression.
 */
static void
ExecInitSubscriptingRef(ExprEvalStep *scratch, SubscriptingRef *sbsref,
            ExprState *state, Datum *resv, bool *resnull)
{
  bool    isAssignment = (sbsref->refassgnexpr != NULL);
  int     nupper = list_length(sbsref->refupperindexpr);
  int     nlower = list_length(sbsref->reflowerindexpr);
  const SubscriptRoutines *sbsroutines;
  SubscriptingRefState *sbsrefstate;
  SubscriptExecSteps methods;
  char     *ptr;
  List     *adjust_jumps = NIL;
  ListCell   *lc;
  int     i;

  /* Look up the subscripting support methods */
  sbsroutines = getSubscriptingRoutines(sbsref->refcontainertype, NULL);
  if (!sbsroutines)
    ereport(ERROR,
        (errcode(ERRCODE_DATATYPE_MISMATCH),
         errmsg("cannot subscript type %s because it does not support subscripting",
            format_type_be(sbsref->refcontainertype)),
         state->parent ?
         executor_errposition(state->parent->state,
                    exprLocation((Node *) sbsref)) : 0));

  /* Allocate sbsrefstate, with enough space for per-subscript arrays too */
  sbsrefstate = palloc0(MAXALIGN(sizeof(SubscriptingRefState)) +
              (nupper + nlower) * (sizeof(Datum) +
                         2 * sizeof(bool)));

  /* Fill constant fields of SubscriptingRefState */
  sbsrefstate->isassignment = isAssignment;
  sbsrefstate->numupper = nupper;
  sbsrefstate->numlower = nlower;
  /* Set up per-subscript arrays */
  ptr = ((char *) sbsrefstate) + MAXALIGN(sizeof(SubscriptingRefState));
  sbsrefstate->upperindex = (Datum *) ptr;
  ptr += nupper * sizeof(Datum);
  sbsrefstate->lowerindex = (Datum *) ptr;
  ptr += nlower * sizeof(Datum);
  sbsrefstate->upperprovided = (bool *) ptr;
  ptr += nupper * sizeof(bool);
  sbsrefstate->lowerprovided = (bool *) ptr;
  ptr += nlower * sizeof(bool);
  sbsrefstate->upperindexnull = (bool *) ptr;
  ptr += nupper * sizeof(bool);
  sbsrefstate->lowerindexnull = (bool *) ptr;
  /* ptr += nlower * sizeof(bool); */

  /*
   * Let the container-type-specific code have a chance.  It must fill the
   * "methods" struct with function pointers for us to possibly use in
   * execution steps below; and it can optionally set up some data pointed
   * to by the workspace field.
   */
  memset(&methods, 0, sizeof(methods));
  sbsroutines->exec_setup(sbsref, sbsrefstate, &methods);

  /*
   * Evaluate array input.  It's safe to do so into resv/resnull, because we
   * won't use that as target for any of the other subexpressions, and it'll
   * be overwritten by the final EEOP_SBSREF_FETCH/ASSIGN step, which is
   * pushed last.
   */
  ExecInitExprRec(sbsref->refexpr, state, resv, resnull);

  /*
   * If refexpr yields NULL, and the operation should be strict, then result
   * is NULL.  We can implement this with just JUMP_IF_NULL, since we
   * evaluated the array into the desired target location.
   */
  if (!isAssignment && sbsroutines->fetch_strict)
  {
    scratch->opcode = EEOP_JUMP_IF_NULL;
    scratch->d.jump.jumpdone = -1;  /* adjust later */
    ExprEvalPushStep(state, scratch);
    adjust_jumps = lappend_int(adjust_jumps,
                   state->steps_len - 1);
  }

  /* Evaluate upper subscripts */
  i = 0;
  foreach(lc, sbsref->refupperindexpr)
  {
    Expr     *e = (Expr *) lfirst(lc);

    /* When slicing, individual subscript bounds can be omitted */
    if (!e)
    {
      sbsrefstate->upperprovided[i] = false;
      sbsrefstate->upperindexnull[i] = true;
    }
    else
    {
      sbsrefstate->upperprovided[i] = true;
      /* Each subscript is evaluated into appropriate array entry */
      ExecInitExprRec(e, state,
              &sbsrefstate->upperindex[i],
              &sbsrefstate->upperindexnull[i]);
    }
    i++;
  }

  /* Evaluate lower subscripts similarly */
  i = 0;
  foreach(lc, sbsref->reflowerindexpr)
  {
    Expr     *e = (Expr *) lfirst(lc);

    /* When slicing, individual subscript bounds can be omitted */
    if (!e)
    {
      sbsrefstate->lowerprovided[i] = false;
      sbsrefstate->lowerindexnull[i] = true;
    }
    else
    {
      sbsrefstate->lowerprovided[i] = true;
      /* Each subscript is evaluated into appropriate array entry */
      ExecInitExprRec(e, state,
              &sbsrefstate->lowerindex[i],
              &sbsrefstate->lowerindexnull[i]);
    }
    i++;
  }

  /* SBSREF_SUBSCRIPTS checks and converts all the subscripts at once */
  if (methods.sbs_check_subscripts)
  {
    scratch->opcode = EEOP_SBSREF_SUBSCRIPTS;
    scratch->d.sbsref_subscript.subscriptfunc = methods.sbs_check_subscripts;
    scratch->d.sbsref_subscript.state = sbsrefstate;
    scratch->d.sbsref_subscript.jumpdone = -1;  /* adjust later */
    ExprEvalPushStep(state, scratch);
    adjust_jumps = lappend_int(adjust_jumps,
                   state->steps_len - 1);
  }

  if (isAssignment)
  {
    Datum    *save_innermost_caseval;
    bool     *save_innermost_casenull;

    /* Check for unimplemented methods */
    if (!methods.sbs_assign)
      ereport(ERROR,
          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
           errmsg("type %s does not support subscripted assignment",
              format_type_be(sbsref->refcontainertype))));

    /*
     * We might have a nested-assignment situation, in which the
     * refassgnexpr is itself a FieldStore or SubscriptingRef that needs
     * to obtain and modify the previous value of the array element or
     * slice being replaced.  If so, we have to extract that value from
     * the array and pass it down via the CaseTestExpr mechanism.  It's
     * safe to reuse the CASE mechanism because there cannot be a CASE
     * between here and where the value would be needed, and an array
     * assignment can't be within a CASE either.  (So saving and restoring
     * innermost_caseval is just paranoia, but let's do it anyway.)
     *
     * Since fetching the old element might be a nontrivial expense, do it
     * only if the argument actually needs it.
     */
    if (isAssignmentIndirectionExpr(sbsref->refassgnexpr))
    {
      if (!methods.sbs_fetch_old)
        ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             errmsg("type %s does not support subscripted assignment",
                format_type_be(sbsref->refcontainertype))));
      scratch->opcode = EEOP_SBSREF_OLD;
      scratch->d.sbsref.subscriptfunc = methods.sbs_fetch_old;
      scratch->d.sbsref.state = sbsrefstate;
      ExprEvalPushStep(state, scratch);
    }

    /* SBSREF_OLD puts extracted value into prevvalue/prevnull */
    save_innermost_caseval = state->innermost_caseval;
    save_innermost_casenull = state->innermost_casenull;
    state->innermost_caseval = &sbsrefstate->prevvalue;
    state->innermost_casenull = &sbsrefstate->prevnull;

    /* evaluate replacement value into replacevalue/replacenull */
    ExecInitExprRec(sbsref->refassgnexpr, state,
            &sbsrefstate->replacevalue, &sbsrefstate->replacenull);

    state->innermost_caseval = save_innermost_caseval;
    state->innermost_casenull = save_innermost_casenull;

    /* and perform the assignment */
    scratch->opcode = EEOP_SBSREF_ASSIGN;
    scratch->d.sbsref.subscriptfunc = methods.sbs_assign;
    scratch->d.sbsref.state = sbsrefstate;
    ExprEvalPushStep(state, scratch);
  }
  else
  {
    /* array fetch is much simpler */
    scratch->opcode = EEOP_SBSREF_FETCH;
    scratch->d.sbsref.subscriptfunc = methods.sbs_fetch;
    scratch->d.sbsref.state = sbsrefstate;
    ExprEvalPushStep(state, scratch);
  }

  /* adjust jump targets */
  foreach(lc, adjust_jumps)
  {
    ExprEvalStep *as = &state->steps[lfirst_int(lc)];

    if (as->opcode == EEOP_SBSREF_SUBSCRIPTS)
    {
      Assert(as->d.sbsref_subscript.jumpdone == -1);
      as->d.sbsref_subscript.jumpdone = state->steps_len;
    }
    else
    {
      Assert(as->opcode == EEOP_JUMP_IF_NULL);
      Assert(as->d.jump.jumpdone == -1);
      as->d.jump.jumpdone = state->steps_len;
    }
  }
}

/*
 * Helper for preparing SubscriptingRef expressions for evaluation: is expr
 * a nested FieldStore or SubscriptingRef that needs the old element value
 * passed down?
 *
 * (We could use this in FieldStore too, but in that case passing the old
 * value is so cheap there's no need.)
 *
 * Note: it might seem that this needs to recurse, but in most cases it does
 * not; the CaseTestExpr, if any, will be directly the arg or refexpr of the
 * top-level node.  Nested-assignment situations give rise to expression
 * trees in which each level of assignment has its own CaseTestExpr, and the
 * recursive structure appears within the newvals or refassgnexpr field.
 * There is an exception, though: if the array is an array-of-domain, we will
 * have a CoerceToDomain or RelabelType as the refassgnexpr, and we need to
 * be able to look through that.
 */
static bool
isAssignmentIndirectionExpr(Expr *expr)
{
  if (expr == NULL)
    return false;     /* just paranoia */
  if (IsA(expr, FieldStore))
  {
    FieldStore *fstore = (FieldStore *) expr;

    if (fstore->arg && IsA(fstore->arg, CaseTestExpr))
      return true;
  }
  else if (IsA(expr, SubscriptingRef))
  {
    SubscriptingRef *sbsRef = (SubscriptingRef *) expr;

    if (sbsRef->refexpr && IsA(sbsRef->refexpr, CaseTestExpr))
      return true;
  }
  else if (IsA(expr, CoerceToDomain))
  {
    CoerceToDomain *cd = (CoerceToDomain *) expr;

    return isAssignmentIndirectionExpr(cd->arg);
  }
  else if (IsA(expr, RelabelType))
  {
    RelabelType *r = (RelabelType *) expr;

    return isAssignmentIndirectionExpr(r->arg);
  }
  return false;
}

/*
 * Prepare evaluation of a CoerceToDomain expression.
 */
static void
ExecInitCoerceToDomain(ExprEvalStep *scratch, CoerceToDomain *ctest,
             ExprState *state, Datum *resv, bool *resnull)
{
  DomainConstraintRef *constraint_ref;
  Datum    *domainval = NULL;
  bool     *domainnull = NULL;
  ListCell   *l;

  scratch->d.domaincheck.resulttype = ctest->resulttype;
  /* we'll allocate workspace only if needed */
  scratch->d.domaincheck.checkvalue = NULL;
  scratch->d.domaincheck.checknull = NULL;
  scratch->d.domaincheck.escontext = state->escontext;

  /*
   * Evaluate argument - it's fine to directly store it into resv/resnull,
   * if there's constraint failures there'll be errors, otherwise it's what
   * needs to be returned.
   */
  ExecInitExprRec(ctest->arg, state, resv, resnull);

  /*
   * Note: if the argument is of varlena type, it could be a R/W expanded
   * object.  We want to return the R/W pointer as the final result, but we
   * have to pass a R/O pointer as the value to be tested by any functions
   * in check expressions.  We don't bother to emit a MAKE_READONLY step
   * unless there's actually at least one check expression, though.  Until
   * we've tested that, domainval/domainnull are NULL.
   */

  /*
   * Collect the constraints associated with the domain.
   *
   * Note: before PG v10 we'd recheck the set of constraints during each
   * evaluation of the expression.  Now we bake them into the ExprState
   * during executor initialization.  That means we don't need typcache.c to
   * provide compiled exprs.
   */
  constraint_ref = (DomainConstraintRef *)
    palloc(sizeof(DomainConstraintRef));
  InitDomainConstraintRef(ctest->resulttype,
              constraint_ref,
              CurrentMemoryContext,
              false);

  /*
   * Compile code to check each domain constraint.  NOTNULL constraints can
   * just be applied on the resv/resnull value, but for CHECK constraints we
   * need more pushups.
   */
  foreach(l, constraint_ref->constraints)
  {
    DomainConstraintState *con = (DomainConstraintState *) lfirst(l);
    Datum    *save_innermost_domainval;
    bool     *save_innermost_domainnull;

    scratch->d.domaincheck.constraintname = con->name;

    switch (con->constrainttype)
    {
      case DOM_CONSTRAINT_NOTNULL:
        scratch->opcode = EEOP_DOMAIN_NOTNULL;
        ExprEvalPushStep(state, scratch);
        break;
      case DOM_CONSTRAINT_CHECK:
        /* Allocate workspace for CHECK output if we didn't yet */
        if (scratch->d.domaincheck.checkvalue == NULL)
        {
          scratch->d.domaincheck.checkvalue =
            (Datum *) palloc(sizeof(Datum));
          scratch->d.domaincheck.checknull =
            (bool *) palloc(sizeof(bool));
        }

        /*
         * If first time through, determine where CoerceToDomainValue
         * nodes should read from.
         */
        if (domainval == NULL)
        {
          /*
           * Since value might be read multiple times, force to R/O
           * - but only if it could be an expanded datum.
           */
          if (get_typlen(ctest->resulttype) == -1)
          {
            ExprEvalStep scratch2 = {0};

            /* Yes, so make output workspace for MAKE_READONLY */
            domainval = (Datum *) palloc(sizeof(Datum));
            domainnull = (bool *) palloc(sizeof(bool));

            /* Emit MAKE_READONLY */
            scratch2.opcode = EEOP_MAKE_READONLY;
            scratch2.resvalue = domainval;
            scratch2.resnull = domainnull;
            scratch2.d.make_readonly.value = resv;
            scratch2.d.make_readonly.isnull = resnull;
            ExprEvalPushStep(state, &scratch2);
          }
          else
          {
            /* No, so it's fine to read from resv/resnull */
            domainval = resv;
            domainnull = resnull;
          }
        }

        /*
         * Set up value to be returned by CoerceToDomainValue nodes.
         * We must save and restore innermost_domainval/null fields,
         * in case this node is itself within a check expression for
         * another domain.
         */
        save_innermost_domainval = state->innermost_domainval;
        save_innermost_domainnull = state->innermost_domainnull;
        state->innermost_domainval = domainval;
        state->innermost_domainnull = domainnull;

        /* evaluate check expression value */
        ExecInitExprRec(con->check_expr, state,
                scratch->d.domaincheck.checkvalue,
                scratch->d.domaincheck.checknull);

        state->innermost_domainval = save_innermost_domainval;
        state->innermost_domainnull = save_innermost_domainnull;

        /* now test result */
        scratch->opcode = EEOP_DOMAIN_CHECK;
        ExprEvalPushStep(state, scratch);

        break;
      default:
        elog(ERROR, "unrecognized constraint type: %d",
           (int) con->constrainttype);
        break;
    }
  }
}

/*
 * Build transition/combine function invocations for all aggregate transition
 * / combination function invocations in a grouping sets phase. This has to
 * invoke all sort based transitions in a phase (if doSort is true), all hash
 * based transitions (if doHash is true), or both (both true).
 *
 * The resulting expression will, for each set of transition values, first
 * check for filters, evaluate aggregate input, check that that input is not
 * NULL for a strict transition function, and then finally invoke the
 * transition for each of the concurrently computed grouping sets.
 *
 * If nullcheck is true, the generated code will check for a NULL pointer to
 * the array of AggStatePerGroup, and skip evaluation if so.
 */
ExprState *
ExecBuildAggTrans(AggState *aggstate, AggStatePerPhase phase,
          bool doSort, bool doHash, bool nullcheck)
{
  ExprState  *state = makeNode(ExprState);
  PlanState  *parent = &aggstate->ss.ps;
  ExprEvalStep scratch = {0};
  bool    isCombine = DO_AGGSPLIT_COMBINE(aggstate->aggsplit);
  ExprSetupInfo deform = {0, 0, 0, 0, 0, NIL};

  state->expr = (Expr *) aggstate;
  state->parent = parent;

  scratch.resvalue = &state->resvalue;
  scratch.resnull = &state->resnull;

  /*
   * First figure out which slots, and how many columns from each, we're
   * going to need.
   */
  for (int transno = 0; transno < aggstate->numtrans; transno++)
  {
    AggStatePerTrans pertrans = &aggstate->pertrans[transno];

    expr_setup_walker((Node *) pertrans->aggref->aggdirectargs,
              &deform);
    expr_setup_walker((Node *) pertrans->aggref->args,
              &deform);
    expr_setup_walker((Node *) pertrans->aggref->aggorder,
              &deform);
    expr_setup_walker((Node *) pertrans->aggref->aggdistinct,
              &deform);
    expr_setup_walker((Node *) pertrans->aggref->aggfilter,
              &deform);
  }
  ExecPushExprSetupSteps(state, &deform);

  /*
   * Emit instructions for each transition value / grouping set combination.
   */
  for (int transno = 0; transno < aggstate->numtrans; transno++)
  {
    AggStatePerTrans pertrans = &aggstate->pertrans[transno];
    FunctionCallInfo trans_fcinfo = pertrans->transfn_fcinfo;
    List     *adjust_bailout = NIL;
    NullableDatum *strictargs = NULL;
    bool     *strictnulls = NULL;
    int     argno;
    ListCell   *bail;

    /*
     * If filter present, emit. Do so before evaluating the input, to
     * avoid potentially unneeded computations, or even worse, unintended
     * side-effects.  When combining, all the necessary filtering has
     * already been done.
     */
    if (pertrans->aggref->aggfilter && !isCombine)
    {
      /* evaluate filter expression */
      ExecInitExprRec(pertrans->aggref->aggfilter, state,
              &state->resvalue, &state->resnull);
      /* and jump out if false */
      scratch.opcode = EEOP_JUMP_IF_NOT_TRUE;
      scratch.d.jump.jumpdone = -1; /* adjust later */
      ExprEvalPushStep(state, &scratch);
      adjust_bailout = lappend_int(adjust_bailout,
                     state->steps_len - 1);
    }

    /*
     * Evaluate arguments to aggregate/combine function.
     */
    argno = 0;
    if (isCombine)
    {
      /*
       * Combining two aggregate transition values. Instead of directly
       * coming from a tuple the input is a, potentially deserialized,
       * transition value.
       */
      TargetEntry *source_tle;

      Assert(pertrans->numSortCols == 0);
      Assert(list_length(pertrans->aggref->args) == 1);

      strictargs = trans_fcinfo->args + 1;
      source_tle = (TargetEntry *) linitial(pertrans->aggref->args);

      /*
       * deserialfn_oid will be set if we must deserialize the input
       * state before calling the combine function.
       */
      if (!OidIsValid(pertrans->deserialfn_oid))
      {
        /*
         * Start from 1, since the 0th arg will be the transition
         * value
         */
        ExecInitExprRec(source_tle->expr, state,
                &trans_fcinfo->args[argno + 1].value,
                &trans_fcinfo->args[argno + 1].isnull);
      }
      else
      {
        FunctionCallInfo ds_fcinfo = pertrans->deserialfn_fcinfo;

        /* evaluate argument */
        ExecInitExprRec(source_tle->expr, state,
                &ds_fcinfo->args[0].value,
                &ds_fcinfo->args[0].isnull);

        /* Dummy second argument for type-safety reasons */
        ds_fcinfo->args[1].value = PointerGetDatum(NULL);
        ds_fcinfo->args[1].isnull = false;

        /*
         * Don't call a strict deserialization function with NULL
         * input
         */
        if (pertrans->deserialfn.fn_strict)
          scratch.opcode = EEOP_AGG_STRICT_DESERIALIZE;
        else
          scratch.opcode = EEOP_AGG_DESERIALIZE;

        scratch.d.agg_deserialize.fcinfo_data = ds_fcinfo;
        scratch.d.agg_deserialize.jumpnull = -1;  /* adjust later */
        scratch.resvalue = &trans_fcinfo->args[argno + 1].value;
        scratch.resnull = &trans_fcinfo->args[argno + 1].isnull;

        ExprEvalPushStep(state, &scratch);
        /* don't add an adjustment unless the function is strict */
        if (pertrans->deserialfn.fn_strict)
          adjust_bailout = lappend_int(adjust_bailout,
                         state->steps_len - 1);

        /* restore normal settings of scratch fields */
        scratch.resvalue = &state->resvalue;
        scratch.resnull = &state->resnull;
      }
      argno++;

      Assert(pertrans->numInputs == argno);
    }
    else if (!pertrans->aggsortrequired)
    {
      ListCell   *arg;

      /*
       * Normal transition function without ORDER BY / DISTINCT or with
       * ORDER BY / DISTINCT but the planner has given us pre-sorted
       * input.
       */
      strictargs = trans_fcinfo->args + 1;

      foreach(arg, pertrans->aggref->args)
      {
        TargetEntry *source_tle = (TargetEntry *) lfirst(arg);

        /*
         * Don't initialize args for any ORDER BY clause that might
         * exist in a presorted aggregate.
         */
        if (argno == pertrans->numTransInputs)
          break;

        /*
         * Start from 1, since the 0th arg will be the transition
         * value
         */
        ExecInitExprRec(source_tle->expr, state,
                &trans_fcinfo->args[argno + 1].value,
                &trans_fcinfo->args[argno + 1].isnull);
        argno++;
      }
      Assert(pertrans->numTransInputs == argno);
    }
    else if (pertrans->numInputs == 1)
    {
      /*
       * Non-presorted DISTINCT and/or ORDER BY case, with a single
       * column sorted on.
       */
      TargetEntry *source_tle =
        (TargetEntry *) linitial(pertrans->aggref->args);

      Assert(list_length(pertrans->aggref->args) == 1);

      ExecInitExprRec(source_tle->expr, state,
              &state->resvalue,
              &state->resnull);
      strictnulls = &state->resnull;
      argno++;

      Assert(pertrans->numInputs == argno);
    }
    else
    {
      /*
       * Non-presorted DISTINCT and/or ORDER BY case, with multiple
       * columns sorted on.
       */
      Datum    *values = pertrans->sortslot->tts_values;
      bool     *nulls = pertrans->sortslot->tts_isnull;
      ListCell   *arg;

      strictnulls = nulls;

      foreach(arg, pertrans->aggref->args)
      {
        TargetEntry *source_tle = (TargetEntry *) lfirst(arg);

        ExecInitExprRec(source_tle->expr, state,
                &values[argno], &nulls[argno]);
        argno++;
      }
      Assert(pertrans->numInputs == argno);
    }

    /*
     * For a strict transfn, nothing happens when there's a NULL input; we
     * just keep the prior transValue. This is true for both plain and
     * sorted/distinct aggregates.
     */
    if (trans_fcinfo->flinfo->fn_strict && pertrans->numTransInputs > 0)
    {
      if (strictnulls)
        scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_NULLS;
      else if (strictargs && pertrans->numTransInputs == 1)
        scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1;
      else
        scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_ARGS;
      scratch.d.agg_strict_input_check.nulls = strictnulls;
      scratch.d.agg_strict_input_check.args = strictargs;
      scratch.d.agg_strict_input_check.jumpnull = -1; /* adjust later */
      scratch.d.agg_strict_input_check.nargs = pertrans->numTransInputs;
      ExprEvalPushStep(state, &scratch);
      adjust_bailout = lappend_int(adjust_bailout,
                     state->steps_len - 1);
    }

    /* Handle DISTINCT aggregates which have pre-sorted input */
    if (pertrans->numDistinctCols > 0 && !pertrans->aggsortrequired)
    {
      if (pertrans->numDistinctCols > 1)
        scratch.opcode = EEOP_AGG_PRESORTED_DISTINCT_MULTI;
      else
        scratch.opcode = EEOP_AGG_PRESORTED_DISTINCT_SINGLE;

      scratch.d.agg_presorted_distinctcheck.pertrans = pertrans;
      scratch.d.agg_presorted_distinctcheck.jumpdistinct = -1;  /* adjust later */
      ExprEvalPushStep(state, &scratch);
      adjust_bailout = lappend_int(adjust_bailout,
                     state->steps_len - 1);
    }

    /*
     * Call transition function (once for each concurrently evaluated
     * grouping set). Do so for both sort and hash based computations, as
     * applicable.
     */
    if (doSort)
    {
      int     processGroupingSets = Max(phase->numsets, 1);
      int     setoff = 0;

      for (int setno = 0; setno < processGroupingSets; setno++)
      {
        ExecBuildAggTransCall(state, aggstate, &scratch, trans_fcinfo,
                    pertrans, transno, setno, setoff, false,
                    nullcheck);
        setoff++;
      }
    }

    if (doHash)
    {
      int     numHashes = aggstate->num_hashes;
      int     setoff;

      /* in MIXED mode, there'll be preceding transition values */
      if (aggstate->aggstrategy != AGG_HASHED)
        setoff = aggstate->maxsets;
      else
        setoff = 0;

      for (int setno = 0; setno < numHashes; setno++)
      {
        ExecBuildAggTransCall(state, aggstate, &scratch, trans_fcinfo,
                    pertrans, transno, setno, setoff, true,
                    nullcheck);
        setoff++;
      }
    }

    /* adjust early bail out jump target(s) */
    foreach(bail, adjust_bailout)
    {
      ExprEvalStep *as = &state->steps[lfirst_int(bail)];

      if (as->opcode == EEOP_JUMP_IF_NOT_TRUE)
      {
        Assert(as->d.jump.jumpdone == -1);
        as->d.jump.jumpdone = state->steps_len;
      }
      else if (as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_ARGS ||
           as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1 ||
           as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_NULLS)
      {
        Assert(as->d.agg_strict_input_check.jumpnull == -1);
        as->d.agg_strict_input_check.jumpnull = state->steps_len;
      }
      else if (as->opcode == EEOP_AGG_STRICT_DESERIALIZE)
      {
        Assert(as->d.agg_deserialize.jumpnull == -1);
        as->d.agg_deserialize.jumpnull = state->steps_len;
      }
      else if (as->opcode == EEOP_AGG_PRESORTED_DISTINCT_SINGLE ||
           as->opcode == EEOP_AGG_PRESORTED_DISTINCT_MULTI)
      {
        Assert(as->d.agg_presorted_distinctcheck.jumpdistinct == -1);
        as->d.agg_presorted_distinctcheck.jumpdistinct = state->steps_len;
      }
      else
        Assert(false);
    }
  }

  scratch.resvalue = NULL;
  scratch.resnull = NULL;
  scratch.opcode = EEOP_DONE_NO_RETURN;
  ExprEvalPushStep(state, &scratch);

  ExecReadyExpr(state);

  return state;
}

/*
 * Build transition/combine function invocation for a single transition
 * value. This is separated from ExecBuildAggTrans() because there are
 * multiple callsites (hash and sort in some grouping set cases).
 */
static void
ExecBuildAggTransCall(ExprState *state, AggState *aggstate,
            ExprEvalStep *scratch,
            FunctionCallInfo fcinfo, AggStatePerTrans pertrans,
            int transno, int setno, int setoff, bool ishash,
            bool nullcheck)
{
  ExprContext *aggcontext;
  int     adjust_jumpnull = -1;

  if (ishash)
    aggcontext = aggstate->hashcontext;
  else
    aggcontext = aggstate->aggcontexts[setno];

  /* add check for NULL pointer? */
  if (nullcheck)
  {
    scratch->opcode = EEOP_AGG_PLAIN_PERGROUP_NULLCHECK;
    scratch->d.agg_plain_pergroup_nullcheck.setoff = setoff;
    /* adjust later */
    scratch->d.agg_plain_pergroup_nullcheck.jumpnull = -1;
    ExprEvalPushStep(state, scratch);
    adjust_jumpnull = state->steps_len - 1;
  }

  /*
   * Determine appropriate transition implementation.
   *
   * For non-ordered aggregates and ORDER BY / DISTINCT aggregates with
   * presorted input:
   *
   * If the initial value for the transition state doesn't exist in the
   * pg_aggregate table then we will let the first non-NULL value returned
   * from the outer procNode become the initial value. (This is useful for
   * aggregates like max() and min().) The noTransValue flag signals that we
   * need to do so. If true, generate a
   * EEOP_AGG_INIT_STRICT_PLAIN_TRANS{,_BYVAL} step. This step also needs to
   * do the work described next:
   *
   * If the function is strict, but does have an initial value, choose
   * EEOP_AGG_STRICT_PLAIN_TRANS{,_BYVAL}, which skips the transition
   * function if the transition value has become NULL (because a previous
   * transition function returned NULL). This step also needs to do the work
   * described next:
   *
   * Otherwise we call EEOP_AGG_PLAIN_TRANS{,_BYVAL}, which does not have to
   * perform either of the above checks.
   *
   * Having steps with overlapping responsibilities is not nice, but
   * aggregations are very performance sensitive, making this worthwhile.
   *
   * For ordered aggregates:
   *
   * Only need to choose between the faster path for a single ordered
   * column, and the one between multiple columns. Checking strictness etc
   * is done when finalizing the aggregate. See
   * process_ordered_aggregate_{single, multi} and
   * advance_transition_function.
   */
  if (!pertrans->aggsortrequired)
  {
    if (pertrans->transtypeByVal)
    {
      if (fcinfo->flinfo->fn_strict &&
        pertrans->initValueIsNull)
        scratch->opcode = EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL;
      else if (fcinfo->flinfo->fn_strict)
        scratch->opcode = EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL;
      else
        scratch->opcode = EEOP_AGG_PLAIN_TRANS_BYVAL;
    }
    else
    {
      if (fcinfo->flinfo->fn_strict &&
        pertrans->initValueIsNull)
        scratch->opcode = EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF;
      else if (fcinfo->flinfo->fn_strict)
        scratch->opcode = EEOP_AGG_PLAIN_TRANS_STRICT_BYREF;
      else
        scratch->opcode = EEOP_AGG_PLAIN_TRANS_BYREF;
    }
  }
  else if (pertrans->numInputs == 1)
    scratch->opcode = EEOP_AGG_ORDERED_TRANS_DATUM;
  else
    scratch->opcode = EEOP_AGG_ORDERED_TRANS_TUPLE;

  scratch->d.agg_trans.pertrans = pertrans;
  scratch->d.agg_trans.setno = setno;
  scratch->d.agg_trans.setoff = setoff;
  scratch->d.agg_trans.transno = transno;
  scratch->d.agg_trans.aggcontext = aggcontext;
  ExprEvalPushStep(state, scratch);

  /* fix up jumpnull */
  if (adjust_jumpnull != -1)
  {
    ExprEvalStep *as = &state->steps[adjust_jumpnull];

    Assert(as->opcode == EEOP_AGG_PLAIN_PERGROUP_NULLCHECK);
    Assert(as->d.agg_plain_pergroup_nullcheck.jumpnull == -1);
    as->d.agg_plain_pergroup_nullcheck.jumpnull = state->steps_len;
  }
}

/*
 * Build an ExprState that calls the given hash function(s) on the attnums
 * given by 'keyColIdx' .  When numCols > 1, the hash values returned by each
 * hash function are combined to produce a single hash value.
 *
 * desc: tuple descriptor for the to-be-hashed columns
 * ops: TupleTableSlotOps to use for the give TupleDesc
 * hashfunctions: FmgrInfos for each hash function to call, one per numCols.
 * These are used directly in the returned ExprState so must remain allocated.
 * collations: collation to use when calling the hash function.
 * numCols: array length of hashfunctions, collations and keyColIdx.
 * parent: PlanState node that the resulting ExprState will be evaluated at
 * init_value: Normally 0, but can be set to other values to seed the hash
 * with.  Non-zero is marginally slower, so best to only use if it's provably
 * worthwhile.
 */
ExprState *
ExecBuildHash32FromAttrs(TupleDesc desc, const TupleTableSlotOps *ops,
             FmgrInfo *hashfunctions, Oid *collations,
             int numCols, AttrNumber *keyColIdx,
             PlanState *parent, uint32 init_value)
{
  ExprState  *state = makeNode(ExprState);
  ExprEvalStep scratch = {0};
  NullableDatum *iresult = NULL;
  intptr_t  opcode;
  AttrNumber  last_attnum = 0;

  Assert(numCols >= 0);

  state->parent = parent;

  /*
   * Make a place to store intermediate hash values between subsequent
   * hashing of individual columns.  We only need this if there is more than
   * one column to hash or an initial value plus one column.
   */
  if ((int64) numCols + (init_value != 0) > 1)
    iresult = palloc(sizeof(NullableDatum));

  /* find the highest attnum so we deform the tuple to that point */
  for (int i = 0; i < numCols; i++)
    last_attnum = Max(last_attnum, keyColIdx[i]);

  scratch.opcode = EEOP_INNER_FETCHSOME;
  scratch.d.fetch.last_var = last_attnum;
  scratch.d.fetch.fixed = false;
  scratch.d.fetch.kind = ops;
  scratch.d.fetch.known_desc = desc;
  if (ExecComputeSlotInfo(state, &scratch))
    ExprEvalPushStep(state, &scratch);

  if (init_value == 0)
  {
    /*
     * No initial value, so we can assign the result of the hash function
     * for the first attribute without having to concern ourselves with
     * combining the result with any initial value.
     */
    opcode = EEOP_HASHDATUM_FIRST;
  }
  else
  {
    /*
     * Set up operation to set the initial value.  Normally we store this
     * in the intermediate hash value location, but if there are no
     * columns to hash, store it in the ExprState's result field.
     */
    scratch.opcode = EEOP_HASHDATUM_SET_INITVAL;
    scratch.d.hashdatum_initvalue.init_value = UInt32GetDatum(init_value);
    scratch.resvalue = numCols > 0 ? &iresult->value : &state->resvalue;
    scratch.resnull = numCols > 0 ? &iresult->isnull : &state->resnull;

    ExprEvalPushStep(state, &scratch);

    /*
     * When using an initial value use the NEXT32 ops as the FIRST ops
     * would overwrite the stored initial value.
     */
    opcode = EEOP_HASHDATUM_NEXT32;
  }

  for (int i = 0; i < numCols; i++)
  {
    FmgrInfo   *finfo;
    FunctionCallInfo fcinfo;
    Oid     inputcollid = collations[i];
    AttrNumber  attnum = keyColIdx[i] - 1;

    finfo = &hashfunctions[i];
    fcinfo = palloc0(SizeForFunctionCallInfo(1));

    /* Initialize function call parameter structure too */
    InitFunctionCallInfoData(*fcinfo, finfo, 1, inputcollid, NULL, NULL);

    /*
     * Fetch inner Var for this attnum and store it in the 1st arg of the
     * hash func.
     */
    scratch.opcode = EEOP_INNER_VAR;
    scratch.resvalue = &fcinfo->args[0].value;
    scratch.resnull = &fcinfo->args[0].isnull;
    scratch.d.var.attnum = attnum;
    scratch.d.var.vartype = TupleDescAttr(desc, attnum)->atttypid;
    scratch.d.var.varreturningtype = VAR_RETURNING_DEFAULT;

    ExprEvalPushStep(state, &scratch);

    /* Call the hash function */
    scratch.opcode = opcode;

    if (i == numCols - 1)
    {
      /*
       * The result for hashing the final column is stored in the
       * ExprState.
       */
      scratch.resvalue = &state->resvalue;
      scratch.resnull = &state->resnull;
    }
    else
    {
      Assert(iresult != NULL);

      /* intermediate values are stored in an intermediate result */
      scratch.resvalue = &iresult->value;
      scratch.resnull = &iresult->isnull;
    }

    /*
     * NEXT32 opcodes need to look at the intermediate result.  We might
     * as well just set this for all ops.  FIRSTs won't look at it.
     */
    scratch.d.hashdatum.iresult = iresult;

    scratch.d.hashdatum.finfo = finfo;
    scratch.d.hashdatum.fcinfo_data = fcinfo;
    scratch.d.hashdatum.fn_addr = finfo->fn_addr;
    scratch.d.hashdatum.jumpdone = -1;

    ExprEvalPushStep(state, &scratch);

    /* subsequent attnums must be combined with the previous */
    opcode = EEOP_HASHDATUM_NEXT32;
  }

  scratch.resvalue = NULL;
  scratch.resnull = NULL;
  scratch.opcode = EEOP_DONE_RETURN;
  ExprEvalPushStep(state, &scratch);

  ExecReadyExpr(state);

  return state;
}

/*
 * Build an ExprState that calls the given hash function(s) on the given
 * 'hash_exprs'.  When multiple expressions are present, the hash values
 * returned by each hash function are combined to produce a single hash value.
 *
 * desc: tuple descriptor for the to-be-hashed expressions
 * ops: TupleTableSlotOps for the TupleDesc
 * hashfunc_oids: Oid for each hash function to call, one for each 'hash_expr'
 * collations: collation to use when calling the hash function.
 * hash_expr: list of expressions to hash the value of
 * opstrict: array corresponding to the 'hashfunc_oids' to store op_strict()
 * parent: PlanState node that the 'hash_exprs' will be evaluated at
 * init_value: Normally 0, but can be set to other values to seed the hash
 * with some other value.  Using non-zero is slightly less efficient but can
 * be useful.
 * keep_nulls: if true, evaluation of the returned ExprState will abort early
 * returning NULL if the given hash function is strict and the Datum to hash
 * is null.  When set to false, any NULL input Datums are skipped.
 */
ExprState *
ExecBuildHash32Expr(TupleDesc desc, const TupleTableSlotOps *ops,
          const Oid *hashfunc_oids, const List *collations,
          const List *hash_exprs, const bool *opstrict,
          PlanState *parent, uint32 init_value, bool keep_nulls)
{
  ExprState  *state = makeNode(ExprState);
  ExprEvalStep scratch = {0};
  NullableDatum *iresult = NULL;
  List     *adjust_jumps = NIL;
  ListCell   *lc;
  ListCell   *lc2;
  intptr_t  strict_opcode;
  intptr_t  opcode;
  int     num_exprs = list_length(hash_exprs);

  Assert(num_exprs == list_length(collations));

  state->parent = parent;

  /* Insert setup steps as needed. */
  ExecCreateExprSetupSteps(state, (Node *) hash_exprs);

  /*
   * Make a place to store intermediate hash values between subsequent
   * hashing of individual expressions.  We only need this if there is more
   * than one expression to hash or an initial value plus one expression.
   */
  if ((int64) num_exprs + (init_value != 0) > 1)
    iresult = palloc(sizeof(NullableDatum));

  if (init_value == 0)
  {
    /*
     * No initial value, so we can assign the result of the hash function
     * for the first hash_expr without having to concern ourselves with
     * combining the result with any initial value.
     */
    strict_opcode = EEOP_HASHDATUM_FIRST_STRICT;
    opcode = EEOP_HASHDATUM_FIRST;
  }
  else
  {
    /*
     * Set up operation to set the initial value.  Normally we store this
     * in the intermediate hash value location, but if there are no exprs
     * to hash, store it in the ExprState's result field.
     */
    scratch.opcode = EEOP_HASHDATUM_SET_INITVAL;
    scratch.d.hashdatum_initvalue.init_value = UInt32GetDatum(init_value);
    scratch.resvalue = num_exprs > 0 ? &iresult->value : &state->resvalue;
    scratch.resnull = num_exprs > 0 ? &iresult->isnull : &state->resnull;

    ExprEvalPushStep(state, &scratch);

    /*
     * When using an initial value use the NEXT32/NEXT32_STRICT ops as the
     * FIRST/FIRST_STRICT ops would overwrite the stored initial value.
     */
    strict_opcode = EEOP_HASHDATUM_NEXT32_STRICT;
    opcode = EEOP_HASHDATUM_NEXT32;
  }

  forboth(lc, hash_exprs, lc2, collations)
  {
    Expr     *expr = (Expr *) lfirst(lc);
    FmgrInfo   *finfo;
    FunctionCallInfo fcinfo;
    int     i = foreach_current_index(lc);
    Oid     funcid;
    Oid     inputcollid = lfirst_oid(lc2);

    funcid = hashfunc_oids[i];

    /* Allocate hash function lookup data. */
    finfo = palloc0(sizeof(FmgrInfo));
    fcinfo = palloc0(SizeForFunctionCallInfo(1));

    fmgr_info(funcid, finfo);

    /*
     * Build the steps to evaluate the hash function's argument have it so
     * the value of that is stored in the 0th argument of the hash func.
     */
    ExecInitExprRec(expr,
            state,
            &fcinfo->args[0].value,
            &fcinfo->args[0].isnull);

    if (i == num_exprs - 1)
    {
      /* the result for hashing the final expr is stored in the state */
      scratch.resvalue = &state->resvalue;
      scratch.resnull = &state->resnull;
    }
    else
    {
      Assert(iresult != NULL);

      /* intermediate values are stored in an intermediate result */
      scratch.resvalue = &iresult->value;
      scratch.resnull = &iresult->isnull;
    }

    /*
     * NEXT32 opcodes need to look at the intermediate result.  We might
     * as well just set this for all ops.  FIRSTs won't look at it.
     */
    scratch.d.hashdatum.iresult = iresult;

    /* Initialize function call parameter structure too */
    InitFunctionCallInfoData(*fcinfo, finfo, 1, inputcollid, NULL, NULL);

    scratch.d.hashdatum.finfo = finfo;
    scratch.d.hashdatum.fcinfo_data = fcinfo;
    scratch.d.hashdatum.fn_addr = finfo->fn_addr;

    scratch.opcode = opstrict[i] && !keep_nulls ? strict_opcode : opcode;
    scratch.d.hashdatum.jumpdone = -1;

    ExprEvalPushStep(state, &scratch);
    adjust_jumps = lappend_int(adjust_jumps, state->steps_len - 1);

    /*
     * For subsequent keys we must combine the hash value with the
     * previous hashes.
     */
    strict_opcode = EEOP_HASHDATUM_NEXT32_STRICT;
    opcode = EEOP_HASHDATUM_NEXT32;
  }

  /* adjust jump targets */
  foreach(lc, adjust_jumps)
  {
    ExprEvalStep *as = &state->steps[lfirst_int(lc)];

    Assert(as->opcode == EEOP_HASHDATUM_FIRST ||
         as->opcode == EEOP_HASHDATUM_FIRST_STRICT ||
         as->opcode == EEOP_HASHDATUM_NEXT32 ||
         as->opcode == EEOP_HASHDATUM_NEXT32_STRICT);
    Assert(as->d.hashdatum.jumpdone == -1);
    as->d.hashdatum.jumpdone = state->steps_len;
  }

  scratch.resvalue = NULL;
  scratch.resnull = NULL;
  scratch.opcode = EEOP_DONE_RETURN;
  ExprEvalPushStep(state, &scratch);

  ExecReadyExpr(state);

  return state;
}

/*
 * Build equality expression that can be evaluated using ExecQual(), returning
 * true if the expression context's inner/outer tuple are NOT DISTINCT. I.e
 * two nulls match, a null and a not-null don't match.
 *
 * desc: tuple descriptor of the to-be-compared tuples
 * numCols: the number of attributes to be examined
 * keyColIdx: array of attribute column numbers
 * eqFunctions: array of function oids of the equality functions to use
 * parent: parent executor node
 */
ExprState *
ExecBuildGroupingEqual(TupleDesc ldesc, TupleDesc rdesc,
             const TupleTableSlotOps *lops, const TupleTableSlotOps *rops,
             int numCols,
             const AttrNumber *keyColIdx,
             const Oid *eqfunctions,
             const Oid *collations,
             PlanState *parent)
{
  ExprState  *state = makeNode(ExprState);
  ExprEvalStep scratch = {0};
  int     maxatt = -1;
  List     *adjust_jumps = NIL;
  ListCell   *lc;

  /*
   * When no columns are actually compared, the result's always true. See
   * special case in ExecQual().
   */
  if (numCols == 0)
    return NULL;

  state->expr = NULL;
  state->flags = EEO_FLAG_IS_QUAL;
  state->parent = parent;

  scratch.resvalue = &state->resvalue;
  scratch.resnull = &state->resnull;

  /* compute max needed attribute */
  for (int natt = 0; natt < numCols; natt++)
  {
    int     attno = keyColIdx[natt];

    if (attno > maxatt)
      maxatt = attno;
  }
  Assert(maxatt >= 0);

  /* push deform steps */
  scratch.opcode = EEOP_INNER_FETCHSOME;
  scratch.d.fetch.last_var = maxatt;
  scratch.d.fetch.fixed = false;
  scratch.d.fetch.known_desc = ldesc;
  scratch.d.fetch.kind = lops;
  if (ExecComputeSlotInfo(state, &scratch))
    ExprEvalPushStep(state, &scratch);

  scratch.opcode = EEOP_OUTER_FETCHSOME;
  scratch.d.fetch.last_var = maxatt;
  scratch.d.fetch.fixed = false;
  scratch.d.fetch.known_desc = rdesc;
  scratch.d.fetch.kind = rops;
  if (ExecComputeSlotInfo(state, &scratch))
    ExprEvalPushStep(state, &scratch);

  /*
   * Start comparing at the last field (least significant sort key). That's
   * the most likely to be different if we are dealing with sorted input.
   */
  for (int natt = numCols; --natt >= 0;)
  {
    int     attno = keyColIdx[natt];
    Form_pg_attribute latt = TupleDescAttr(ldesc, attno - 1);
    Form_pg_attribute ratt = TupleDescAttr(rdesc, attno - 1);
    Oid     foid = eqfunctions[natt];
    Oid     collid = collations[natt];
    FmgrInfo   *finfo;
    FunctionCallInfo fcinfo;
    AclResult aclresult;

    /* Check permission to call function */
    aclresult = object_aclcheck(ProcedureRelationId, foid, GetUserId(), ACL_EXECUTE);
    if (aclresult != ACLCHECK_OK)
      aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(foid));

    InvokeFunctionExecuteHook(foid);

    /* Set up the primary fmgr lookup information */
    finfo = palloc0(sizeof(FmgrInfo));
    fcinfo = palloc0(SizeForFunctionCallInfo(2));
    fmgr_info(foid, finfo);
    fmgr_info_set_expr(NULL, finfo);
    InitFunctionCallInfoData(*fcinfo, finfo, 2,
                 collid, NULL, NULL);

    /* left arg */
    scratch.opcode = EEOP_INNER_VAR;
    scratch.d.var.attnum = attno - 1;
    scratch.d.var.vartype = latt->atttypid;
    scratch.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
    scratch.resvalue = &fcinfo->args[0].value;
    scratch.resnull = &fcinfo->args[0].isnull;
    ExprEvalPushStep(state, &scratch);

    /* right arg */
    scratch.opcode = EEOP_OUTER_VAR;
    scratch.d.var.attnum = attno - 1;
    scratch.d.var.vartype = ratt->atttypid;
    scratch.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
    scratch.resvalue = &fcinfo->args[1].value;
    scratch.resnull = &fcinfo->args[1].isnull;
    ExprEvalPushStep(state, &scratch);

    /* evaluate distinctness */
    scratch.opcode = EEOP_NOT_DISTINCT;
    scratch.d.func.finfo = finfo;
    scratch.d.func.fcinfo_data = fcinfo;
    scratch.d.func.fn_addr = finfo->fn_addr;
    scratch.d.func.nargs = 2;
    scratch.resvalue = &state->resvalue;
    scratch.resnull = &state->resnull;
    ExprEvalPushStep(state, &scratch);

    /* then emit EEOP_QUAL to detect if result is false (or null) */
    scratch.opcode = EEOP_QUAL;
    scratch.d.qualexpr.jumpdone = -1;
    scratch.resvalue = &state->resvalue;
    scratch.resnull = &state->resnull;
    ExprEvalPushStep(state, &scratch);
    adjust_jumps = lappend_int(adjust_jumps,
                   state->steps_len - 1);
  }

  /* adjust jump targets */
  foreach(lc, adjust_jumps)
  {
    ExprEvalStep *as = &state->steps[lfirst_int(lc)];

    Assert(as->opcode == EEOP_QUAL);
    Assert(as->d.qualexpr.jumpdone == -1);
    as->d.qualexpr.jumpdone = state->steps_len;
  }

  scratch.resvalue = NULL;
  scratch.resnull = NULL;
  scratch.opcode = EEOP_DONE_RETURN;
  ExprEvalPushStep(state, &scratch);

  ExecReadyExpr(state);

  return state;
}

/*
 * Build equality expression that can be evaluated using ExecQual(), returning
 * true if the expression context's inner/outer tuples are equal.  Datums in
 * the inner/outer slots are assumed to be in the same order and quantity as
 * the 'eqfunctions' parameter.  NULLs are treated as equal.
 *
 * desc: tuple descriptor of the to-be-compared tuples
 * lops: the slot ops for the inner tuple slots
 * rops: the slot ops for the outer tuple slots
 * eqFunctions: array of function oids of the equality functions to use
 * this must be the same length as the 'param_exprs' list.
 * collations: collation Oids to use for equality comparison. Must be the
 * same length as the 'param_exprs' list.
 * parent: parent executor node
 */
ExprState *
ExecBuildParamSetEqual(TupleDesc desc,
             const TupleTableSlotOps *lops,
             const TupleTableSlotOps *rops,
             const Oid *eqfunctions,
             const Oid *collations,
             const List *param_exprs,
             PlanState *parent)
{
  ExprState  *state = makeNode(ExprState);
  ExprEvalStep scratch = {0};
  int     maxatt = list_length(param_exprs);
  List     *adjust_jumps = NIL;
  ListCell   *lc;

  state->expr = NULL;
  state->flags = EEO_FLAG_IS_QUAL;
  state->parent = parent;

  scratch.resvalue = &state->resvalue;
  scratch.resnull = &state->resnull;

  /* push deform steps */
  scratch.opcode = EEOP_INNER_FETCHSOME;
  scratch.d.fetch.last_var = maxatt;
  scratch.d.fetch.fixed = false;
  scratch.d.fetch.known_desc = desc;
  scratch.d.fetch.kind = lops;
  if (ExecComputeSlotInfo(state, &scratch))
    ExprEvalPushStep(state, &scratch);

  scratch.opcode = EEOP_OUTER_FETCHSOME;
  scratch.d.fetch.last_var = maxatt;
  scratch.d.fetch.fixed = false;
  scratch.d.fetch.known_desc = desc;
  scratch.d.fetch.kind = rops;
  if (ExecComputeSlotInfo(state, &scratch))
    ExprEvalPushStep(state, &scratch);

  for (int attno = 0; attno < maxatt; attno++)
  {
    Form_pg_attribute att = TupleDescAttr(desc, attno);
    Oid     foid = eqfunctions[attno];
    Oid     collid = collations[attno];
    FmgrInfo   *finfo;
    FunctionCallInfo fcinfo;
    AclResult aclresult;

    /* Check permission to call function */
    aclresult = object_aclcheck(ProcedureRelationId, foid, GetUserId(), ACL_EXECUTE);
    if (aclresult != ACLCHECK_OK)
      aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(foid));

    InvokeFunctionExecuteHook(foid);

    /* Set up the primary fmgr lookup information */
    finfo = palloc0(sizeof(FmgrInfo));
    fcinfo = palloc0(SizeForFunctionCallInfo(2));
    fmgr_info(foid, finfo);
    fmgr_info_set_expr(NULL, finfo);
    InitFunctionCallInfoData(*fcinfo, finfo, 2,
                 collid, NULL, NULL);

    /* left arg */
    scratch.opcode = EEOP_INNER_VAR;
    scratch.d.var.attnum = attno;
    scratch.d.var.vartype = att->atttypid;
    scratch.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
    scratch.resvalue = &fcinfo->args[0].value;
    scratch.resnull = &fcinfo->args[0].isnull;
    ExprEvalPushStep(state, &scratch);

    /* right arg */
    scratch.opcode = EEOP_OUTER_VAR;
    scratch.d.var.attnum = attno;
    scratch.d.var.vartype = att->atttypid;
    scratch.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
    scratch.resvalue = &fcinfo->args[1].value;
    scratch.resnull = &fcinfo->args[1].isnull;
    ExprEvalPushStep(state, &scratch);

    /* evaluate distinctness */
    scratch.opcode = EEOP_NOT_DISTINCT;
    scratch.d.func.finfo = finfo;
    scratch.d.func.fcinfo_data = fcinfo;
    scratch.d.func.fn_addr = finfo->fn_addr;
    scratch.d.func.nargs = 2;
    scratch.resvalue = &state->resvalue;
    scratch.resnull = &state->resnull;
    ExprEvalPushStep(state, &scratch);

    /* then emit EEOP_QUAL to detect if result is false (or null) */
    scratch.opcode = EEOP_QUAL;
    scratch.d.qualexpr.jumpdone = -1;
    scratch.resvalue = &state->resvalue;
    scratch.resnull = &state->resnull;
    ExprEvalPushStep(state, &scratch);
    adjust_jumps = lappend_int(adjust_jumps,
                   state->steps_len - 1);
  }

  /* adjust jump targets */
  foreach(lc, adjust_jumps)
  {
    ExprEvalStep *as = &state->steps[lfirst_int(lc)];

    Assert(as->opcode == EEOP_QUAL);
    Assert(as->d.qualexpr.jumpdone == -1);
    as->d.qualexpr.jumpdone = state->steps_len;
  }

  scratch.resvalue = NULL;
  scratch.resnull = NULL;
  scratch.opcode = EEOP_DONE_RETURN;
  ExprEvalPushStep(state, &scratch);

  ExecReadyExpr(state);

  return state;
}

/*
 * Push steps to evaluate a JsonExpr and its various subsidiary expressions.
 */
static void
ExecInitJsonExpr(JsonExpr *jsexpr, ExprState *state,
         Datum *resv, bool *resnull,
         ExprEvalStep *scratch)
{
  JsonExprState *jsestate = palloc0(sizeof(JsonExprState));
  ListCell   *argexprlc;
  ListCell   *argnamelc;
  List     *jumps_return_null = NIL;
  List     *jumps_to_end = NIL;
  ListCell   *lc;
  ErrorSaveContext *escontext;
  bool    returning_domain =
    get_typtype(jsexpr->returning->typid) == TYPTYPE_DOMAIN;

  Assert(jsexpr->on_error != NULL);

  jsestate->jsexpr = jsexpr;

  /*
   * Evaluate formatted_expr storing the result into
   * jsestate->formatted_expr.
   */
  ExecInitExprRec((Expr *) jsexpr->formatted_expr, state,
          &jsestate->formatted_expr.value,
          &jsestate->formatted_expr.isnull);

  /* JUMP to return NULL if formatted_expr evaluates to NULL */
  jumps_return_null = lappend_int(jumps_return_null, state->steps_len);
  scratch->opcode = EEOP_JUMP_IF_NULL;
  scratch->resnull = &jsestate->formatted_expr.isnull;
  scratch->d.jump.jumpdone = -1;  /* set below */
  ExprEvalPushStep(state, scratch);

  /*
   * Evaluate pathspec expression storing the result into
   * jsestate->pathspec.
   */
  ExecInitExprRec((Expr *) jsexpr->path_spec, state,
          &jsestate->pathspec.value,
          &jsestate->pathspec.isnull);

  /* JUMP to return NULL if path_spec evaluates to NULL */
  jumps_return_null = lappend_int(jumps_return_null, state->steps_len);
  scratch->opcode = EEOP_JUMP_IF_NULL;
  scratch->resnull = &jsestate->pathspec.isnull;
  scratch->d.jump.jumpdone = -1;  /* set below */
  ExprEvalPushStep(state, scratch);

  /* Steps to compute PASSING args. */
  jsestate->args = NIL;
  forboth(argexprlc, jsexpr->passing_values,
      argnamelc, jsexpr->passing_names)
  {
    Expr     *argexpr = (Expr *) lfirst(argexprlc);
    String     *argname = lfirst_node(String, argnamelc);
    JsonPathVariable *var = palloc(sizeof(*var));

    var->name = argname->sval;
    var->namelen = strlen(var->name);
    var->typid = exprType((Node *) argexpr);
    var->typmod = exprTypmod((Node *) argexpr);

    ExecInitExprRec((Expr *) argexpr, state, &var->value, &var->isnull);

    jsestate->args = lappend(jsestate->args, var);
  }

  /* Step for jsonpath evaluation; see ExecEvalJsonExprPath(). */
  scratch->opcode = EEOP_JSONEXPR_PATH;
  scratch->resvalue = resv;
  scratch->resnull = resnull;
  scratch->d.jsonexpr.jsestate = jsestate;
  ExprEvalPushStep(state, scratch);

  /*
   * Step to return NULL after jumping to skip the EEOP_JSONEXPR_PATH step
   * when either formatted_expr or pathspec is NULL.  Adjust jump target
   * addresses of JUMPs that we added above.
   */
  foreach(lc, jumps_return_null)
  {
    ExprEvalStep *as = &state->steps[lfirst_int(lc)];

    as->d.jump.jumpdone = state->steps_len;
  }
  scratch->opcode = EEOP_CONST;
  scratch->resvalue = resv;
  scratch->resnull = resnull;
  scratch->d.constval.value = (Datum) 0;
  scratch->d.constval.isnull = true;
  ExprEvalPushStep(state, scratch);

  escontext = jsexpr->on_error->btype != JSON_BEHAVIOR_ERROR ?
    &jsestate->escontext : NULL;

  /*
   * To handle coercion errors softly, use the following ErrorSaveContext to
   * pass to ExecInitExprRec() when initializing the coercion expressions
   * and in the EEOP_JSONEXPR_COERCION step.
   */
  jsestate->escontext.type = T_ErrorSaveContext;

  /*
   * Steps to coerce the result value computed by EEOP_JSONEXPR_PATH or the
   * NULL returned on NULL input as described above.
   */
  jsestate->jump_eval_coercion = -1;
  if (jsexpr->use_json_coercion)
  {
    jsestate->jump_eval_coercion = state->steps_len;

    ExecInitJsonCoercion(state, jsexpr->returning, escontext,
               jsexpr->omit_quotes,
               jsexpr->op == JSON_EXISTS_OP,
               resv, resnull);
  }
  else if (jsexpr->use_io_coercion)
  {
    /*
     * Here we only need to initialize the FunctionCallInfo for the target
     * type's input function, which is called by ExecEvalJsonExprPath()
     * itself, so no additional step is necessary.
     */
    Oid     typinput;
    Oid     typioparam;
    FmgrInfo   *finfo;
    FunctionCallInfo fcinfo;

    getTypeInputInfo(jsexpr->returning->typid, &typinput, &typioparam);
    finfo = palloc0(sizeof(FmgrInfo));
    fcinfo = palloc0(SizeForFunctionCallInfo(3));
    fmgr_info(typinput, finfo);
    fmgr_info_set_expr((Node *) jsexpr->returning, finfo);
    InitFunctionCallInfoData(*fcinfo, finfo, 3, InvalidOid, NULL, NULL);

    /*
     * We can preload the second and third arguments for the input
     * function, since they're constants.
     */
    fcinfo->args[1].value = ObjectIdGetDatum(typioparam);
    fcinfo->args[1].isnull = false;
    fcinfo->args[2].value = Int32GetDatum(jsexpr->returning->typmod);
    fcinfo->args[2].isnull = false;
    fcinfo->context = (Node *) escontext;

    jsestate->input_fcinfo = fcinfo;
  }

  /*
   * Add a special step, if needed, to check if the coercion evaluation ran
   * into an error but was not thrown because the ON ERROR behavior is not
   * ERROR.  It will set jsestate->error if an error did occur.
   */
  if (jsestate->jump_eval_coercion >= 0 && escontext != NULL)
  {
    scratch->opcode = EEOP_JSONEXPR_COERCION_FINISH;
    scratch->d.jsonexpr.jsestate = jsestate;
    ExprEvalPushStep(state, scratch);
  }

  jsestate->jump_empty = jsestate->jump_error = -1;

  /*
   * Step to check jsestate->error and return the ON ERROR expression if
   * there is one.  This handles both the errors that occur during jsonpath
   * evaluation in EEOP_JSONEXPR_PATH and subsequent coercion evaluation.
   *
   * Speed up common cases by avoiding extra steps for a NULL-valued ON
   * ERROR expression unless RETURNING a domain type, where constraints must
   * be checked. ExecEvalJsonExprPath() already returns NULL on error,
   * making additional steps unnecessary in typical scenarios. Note that the
   * default ON ERROR behavior for JSON_VALUE() and JSON_QUERY() is to
   * return NULL.
   */
  if (jsexpr->on_error->btype != JSON_BEHAVIOR_ERROR &&
    (!(IsA(jsexpr->on_error->expr, Const) &&
       ((Const *) jsexpr->on_error->expr)->constisnull) ||
     returning_domain))
  {
    ErrorSaveContext *saved_escontext;

    jsestate->jump_error = state->steps_len;

    /* JUMP to end if false, that is, skip the ON ERROR expression. */
    jumps_to_end = lappend_int(jumps_to_end, state->steps_len);
    scratch->opcode = EEOP_JUMP_IF_NOT_TRUE;
    scratch->resvalue = &jsestate->error.value;
    scratch->resnull = &jsestate->error.isnull;
    scratch->d.jump.jumpdone = -1;  /* set below */
    ExprEvalPushStep(state, scratch);

    /*
     * Steps to evaluate the ON ERROR expression; handle errors softly to
     * rethrow them in COERCION_FINISH step that will be added later.
     */
    saved_escontext = state->escontext;
    state->escontext = escontext;
    ExecInitExprRec((Expr *) jsexpr->on_error->expr,
            state, resv, resnull);
    state->escontext = saved_escontext;

    /* Step to coerce the ON ERROR expression if needed */
    if (jsexpr->on_error->coerce)
      ExecInitJsonCoercion(state, jsexpr->returning, escontext,
                 jsexpr->omit_quotes, false,
                 resv, resnull);

    /*
     * Add a COERCION_FINISH step to check for errors that may occur when
     * coercing and rethrow them.
     */
    if (jsexpr->on_error->coerce ||
      IsA(jsexpr->on_error->expr, CoerceViaIO) ||
      IsA(jsexpr->on_error->expr, CoerceToDomain))
    {
      scratch->opcode = EEOP_JSONEXPR_COERCION_FINISH;
      scratch->resvalue = resv;
      scratch->resnull = resnull;
      scratch->d.jsonexpr.jsestate = jsestate;
      ExprEvalPushStep(state, scratch);
    }

    /* JUMP to end to skip the ON EMPTY steps added below. */
    jumps_to_end = lappend_int(jumps_to_end, state->steps_len);
    scratch->opcode = EEOP_JUMP;
    scratch->d.jump.jumpdone = -1;
    ExprEvalPushStep(state, scratch);
  }

  /*
   * Step to check jsestate->empty and return the ON EMPTY expression if
   * there is one.
   *
   * See the comment above for details on the optimization for NULL-valued
   * expressions.
   */
  if (jsexpr->on_empty != NULL &&
    jsexpr->on_empty->btype != JSON_BEHAVIOR_ERROR &&
    (!(IsA(jsexpr->on_empty->expr, Const) &&
       ((Const *) jsexpr->on_empty->expr)->constisnull) ||
     returning_domain))
  {
    ErrorSaveContext *saved_escontext;

    jsestate->jump_empty = state->steps_len;

    /* JUMP to end if false, that is, skip the ON EMPTY expression. */
    jumps_to_end = lappend_int(jumps_to_end, state->steps_len);
    scratch->opcode = EEOP_JUMP_IF_NOT_TRUE;
    scratch->resvalue = &jsestate->empty.value;
    scratch->resnull = &jsestate->empty.isnull;
    scratch->d.jump.jumpdone = -1;  /* set below */
    ExprEvalPushStep(state, scratch);

    /*
     * Steps to evaluate the ON EMPTY expression; handle errors softly to
     * rethrow them in COERCION_FINISH step that will be added later.
     */
    saved_escontext = state->escontext;
    state->escontext = escontext;
    ExecInitExprRec((Expr *) jsexpr->on_empty->expr,
            state, resv, resnull);
    state->escontext = saved_escontext;

    /* Step to coerce the ON EMPTY expression if needed */
    if (jsexpr->on_empty->coerce)
      ExecInitJsonCoercion(state, jsexpr->returning, escontext,
                 jsexpr->omit_quotes, false,
                 resv, resnull);

    /*
     * Add a COERCION_FINISH step to check for errors that may occur when
     * coercing and rethrow them.
     */
    if (jsexpr->on_empty->coerce ||
      IsA(jsexpr->on_empty->expr, CoerceViaIO) ||
      IsA(jsexpr->on_empty->expr, CoerceToDomain))
    {

      scratch->opcode = EEOP_JSONEXPR_COERCION_FINISH;
      scratch->resvalue = resv;
      scratch->resnull = resnull;
      scratch->d.jsonexpr.jsestate = jsestate;
      ExprEvalPushStep(state, scratch);
    }
  }

  foreach(lc, jumps_to_end)
  {
    ExprEvalStep *as = &state->steps[lfirst_int(lc)];

    as->d.jump.jumpdone = state->steps_len;
  }

  jsestate->jump_end = state->steps_len;
}

/*
 * Initialize a EEOP_JSONEXPR_COERCION step to coerce the value given in resv
 * to the given RETURNING type.
 */
static void
ExecInitJsonCoercion(ExprState *state, JsonReturning *returning,
           ErrorSaveContext *escontext, bool omit_quotes,
           bool exists_coerce,
           Datum *resv, bool *resnull)
{
  ExprEvalStep scratch = {0};

  /* For json_populate_type() */
  scratch.opcode = EEOP_JSONEXPR_COERCION;
  scratch.resvalue = resv;
  scratch.resnull = resnull;
  scratch.d.jsonexpr_coercion.targettype = returning->typid;
  scratch.d.jsonexpr_coercion.targettypmod = returning->typmod;
  scratch.d.jsonexpr_coercion.json_coercion_cache = NULL;
  scratch.d.jsonexpr_coercion.escontext = escontext;
  scratch.d.jsonexpr_coercion.omit_quotes = omit_quotes;
  scratch.d.jsonexpr_coercion.exists_coerce = exists_coerce;
  scratch.d.jsonexpr_coercion.exists_cast_to_int = exists_coerce &&
    getBaseType(returning->typid) == INT4OID;
  scratch.d.jsonexpr_coercion.exists_check_domain = exists_coerce &&
    DomainHasConstraints(returning->typid);
  ExprEvalPushStep(state, &scratch);
}

Coverage Report

Created: 2025-09-27 06:52