LCOV - code coverage report
Current view: top level - src/backend/executor - execExpr.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 1582 1632 96.9 %
Date: 2023-12-11 15:11:28 Functions: 28 28 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * execExpr.c
       4             :  *    Expression evaluation infrastructure.
       5             :  *
       6             :  *  During executor startup, we compile each expression tree (which has
       7             :  *  previously been processed by the parser and planner) into an ExprState,
       8             :  *  using ExecInitExpr() et al.  This converts the tree into a flat array
       9             :  *  of ExprEvalSteps, which may be thought of as instructions in a program.
      10             :  *  At runtime, we'll execute steps, starting with the first, until we reach
      11             :  *  an EEOP_DONE opcode.
      12             :  *
      13             :  *  This file contains the "compilation" logic.  It is independent of the
      14             :  *  specific execution technology we use (switch statement, computed goto,
      15             :  *  JIT compilation, etc).
      16             :  *
      17             :  *  See src/backend/executor/README for some background, specifically the
      18             :  *  "Expression Trees and ExprState nodes", "Expression Initialization",
      19             :  *  and "Expression Evaluation" sections.
      20             :  *
      21             :  *
      22             :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
      23             :  * Portions Copyright (c) 1994, Regents of the University of California
      24             :  *
      25             :  *
      26             :  * IDENTIFICATION
      27             :  *    src/backend/executor/execExpr.c
      28             :  *
      29             :  *-------------------------------------------------------------------------
      30             :  */
      31             : #include "postgres.h"
      32             : 
      33             : #include "access/nbtree.h"
      34             : #include "catalog/objectaccess.h"
      35             : #include "catalog/pg_proc.h"
      36             : #include "catalog/pg_type.h"
      37             : #include "executor/execExpr.h"
      38             : #include "executor/nodeSubplan.h"
      39             : #include "funcapi.h"
      40             : #include "jit/jit.h"
      41             : #include "miscadmin.h"
      42             : #include "nodes/makefuncs.h"
      43             : #include "nodes/nodeFuncs.h"
      44             : #include "nodes/subscripting.h"
      45             : #include "optimizer/optimizer.h"
      46             : #include "pgstat.h"
      47             : #include "utils/acl.h"
      48             : #include "utils/array.h"
      49             : #include "utils/builtins.h"
      50             : #include "utils/datum.h"
      51             : #include "utils/jsonfuncs.h"
      52             : #include "utils/lsyscache.h"
      53             : #include "utils/typcache.h"
      54             : 
      55             : 
      56             : typedef struct ExprSetupInfo
      57             : {
      58             :     /* Highest attribute numbers fetched from inner/outer/scan tuple slots: */
      59             :     AttrNumber  last_inner;
      60             :     AttrNumber  last_outer;
      61             :     AttrNumber  last_scan;
      62             :     /* MULTIEXPR SubPlan nodes appearing in the expression: */
      63             :     List       *multiexpr_subplans;
      64             : } ExprSetupInfo;
      65             : 
      66             : static void ExecReadyExpr(ExprState *state);
      67             : static void ExecInitExprRec(Expr *node, ExprState *state,
      68             :                             Datum *resv, bool *resnull);
      69             : static void ExecInitFunc(ExprEvalStep *scratch, Expr *node, List *args,
      70             :                          Oid funcid, Oid inputcollid,
      71             :                          ExprState *state);
      72             : static void ExecCreateExprSetupSteps(ExprState *state, Node *node);
      73             : static void ExecPushExprSetupSteps(ExprState *state, ExprSetupInfo *info);
      74             : static bool expr_setup_walker(Node *node, ExprSetupInfo *info);
      75             : static bool ExecComputeSlotInfo(ExprState *state, ExprEvalStep *op);
      76             : static void ExecInitWholeRowVar(ExprEvalStep *scratch, Var *variable,
      77             :                                 ExprState *state);
      78             : static void ExecInitSubscriptingRef(ExprEvalStep *scratch,
      79             :                                     SubscriptingRef *sbsref,
      80             :                                     ExprState *state,
      81             :                                     Datum *resv, bool *resnull);
      82             : static bool isAssignmentIndirectionExpr(Expr *expr);
      83             : static void ExecInitCoerceToDomain(ExprEvalStep *scratch, CoerceToDomain *ctest,
      84             :                                    ExprState *state,
      85             :                                    Datum *resv, bool *resnull);
      86             : static void ExecBuildAggTransCall(ExprState *state, AggState *aggstate,
      87             :                                   ExprEvalStep *scratch,
      88             :                                   FunctionCallInfo fcinfo, AggStatePerTrans pertrans,
      89             :                                   int transno, int setno, int setoff, bool ishash,
      90             :                                   bool nullcheck);
      91             : 
      92             : 
      93             : /*
      94             :  * ExecInitExpr: prepare an expression tree for execution
      95             :  *
      96             :  * This function builds and returns an ExprState implementing the given
      97             :  * Expr node tree.  The return ExprState can then be handed to ExecEvalExpr
      98             :  * for execution.  Because the Expr tree itself is read-only as far as
      99             :  * ExecInitExpr and ExecEvalExpr are concerned, several different executions
     100             :  * of the same plan tree can occur concurrently.  (But note that an ExprState
     101             :  * does mutate at runtime, so it can't be re-used concurrently.)
     102             :  *
     103             :  * This must be called in a memory context that will last as long as repeated
     104             :  * executions of the expression are needed.  Typically the context will be
     105             :  * the same as the per-query context of the associated ExprContext.
     106             :  *
     107             :  * Any Aggref, WindowFunc, or SubPlan nodes found in the tree are added to
     108             :  * the lists of such nodes held by the parent PlanState.
     109             :  *
     110             :  * Note: there is no ExecEndExpr function; we assume that any resource
     111             :  * cleanup needed will be handled by just releasing the memory context
     112             :  * in which the state tree is built.  Functions that require additional
     113             :  * cleanup work can register a shutdown callback in the ExprContext.
     114             :  *
     115             :  *  'node' is the root of the expression tree to compile.
     116             :  *  'parent' is the PlanState node that owns the expression.
     117             :  *
     118             :  * 'parent' may be NULL if we are preparing an expression that is not
     119             :  * associated with a plan tree.  (If so, it can't have aggs or subplans.)
     120             :  * Such cases should usually come through ExecPrepareExpr, not directly here.
     121             :  *
     122             :  * Also, if 'node' is NULL, we just return NULL.  This is convenient for some
     123             :  * callers that may or may not have an expression that needs to be compiled.
     124             :  * Note that a NULL ExprState pointer *cannot* be handed to ExecEvalExpr,
     125             :  * although ExecQual and ExecCheck will accept one (and treat it as "true").
     126             :  */
     127             : ExprState *
     128      953938 : ExecInitExpr(Expr *node, PlanState *parent)
     129             : {
     130             :     ExprState  *state;
     131      953938 :     ExprEvalStep scratch = {0};
     132             : 
     133             :     /* Special case: NULL expression produces a NULL ExprState pointer */
     134      953938 :     if (node == NULL)
     135       44346 :         return NULL;
     136             : 
     137             :     /* Initialize ExprState with empty step list */
     138      909592 :     state = makeNode(ExprState);
     139      909592 :     state->expr = node;
     140      909592 :     state->parent = parent;
     141      909592 :     state->ext_params = NULL;
     142             : 
     143             :     /* Insert setup steps as needed */
     144      909592 :     ExecCreateExprSetupSteps(state, (Node *) node);
     145             : 
     146             :     /* Compile the expression proper */
     147      909592 :     ExecInitExprRec(node, state, &state->resvalue, &state->resnull);
     148             : 
     149             :     /* Finally, append a DONE step */
     150      909574 :     scratch.opcode = EEOP_DONE;
     151      909574 :     ExprEvalPushStep(state, &scratch);
     152             : 
     153      909574 :     ExecReadyExpr(state);
     154             : 
     155      909574 :     return state;
     156             : }
     157             : 
     158             : /*
     159             :  * ExecInitExprWithParams: prepare a standalone expression tree for execution
     160             :  *
     161             :  * This is the same as ExecInitExpr, except that there is no parent PlanState,
     162             :  * and instead we may have a ParamListInfo describing PARAM_EXTERN Params.
     163             :  */
     164             : ExprState *
     165       73608 : ExecInitExprWithParams(Expr *node, ParamListInfo ext_params)
     166             : {
     167             :     ExprState  *state;
     168       73608 :     ExprEvalStep scratch = {0};
     169             : 
     170             :     /* Special case: NULL expression produces a NULL ExprState pointer */
     171       73608 :     if (node == NULL)
     172           0 :         return NULL;
     173             : 
     174             :     /* Initialize ExprState with empty step list */
     175       73608 :     state = makeNode(ExprState);
     176       73608 :     state->expr = node;
     177       73608 :     state->parent = NULL;
     178       73608 :     state->ext_params = ext_params;
     179             : 
     180             :     /* Insert setup steps as needed */
     181       73608 :     ExecCreateExprSetupSteps(state, (Node *) node);
     182             : 
     183             :     /* Compile the expression proper */
     184       73608 :     ExecInitExprRec(node, state, &state->resvalue, &state->resnull);
     185             : 
     186             :     /* Finally, append a DONE step */
     187       73608 :     scratch.opcode = EEOP_DONE;
     188       73608 :     ExprEvalPushStep(state, &scratch);
     189             : 
     190       73608 :     ExecReadyExpr(state);
     191             : 
     192       73608 :     return state;
     193             : }
     194             : 
     195             : /*
     196             :  * ExecInitQual: prepare a qual for execution by ExecQual
     197             :  *
     198             :  * Prepares for the evaluation of a conjunctive boolean expression (qual list
     199             :  * with implicit AND semantics) that returns true if none of the
     200             :  * subexpressions are false.
     201             :  *
     202             :  * We must return true if the list is empty.  Since that's a very common case,
     203             :  * we optimize it a bit further by translating to a NULL ExprState pointer
     204             :  * rather than setting up an ExprState that computes constant TRUE.  (Some
     205             :  * especially hot-spot callers of ExecQual detect this and avoid calling
     206             :  * ExecQual at all.)
     207             :  *
     208             :  * If any of the subexpressions yield NULL, then the result of the conjunction
     209             :  * is false.  This makes ExecQual primarily useful for evaluating WHERE
     210             :  * clauses, since SQL specifies that tuples with null WHERE results do not
     211             :  * get selected.
     212             :  */
     213             : ExprState *
     214     1597444 : ExecInitQual(List *qual, PlanState *parent)
     215             : {
     216             :     ExprState  *state;
     217     1597444 :     ExprEvalStep scratch = {0};
     218     1597444 :     List       *adjust_jumps = NIL;
     219             :     ListCell   *lc;
     220             : 
     221             :     /* short-circuit (here and in ExecQual) for empty restriction list */
     222     1597444 :     if (qual == NIL)
     223     1218052 :         return NULL;
     224             : 
     225             :     Assert(IsA(qual, List));
     226             : 
     227      379392 :     state = makeNode(ExprState);
     228      379392 :     state->expr = (Expr *) qual;
     229      379392 :     state->parent = parent;
     230      379392 :     state->ext_params = NULL;
     231             : 
     232             :     /* mark expression as to be used with ExecQual() */
     233      379392 :     state->flags = EEO_FLAG_IS_QUAL;
     234             : 
     235             :     /* Insert setup steps as needed */
     236      379392 :     ExecCreateExprSetupSteps(state, (Node *) qual);
     237             : 
     238             :     /*
     239             :      * ExecQual() needs to return false for an expression returning NULL. That
     240             :      * allows us to short-circuit the evaluation the first time a NULL is
     241             :      * encountered.  As qual evaluation is a hot-path this warrants using a
     242             :      * special opcode for qual evaluation that's simpler than BOOL_AND (which
     243             :      * has more complex NULL handling).
     244             :      */
     245      379392 :     scratch.opcode = EEOP_QUAL;
     246             : 
     247             :     /*
     248             :      * We can use ExprState's resvalue/resnull as target for each qual expr.
     249             :      */
     250      379392 :     scratch.resvalue = &state->resvalue;
     251      379392 :     scratch.resnull = &state->resnull;
     252             : 
     253      840016 :     foreach(lc, qual)
     254             :     {
     255      460624 :         Expr       *node = (Expr *) lfirst(lc);
     256             : 
     257             :         /* first evaluate expression */
     258      460624 :         ExecInitExprRec(node, state, &state->resvalue, &state->resnull);
     259             : 
     260             :         /* then emit EEOP_QUAL to detect if it's false (or null) */
     261      460624 :         scratch.d.qualexpr.jumpdone = -1;
     262      460624 :         ExprEvalPushStep(state, &scratch);
     263      460624 :         adjust_jumps = lappend_int(adjust_jumps,
     264      460624 :                                    state->steps_len - 1);
     265             :     }
     266             : 
     267             :     /* adjust jump targets */
     268      840016 :     foreach(lc, adjust_jumps)
     269             :     {
     270      460624 :         ExprEvalStep *as = &state->steps[lfirst_int(lc)];
     271             : 
     272             :         Assert(as->opcode == EEOP_QUAL);
     273             :         Assert(as->d.qualexpr.jumpdone == -1);
     274      460624 :         as->d.qualexpr.jumpdone = state->steps_len;
     275             :     }
     276             : 
     277             :     /*
     278             :      * At the end, we don't need to do anything more.  The last qual expr must
     279             :      * have yielded TRUE, and since its result is stored in the desired output
     280             :      * location, we're done.
     281             :      */
     282      379392 :     scratch.opcode = EEOP_DONE;
     283      379392 :     ExprEvalPushStep(state, &scratch);
     284             : 
     285      379392 :     ExecReadyExpr(state);
     286             : 
     287      379392 :     return state;
     288             : }
     289             : 
     290             : /*
     291             :  * ExecInitCheck: prepare a check constraint for execution by ExecCheck
     292             :  *
     293             :  * This is much like ExecInitQual/ExecQual, except that a null result from
     294             :  * the conjunction is treated as TRUE.  This behavior is appropriate for
     295             :  * evaluating CHECK constraints, since SQL specifies that NULL constraint
     296             :  * conditions are not failures.
     297             :  *
     298             :  * Note that like ExecInitQual, this expects input in implicit-AND format.
     299             :  * Users of ExecCheck that have expressions in normal explicit-AND format
     300             :  * can just apply ExecInitExpr to produce suitable input for ExecCheck.
     301             :  */
     302             : ExprState *
     303        5158 : ExecInitCheck(List *qual, PlanState *parent)
     304             : {
     305             :     /* short-circuit (here and in ExecCheck) for empty restriction list */
     306        5158 :     if (qual == NIL)
     307          96 :         return NULL;
     308             : 
     309             :     Assert(IsA(qual, List));
     310             : 
     311             :     /*
     312             :      * Just convert the implicit-AND list to an explicit AND (if there's more
     313             :      * than one entry), and compile normally.  Unlike ExecQual, we can't
     314             :      * short-circuit on NULL results, so the regular AND behavior is needed.
     315             :      */
     316        5062 :     return ExecInitExpr(make_ands_explicit(qual), parent);
     317             : }
     318             : 
     319             : /*
     320             :  * Call ExecInitExpr() on a list of expressions, return a list of ExprStates.
     321             :  */
     322             : List *
     323      495696 : ExecInitExprList(List *nodes, PlanState *parent)
     324             : {
     325      495696 :     List       *result = NIL;
     326             :     ListCell   *lc;
     327             : 
     328      926886 :     foreach(lc, nodes)
     329             :     {
     330      431190 :         Expr       *e = lfirst(lc);
     331             : 
     332      431190 :         result = lappend(result, ExecInitExpr(e, parent));
     333             :     }
     334             : 
     335      495696 :     return result;
     336             : }
     337             : 
     338             : /*
     339             :  *      ExecBuildProjectionInfo
     340             :  *
     341             :  * Build a ProjectionInfo node for evaluating the given tlist in the given
     342             :  * econtext, and storing the result into the tuple slot.  (Caller must have
     343             :  * ensured that tuple slot has a descriptor matching the tlist!)
     344             :  *
     345             :  * inputDesc can be NULL, but if it is not, we check to see whether simple
     346             :  * Vars in the tlist match the descriptor.  It is important to provide
     347             :  * inputDesc for relation-scan plan nodes, as a cross check that the relation
     348             :  * hasn't been changed since the plan was made.  At higher levels of a plan,
     349             :  * there is no need to recheck.
     350             :  *
     351             :  * This is implemented by internally building an ExprState that performs the
     352             :  * whole projection in one go.
     353             :  *
     354             :  * Caution: before PG v10, the targetList was a list of ExprStates; now it
     355             :  * should be the planner-created targetlist, since we do the compilation here.
     356             :  */
     357             : ProjectionInfo *
     358      686674 : ExecBuildProjectionInfo(List *targetList,
     359             :                         ExprContext *econtext,
     360             :                         TupleTableSlot *slot,
     361             :                         PlanState *parent,
     362             :                         TupleDesc inputDesc)
     363             : {
     364      686674 :     ProjectionInfo *projInfo = makeNode(ProjectionInfo);
     365             :     ExprState  *state;
     366      686674 :     ExprEvalStep scratch = {0};
     367             :     ListCell   *lc;
     368             : 
     369      686674 :     projInfo->pi_exprContext = econtext;
     370             :     /* We embed ExprState into ProjectionInfo instead of doing extra palloc */
     371      686674 :     projInfo->pi_state.type = T_ExprState;
     372      686674 :     state = &projInfo->pi_state;
     373      686674 :     state->expr = (Expr *) targetList;
     374      686674 :     state->parent = parent;
     375      686674 :     state->ext_params = NULL;
     376             : 
     377      686674 :     state->resultslot = slot;
     378             : 
     379             :     /* Insert setup steps as needed */
     380      686674 :     ExecCreateExprSetupSteps(state, (Node *) targetList);
     381             : 
     382             :     /* Now compile each tlist column */
     383     2339604 :     foreach(lc, targetList)
     384             :     {
     385     1653000 :         TargetEntry *tle = lfirst_node(TargetEntry, lc);
     386     1653000 :         Var        *variable = NULL;
     387     1653000 :         AttrNumber  attnum = 0;
     388     1653000 :         bool        isSafeVar = false;
     389             : 
     390             :         /*
     391             :          * If tlist expression is a safe non-system Var, use the fast-path
     392             :          * ASSIGN_*_VAR opcodes.  "Safe" means that we don't need to apply
     393             :          * CheckVarSlotCompatibility() during plan startup.  If a source slot
     394             :          * was provided, we make the equivalent tests here; if a slot was not
     395             :          * provided, we assume that no check is needed because we're dealing
     396             :          * with a non-relation-scan-level expression.
     397             :          */
     398     1653000 :         if (tle->expr != NULL &&
     399     1653000 :             IsA(tle->expr, Var) &&
     400      948386 :             ((Var *) tle->expr)->varattno > 0)
     401             :         {
     402             :             /* Non-system Var, but how safe is it? */
     403      878358 :             variable = (Var *) tle->expr;
     404      878358 :             attnum = variable->varattno;
     405             : 
     406      878358 :             if (inputDesc == NULL)
     407      536616 :                 isSafeVar = true;   /* can't check, just assume OK */
     408      341742 :             else if (attnum <= inputDesc->natts)
     409             :             {
     410      341290 :                 Form_pg_attribute attr = TupleDescAttr(inputDesc, attnum - 1);
     411             : 
     412             :                 /*
     413             :                  * If user attribute is dropped or has a type mismatch, don't
     414             :                  * use ASSIGN_*_VAR.  Instead let the normal expression
     415             :                  * machinery handle it (which'll possibly error out).
     416             :                  */
     417      341290 :                 if (!attr->attisdropped && variable->vartype == attr->atttypid)
     418             :                 {
     419      340564 :                     isSafeVar = true;
     420             :                 }
     421             :             }
     422             :         }
     423             : 
     424     1653000 :         if (isSafeVar)
     425             :         {
     426             :             /* Fast-path: just generate an EEOP_ASSIGN_*_VAR step */
     427      877180 :             switch (variable->varno)
     428             :             {
     429      156884 :                 case INNER_VAR:
     430             :                     /* get the tuple from the inner node */
     431      156884 :                     scratch.opcode = EEOP_ASSIGN_INNER_VAR;
     432      156884 :                     break;
     433             : 
     434      378776 :                 case OUTER_VAR:
     435             :                     /* get the tuple from the outer node */
     436      378776 :                     scratch.opcode = EEOP_ASSIGN_OUTER_VAR;
     437      378776 :                     break;
     438             : 
     439             :                     /* INDEX_VAR is handled by default case */
     440             : 
     441      341520 :                 default:
     442             :                     /* get the tuple from the relation being scanned */
     443      341520 :                     scratch.opcode = EEOP_ASSIGN_SCAN_VAR;
     444      341520 :                     break;
     445             :             }
     446             : 
     447      877180 :             scratch.d.assign_var.attnum = attnum - 1;
     448      877180 :             scratch.d.assign_var.resultnum = tle->resno - 1;
     449      877180 :             ExprEvalPushStep(state, &scratch);
     450             :         }
     451             :         else
     452             :         {
     453             :             /*
     454             :              * Otherwise, compile the column expression normally.
     455             :              *
     456             :              * We can't tell the expression to evaluate directly into the
     457             :              * result slot, as the result slot (and the exprstate for that
     458             :              * matter) can change between executions.  We instead evaluate
     459             :              * into the ExprState's resvalue/resnull and then move.
     460             :              */
     461      775820 :             ExecInitExprRec(tle->expr, state,
     462             :                             &state->resvalue, &state->resnull);
     463             : 
     464             :             /*
     465             :              * Column might be referenced multiple times in upper nodes, so
     466             :              * force value to R/O - but only if it could be an expanded datum.
     467             :              */
     468      775750 :             if (get_typlen(exprType((Node *) tle->expr)) == -1)
     469      242342 :                 scratch.opcode = EEOP_ASSIGN_TMP_MAKE_RO;
     470             :             else
     471      533408 :                 scratch.opcode = EEOP_ASSIGN_TMP;
     472      775750 :             scratch.d.assign_tmp.resultnum = tle->resno - 1;
     473      775750 :             ExprEvalPushStep(state, &scratch);
     474             :         }
     475             :     }
     476             : 
     477      686604 :     scratch.opcode = EEOP_DONE;
     478      686604 :     ExprEvalPushStep(state, &scratch);
     479             : 
     480      686604 :     ExecReadyExpr(state);
     481             : 
     482      686604 :     return projInfo;
     483             : }
     484             : 
     485             : /*
     486             :  *      ExecBuildUpdateProjection
     487             :  *
     488             :  * Build a ProjectionInfo node for constructing a new tuple during UPDATE.
     489             :  * The projection will be executed in the given econtext and the result will
     490             :  * be stored into the given tuple slot.  (Caller must have ensured that tuple
     491             :  * slot has a descriptor matching the target rel!)
     492             :  *
     493             :  * When evalTargetList is false, targetList contains the UPDATE ... SET
     494             :  * expressions that have already been computed by a subplan node; the values
     495             :  * from this tlist are assumed to be available in the "outer" tuple slot.
     496             :  * When evalTargetList is true, targetList contains the UPDATE ... SET
     497             :  * expressions that must be computed (which could contain references to
     498             :  * the outer, inner, or scan tuple slots).
     499             :  *
     500             :  * In either case, targetColnos contains a list of the target column numbers
     501             :  * corresponding to the non-resjunk entries of targetList.  The tlist values
     502             :  * are assigned into these columns of the result tuple slot.  Target columns
     503             :  * not listed in targetColnos are filled from the UPDATE's old tuple, which
     504             :  * is assumed to be available in the "scan" tuple slot.
     505             :  *
     506             :  * targetList can also contain resjunk columns.  These must be evaluated
     507             :  * if evalTargetList is true, but their values are discarded.
     508             :  *
     509             :  * relDesc must describe the relation we intend to update.
     510             :  *
     511             :  * This is basically a specialized variant of ExecBuildProjectionInfo.
     512             :  * However, it also performs sanity checks equivalent to ExecCheckPlanOutput.
     513             :  * Since we never make a normal tlist equivalent to the whole
     514             :  * tuple-to-be-assigned, there is no convenient way to apply
     515             :  * ExecCheckPlanOutput, so we must do our safety checks here.
     516             :  */
     517             : ProjectionInfo *
     518       13948 : ExecBuildUpdateProjection(List *targetList,
     519             :                           bool evalTargetList,
     520             :                           List *targetColnos,
     521             :                           TupleDesc relDesc,
     522             :                           ExprContext *econtext,
     523             :                           TupleTableSlot *slot,
     524             :                           PlanState *parent)
     525             : {
     526       13948 :     ProjectionInfo *projInfo = makeNode(ProjectionInfo);
     527             :     ExprState  *state;
     528             :     int         nAssignableCols;
     529             :     bool        sawJunk;
     530             :     Bitmapset  *assignedCols;
     531       13948 :     ExprSetupInfo deform = {0, 0, 0, NIL};
     532       13948 :     ExprEvalStep scratch = {0};
     533             :     int         outerattnum;
     534             :     ListCell   *lc,
     535             :                *lc2;
     536             : 
     537       13948 :     projInfo->pi_exprContext = econtext;
     538             :     /* We embed ExprState into ProjectionInfo instead of doing extra palloc */
     539       13948 :     projInfo->pi_state.type = T_ExprState;
     540       13948 :     state = &projInfo->pi_state;
     541       13948 :     if (evalTargetList)
     542        1806 :         state->expr = (Expr *) targetList;
     543             :     else
     544       12142 :         state->expr = NULL;      /* not used */
     545       13948 :     state->parent = parent;
     546       13948 :     state->ext_params = NULL;
     547             : 
     548       13948 :     state->resultslot = slot;
     549             : 
     550             :     /*
     551             :      * Examine the targetList to see how many non-junk columns there are, and
     552             :      * to verify that the non-junk columns come before the junk ones.
     553             :      */
     554       13948 :     nAssignableCols = 0;
     555       13948 :     sawJunk = false;
     556       47094 :     foreach(lc, targetList)
     557             :     {
     558       33146 :         TargetEntry *tle = lfirst_node(TargetEntry, lc);
     559             : 
     560       33146 :         if (tle->resjunk)
     561       15286 :             sawJunk = true;
     562             :         else
     563             :         {
     564       17860 :             if (sawJunk)
     565           0 :                 elog(ERROR, "subplan target list is out of order");
     566       17860 :             nAssignableCols++;
     567             :         }
     568             :     }
     569             : 
     570             :     /* We should have one targetColnos entry per non-junk column */
     571       13948 :     if (nAssignableCols != list_length(targetColnos))
     572           0 :         elog(ERROR, "targetColnos does not match subplan target list");
     573             : 
     574             :     /*
     575             :      * Build a bitmapset of the columns in targetColnos.  (We could just use
     576             :      * list_member_int() tests, but that risks O(N^2) behavior with many
     577             :      * columns.)
     578             :      */
     579       13948 :     assignedCols = NULL;
     580       31808 :     foreach(lc, targetColnos)
     581             :     {
     582       17860 :         AttrNumber  targetattnum = lfirst_int(lc);
     583             : 
     584       17860 :         assignedCols = bms_add_member(assignedCols, targetattnum);
     585             :     }
     586             : 
     587             :     /*
     588             :      * We need to insert EEOP_*_FETCHSOME steps to ensure the input tuples are
     589             :      * sufficiently deconstructed.  The scan tuple must be deconstructed at
     590             :      * least as far as the last old column we need.
     591             :      */
     592       22962 :     for (int attnum = relDesc->natts; attnum > 0; attnum--)
     593             :     {
     594       20792 :         Form_pg_attribute attr = TupleDescAttr(relDesc, attnum - 1);
     595             : 
     596       20792 :         if (attr->attisdropped)
     597         198 :             continue;
     598       20594 :         if (bms_is_member(attnum, assignedCols))
     599        8816 :             continue;
     600       11778 :         deform.last_scan = attnum;
     601       11778 :         break;
     602             :     }
     603             : 
     604             :     /*
     605             :      * If we're actually evaluating the tlist, incorporate its input
     606             :      * requirements too; otherwise, we'll just need to fetch the appropriate
     607             :      * number of columns of the "outer" tuple.
     608             :      */
     609       13948 :     if (evalTargetList)
     610        1806 :         expr_setup_walker((Node *) targetList, &deform);
     611             :     else
     612       12142 :         deform.last_outer = nAssignableCols;
     613             : 
     614       13948 :     ExecPushExprSetupSteps(state, &deform);
     615             : 
     616             :     /*
     617             :      * Now generate code to evaluate the tlist's assignable expressions or
     618             :      * fetch them from the outer tuple, incidentally validating that they'll
     619             :      * be of the right data type.  The checks above ensure that the forboth()
     620             :      * will iterate over exactly the non-junk columns.  Note that we don't
     621             :      * bother evaluating any remaining resjunk columns.
     622             :      */
     623       13948 :     outerattnum = 0;
     624       31808 :     forboth(lc, targetList, lc2, targetColnos)
     625             :     {
     626       17860 :         TargetEntry *tle = lfirst_node(TargetEntry, lc);
     627       17860 :         AttrNumber  targetattnum = lfirst_int(lc2);
     628             :         Form_pg_attribute attr;
     629             : 
     630             :         Assert(!tle->resjunk);
     631             : 
     632             :         /*
     633             :          * Apply sanity checks comparable to ExecCheckPlanOutput().
     634             :          */
     635       17860 :         if (targetattnum <= 0 || targetattnum > relDesc->natts)
     636           0 :             ereport(ERROR,
     637             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
     638             :                      errmsg("table row type and query-specified row type do not match"),
     639             :                      errdetail("Query has too many columns.")));
     640       17860 :         attr = TupleDescAttr(relDesc, targetattnum - 1);
     641             : 
     642       17860 :         if (attr->attisdropped)
     643           0 :             ereport(ERROR,
     644             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
     645             :                      errmsg("table row type and query-specified row type do not match"),
     646             :                      errdetail("Query provides a value for a dropped column at ordinal position %d.",
     647             :                                targetattnum)));
     648       17860 :         if (exprType((Node *) tle->expr) != attr->atttypid)
     649           0 :             ereport(ERROR,
     650             :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
     651             :                      errmsg("table row type and query-specified row type do not match"),
     652             :                      errdetail("Table has type %s at ordinal position %d, but query expects %s.",
     653             :                                format_type_be(attr->atttypid),
     654             :                                targetattnum,
     655             :                                format_type_be(exprType((Node *) tle->expr)))));
     656             : 
     657             :         /* OK, generate code to perform the assignment. */
     658       17860 :         if (evalTargetList)
     659             :         {
     660             :             /*
     661             :              * We must evaluate the TLE's expression and assign it.  We do not
     662             :              * bother jumping through hoops for "safe" Vars like
     663             :              * ExecBuildProjectionInfo does; this is a relatively less-used
     664             :              * path and it doesn't seem worth expending code for that.
     665             :              */
     666        2464 :             ExecInitExprRec(tle->expr, state,
     667             :                             &state->resvalue, &state->resnull);
     668             :             /* Needn't worry about read-only-ness here, either. */
     669        2464 :             scratch.opcode = EEOP_ASSIGN_TMP;
     670        2464 :             scratch.d.assign_tmp.resultnum = targetattnum - 1;
     671        2464 :             ExprEvalPushStep(state, &scratch);
     672             :         }
     673             :         else
     674             :         {
     675             :             /* Just assign from the outer tuple. */
     676       15396 :             scratch.opcode = EEOP_ASSIGN_OUTER_VAR;
     677       15396 :             scratch.d.assign_var.attnum = outerattnum;
     678       15396 :             scratch.d.assign_var.resultnum = targetattnum - 1;
     679       15396 :             ExprEvalPushStep(state, &scratch);
     680             :         }
     681       17860 :         outerattnum++;
     682             :     }
     683             : 
     684             :     /*
     685             :      * Now generate code to copy over any old columns that were not assigned
     686             :      * to, and to ensure that dropped columns are set to NULL.
     687             :      */
     688      138558 :     for (int attnum = 1; attnum <= relDesc->natts; attnum++)
     689             :     {
     690      124610 :         Form_pg_attribute attr = TupleDescAttr(relDesc, attnum - 1);
     691             : 
     692      124610 :         if (attr->attisdropped)
     693             :         {
     694             :             /* Put a null into the ExprState's resvalue/resnull ... */
     695         314 :             scratch.opcode = EEOP_CONST;
     696         314 :             scratch.resvalue = &state->resvalue;
     697         314 :             scratch.resnull = &state->resnull;
     698         314 :             scratch.d.constval.value = (Datum) 0;
     699         314 :             scratch.d.constval.isnull = true;
     700         314 :             ExprEvalPushStep(state, &scratch);
     701             :             /* ... then assign it to the result slot */
     702         314 :             scratch.opcode = EEOP_ASSIGN_TMP;
     703         314 :             scratch.d.assign_tmp.resultnum = attnum - 1;
     704         314 :             ExprEvalPushStep(state, &scratch);
     705             :         }
     706      124296 :         else if (!bms_is_member(attnum, assignedCols))
     707             :         {
     708             :             /* Certainly the right type, so needn't check */
     709      106436 :             scratch.opcode = EEOP_ASSIGN_SCAN_VAR;
     710      106436 :             scratch.d.assign_var.attnum = attnum - 1;
     711      106436 :             scratch.d.assign_var.resultnum = attnum - 1;
     712      106436 :             ExprEvalPushStep(state, &scratch);
     713             :         }
     714             :     }
     715             : 
     716       13948 :     scratch.opcode = EEOP_DONE;
     717       13948 :     ExprEvalPushStep(state, &scratch);
     718             : 
     719       13948 :     ExecReadyExpr(state);
     720             : 
     721       13948 :     return projInfo;
     722             : }
     723             : 
     724             : /*
     725             :  * ExecPrepareExpr --- initialize for expression execution outside a normal
     726             :  * Plan tree context.
     727             :  *
     728             :  * This differs from ExecInitExpr in that we don't assume the caller is
     729             :  * already running in the EState's per-query context.  Also, we run the
     730             :  * passed expression tree through expression_planner() to prepare it for
     731             :  * execution.  (In ordinary Plan trees the regular planning process will have
     732             :  * made the appropriate transformations on expressions, but for standalone
     733             :  * expressions this won't have happened.)
     734             :  */
     735             : ExprState *
     736       19162 : ExecPrepareExpr(Expr *node, EState *estate)
     737             : {
     738             :     ExprState  *result;
     739             :     MemoryContext oldcontext;
     740             : 
     741       19162 :     oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
     742             : 
     743       19162 :     node = expression_planner(node);
     744             : 
     745       19156 :     result = ExecInitExpr(node, NULL);
     746             : 
     747       19156 :     MemoryContextSwitchTo(oldcontext);
     748             : 
     749       19156 :     return result;
     750             : }
     751             : 
     752             : /*
     753             :  * ExecPrepareQual --- initialize for qual execution outside a normal
     754             :  * Plan tree context.
     755             :  *
     756             :  * This differs from ExecInitQual in that we don't assume the caller is
     757             :  * already running in the EState's per-query context.  Also, we run the
     758             :  * passed expression tree through expression_planner() to prepare it for
     759             :  * execution.  (In ordinary Plan trees the regular planning process will have
     760             :  * made the appropriate transformations on expressions, but for standalone
     761             :  * expressions this won't have happened.)
     762             :  */
     763             : ExprState *
     764       45472 : ExecPrepareQual(List *qual, EState *estate)
     765             : {
     766             :     ExprState  *result;
     767             :     MemoryContext oldcontext;
     768             : 
     769       45472 :     oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
     770             : 
     771       45472 :     qual = (List *) expression_planner((Expr *) qual);
     772             : 
     773       45472 :     result = ExecInitQual(qual, NULL);
     774             : 
     775       45472 :     MemoryContextSwitchTo(oldcontext);
     776             : 
     777       45472 :     return result;
     778             : }
     779             : 
     780             : /*
     781             :  * ExecPrepareCheck -- initialize check constraint for execution outside a
     782             :  * normal Plan tree context.
     783             :  *
     784             :  * See ExecPrepareExpr() and ExecInitCheck() for details.
     785             :  */
     786             : ExprState *
     787        5158 : ExecPrepareCheck(List *qual, EState *estate)
     788             : {
     789             :     ExprState  *result;
     790             :     MemoryContext oldcontext;
     791             : 
     792        5158 :     oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
     793             : 
     794        5158 :     qual = (List *) expression_planner((Expr *) qual);
     795             : 
     796        5158 :     result = ExecInitCheck(qual, NULL);
     797             : 
     798        5158 :     MemoryContextSwitchTo(oldcontext);
     799             : 
     800        5158 :     return result;
     801             : }
     802             : 
     803             : /*
     804             :  * Call ExecPrepareExpr() on each member of a list of Exprs, and return
     805             :  * a list of ExprStates.
     806             :  *
     807             :  * See ExecPrepareExpr() for details.
     808             :  */
     809             : List *
     810       11972 : ExecPrepareExprList(List *nodes, EState *estate)
     811             : {
     812       11972 :     List       *result = NIL;
     813             :     MemoryContext oldcontext;
     814             :     ListCell   *lc;
     815             : 
     816             :     /* Ensure that the list cell nodes are in the right context too */
     817       11972 :     oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
     818             : 
     819       24218 :     foreach(lc, nodes)
     820             :     {
     821       12246 :         Expr       *e = (Expr *) lfirst(lc);
     822             : 
     823       12246 :         result = lappend(result, ExecPrepareExpr(e, estate));
     824             :     }
     825             : 
     826       11972 :     MemoryContextSwitchTo(oldcontext);
     827             : 
     828       11972 :     return result;
     829             : }
     830             : 
     831             : /*
     832             :  * ExecCheck - evaluate a check constraint
     833             :  *
     834             :  * For check constraints, a null result is taken as TRUE, ie the constraint
     835             :  * passes.
     836             :  *
     837             :  * The check constraint may have been prepared with ExecInitCheck
     838             :  * (possibly via ExecPrepareCheck) if the caller had it in implicit-AND
     839             :  * format, but a regular boolean expression prepared with ExecInitExpr or
     840             :  * ExecPrepareExpr works too.
     841             :  */
     842             : bool
     843       82482 : ExecCheck(ExprState *state, ExprContext *econtext)
     844             : {
     845             :     Datum       ret;
     846             :     bool        isnull;
     847             : 
     848             :     /* short-circuit (here and in ExecInitCheck) for empty restriction list */
     849       82482 :     if (state == NULL)
     850          96 :         return true;
     851             : 
     852             :     /* verify that expression was not compiled using ExecInitQual */
     853             :     Assert(!(state->flags & EEO_FLAG_IS_QUAL));
     854             : 
     855       82386 :     ret = ExecEvalExprSwitchContext(state, econtext, &isnull);
     856             : 
     857       82380 :     if (isnull)
     858        2782 :         return true;
     859             : 
     860       79598 :     return DatumGetBool(ret);
     861             : }
     862             : 
     863             : /*
     864             :  * Prepare a compiled expression for execution.  This has to be called for
     865             :  * every ExprState before it can be executed.
     866             :  *
     867             :  * NB: While this currently only calls ExecReadyInterpretedExpr(),
     868             :  * this will likely get extended to further expression evaluation methods.
     869             :  * Therefore this should be used instead of directly calling
     870             :  * ExecReadyInterpretedExpr().
     871             :  */
     872             : static void
     873     2123688 : ExecReadyExpr(ExprState *state)
     874             : {
     875     2123688 :     if (jit_compile_expr(state))
     876       10156 :         return;
     877             : 
     878     2113532 :     ExecReadyInterpretedExpr(state);
     879             : }
     880             : 
     881             : /*
     882             :  * Append the steps necessary for the evaluation of node to ExprState->steps,
     883             :  * possibly recursing into sub-expressions of node.
     884             :  *
     885             :  * node - expression to evaluate
     886             :  * state - ExprState to whose ->steps to append the necessary operations
     887             :  * resv / resnull - where to store the result of the node into
     888             :  */
     889             : static void
     890     4494030 : ExecInitExprRec(Expr *node, ExprState *state,
     891             :                 Datum *resv, bool *resnull)
     892             : {
     893     4494030 :     ExprEvalStep scratch = {0};
     894             : 
     895             :     /* Guard against stack overflow due to overly complex expressions */
     896     4494030 :     check_stack_depth();
     897             : 
     898             :     /* Step's output location is always what the caller gave us */
     899             :     Assert(resv != NULL && resnull != NULL);
     900     4494030 :     scratch.resvalue = resv;
     901     4494030 :     scratch.resnull = resnull;
     902             : 
     903             :     /* cases should be ordered as they are in enum NodeTag */
     904     4494030 :     switch (nodeTag(node))
     905             :     {
     906     1006466 :         case T_Var:
     907             :             {
     908     1006466 :                 Var        *variable = (Var *) node;
     909             : 
     910     1006466 :                 if (variable->varattno == InvalidAttrNumber)
     911             :                 {
     912             :                     /* whole-row Var */
     913        3540 :                     ExecInitWholeRowVar(&scratch, variable, state);
     914             :                 }
     915     1002926 :                 else if (variable->varattno <= 0)
     916             :                 {
     917             :                     /* system column */
     918       70494 :                     scratch.d.var.attnum = variable->varattno;
     919       70494 :                     scratch.d.var.vartype = variable->vartype;
     920       70494 :                     switch (variable->varno)
     921             :                     {
     922           6 :                         case INNER_VAR:
     923           6 :                             scratch.opcode = EEOP_INNER_SYSVAR;
     924           6 :                             break;
     925          12 :                         case OUTER_VAR:
     926          12 :                             scratch.opcode = EEOP_OUTER_SYSVAR;
     927          12 :                             break;
     928             : 
     929             :                             /* INDEX_VAR is handled by default case */
     930             : 
     931       70476 :                         default:
     932       70476 :                             scratch.opcode = EEOP_SCAN_SYSVAR;
     933       70476 :                             break;
     934             :                     }
     935             :                 }
     936             :                 else
     937             :                 {
     938             :                     /* regular user column */
     939      932432 :                     scratch.d.var.attnum = variable->varattno - 1;
     940      932432 :                     scratch.d.var.vartype = variable->vartype;
     941      932432 :                     switch (variable->varno)
     942             :                     {
     943      104058 :                         case INNER_VAR:
     944      104058 :                             scratch.opcode = EEOP_INNER_VAR;
     945      104058 :                             break;
     946      257512 :                         case OUTER_VAR:
     947      257512 :                             scratch.opcode = EEOP_OUTER_VAR;
     948      257512 :                             break;
     949             : 
     950             :                             /* INDEX_VAR is handled by default case */
     951             : 
     952      570862 :                         default:
     953      570862 :                             scratch.opcode = EEOP_SCAN_VAR;
     954      570862 :                             break;
     955             :                     }
     956             :                 }
     957             : 
     958     1006466 :                 ExprEvalPushStep(state, &scratch);
     959     1006466 :                 break;
     960             :             }
     961             : 
     962      928290 :         case T_Const:
     963             :             {
     964      928290 :                 Const      *con = (Const *) node;
     965             : 
     966      928290 :                 scratch.opcode = EEOP_CONST;
     967      928290 :                 scratch.d.constval.value = con->constvalue;
     968      928290 :                 scratch.d.constval.isnull = con->constisnull;
     969             : 
     970      928290 :                 ExprEvalPushStep(state, &scratch);
     971      928290 :                 break;
     972             :             }
     973             : 
     974      727838 :         case T_Param:
     975             :             {
     976      727838 :                 Param      *param = (Param *) node;
     977             :                 ParamListInfo params;
     978             : 
     979      727838 :                 switch (param->paramkind)
     980             :                 {
     981      209068 :                     case PARAM_EXEC:
     982      209068 :                         scratch.opcode = EEOP_PARAM_EXEC;
     983      209068 :                         scratch.d.param.paramid = param->paramid;
     984      209068 :                         scratch.d.param.paramtype = param->paramtype;
     985      209068 :                         ExprEvalPushStep(state, &scratch);
     986      209068 :                         break;
     987      518770 :                     case PARAM_EXTERN:
     988             : 
     989             :                         /*
     990             :                          * If we have a relevant ParamCompileHook, use it;
     991             :                          * otherwise compile a standard EEOP_PARAM_EXTERN
     992             :                          * step.  ext_params, if supplied, takes precedence
     993             :                          * over info from the parent node's EState (if any).
     994             :                          */
     995      518770 :                         if (state->ext_params)
     996       67148 :                             params = state->ext_params;
     997      451622 :                         else if (state->parent &&
     998      451324 :                                  state->parent->state)
     999      451324 :                             params = state->parent->state->es_param_list_info;
    1000             :                         else
    1001         298 :                             params = NULL;
    1002      518770 :                         if (params && params->paramCompile)
    1003             :                         {
    1004      123040 :                             params->paramCompile(params, param, state,
    1005             :                                                  resv, resnull);
    1006             :                         }
    1007             :                         else
    1008             :                         {
    1009      395730 :                             scratch.opcode = EEOP_PARAM_EXTERN;
    1010      395730 :                             scratch.d.param.paramid = param->paramid;
    1011      395730 :                             scratch.d.param.paramtype = param->paramtype;
    1012      395730 :                             ExprEvalPushStep(state, &scratch);
    1013             :                         }
    1014      518770 :                         break;
    1015           0 :                     default:
    1016           0 :                         elog(ERROR, "unrecognized paramkind: %d",
    1017             :                              (int) param->paramkind);
    1018             :                         break;
    1019             :                 }
    1020      727838 :                 break;
    1021             :             }
    1022             : 
    1023       45112 :         case T_Aggref:
    1024             :             {
    1025       45112 :                 Aggref     *aggref = (Aggref *) node;
    1026             : 
    1027       45112 :                 scratch.opcode = EEOP_AGGREF;
    1028       45112 :                 scratch.d.aggref.aggno = aggref->aggno;
    1029             : 
    1030       45112 :                 if (state->parent && IsA(state->parent, AggState))
    1031       45112 :                 {
    1032       45112 :                     AggState   *aggstate = (AggState *) state->parent;
    1033             : 
    1034       45112 :                     aggstate->aggs = lappend(aggstate->aggs, aggref);
    1035             :                 }
    1036             :                 else
    1037             :                 {
    1038             :                     /* planner messed up */
    1039           0 :                     elog(ERROR, "Aggref found in non-Agg plan node");
    1040             :                 }
    1041             : 
    1042       45112 :                 ExprEvalPushStep(state, &scratch);
    1043       45112 :                 break;
    1044             :             }
    1045             : 
    1046         302 :         case T_GroupingFunc:
    1047             :             {
    1048         302 :                 GroupingFunc *grp_node = (GroupingFunc *) node;
    1049             :                 Agg        *agg;
    1050             : 
    1051         302 :                 if (!state->parent || !IsA(state->parent, AggState) ||
    1052         302 :                     !IsA(state->parent->plan, Agg))
    1053           0 :                     elog(ERROR, "GroupingFunc found in non-Agg plan node");
    1054             : 
    1055         302 :                 scratch.opcode = EEOP_GROUPING_FUNC;
    1056             : 
    1057         302 :                 agg = (Agg *) (state->parent->plan);
    1058             : 
    1059         302 :                 if (agg->groupingSets)
    1060         212 :                     scratch.d.grouping_func.clauses = grp_node->cols;
    1061             :                 else
    1062          90 :                     scratch.d.grouping_func.clauses = NIL;
    1063             : 
    1064         302 :                 ExprEvalPushStep(state, &scratch);
    1065         302 :                 break;
    1066             :             }
    1067             : 
    1068        3066 :         case T_WindowFunc:
    1069             :             {
    1070        3066 :                 WindowFunc *wfunc = (WindowFunc *) node;
    1071        3066 :                 WindowFuncExprState *wfstate = makeNode(WindowFuncExprState);
    1072             : 
    1073        3066 :                 wfstate->wfunc = wfunc;
    1074             : 
    1075        3066 :                 if (state->parent && IsA(state->parent, WindowAggState))
    1076        3066 :                 {
    1077        3066 :                     WindowAggState *winstate = (WindowAggState *) state->parent;
    1078             :                     int         nfuncs;
    1079             : 
    1080        3066 :                     winstate->funcs = lappend(winstate->funcs, wfstate);
    1081        3066 :                     nfuncs = ++winstate->numfuncs;
    1082        3066 :                     if (wfunc->winagg)
    1083        1434 :                         winstate->numaggs++;
    1084             : 
    1085             :                     /* for now initialize agg using old style expressions */
    1086        6132 :                     wfstate->args = ExecInitExprList(wfunc->args,
    1087        3066 :                                                      state->parent);
    1088        6132 :                     wfstate->aggfilter = ExecInitExpr(wfunc->aggfilter,
    1089        3066 :                                                       state->parent);
    1090             : 
    1091             :                     /*
    1092             :                      * Complain if the windowfunc's arguments contain any
    1093             :                      * windowfuncs; nested window functions are semantically
    1094             :                      * nonsensical.  (This should have been caught earlier,
    1095             :                      * but we defend against it here anyway.)
    1096             :                      */
    1097        3066 :                     if (nfuncs != winstate->numfuncs)
    1098           0 :                         ereport(ERROR,
    1099             :                                 (errcode(ERRCODE_WINDOWING_ERROR),
    1100             :                                  errmsg("window function calls cannot be nested")));
    1101             :                 }
    1102             :                 else
    1103             :                 {
    1104             :                     /* planner messed up */
    1105           0 :                     elog(ERROR, "WindowFunc found in non-WindowAgg plan node");
    1106             :                 }
    1107             : 
    1108        3066 :                 scratch.opcode = EEOP_WINDOW_FUNC;
    1109        3066 :                 scratch.d.window_func.wfstate = wfstate;
    1110        3066 :                 ExprEvalPushStep(state, &scratch);
    1111        3066 :                 break;
    1112             :             }
    1113             : 
    1114       21198 :         case T_SubscriptingRef:
    1115             :             {
    1116       21198 :                 SubscriptingRef *sbsref = (SubscriptingRef *) node;
    1117             : 
    1118       21198 :                 ExecInitSubscriptingRef(&scratch, sbsref, state, resv, resnull);
    1119       21198 :                 break;
    1120             :             }
    1121             : 
    1122      600292 :         case T_FuncExpr:
    1123             :             {
    1124      600292 :                 FuncExpr   *func = (FuncExpr *) node;
    1125             : 
    1126      600292 :                 ExecInitFunc(&scratch, node,
    1127             :                              func->args, func->funcid, func->inputcollid,
    1128             :                              state);
    1129      600210 :                 ExprEvalPushStep(state, &scratch);
    1130      600210 :                 break;
    1131             :             }
    1132             : 
    1133      725940 :         case T_OpExpr:
    1134             :             {
    1135      725940 :                 OpExpr     *op = (OpExpr *) node;
    1136             : 
    1137      725940 :                 ExecInitFunc(&scratch, node,
    1138             :                              op->args, op->opfuncid, op->inputcollid,
    1139             :                              state);
    1140      725940 :                 ExprEvalPushStep(state, &scratch);
    1141      725940 :                 break;
    1142             :             }
    1143             : 
    1144         894 :         case T_DistinctExpr:
    1145             :             {
    1146         894 :                 DistinctExpr *op = (DistinctExpr *) node;
    1147             : 
    1148         894 :                 ExecInitFunc(&scratch, node,
    1149             :                              op->args, op->opfuncid, op->inputcollid,
    1150             :                              state);
    1151             : 
    1152             :                 /*
    1153             :                  * Change opcode of call instruction to EEOP_DISTINCT.
    1154             :                  *
    1155             :                  * XXX: historically we've not called the function usage
    1156             :                  * pgstat infrastructure - that seems inconsistent given that
    1157             :                  * we do so for normal function *and* operator evaluation.  If
    1158             :                  * we decided to do that here, we'd probably want separate
    1159             :                  * opcodes for FUSAGE or not.
    1160             :                  */
    1161         894 :                 scratch.opcode = EEOP_DISTINCT;
    1162         894 :                 ExprEvalPushStep(state, &scratch);
    1163         894 :                 break;
    1164             :             }
    1165             : 
    1166         148 :         case T_NullIfExpr:
    1167             :             {
    1168         148 :                 NullIfExpr *op = (NullIfExpr *) node;
    1169             : 
    1170         148 :                 ExecInitFunc(&scratch, node,
    1171             :                              op->args, op->opfuncid, op->inputcollid,
    1172             :                              state);
    1173             : 
    1174             :                 /*
    1175             :                  * Change opcode of call instruction to EEOP_NULLIF.
    1176             :                  *
    1177             :                  * XXX: historically we've not called the function usage
    1178             :                  * pgstat infrastructure - that seems inconsistent given that
    1179             :                  * we do so for normal function *and* operator evaluation.  If
    1180             :                  * we decided to do that here, we'd probably want separate
    1181             :                  * opcodes for FUSAGE or not.
    1182             :                  */
    1183         148 :                 scratch.opcode = EEOP_NULLIF;
    1184         148 :                 ExprEvalPushStep(state, &scratch);
    1185         148 :                 break;
    1186             :             }
    1187             : 
    1188       27866 :         case T_ScalarArrayOpExpr:
    1189             :             {
    1190       27866 :                 ScalarArrayOpExpr *opexpr = (ScalarArrayOpExpr *) node;
    1191             :                 Expr       *scalararg;
    1192             :                 Expr       *arrayarg;
    1193             :                 FmgrInfo   *finfo;
    1194             :                 FunctionCallInfo fcinfo;
    1195             :                 AclResult   aclresult;
    1196             :                 Oid         cmpfuncid;
    1197             : 
    1198             :                 /*
    1199             :                  * Select the correct comparison function.  When we do hashed
    1200             :                  * NOT IN clauses, the opfuncid will be the inequality
    1201             :                  * comparison function and negfuncid will be set to equality.
    1202             :                  * We need to use the equality function for hash probes.
    1203             :                  */
    1204       27866 :                 if (OidIsValid(opexpr->negfuncid))
    1205             :                 {
    1206             :                     Assert(OidIsValid(opexpr->hashfuncid));
    1207          70 :                     cmpfuncid = opexpr->negfuncid;
    1208             :                 }
    1209             :                 else
    1210       27796 :                     cmpfuncid = opexpr->opfuncid;
    1211             : 
    1212             :                 Assert(list_length(opexpr->args) == 2);
    1213       27866 :                 scalararg = (Expr *) linitial(opexpr->args);
    1214       27866 :                 arrayarg = (Expr *) lsecond(opexpr->args);
    1215             : 
    1216             :                 /* Check permission to call function */
    1217       27866 :                 aclresult = object_aclcheck(ProcedureRelationId, cmpfuncid,
    1218             :                                             GetUserId(),
    1219             :                                             ACL_EXECUTE);
    1220       27866 :                 if (aclresult != ACLCHECK_OK)
    1221           0 :                     aclcheck_error(aclresult, OBJECT_FUNCTION,
    1222           0 :                                    get_func_name(cmpfuncid));
    1223       27866 :                 InvokeFunctionExecuteHook(cmpfuncid);
    1224             : 
    1225       27866 :                 if (OidIsValid(opexpr->hashfuncid))
    1226             :                 {
    1227         260 :                     aclresult = object_aclcheck(ProcedureRelationId, opexpr->hashfuncid,
    1228             :                                                 GetUserId(),
    1229             :                                                 ACL_EXECUTE);
    1230         260 :                     if (aclresult != ACLCHECK_OK)
    1231           0 :                         aclcheck_error(aclresult, OBJECT_FUNCTION,
    1232           0 :                                        get_func_name(opexpr->hashfuncid));
    1233         260 :                     InvokeFunctionExecuteHook(opexpr->hashfuncid);
    1234             :                 }
    1235             : 
    1236             :                 /* Set up the primary fmgr lookup information */
    1237       27866 :                 finfo = palloc0(sizeof(FmgrInfo));
    1238       27866 :                 fcinfo = palloc0(SizeForFunctionCallInfo(2));
    1239       27866 :                 fmgr_info(cmpfuncid, finfo);
    1240       27866 :                 fmgr_info_set_expr((Node *) node, finfo);
    1241       27866 :                 InitFunctionCallInfoData(*fcinfo, finfo, 2,
    1242             :                                          opexpr->inputcollid, NULL, NULL);
    1243             : 
    1244             :                 /*
    1245             :                  * If hashfuncid is set, we create a EEOP_HASHED_SCALARARRAYOP
    1246             :                  * step instead of a EEOP_SCALARARRAYOP.  This provides much
    1247             :                  * faster lookup performance than the normal linear search
    1248             :                  * when the number of items in the array is anything but very
    1249             :                  * small.
    1250             :                  */
    1251       27866 :                 if (OidIsValid(opexpr->hashfuncid))
    1252             :                 {
    1253             :                     /* Evaluate scalar directly into left function argument */
    1254         260 :                     ExecInitExprRec(scalararg, state,
    1255             :                                     &fcinfo->args[0].value, &fcinfo->args[0].isnull);
    1256             : 
    1257             :                     /*
    1258             :                      * Evaluate array argument into our return value.  There's
    1259             :                      * no danger in that, because the return value is
    1260             :                      * guaranteed to be overwritten by
    1261             :                      * EEOP_HASHED_SCALARARRAYOP, and will not be passed to
    1262             :                      * any other expression.
    1263             :                      */
    1264         260 :                     ExecInitExprRec(arrayarg, state, resv, resnull);
    1265             : 
    1266             :                     /* And perform the operation */
    1267         260 :                     scratch.opcode = EEOP_HASHED_SCALARARRAYOP;
    1268         260 :                     scratch.d.hashedscalararrayop.inclause = opexpr->useOr;
    1269         260 :                     scratch.d.hashedscalararrayop.finfo = finfo;
    1270         260 :                     scratch.d.hashedscalararrayop.fcinfo_data = fcinfo;
    1271         260 :                     scratch.d.hashedscalararrayop.saop = opexpr;
    1272             : 
    1273             : 
    1274         260 :                     ExprEvalPushStep(state, &scratch);
    1275             :                 }
    1276             :                 else
    1277             :                 {
    1278             :                     /* Evaluate scalar directly into left function argument */
    1279       27606 :                     ExecInitExprRec(scalararg, state,
    1280             :                                     &fcinfo->args[0].value,
    1281             :                                     &fcinfo->args[0].isnull);
    1282             : 
    1283             :                     /*
    1284             :                      * Evaluate array argument into our return value.  There's
    1285             :                      * no danger in that, because the return value is
    1286             :                      * guaranteed to be overwritten by EEOP_SCALARARRAYOP, and
    1287             :                      * will not be passed to any other expression.
    1288             :                      */
    1289       27606 :                     ExecInitExprRec(arrayarg, state, resv, resnull);
    1290             : 
    1291             :                     /* And perform the operation */
    1292       27606 :                     scratch.opcode = EEOP_SCALARARRAYOP;
    1293       27606 :                     scratch.d.scalararrayop.element_type = InvalidOid;
    1294       27606 :                     scratch.d.scalararrayop.useOr = opexpr->useOr;
    1295       27606 :                     scratch.d.scalararrayop.finfo = finfo;
    1296       27606 :                     scratch.d.scalararrayop.fcinfo_data = fcinfo;
    1297       27606 :                     scratch.d.scalararrayop.fn_addr = finfo->fn_addr;
    1298       27606 :                     ExprEvalPushStep(state, &scratch);
    1299             :                 }
    1300       27866 :                 break;
    1301             :             }
    1302             : 
    1303       60126 :         case T_BoolExpr:
    1304             :             {
    1305       60126 :                 BoolExpr   *boolexpr = (BoolExpr *) node;
    1306       60126 :                 int         nargs = list_length(boolexpr->args);
    1307       60126 :                 List       *adjust_jumps = NIL;
    1308             :                 int         off;
    1309             :                 ListCell   *lc;
    1310             : 
    1311             :                 /* allocate scratch memory used by all steps of AND/OR */
    1312       60126 :                 if (boolexpr->boolop != NOT_EXPR)
    1313       49472 :                     scratch.d.boolexpr.anynull = (bool *) palloc(sizeof(bool));
    1314             : 
    1315             :                 /*
    1316             :                  * For each argument evaluate the argument itself, then
    1317             :                  * perform the bool operation's appropriate handling.
    1318             :                  *
    1319             :                  * We can evaluate each argument into our result area, since
    1320             :                  * the short-circuiting logic means we only need to remember
    1321             :                  * previous NULL values.
    1322             :                  *
    1323             :                  * AND/OR is split into separate STEP_FIRST (one) / STEP (zero
    1324             :                  * or more) / STEP_LAST (one) steps, as each of those has to
    1325             :                  * perform different work.  The FIRST/LAST split is valid
    1326             :                  * because AND/OR have at least two arguments.
    1327             :                  */
    1328       60126 :                 off = 0;
    1329      181572 :                 foreach(lc, boolexpr->args)
    1330             :                 {
    1331      121446 :                     Expr       *arg = (Expr *) lfirst(lc);
    1332             : 
    1333             :                     /* Evaluate argument into our output variable */
    1334      121446 :                     ExecInitExprRec(arg, state, resv, resnull);
    1335             : 
    1336             :                     /* Perform the appropriate step type */
    1337      121446 :                     switch (boolexpr->boolop)
    1338             :                     {
    1339       76160 :                         case AND_EXPR:
    1340             :                             Assert(nargs >= 2);
    1341             : 
    1342       76160 :                             if (off == 0)
    1343       34410 :                                 scratch.opcode = EEOP_BOOL_AND_STEP_FIRST;
    1344       41750 :                             else if (off + 1 == nargs)
    1345       34410 :                                 scratch.opcode = EEOP_BOOL_AND_STEP_LAST;
    1346             :                             else
    1347        7340 :                                 scratch.opcode = EEOP_BOOL_AND_STEP;
    1348       76160 :                             break;
    1349       34632 :                         case OR_EXPR:
    1350             :                             Assert(nargs >= 2);
    1351             : 
    1352       34632 :                             if (off == 0)
    1353       15062 :                                 scratch.opcode = EEOP_BOOL_OR_STEP_FIRST;
    1354       19570 :                             else if (off + 1 == nargs)
    1355       15062 :                                 scratch.opcode = EEOP_BOOL_OR_STEP_LAST;
    1356             :                             else
    1357        4508 :                                 scratch.opcode = EEOP_BOOL_OR_STEP;
    1358       34632 :                             break;
    1359       10654 :                         case NOT_EXPR:
    1360             :                             Assert(nargs == 1);
    1361             : 
    1362       10654 :                             scratch.opcode = EEOP_BOOL_NOT_STEP;
    1363       10654 :                             break;
    1364           0 :                         default:
    1365           0 :                             elog(ERROR, "unrecognized boolop: %d",
    1366             :                                  (int) boolexpr->boolop);
    1367             :                             break;
    1368             :                     }
    1369             : 
    1370      121446 :                     scratch.d.boolexpr.jumpdone = -1;
    1371      121446 :                     ExprEvalPushStep(state, &scratch);
    1372      121446 :                     adjust_jumps = lappend_int(adjust_jumps,
    1373      121446 :                                                state->steps_len - 1);
    1374      121446 :                     off++;
    1375             :                 }
    1376             : 
    1377             :                 /* adjust jump targets */
    1378      181572 :                 foreach(lc, adjust_jumps)
    1379             :                 {
    1380      121446 :                     ExprEvalStep *as = &state->steps[lfirst_int(lc)];
    1381             : 
    1382             :                     Assert(as->d.boolexpr.jumpdone == -1);
    1383      121446 :                     as->d.boolexpr.jumpdone = state->steps_len;
    1384             :                 }
    1385             : 
    1386       60126 :                 break;
    1387             :             }
    1388             : 
    1389       22230 :         case T_SubPlan:
    1390             :             {
    1391       22230 :                 SubPlan    *subplan = (SubPlan *) node;
    1392             :                 SubPlanState *sstate;
    1393             : 
    1394             :                 /*
    1395             :                  * Real execution of a MULTIEXPR SubPlan has already been
    1396             :                  * done. What we have to do here is return a dummy NULL record
    1397             :                  * value in case this targetlist element is assigned
    1398             :                  * someplace.
    1399             :                  */
    1400       22230 :                 if (subplan->subLinkType == MULTIEXPR_SUBLINK)
    1401             :                 {
    1402          60 :                     scratch.opcode = EEOP_CONST;
    1403          60 :                     scratch.d.constval.value = (Datum) 0;
    1404          60 :                     scratch.d.constval.isnull = true;
    1405          60 :                     ExprEvalPushStep(state, &scratch);
    1406          60 :                     break;
    1407             :                 }
    1408             : 
    1409       22170 :                 if (!state->parent)
    1410           0 :                     elog(ERROR, "SubPlan found with no parent plan");
    1411             : 
    1412       22170 :                 sstate = ExecInitSubPlan(subplan, state->parent);
    1413             : 
    1414             :                 /* add SubPlanState nodes to state->parent->subPlan */
    1415       22170 :                 state->parent->subPlan = lappend(state->parent->subPlan,
    1416             :                                                  sstate);
    1417             : 
    1418       22170 :                 scratch.opcode = EEOP_SUBPLAN;
    1419       22170 :                 scratch.d.subplan.sstate = sstate;
    1420             : 
    1421       22170 :                 ExprEvalPushStep(state, &scratch);
    1422       22170 :                 break;
    1423             :             }
    1424             : 
    1425        7470 :         case T_FieldSelect:
    1426             :             {
    1427        7470 :                 FieldSelect *fselect = (FieldSelect *) node;
    1428             : 
    1429             :                 /* evaluate row/record argument into result area */
    1430        7470 :                 ExecInitExprRec(fselect->arg, state, resv, resnull);
    1431             : 
    1432             :                 /* and extract field */
    1433        7470 :                 scratch.opcode = EEOP_FIELDSELECT;
    1434        7470 :                 scratch.d.fieldselect.fieldnum = fselect->fieldnum;
    1435        7470 :                 scratch.d.fieldselect.resulttype = fselect->resulttype;
    1436        7470 :                 scratch.d.fieldselect.rowcache.cacheptr = NULL;
    1437             : 
    1438        7470 :                 ExprEvalPushStep(state, &scratch);
    1439        7470 :                 break;
    1440             :             }
    1441             : 
    1442         280 :         case T_FieldStore:
    1443             :             {
    1444         280 :                 FieldStore *fstore = (FieldStore *) node;
    1445             :                 TupleDesc   tupDesc;
    1446             :                 ExprEvalRowtypeCache *rowcachep;
    1447             :                 Datum      *values;
    1448             :                 bool       *nulls;
    1449             :                 int         ncolumns;
    1450             :                 ListCell   *l1,
    1451             :                            *l2;
    1452             : 
    1453             :                 /* find out the number of columns in the composite type */
    1454         280 :                 tupDesc = lookup_rowtype_tupdesc(fstore->resulttype, -1);
    1455         280 :                 ncolumns = tupDesc->natts;
    1456         280 :                 ReleaseTupleDesc(tupDesc);
    1457             : 
    1458             :                 /* create workspace for column values */
    1459         280 :                 values = (Datum *) palloc(sizeof(Datum) * ncolumns);
    1460         280 :                 nulls = (bool *) palloc(sizeof(bool) * ncolumns);
    1461             : 
    1462             :                 /* create shared composite-type-lookup cache struct */
    1463         280 :                 rowcachep = palloc(sizeof(ExprEvalRowtypeCache));
    1464         280 :                 rowcachep->cacheptr = NULL;
    1465             : 
    1466             :                 /* emit code to evaluate the composite input value */
    1467         280 :                 ExecInitExprRec(fstore->arg, state, resv, resnull);
    1468             : 
    1469             :                 /* next, deform the input tuple into our workspace */
    1470         280 :                 scratch.opcode = EEOP_FIELDSTORE_DEFORM;
    1471         280 :                 scratch.d.fieldstore.fstore = fstore;
    1472         280 :                 scratch.d.fieldstore.rowcache = rowcachep;
    1473         280 :                 scratch.d.fieldstore.values = values;
    1474         280 :                 scratch.d.fieldstore.nulls = nulls;
    1475         280 :                 scratch.d.fieldstore.ncolumns = ncolumns;
    1476         280 :                 ExprEvalPushStep(state, &scratch);
    1477             : 
    1478             :                 /* evaluate new field values, store in workspace columns */
    1479         626 :                 forboth(l1, fstore->newvals, l2, fstore->fieldnums)
    1480             :                 {
    1481         346 :                     Expr       *e = (Expr *) lfirst(l1);
    1482         346 :                     AttrNumber  fieldnum = lfirst_int(l2);
    1483             :                     Datum      *save_innermost_caseval;
    1484             :                     bool       *save_innermost_casenull;
    1485             : 
    1486         346 :                     if (fieldnum <= 0 || fieldnum > ncolumns)
    1487           0 :                         elog(ERROR, "field number %d is out of range in FieldStore",
    1488             :                              fieldnum);
    1489             : 
    1490             :                     /*
    1491             :                      * Use the CaseTestExpr mechanism to pass down the old
    1492             :                      * value of the field being replaced; this is needed in
    1493             :                      * case the newval is itself a FieldStore or
    1494             :                      * SubscriptingRef that has to obtain and modify the old
    1495             :                      * value.  It's safe to reuse the CASE mechanism because
    1496             :                      * there cannot be a CASE between here and where the value
    1497             :                      * would be needed, and a field assignment can't be within
    1498             :                      * a CASE either.  (So saving and restoring
    1499             :                      * innermost_caseval is just paranoia, but let's do it
    1500             :                      * anyway.)
    1501             :                      *
    1502             :                      * Another non-obvious point is that it's safe to use the
    1503             :                      * field's values[]/nulls[] entries as both the caseval
    1504             :                      * source and the result address for this subexpression.
    1505             :                      * That's okay only because (1) both FieldStore and
    1506             :                      * SubscriptingRef evaluate their arg or refexpr inputs
    1507             :                      * first, and (2) any such CaseTestExpr is directly the
    1508             :                      * arg or refexpr input.  So any read of the caseval will
    1509             :                      * occur before there's a chance to overwrite it.  Also,
    1510             :                      * if multiple entries in the newvals/fieldnums lists
    1511             :                      * target the same field, they'll effectively be applied
    1512             :                      * left-to-right which is what we want.
    1513             :                      */
    1514         346 :                     save_innermost_caseval = state->innermost_caseval;
    1515         346 :                     save_innermost_casenull = state->innermost_casenull;
    1516         346 :                     state->innermost_caseval = &values[fieldnum - 1];
    1517         346 :                     state->innermost_casenull = &nulls[fieldnum - 1];
    1518             : 
    1519         346 :                     ExecInitExprRec(e, state,
    1520         346 :                                     &values[fieldnum - 1],
    1521         346 :                                     &nulls[fieldnum - 1]);
    1522             : 
    1523         346 :                     state->innermost_caseval = save_innermost_caseval;
    1524         346 :                     state->innermost_casenull = save_innermost_casenull;
    1525             :                 }
    1526             : 
    1527             :                 /* finally, form result tuple */
    1528         280 :                 scratch.opcode = EEOP_FIELDSTORE_FORM;
    1529         280 :                 scratch.d.fieldstore.fstore = fstore;
    1530         280 :                 scratch.d.fieldstore.rowcache = rowcachep;
    1531         280 :                 scratch.d.fieldstore.values = values;
    1532         280 :                 scratch.d.fieldstore.nulls = nulls;
    1533         280 :                 scratch.d.fieldstore.ncolumns = ncolumns;
    1534         280 :                 ExprEvalPushStep(state, &scratch);
    1535         280 :                 break;
    1536             :             }
    1537             : 
    1538       77550 :         case T_RelabelType:
    1539             :             {
    1540             :                 /* relabel doesn't need to do anything at runtime */
    1541       77550 :                 RelabelType *relabel = (RelabelType *) node;
    1542             : 
    1543       77550 :                 ExecInitExprRec(relabel->arg, state, resv, resnull);
    1544       77550 :                 break;
    1545             :             }
    1546             : 
    1547       35366 :         case T_CoerceViaIO:
    1548             :             {
    1549       35366 :                 CoerceViaIO *iocoerce = (CoerceViaIO *) node;
    1550             :                 Oid         iofunc;
    1551             :                 bool        typisvarlena;
    1552             :                 Oid         typioparam;
    1553             :                 FunctionCallInfo fcinfo_in;
    1554             : 
    1555             :                 /* evaluate argument into step's result area */
    1556       35366 :                 ExecInitExprRec(iocoerce->arg, state, resv, resnull);
    1557             : 
    1558             :                 /*
    1559             :                  * Prepare both output and input function calls, to be
    1560             :                  * evaluated inside a single evaluation step for speed - this
    1561             :                  * can be a very common operation.
    1562             :                  *
    1563             :                  * We don't check permissions here as a type's input/output
    1564             :                  * function are assumed to be executable by everyone.
    1565             :                  */
    1566       35366 :                 scratch.opcode = EEOP_IOCOERCE;
    1567             : 
    1568             :                 /* lookup the source type's output function */
    1569       35366 :                 scratch.d.iocoerce.finfo_out = palloc0(sizeof(FmgrInfo));
    1570       35366 :                 scratch.d.iocoerce.fcinfo_data_out = palloc0(SizeForFunctionCallInfo(1));
    1571             : 
    1572       35366 :                 getTypeOutputInfo(exprType((Node *) iocoerce->arg),
    1573             :                                   &iofunc, &typisvarlena);
    1574       35366 :                 fmgr_info(iofunc, scratch.d.iocoerce.finfo_out);
    1575       35366 :                 fmgr_info_set_expr((Node *) node, scratch.d.iocoerce.finfo_out);
    1576       35366 :                 InitFunctionCallInfoData(*scratch.d.iocoerce.fcinfo_data_out,
    1577             :                                          scratch.d.iocoerce.finfo_out,
    1578             :                                          1, InvalidOid, NULL, NULL);
    1579             : 
    1580             :                 /* lookup the result type's input function */
    1581       35366 :                 scratch.d.iocoerce.finfo_in = palloc0(sizeof(FmgrInfo));
    1582       35366 :                 scratch.d.iocoerce.fcinfo_data_in = palloc0(SizeForFunctionCallInfo(3));
    1583             : 
    1584       35366 :                 getTypeInputInfo(iocoerce->resulttype,
    1585             :                                  &iofunc, &typioparam);
    1586       35366 :                 fmgr_info(iofunc, scratch.d.iocoerce.finfo_in);
    1587       35366 :                 fmgr_info_set_expr((Node *) node, scratch.d.iocoerce.finfo_in);
    1588       35366 :                 InitFunctionCallInfoData(*scratch.d.iocoerce.fcinfo_data_in,
    1589             :                                          scratch.d.iocoerce.finfo_in,
    1590             :                                          3, InvalidOid, NULL, NULL);
    1591             : 
    1592             :                 /*
    1593             :                  * We can preload the second and third arguments for the input
    1594             :                  * function, since they're constants.
    1595             :                  */
    1596       35366 :                 fcinfo_in = scratch.d.iocoerce.fcinfo_data_in;
    1597       35366 :                 fcinfo_in->args[1].value = ObjectIdGetDatum(typioparam);
    1598       35366 :                 fcinfo_in->args[1].isnull = false;
    1599       35366 :                 fcinfo_in->args[2].value = Int32GetDatum(-1);
    1600       35366 :                 fcinfo_in->args[2].isnull = false;
    1601             : 
    1602       35366 :                 ExprEvalPushStep(state, &scratch);
    1603       35366 :                 break;
    1604             :             }
    1605             : 
    1606        4718 :         case T_ArrayCoerceExpr:
    1607             :             {
    1608        4718 :                 ArrayCoerceExpr *acoerce = (ArrayCoerceExpr *) node;
    1609             :                 Oid         resultelemtype;
    1610             :                 ExprState  *elemstate;
    1611             : 
    1612             :                 /* evaluate argument into step's result area */
    1613        4718 :                 ExecInitExprRec(acoerce->arg, state, resv, resnull);
    1614             : 
    1615        4718 :                 resultelemtype = get_element_type(acoerce->resulttype);
    1616        4718 :                 if (!OidIsValid(resultelemtype))
    1617           0 :                     ereport(ERROR,
    1618             :                             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1619             :                              errmsg("target type is not an array")));
    1620             : 
    1621             :                 /*
    1622             :                  * Construct a sub-expression for the per-element expression;
    1623             :                  * but don't ready it until after we check it for triviality.
    1624             :                  * We assume it hasn't any Var references, but does have a
    1625             :                  * CaseTestExpr representing the source array element values.
    1626             :                  */
    1627        4718 :                 elemstate = makeNode(ExprState);
    1628        4718 :                 elemstate->expr = acoerce->elemexpr;
    1629        4718 :                 elemstate->parent = state->parent;
    1630        4718 :                 elemstate->ext_params = state->ext_params;
    1631             : 
    1632        4718 :                 elemstate->innermost_caseval = (Datum *) palloc(sizeof(Datum));
    1633        4718 :                 elemstate->innermost_casenull = (bool *) palloc(sizeof(bool));
    1634             : 
    1635        4718 :                 ExecInitExprRec(acoerce->elemexpr, elemstate,
    1636             :                                 &elemstate->resvalue, &elemstate->resnull);
    1637             : 
    1638        4712 :                 if (elemstate->steps_len == 1 &&
    1639        4286 :                     elemstate->steps[0].opcode == EEOP_CASE_TESTVAL)
    1640             :                 {
    1641             :                     /* Trivial, so we need no per-element work at runtime */
    1642        4286 :                     elemstate = NULL;
    1643             :                 }
    1644             :                 else
    1645             :                 {
    1646             :                     /* Not trivial, so append a DONE step */
    1647         426 :                     scratch.opcode = EEOP_DONE;
    1648         426 :                     ExprEvalPushStep(elemstate, &scratch);
    1649             :                     /* and ready the subexpression */
    1650         426 :                     ExecReadyExpr(elemstate);
    1651             :                 }
    1652             : 
    1653        4712 :                 scratch.opcode = EEOP_ARRAYCOERCE;
    1654        4712 :                 scratch.d.arraycoerce.elemexprstate = elemstate;
    1655        4712 :                 scratch.d.arraycoerce.resultelemtype = resultelemtype;
    1656             : 
    1657        4712 :                 if (elemstate)
    1658             :                 {
    1659             :                     /* Set up workspace for array_map */
    1660         426 :                     scratch.d.arraycoerce.amstate =
    1661         426 :                         (ArrayMapState *) palloc0(sizeof(ArrayMapState));
    1662             :                 }
    1663             :                 else
    1664             :                 {
    1665             :                     /* Don't need workspace if there's no subexpression */
    1666        4286 :                     scratch.d.arraycoerce.amstate = NULL;
    1667             :                 }
    1668             : 
    1669        4712 :                 ExprEvalPushStep(state, &scratch);
    1670        4712 :                 break;
    1671             :             }
    1672             : 
    1673         656 :         case T_ConvertRowtypeExpr:
    1674             :             {
    1675         656 :                 ConvertRowtypeExpr *convert = (ConvertRowtypeExpr *) node;
    1676             :                 ExprEvalRowtypeCache *rowcachep;
    1677             : 
    1678             :                 /* cache structs must be out-of-line for space reasons */
    1679         656 :                 rowcachep = palloc(2 * sizeof(ExprEvalRowtypeCache));
    1680         656 :                 rowcachep[0].cacheptr = NULL;
    1681         656 :                 rowcachep[1].cacheptr = NULL;
    1682             : 
    1683             :                 /* evaluate argument into step's result area */
    1684         656 :                 ExecInitExprRec(convert->arg, state, resv, resnull);
    1685             : 
    1686             :                 /* and push conversion step */
    1687         656 :                 scratch.opcode = EEOP_CONVERT_ROWTYPE;
    1688         656 :                 scratch.d.convert_rowtype.inputtype =
    1689         656 :                     exprType((Node *) convert->arg);
    1690         656 :                 scratch.d.convert_rowtype.outputtype = convert->resulttype;
    1691         656 :                 scratch.d.convert_rowtype.incache = &rowcachep[0];
    1692         656 :                 scratch.d.convert_rowtype.outcache = &rowcachep[1];
    1693         656 :                 scratch.d.convert_rowtype.map = NULL;
    1694             : 
    1695         656 :                 ExprEvalPushStep(state, &scratch);
    1696         656 :                 break;
    1697             :             }
    1698             : 
    1699             :             /* note that CaseWhen expressions are handled within this block */
    1700       94272 :         case T_CaseExpr:
    1701             :             {
    1702       94272 :                 CaseExpr   *caseExpr = (CaseExpr *) node;
    1703       94272 :                 List       *adjust_jumps = NIL;
    1704       94272 :                 Datum      *caseval = NULL;
    1705       94272 :                 bool       *casenull = NULL;
    1706             :                 ListCell   *lc;
    1707             : 
    1708             :                 /*
    1709             :                  * If there's a test expression, we have to evaluate it and
    1710             :                  * save the value where the CaseTestExpr placeholders can find
    1711             :                  * it.
    1712             :                  */
    1713       94272 :                 if (caseExpr->arg != NULL)
    1714             :                 {
    1715             :                     /* Evaluate testexpr into caseval/casenull workspace */
    1716        3566 :                     caseval = palloc(sizeof(Datum));
    1717        3566 :                     casenull = palloc(sizeof(bool));
    1718             : 
    1719        3566 :                     ExecInitExprRec(caseExpr->arg, state,
    1720             :                                     caseval, casenull);
    1721             : 
    1722             :                     /*
    1723             :                      * Since value might be read multiple times, force to R/O
    1724             :                      * - but only if it could be an expanded datum.
    1725             :                      */
    1726        3566 :                     if (get_typlen(exprType((Node *) caseExpr->arg)) == -1)
    1727             :                     {
    1728             :                         /* change caseval in-place */
    1729          60 :                         scratch.opcode = EEOP_MAKE_READONLY;
    1730          60 :                         scratch.resvalue = caseval;
    1731          60 :                         scratch.resnull = casenull;
    1732          60 :                         scratch.d.make_readonly.value = caseval;
    1733          60 :                         scratch.d.make_readonly.isnull = casenull;
    1734          60 :                         ExprEvalPushStep(state, &scratch);
    1735             :                         /* restore normal settings of scratch fields */
    1736          60 :                         scratch.resvalue = resv;
    1737          60 :                         scratch.resnull = resnull;
    1738             :                     }
    1739             :                 }
    1740             : 
    1741             :                 /*
    1742             :                  * Prepare to evaluate each of the WHEN clauses in turn; as
    1743             :                  * soon as one is true we return the value of the
    1744             :                  * corresponding THEN clause.  If none are true then we return
    1745             :                  * the value of the ELSE clause, or NULL if there is none.
    1746             :                  */
    1747      253788 :                 foreach(lc, caseExpr->args)
    1748             :                 {
    1749      159516 :                     CaseWhen   *when = (CaseWhen *) lfirst(lc);
    1750             :                     Datum      *save_innermost_caseval;
    1751             :                     bool       *save_innermost_casenull;
    1752             :                     int         whenstep;
    1753             : 
    1754             :                     /*
    1755             :                      * Make testexpr result available to CaseTestExpr nodes
    1756             :                      * within the condition.  We must save and restore prior
    1757             :                      * setting of innermost_caseval fields, in case this node
    1758             :                      * is itself within a larger CASE.
    1759             :                      *
    1760             :                      * If there's no test expression, we don't actually need
    1761             :                      * to save and restore these fields; but it's less code to
    1762             :                      * just do so unconditionally.
    1763             :                      */
    1764      159516 :                     save_innermost_caseval = state->innermost_caseval;
    1765      159516 :                     save_innermost_casenull = state->innermost_casenull;
    1766      159516 :                     state->innermost_caseval = caseval;
    1767      159516 :                     state->innermost_casenull = casenull;
    1768             : 
    1769             :                     /* evaluate condition into CASE's result variables */
    1770      159516 :                     ExecInitExprRec(when->expr, state, resv, resnull);
    1771             : 
    1772      159516 :                     state->innermost_caseval = save_innermost_caseval;
    1773      159516 :                     state->innermost_casenull = save_innermost_casenull;
    1774             : 
    1775             :                     /* If WHEN result isn't true, jump to next CASE arm */
    1776      159516 :                     scratch.opcode = EEOP_JUMP_IF_NOT_TRUE;
    1777      159516 :                     scratch.d.jump.jumpdone = -1;   /* computed later */
    1778      159516 :                     ExprEvalPushStep(state, &scratch);
    1779      159516 :                     whenstep = state->steps_len - 1;
    1780             : 
    1781             :                     /*
    1782             :                      * If WHEN result is true, evaluate THEN result, storing
    1783             :                      * it into the CASE's result variables.
    1784             :                      */
    1785      159516 :                     ExecInitExprRec(when->result, state, resv, resnull);
    1786             : 
    1787             :                     /* Emit JUMP step to jump to end of CASE's code */
    1788      159516 :                     scratch.opcode = EEOP_JUMP;
    1789      159516 :                     scratch.d.jump.jumpdone = -1;   /* computed later */
    1790      159516 :                     ExprEvalPushStep(state, &scratch);
    1791             : 
    1792             :                     /*
    1793             :                      * Don't know address for that jump yet, compute once the
    1794             :                      * whole CASE expression is built.
    1795             :                      */
    1796      159516 :                     adjust_jumps = lappend_int(adjust_jumps,
    1797      159516 :                                                state->steps_len - 1);
    1798             : 
    1799             :                     /*
    1800             :                      * But we can set WHEN test's jump target now, to make it
    1801             :                      * jump to the next WHEN subexpression or the ELSE.
    1802             :                      */
    1803      159516 :                     state->steps[whenstep].d.jump.jumpdone = state->steps_len;
    1804             :                 }
    1805             : 
    1806             :                 /* transformCaseExpr always adds a default */
    1807             :                 Assert(caseExpr->defresult);
    1808             : 
    1809             :                 /* evaluate ELSE expr into CASE's result variables */
    1810       94272 :                 ExecInitExprRec(caseExpr->defresult, state,
    1811             :                                 resv, resnull);
    1812             : 
    1813             :                 /* adjust jump targets */
    1814      253788 :                 foreach(lc, adjust_jumps)
    1815             :                 {
    1816      159516 :                     ExprEvalStep *as = &state->steps[lfirst_int(lc)];
    1817             : 
    1818             :                     Assert(as->opcode == EEOP_JUMP);
    1819             :                     Assert(as->d.jump.jumpdone == -1);
    1820      159516 :                     as->d.jump.jumpdone = state->steps_len;
    1821             :                 }
    1822             : 
    1823       94272 :                 break;
    1824             :             }
    1825             : 
    1826       19928 :         case T_CaseTestExpr:
    1827             :             {
    1828             :                 /*
    1829             :                  * Read from location identified by innermost_caseval.  Note
    1830             :                  * that innermost_caseval could be NULL, if this node isn't
    1831             :                  * actually within a CaseExpr, ArrayCoerceExpr, etc structure.
    1832             :                  * That can happen because some parts of the system abuse
    1833             :                  * CaseTestExpr to cause a read of a value externally supplied
    1834             :                  * in econtext->caseValue_datum.  We'll take care of that
    1835             :                  * scenario at runtime.
    1836             :                  */
    1837       19928 :                 scratch.opcode = EEOP_CASE_TESTVAL;
    1838       19928 :                 scratch.d.casetest.value = state->innermost_caseval;
    1839       19928 :                 scratch.d.casetest.isnull = state->innermost_casenull;
    1840             : 
    1841       19928 :                 ExprEvalPushStep(state, &scratch);
    1842       19928 :                 break;
    1843             :             }
    1844             : 
    1845       23600 :         case T_ArrayExpr:
    1846             :             {
    1847       23600 :                 ArrayExpr  *arrayexpr = (ArrayExpr *) node;
    1848       23600 :                 int         nelems = list_length(arrayexpr->elements);
    1849             :                 ListCell   *lc;
    1850             :                 int         elemoff;
    1851             : 
    1852             :                 /*
    1853             :                  * Evaluate by computing each element, and then forming the
    1854             :                  * array.  Elements are computed into scratch arrays
    1855             :                  * associated with the ARRAYEXPR step.
    1856             :                  */
    1857       23600 :                 scratch.opcode = EEOP_ARRAYEXPR;
    1858       23600 :                 scratch.d.arrayexpr.elemvalues =
    1859       23600 :                     (Datum *) palloc(sizeof(Datum) * nelems);
    1860       23600 :                 scratch.d.arrayexpr.elemnulls =
    1861       23600 :                     (bool *) palloc(sizeof(bool) * nelems);
    1862       23600 :                 scratch.d.arrayexpr.nelems = nelems;
    1863             : 
    1864             :                 /* fill remaining fields of step */
    1865       23600 :                 scratch.d.arrayexpr.multidims = arrayexpr->multidims;
    1866       23600 :                 scratch.d.arrayexpr.elemtype = arrayexpr->element_typeid;
    1867             : 
    1868             :                 /* do one-time catalog lookup for type info */
    1869       23600 :                 get_typlenbyvalalign(arrayexpr->element_typeid,
    1870             :                                      &scratch.d.arrayexpr.elemlength,
    1871             :                                      &scratch.d.arrayexpr.elembyval,
    1872             :                                      &scratch.d.arrayexpr.elemalign);
    1873             : 
    1874             :                 /* prepare to evaluate all arguments */
    1875       23600 :                 elemoff = 0;
    1876       86798 :                 foreach(lc, arrayexpr->elements)
    1877             :                 {
    1878       63198 :                     Expr       *e = (Expr *) lfirst(lc);
    1879             : 
    1880       63198 :                     ExecInitExprRec(e, state,
    1881       63198 :                                     &scratch.d.arrayexpr.elemvalues[elemoff],
    1882       63198 :                                     &scratch.d.arrayexpr.elemnulls[elemoff]);
    1883       63198 :                     elemoff++;
    1884             :                 }
    1885             : 
    1886             :                 /* and then collect all into an array */
    1887       23600 :                 ExprEvalPushStep(state, &scratch);
    1888       23600 :                 break;
    1889             :             }
    1890             : 
    1891        5040 :         case T_RowExpr:
    1892             :             {
    1893        5040 :                 RowExpr    *rowexpr = (RowExpr *) node;
    1894        5040 :                 int         nelems = list_length(rowexpr->args);
    1895             :                 TupleDesc   tupdesc;
    1896             :                 int         i;
    1897             :                 ListCell   *l;
    1898             : 
    1899             :                 /* Build tupdesc to describe result tuples */
    1900        5040 :                 if (rowexpr->row_typeid == RECORDOID)
    1901             :                 {
    1902             :                     /* generic record, use types of given expressions */
    1903        2658 :                     tupdesc = ExecTypeFromExprList(rowexpr->args);
    1904             :                     /* ... but adopt RowExpr's column aliases */
    1905        2658 :                     ExecTypeSetColNames(tupdesc, rowexpr->colnames);
    1906             :                     /* Bless the tupdesc so it can be looked up later */
    1907        2658 :                     BlessTupleDesc(tupdesc);
    1908             :                 }
    1909             :                 else
    1910             :                 {
    1911             :                     /* it's been cast to a named type, use that */
    1912        2382 :                     tupdesc = lookup_rowtype_tupdesc_copy(rowexpr->row_typeid, -1);
    1913             :                 }
    1914             : 
    1915             :                 /*
    1916             :                  * In the named-type case, the tupdesc could have more columns
    1917             :                  * than are in the args list, since the type might have had
    1918             :                  * columns added since the ROW() was parsed.  We want those
    1919             :                  * extra columns to go to nulls, so we make sure that the
    1920             :                  * workspace arrays are large enough and then initialize any
    1921             :                  * extra columns to read as NULLs.
    1922             :                  */
    1923             :                 Assert(nelems <= tupdesc->natts);
    1924        5040 :                 nelems = Max(nelems, tupdesc->natts);
    1925             : 
    1926             :                 /*
    1927             :                  * Evaluate by first building datums for each field, and then
    1928             :                  * a final step forming the composite datum.
    1929             :                  */
    1930        5040 :                 scratch.opcode = EEOP_ROW;
    1931        5040 :                 scratch.d.row.tupdesc = tupdesc;
    1932             : 
    1933             :                 /* space for the individual field datums */
    1934        5040 :                 scratch.d.row.elemvalues =
    1935        5040 :                     (Datum *) palloc(sizeof(Datum) * nelems);
    1936        5040 :                 scratch.d.row.elemnulls =
    1937        5040 :                     (bool *) palloc(sizeof(bool) * nelems);
    1938             :                 /* as explained above, make sure any extra columns are null */
    1939        5040 :                 memset(scratch.d.row.elemnulls, true, sizeof(bool) * nelems);
    1940             : 
    1941             :                 /* Set up evaluation, skipping any deleted columns */
    1942        5040 :                 i = 0;
    1943       17860 :                 foreach(l, rowexpr->args)
    1944             :                 {
    1945       12826 :                     Form_pg_attribute att = TupleDescAttr(tupdesc, i);
    1946       12826 :                     Expr       *e = (Expr *) lfirst(l);
    1947             : 
    1948       12826 :                     if (!att->attisdropped)
    1949             :                     {
    1950             :                         /*
    1951             :                          * Guard against ALTER COLUMN TYPE on rowtype since
    1952             :                          * the RowExpr was created.  XXX should we check
    1953             :                          * typmod too?  Not sure we can be sure it'll be the
    1954             :                          * same.
    1955             :                          */
    1956       12808 :                         if (exprType((Node *) e) != att->atttypid)
    1957           6 :                             ereport(ERROR,
    1958             :                                     (errcode(ERRCODE_DATATYPE_MISMATCH),
    1959             :                                      errmsg("ROW() column has type %s instead of type %s",
    1960             :                                             format_type_be(exprType((Node *) e)),
    1961             :                                             format_type_be(att->atttypid))));
    1962             :                     }
    1963             :                     else
    1964             :                     {
    1965             :                         /*
    1966             :                          * Ignore original expression and insert a NULL. We
    1967             :                          * don't really care what type of NULL it is, so
    1968             :                          * always make an int4 NULL.
    1969             :                          */
    1970          18 :                         e = (Expr *) makeNullConst(INT4OID, -1, InvalidOid);
    1971             :                     }
    1972             : 
    1973             :                     /* Evaluate column expr into appropriate workspace slot */
    1974       12820 :                     ExecInitExprRec(e, state,
    1975       12820 :                                     &scratch.d.row.elemvalues[i],
    1976       12820 :                                     &scratch.d.row.elemnulls[i]);
    1977       12820 :                     i++;
    1978             :                 }
    1979             : 
    1980             :                 /* And finally build the row value */
    1981        5034 :                 ExprEvalPushStep(state, &scratch);
    1982        5034 :                 break;
    1983             :             }
    1984             : 
    1985         168 :         case T_RowCompareExpr:
    1986             :             {
    1987         168 :                 RowCompareExpr *rcexpr = (RowCompareExpr *) node;
    1988         168 :                 int         nopers = list_length(rcexpr->opnos);
    1989         168 :                 List       *adjust_jumps = NIL;
    1990             :                 ListCell   *l_left_expr,
    1991             :                            *l_right_expr,
    1992             :                            *l_opno,
    1993             :                            *l_opfamily,
    1994             :                            *l_inputcollid;
    1995             :                 ListCell   *lc;
    1996             : 
    1997             :                 /*
    1998             :                  * Iterate over each field, prepare comparisons.  To handle
    1999             :                  * NULL results, prepare jumps to after the expression.  If a
    2000             :                  * comparison yields a != 0 result, jump to the final step.
    2001             :                  */
    2002             :                 Assert(list_length(rcexpr->largs) == nopers);
    2003             :                 Assert(list_length(rcexpr->rargs) == nopers);
    2004             :                 Assert(list_length(rcexpr->opfamilies) == nopers);
    2005             :                 Assert(list_length(rcexpr->inputcollids) == nopers);
    2006             : 
    2007         558 :                 forfive(l_left_expr, rcexpr->largs,
    2008             :                         l_right_expr, rcexpr->rargs,
    2009             :                         l_opno, rcexpr->opnos,
    2010             :                         l_opfamily, rcexpr->opfamilies,
    2011             :                         l_inputcollid, rcexpr->inputcollids)
    2012             :                 {
    2013         390 :                     Expr       *left_expr = (Expr *) lfirst(l_left_expr);
    2014         390 :                     Expr       *right_expr = (Expr *) lfirst(l_right_expr);
    2015         390 :                     Oid         opno = lfirst_oid(l_opno);
    2016         390 :                     Oid         opfamily = lfirst_oid(l_opfamily);
    2017         390 :                     Oid         inputcollid = lfirst_oid(l_inputcollid);
    2018             :                     int         strategy;
    2019             :                     Oid         lefttype;
    2020             :                     Oid         righttype;
    2021             :                     Oid         proc;
    2022             :                     FmgrInfo   *finfo;
    2023             :                     FunctionCallInfo fcinfo;
    2024             : 
    2025         390 :                     get_op_opfamily_properties(opno, opfamily, false,
    2026             :                                                &strategy,
    2027             :                                                &lefttype,
    2028             :                                                &righttype);
    2029         390 :                     proc = get_opfamily_proc(opfamily,
    2030             :                                              lefttype,
    2031             :                                              righttype,
    2032             :                                              BTORDER_PROC);
    2033         390 :                     if (!OidIsValid(proc))
    2034           0 :                         elog(ERROR, "missing support function %d(%u,%u) in opfamily %u",
    2035             :                              BTORDER_PROC, lefttype, righttype, opfamily);
    2036             : 
    2037             :                     /* Set up the primary fmgr lookup information */
    2038         390 :                     finfo = palloc0(sizeof(FmgrInfo));
    2039         390 :                     fcinfo = palloc0(SizeForFunctionCallInfo(2));
    2040         390 :                     fmgr_info(proc, finfo);
    2041         390 :                     fmgr_info_set_expr((Node *) node, finfo);
    2042         390 :                     InitFunctionCallInfoData(*fcinfo, finfo, 2,
    2043             :                                              inputcollid, NULL, NULL);
    2044             : 
    2045             :                     /*
    2046             :                      * If we enforced permissions checks on index support
    2047             :                      * functions, we'd need to make a check here.  But the
    2048             :                      * index support machinery doesn't do that, and thus
    2049             :                      * neither does this code.
    2050             :                      */
    2051             : 
    2052             :                     /* evaluate left and right args directly into fcinfo */
    2053         390 :                     ExecInitExprRec(left_expr, state,
    2054             :                                     &fcinfo->args[0].value, &fcinfo->args[0].isnull);
    2055         390 :                     ExecInitExprRec(right_expr, state,
    2056             :                                     &fcinfo->args[1].value, &fcinfo->args[1].isnull);
    2057             : 
    2058         390 :                     scratch.opcode = EEOP_ROWCOMPARE_STEP;
    2059         390 :                     scratch.d.rowcompare_step.finfo = finfo;
    2060         390 :                     scratch.d.rowcompare_step.fcinfo_data = fcinfo;
    2061         390 :                     scratch.d.rowcompare_step.fn_addr = finfo->fn_addr;
    2062             :                     /* jump targets filled below */
    2063         390 :                     scratch.d.rowcompare_step.jumpnull = -1;
    2064         390 :                     scratch.d.rowcompare_step.jumpdone = -1;
    2065             : 
    2066         390 :                     ExprEvalPushStep(state, &scratch);
    2067         390 :                     adjust_jumps = lappend_int(adjust_jumps,
    2068         390 :                                                state->steps_len - 1);
    2069             :                 }
    2070             : 
    2071             :                 /*
    2072             :                  * We could have a zero-column rowtype, in which case the rows
    2073             :                  * necessarily compare equal.
    2074             :                  */
    2075         168 :                 if (nopers == 0)
    2076             :                 {
    2077           0 :                     scratch.opcode = EEOP_CONST;
    2078           0 :                     scratch.d.constval.value = Int32GetDatum(0);
    2079           0 :                     scratch.d.constval.isnull = false;
    2080           0 :                     ExprEvalPushStep(state, &scratch);
    2081             :                 }
    2082             : 
    2083             :                 /* Finally, examine the last comparison result */
    2084         168 :                 scratch.opcode = EEOP_ROWCOMPARE_FINAL;
    2085         168 :                 scratch.d.rowcompare_final.rctype = rcexpr->rctype;
    2086         168 :                 ExprEvalPushStep(state, &scratch);
    2087             : 
    2088             :                 /* adjust jump targets */
    2089         558 :                 foreach(lc, adjust_jumps)
    2090             :                 {
    2091         390 :                     ExprEvalStep *as = &state->steps[lfirst_int(lc)];
    2092             : 
    2093             :                     Assert(as->opcode == EEOP_ROWCOMPARE_STEP);
    2094             :                     Assert(as->d.rowcompare_step.jumpdone == -1);
    2095             :                     Assert(as->d.rowcompare_step.jumpnull == -1);
    2096             : 
    2097             :                     /* jump to comparison evaluation */
    2098         390 :                     as->d.rowcompare_step.jumpdone = state->steps_len - 1;
    2099             :                     /* jump to the following expression */
    2100         390 :                     as->d.rowcompare_step.jumpnull = state->steps_len;
    2101             :                 }
    2102             : 
    2103         168 :                 break;
    2104             :             }
    2105             : 
    2106        3502 :         case T_CoalesceExpr:
    2107             :             {
    2108        3502 :                 CoalesceExpr *coalesce = (CoalesceExpr *) node;
    2109        3502 :                 List       *adjust_jumps = NIL;
    2110             :                 ListCell   *lc;
    2111             : 
    2112             :                 /* We assume there's at least one arg */
    2113             :                 Assert(coalesce->args != NIL);
    2114             : 
    2115             :                 /*
    2116             :                  * Prepare evaluation of all coalesced arguments, after each
    2117             :                  * one push a step that short-circuits if not null.
    2118             :                  */
    2119       10494 :                 foreach(lc, coalesce->args)
    2120             :                 {
    2121        6992 :                     Expr       *e = (Expr *) lfirst(lc);
    2122             : 
    2123             :                     /* evaluate argument, directly into result datum */
    2124        6992 :                     ExecInitExprRec(e, state, resv, resnull);
    2125             : 
    2126             :                     /* if it's not null, skip to end of COALESCE expr */
    2127        6992 :                     scratch.opcode = EEOP_JUMP_IF_NOT_NULL;
    2128        6992 :                     scratch.d.jump.jumpdone = -1;   /* adjust later */
    2129        6992 :                     ExprEvalPushStep(state, &scratch);
    2130             : 
    2131        6992 :                     adjust_jumps = lappend_int(adjust_jumps,
    2132        6992 :                                                state->steps_len - 1);
    2133             :                 }
    2134             : 
    2135             :                 /*
    2136             :                  * No need to add a constant NULL return - we only can get to
    2137             :                  * the end of the expression if a NULL already is being
    2138             :                  * returned.
    2139             :                  */
    2140             : 
    2141             :                 /* adjust jump targets */
    2142       10494 :                 foreach(lc, adjust_jumps)
    2143             :                 {
    2144        6992 :                     ExprEvalStep *as = &state->steps[lfirst_int(lc)];
    2145             : 
    2146             :                     Assert(as->opcode == EEOP_JUMP_IF_NOT_NULL);
    2147             :                     Assert(as->d.jump.jumpdone == -1);
    2148        6992 :                     as->d.jump.jumpdone = state->steps_len;
    2149             :                 }
    2150             : 
    2151        3502 :                 break;
    2152             :             }
    2153             : 
    2154        2416 :         case T_MinMaxExpr:
    2155             :             {
    2156        2416 :                 MinMaxExpr *minmaxexpr = (MinMaxExpr *) node;
    2157        2416 :                 int         nelems = list_length(minmaxexpr->args);
    2158             :                 TypeCacheEntry *typentry;
    2159             :                 FmgrInfo   *finfo;
    2160             :                 FunctionCallInfo fcinfo;
    2161             :                 ListCell   *lc;
    2162             :                 int         off;
    2163             : 
    2164             :                 /* Look up the btree comparison function for the datatype */
    2165        2416 :                 typentry = lookup_type_cache(minmaxexpr->minmaxtype,
    2166             :                                              TYPECACHE_CMP_PROC);
    2167        2416 :                 if (!OidIsValid(typentry->cmp_proc))
    2168           0 :                     ereport(ERROR,
    2169             :                             (errcode(ERRCODE_UNDEFINED_FUNCTION),
    2170             :                              errmsg("could not identify a comparison function for type %s",
    2171             :                                     format_type_be(minmaxexpr->minmaxtype))));
    2172             : 
    2173             :                 /*
    2174             :                  * If we enforced permissions checks on index support
    2175             :                  * functions, we'd need to make a check here.  But the index
    2176             :                  * support machinery doesn't do that, and thus neither does
    2177             :                  * this code.
    2178             :                  */
    2179             : 
    2180             :                 /* Perform function lookup */
    2181        2416 :                 finfo = palloc0(sizeof(FmgrInfo));
    2182        2416 :                 fcinfo = palloc0(SizeForFunctionCallInfo(2));
    2183        2416 :                 fmgr_info(typentry->cmp_proc, finfo);
    2184        2416 :                 fmgr_info_set_expr((Node *) node, finfo);
    2185        2416 :                 InitFunctionCallInfoData(*fcinfo, finfo, 2,
    2186             :                                          minmaxexpr->inputcollid, NULL, NULL);
    2187             : 
    2188        2416 :                 scratch.opcode = EEOP_MINMAX;
    2189             :                 /* allocate space to store arguments */
    2190        2416 :                 scratch.d.minmax.values =
    2191        2416 :                     (Datum *) palloc(sizeof(Datum) * nelems);
    2192        2416 :                 scratch.d.minmax.nulls =
    2193        2416 :                     (bool *) palloc(sizeof(bool) * nelems);
    2194        2416 :                 scratch.d.minmax.nelems = nelems;
    2195             : 
    2196        2416 :                 scratch.d.minmax.op = minmaxexpr->op;
    2197        2416 :                 scratch.d.minmax.finfo = finfo;
    2198        2416 :                 scratch.d.minmax.fcinfo_data = fcinfo;
    2199             : 
    2200             :                 /* evaluate expressions into minmax->values/nulls */
    2201        2416 :                 off = 0;
    2202        7356 :                 foreach(lc, minmaxexpr->args)
    2203             :                 {
    2204        4940 :                     Expr       *e = (Expr *) lfirst(lc);
    2205             : 
    2206        4940 :                     ExecInitExprRec(e, state,
    2207        4940 :                                     &scratch.d.minmax.values[off],
    2208        4940 :                                     &scratch.d.minmax.nulls[off]);
    2209        4940 :                     off++;
    2210             :                 }
    2211             : 
    2212             :                 /* and push the final comparison */
    2213        2416 :                 ExprEvalPushStep(state, &scratch);
    2214        2416 :                 break;
    2215             :             }
    2216             : 
    2217        4538 :         case T_SQLValueFunction:
    2218             :             {
    2219        4538 :                 SQLValueFunction *svf = (SQLValueFunction *) node;
    2220             : 
    2221        4538 :                 scratch.opcode = EEOP_SQLVALUEFUNCTION;
    2222        4538 :                 scratch.d.sqlvaluefunction.svf = svf;
    2223             : 
    2224        4538 :                 ExprEvalPushStep(state, &scratch);
    2225        4538 :                 break;
    2226             :             }
    2227             : 
    2228         690 :         case T_XmlExpr:
    2229             :             {
    2230         690 :                 XmlExpr    *xexpr = (XmlExpr *) node;
    2231         690 :                 int         nnamed = list_length(xexpr->named_args);
    2232         690 :                 int         nargs = list_length(xexpr->args);
    2233             :                 int         off;
    2234             :                 ListCell   *arg;
    2235             : 
    2236         690 :                 scratch.opcode = EEOP_XMLEXPR;
    2237         690 :                 scratch.d.xmlexpr.xexpr = xexpr;
    2238             : 
    2239             :                 /* allocate space for storing all the arguments */
    2240         690 :                 if (nnamed)
    2241             :                 {
    2242          60 :                     scratch.d.xmlexpr.named_argvalue =
    2243          60 :                         (Datum *) palloc(sizeof(Datum) * nnamed);
    2244          60 :                     scratch.d.xmlexpr.named_argnull =
    2245          60 :                         (bool *) palloc(sizeof(bool) * nnamed);
    2246             :                 }
    2247             :                 else
    2248             :                 {
    2249         630 :                     scratch.d.xmlexpr.named_argvalue = NULL;
    2250         630 :                     scratch.d.xmlexpr.named_argnull = NULL;
    2251             :                 }
    2252             : 
    2253         690 :                 if (nargs)
    2254             :                 {
    2255         606 :                     scratch.d.xmlexpr.argvalue =
    2256         606 :                         (Datum *) palloc(sizeof(Datum) * nargs);
    2257         606 :                     scratch.d.xmlexpr.argnull =
    2258         606 :                         (bool *) palloc(sizeof(bool) * nargs);
    2259             :                 }
    2260             :                 else
    2261             :                 {
    2262          84 :                     scratch.d.xmlexpr.argvalue = NULL;
    2263          84 :                     scratch.d.xmlexpr.argnull = NULL;
    2264             :                 }
    2265             : 
    2266             :                 /* prepare argument execution */
    2267         690 :                 off = 0;
    2268         858 :                 foreach(arg, xexpr->named_args)
    2269             :                 {
    2270         168 :                     Expr       *e = (Expr *) lfirst(arg);
    2271             : 
    2272         168 :                     ExecInitExprRec(e, state,
    2273         168 :                                     &scratch.d.xmlexpr.named_argvalue[off],
    2274         168 :                                     &scratch.d.xmlexpr.named_argnull[off]);
    2275         168 :                     off++;
    2276             :                 }
    2277             : 
    2278         690 :                 off = 0;
    2279        1614 :                 foreach(arg, xexpr->args)
    2280             :                 {
    2281         924 :                     Expr       *e = (Expr *) lfirst(arg);
    2282             : 
    2283         924 :                     ExecInitExprRec(e, state,
    2284         924 :                                     &scratch.d.xmlexpr.argvalue[off],
    2285         924 :                                     &scratch.d.xmlexpr.argnull[off]);
    2286         924 :                     off++;
    2287             :                 }
    2288             : 
    2289             :                 /* and evaluate the actual XML expression */
    2290         690 :                 ExprEvalPushStep(state, &scratch);
    2291         690 :                 break;
    2292             :             }
    2293             : 
    2294         120 :         case T_JsonValueExpr:
    2295             :             {
    2296         120 :                 JsonValueExpr *jve = (JsonValueExpr *) node;
    2297             : 
    2298             :                 Assert(jve->formatted_expr != NULL);
    2299         120 :                 ExecInitExprRec(jve->formatted_expr, state, resv, resnull);
    2300         120 :                 break;
    2301             :             }
    2302             : 
    2303        1138 :         case T_JsonConstructorExpr:
    2304             :             {
    2305        1138 :                 JsonConstructorExpr *ctor = (JsonConstructorExpr *) node;
    2306        1138 :                 List       *args = ctor->args;
    2307             :                 ListCell   *lc;
    2308        1138 :                 int         nargs = list_length(args);
    2309        1138 :                 int         argno = 0;
    2310             : 
    2311        1138 :                 if (ctor->func)
    2312             :                 {
    2313         324 :                     ExecInitExprRec(ctor->func, state, resv, resnull);
    2314             :                 }
    2315         814 :                 else if ((ctor->type == JSCTOR_JSON_PARSE && !ctor->unique) ||
    2316         692 :                          ctor->type == JSCTOR_JSON_SERIALIZE)
    2317             :                 {
    2318             :                     /* Use the value of the first argument as result */
    2319         202 :                     ExecInitExprRec(linitial(args), state, resv, resnull);
    2320             :                 }
    2321             :                 else
    2322             :                 {
    2323             :                     JsonConstructorExprState *jcstate;
    2324             : 
    2325         612 :                     jcstate = palloc0(sizeof(JsonConstructorExprState));
    2326             : 
    2327         612 :                     scratch.opcode = EEOP_JSON_CONSTRUCTOR;
    2328         612 :                     scratch.d.json_constructor.jcstate = jcstate;
    2329             : 
    2330         612 :                     jcstate->constructor = ctor;
    2331         612 :                     jcstate->arg_values = (Datum *) palloc(sizeof(Datum) * nargs);
    2332         612 :                     jcstate->arg_nulls = (bool *) palloc(sizeof(bool) * nargs);
    2333         612 :                     jcstate->arg_types = (Oid *) palloc(sizeof(Oid) * nargs);
    2334         612 :                     jcstate->nargs = nargs;
    2335             : 
    2336        1918 :                     foreach(lc, args)
    2337             :                     {
    2338        1306 :                         Expr       *arg = (Expr *) lfirst(lc);
    2339             : 
    2340        1306 :                         jcstate->arg_types[argno] = exprType((Node *) arg);
    2341             : 
    2342        1306 :                         if (IsA(arg, Const))
    2343             :                         {
    2344             :                             /* Don't evaluate const arguments every round */
    2345        1240 :                             Const      *con = (Const *) arg;
    2346             : 
    2347        1240 :                             jcstate->arg_values[argno] = con->constvalue;
    2348        1240 :                             jcstate->arg_nulls[argno] = con->constisnull;
    2349             :                         }
    2350             :                         else
    2351             :                         {
    2352          66 :                             ExecInitExprRec(arg, state,
    2353          66 :                                             &jcstate->arg_values[argno],
    2354          66 :                                             &jcstate->arg_nulls[argno]);
    2355             :                         }
    2356        1306 :                         argno++;
    2357             :                     }
    2358             : 
    2359             :                     /* prepare type cache for datum_to_json[b]() */
    2360         612 :                     if (ctor->type == JSCTOR_JSON_SCALAR)
    2361             :                     {
    2362         112 :                         bool        is_jsonb =
    2363         112 :                             ctor->returning->format->format_type == JS_FORMAT_JSONB;
    2364             : 
    2365         112 :                         jcstate->arg_type_cache =
    2366         112 :                             palloc(sizeof(*jcstate->arg_type_cache) * nargs);
    2367             : 
    2368         224 :                         for (int i = 0; i < nargs; i++)
    2369             :                         {
    2370             :                             JsonTypeCategory category;
    2371             :                             Oid         outfuncid;
    2372         112 :                             Oid         typid = jcstate->arg_types[i];
    2373             : 
    2374         112 :                             json_categorize_type(typid, is_jsonb,
    2375             :                                                  &category, &outfuncid);
    2376             : 
    2377         112 :                             jcstate->arg_type_cache[i].outfuncid = outfuncid;
    2378         112 :                             jcstate->arg_type_cache[i].category = (int) category;
    2379             :                         }
    2380             :                     }
    2381             : 
    2382         612 :                     ExprEvalPushStep(state, &scratch);
    2383             :                 }
    2384             : 
    2385        1138 :                 if (ctor->coercion)
    2386             :                 {
    2387         236 :                     Datum      *innermost_caseval = state->innermost_caseval;
    2388         236 :                     bool       *innermost_isnull = state->innermost_casenull;
    2389             : 
    2390         236 :                     state->innermost_caseval = resv;
    2391         236 :                     state->innermost_casenull = resnull;
    2392             : 
    2393         236 :                     ExecInitExprRec(ctor->coercion, state, resv, resnull);
    2394             : 
    2395         236 :                     state->innermost_caseval = innermost_caseval;
    2396         236 :                     state->innermost_casenull = innermost_isnull;
    2397             :                 }
    2398             :             }
    2399        1138 :             break;
    2400             : 
    2401         314 :         case T_JsonIsPredicate:
    2402             :             {
    2403         314 :                 JsonIsPredicate *pred = (JsonIsPredicate *) node;
    2404             : 
    2405         314 :                 ExecInitExprRec((Expr *) pred->expr, state, resv, resnull);
    2406             : 
    2407         314 :                 scratch.opcode = EEOP_IS_JSON;
    2408         314 :                 scratch.d.is_json.pred = pred;
    2409             : 
    2410         314 :                 ExprEvalPushStep(state, &scratch);
    2411         314 :                 break;
    2412             :             }
    2413             : 
    2414       23808 :         case T_NullTest:
    2415             :             {
    2416       23808 :                 NullTest   *ntest = (NullTest *) node;
    2417             : 
    2418       23808 :                 if (ntest->nulltesttype == IS_NULL)
    2419             :                 {
    2420        7294 :                     if (ntest->argisrow)
    2421         228 :                         scratch.opcode = EEOP_NULLTEST_ROWISNULL;
    2422             :                     else
    2423        7066 :                         scratch.opcode = EEOP_NULLTEST_ISNULL;
    2424             :                 }
    2425       16514 :                 else if (ntest->nulltesttype == IS_NOT_NULL)
    2426             :                 {
    2427       16514 :                     if (ntest->argisrow)
    2428         210 :                         scratch.opcode = EEOP_NULLTEST_ROWISNOTNULL;
    2429             :                     else
    2430       16304 :                         scratch.opcode = EEOP_NULLTEST_ISNOTNULL;
    2431             :                 }
    2432             :                 else
    2433             :                 {
    2434           0 :                     elog(ERROR, "unrecognized nulltesttype: %d",
    2435             :                          (int) ntest->nulltesttype);
    2436             :                 }
    2437             :                 /* initialize cache in case it's a row test */
    2438       23808 :                 scratch.d.nulltest_row.rowcache.cacheptr = NULL;
    2439             : 
    2440             :                 /* first evaluate argument into result variable */
    2441       23808 :                 ExecInitExprRec(ntest->arg, state,
    2442             :                                 resv, resnull);
    2443             : 
    2444             :                 /* then push the test of that argument */
    2445       23808 :                 ExprEvalPushStep(state, &scratch);
    2446       23808 :                 break;
    2447             :             }
    2448             : 
    2449        1016 :         case T_BooleanTest:
    2450             :             {
    2451        1016 :                 BooleanTest *btest = (BooleanTest *) node;
    2452             : 
    2453             :                 /*
    2454             :                  * Evaluate argument, directly into result datum.  That's ok,
    2455             :                  * because resv/resnull is definitely not used anywhere else,
    2456             :                  * and will get overwritten by the below EEOP_BOOLTEST_IS_*
    2457             :                  * step.
    2458             :                  */
    2459        1016 :                 ExecInitExprRec(btest->arg, state, resv, resnull);
    2460             : 
    2461        1016 :                 switch (btest->booltesttype)
    2462             :                 {
    2463         412 :                     case IS_TRUE:
    2464         412 :                         scratch.opcode = EEOP_BOOLTEST_IS_TRUE;
    2465         412 :                         break;
    2466         288 :                     case IS_NOT_TRUE:
    2467         288 :                         scratch.opcode = EEOP_BOOLTEST_IS_NOT_TRUE;
    2468         288 :                         break;
    2469          84 :                     case IS_FALSE:
    2470          84 :                         scratch.opcode = EEOP_BOOLTEST_IS_FALSE;
    2471          84 :                         break;
    2472          72 :                     case IS_NOT_FALSE:
    2473          72 :                         scratch.opcode = EEOP_BOOLTEST_IS_NOT_FALSE;
    2474          72 :                         break;
    2475          82 :                     case IS_UNKNOWN:
    2476             :                         /* Same as scalar IS NULL test */
    2477          82 :                         scratch.opcode = EEOP_NULLTEST_ISNULL;
    2478          82 :                         break;
    2479          78 :                     case IS_NOT_UNKNOWN:
    2480             :                         /* Same as scalar IS NOT NULL test */
    2481          78 :                         scratch.opcode = EEOP_NULLTEST_ISNOTNULL;
    2482          78 :                         break;
    2483           0 :                     default:
    2484           0 :                         elog(ERROR, "unrecognized booltesttype: %d",
    2485             :                              (int) btest->booltesttype);
    2486             :                 }
    2487             : 
    2488        1016 :                 ExprEvalPushStep(state, &scratch);
    2489        1016 :                 break;
    2490             :             }
    2491             : 
    2492        6744 :         case T_CoerceToDomain:
    2493             :             {
    2494        6744 :                 CoerceToDomain *ctest = (CoerceToDomain *) node;
    2495             : 
    2496        6744 :                 ExecInitCoerceToDomain(&scratch, ctest, state,
    2497             :                                        resv, resnull);
    2498        6744 :                 break;
    2499             :             }
    2500             : 
    2501       10530 :         case T_CoerceToDomainValue:
    2502             :             {
    2503             :                 /*
    2504             :                  * Read from location identified by innermost_domainval.  Note
    2505             :                  * that innermost_domainval could be NULL, if we're compiling
    2506             :                  * a standalone domain check rather than one embedded in a
    2507             :                  * larger expression.  In that case we must read from
    2508             :                  * econtext->domainValue_datum.  We'll take care of that
    2509             :                  * scenario at runtime.
    2510             :                  */
    2511       10530 :                 scratch.opcode = EEOP_DOMAIN_TESTVAL;
    2512             :                 /* we share instruction union variant with case testval */
    2513       10530 :                 scratch.d.casetest.value = state->innermost_domainval;
    2514       10530 :                 scratch.d.casetest.isnull = state->innermost_domainnull;
    2515             : 
    2516       10530 :                 ExprEvalPushStep(state, &scratch);
    2517       10530 :                 break;
    2518             :             }
    2519             : 
    2520           2 :         case T_CurrentOfExpr:
    2521             :             {
    2522           2 :                 scratch.opcode = EEOP_CURRENTOFEXPR;
    2523           2 :                 ExprEvalPushStep(state, &scratch);
    2524           2 :                 break;
    2525             :             }
    2526             : 
    2527         396 :         case T_NextValueExpr:
    2528             :             {
    2529         396 :                 NextValueExpr *nve = (NextValueExpr *) node;
    2530             : 
    2531         396 :                 scratch.opcode = EEOP_NEXTVALUEEXPR;
    2532         396 :                 scratch.d.nextvalueexpr.seqid = nve->seqid;
    2533         396 :                 scratch.d.nextvalueexpr.seqtypid = nve->typeId;
    2534             : 
    2535         396 :                 ExprEvalPushStep(state, &scratch);
    2536         396 :                 break;
    2537             :             }
    2538             : 
    2539           0 :         default:
    2540           0 :             elog(ERROR, "unrecognized node type: %d",
    2541             :                  (int) nodeTag(node));
    2542             :             break;
    2543             :     }
    2544     4493936 : }
    2545             : 
    2546             : /*
    2547             :  * Add another expression evaluation step to ExprState->steps.
    2548             :  *
    2549             :  * Note that this potentially re-allocates es->steps, therefore no pointer
    2550             :  * into that array may be used while the expression is still being built.
    2551             :  */
    2552             : void
    2553    10110334 : ExprEvalPushStep(ExprState *es, const ExprEvalStep *s)
    2554             : {
    2555    10110334 :     if (es->steps_alloc == 0)
    2556             :     {
    2557     2127986 :         es->steps_alloc = 16;
    2558     2127986 :         es->steps = palloc(sizeof(ExprEvalStep) * es->steps_alloc);
    2559             :     }
    2560     7982348 :     else if (es->steps_alloc == es->steps_len)
    2561             :     {
    2562       68046 :         es->steps_alloc *= 2;
    2563       68046 :         es->steps = repalloc(es->steps,
    2564       68046 :                              sizeof(ExprEvalStep) * es->steps_alloc);
    2565             :     }
    2566             : 
    2567    10110334 :     memcpy(&es->steps[es->steps_len++], s, sizeof(ExprEvalStep));
    2568    10110334 : }
    2569             : 
    2570             : /*
    2571             :  * Perform setup necessary for the evaluation of a function-like expression,
    2572             :  * appending argument evaluation steps to the steps list in *state, and
    2573             :  * setting up *scratch so it is ready to be pushed.
    2574             :  *
    2575             :  * *scratch is not pushed here, so that callers may override the opcode,
    2576             :  * which is useful for function-like cases like DISTINCT.
    2577             :  */
    2578             : static void
    2579     1327274 : ExecInitFunc(ExprEvalStep *scratch, Expr *node, List *args, Oid funcid,
    2580             :              Oid inputcollid, ExprState *state)
    2581             : {
    2582     1327274 :     int         nargs = list_length(args);
    2583             :     AclResult   aclresult;
    2584             :     FmgrInfo   *flinfo;
    2585             :     FunctionCallInfo fcinfo;
    2586             :     int         argno;
    2587             :     ListCell   *lc;
    2588             : 
    2589             :     /* Check permission to call function */
    2590     1327274 :     aclresult = object_aclcheck(ProcedureRelationId, funcid, GetUserId(), ACL_EXECUTE);
    2591     1327274 :     if (aclresult != ACLCHECK_OK)
    2592          82 :         aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(funcid));
    2593     1327192 :     InvokeFunctionExecuteHook(funcid);
    2594             : 
    2595             :     /*
    2596             :      * Safety check on nargs.  Under normal circumstances this should never
    2597             :      * fail, as parser should check sooner.  But possibly it might fail if
    2598             :      * server has been compiled with FUNC_MAX_ARGS smaller than some functions
    2599             :      * declared in pg_proc?
    2600             :      */
    2601     1327192 :     if (nargs > FUNC_MAX_ARGS)
    2602           0 :         ereport(ERROR,
    2603             :                 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
    2604             :                  errmsg_plural("cannot pass more than %d argument to a function",
    2605             :                                "cannot pass more than %d arguments to a function",
    2606             :                                FUNC_MAX_ARGS,
    2607             :                                FUNC_MAX_ARGS)));
    2608             : 
    2609             :     /* Allocate function lookup data and parameter workspace for this call */
    2610     1327192 :     scratch->d.func.finfo = palloc0(sizeof(FmgrInfo));
    2611     1327192 :     scratch->d.func.fcinfo_data = palloc0(SizeForFunctionCallInfo(nargs));
    2612     1327192 :     flinfo = scratch->d.func.finfo;
    2613     1327192 :     fcinfo = scratch->d.func.fcinfo_data;
    2614             : 
    2615             :     /* Set up the primary fmgr lookup information */
    2616     1327192 :     fmgr_info(funcid, flinfo);
    2617     1327192 :     fmgr_info_set_expr((Node *) node, flinfo);
    2618             : 
    2619             :     /* Initialize function call parameter structure too */
    2620     1327192 :     InitFunctionCallInfoData(*fcinfo, flinfo,
    2621             :                              nargs, inputcollid, NULL, NULL);
    2622             : 
    2623             :     /* Keep extra copies of this info to save an indirection at runtime */
    2624     1327192 :     scratch->d.func.fn_addr = flinfo->fn_addr;
    2625     1327192 :     scratch->d.func.nargs = nargs;
    2626             : 
    2627             :     /* We only support non-set functions here */
    2628     1327192 :     if (flinfo->fn_retset)
    2629           0 :         ereport(ERROR,
    2630             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    2631             :                  errmsg("set-valued function called in context that cannot accept a set"),
    2632             :                  state->parent ?
    2633             :                  executor_errposition(state->parent->state,
    2634             :                                       exprLocation((Node *) node)) : 0));
    2635             : 
    2636             :     /* Build code to evaluate arguments directly into the fcinfo struct */
    2637     1327192 :     argno = 0;
    2638     3498278 :     foreach(lc, args)
    2639             :     {
    2640     2171086 :         Expr       *arg = (Expr *) lfirst(lc);
    2641             : 
    2642     2171086 :         if (IsA(arg, Const))
    2643             :         {
    2644             :             /*
    2645             :              * Don't evaluate const arguments every round; especially
    2646             :              * interesting for constants in comparisons.
    2647             :              */
    2648      835306 :             Const      *con = (Const *) arg;
    2649             : 
    2650      835306 :             fcinfo->args[argno].value = con->constvalue;
    2651      835306 :             fcinfo->args[argno].isnull = con->constisnull;
    2652             :         }
    2653             :         else
    2654             :         {
    2655     1335780 :             ExecInitExprRec(arg, state,
    2656             :                             &fcinfo->args[argno].value,
    2657             :                             &fcinfo->args[argno].isnull);
    2658             :         }
    2659     2171086 :         argno++;
    2660             :     }
    2661             : 
    2662             :     /* Insert appropriate opcode depending on strictness and stats level */
    2663     1327192 :     if (pgstat_track_functions <= flinfo->fn_stats)
    2664             :     {
    2665     1326978 :         if (flinfo->fn_strict && nargs > 0)
    2666     1184950 :             scratch->opcode = EEOP_FUNCEXPR_STRICT;
    2667             :         else
    2668      142028 :             scratch->opcode = EEOP_FUNCEXPR;
    2669             :     }
    2670             :     else
    2671             :     {
    2672         214 :         if (flinfo->fn_strict && nargs > 0)
    2673           6 :             scratch->opcode = EEOP_FUNCEXPR_STRICT_FUSAGE;
    2674             :         else
    2675         208 :             scratch->opcode = EEOP_FUNCEXPR_FUSAGE;
    2676             :     }
    2677     1327192 : }
    2678             : 
    2679             : /*
    2680             :  * Add expression steps performing setup that's needed before any of the
    2681             :  * main execution of the expression.
    2682             :  */
    2683             : static void
    2684     2049266 : ExecCreateExprSetupSteps(ExprState *state, Node *node)
    2685             : {
    2686     2049266 :     ExprSetupInfo info = {0, 0, 0, NIL};
    2687             : 
    2688             :     /* Prescan to find out what we need. */
    2689     2049266 :     expr_setup_walker(node, &info);
    2690             : 
    2691             :     /* And generate those steps. */
    2692     2049266 :     ExecPushExprSetupSteps(state, &info);
    2693     2049266 : }
    2694             : 
    2695             : /*
    2696             :  * Add steps performing expression setup as indicated by "info".
    2697             :  * This is useful when building an ExprState covering more than one expression.
    2698             :  */
    2699             : static void
    2700     2105630 : ExecPushExprSetupSteps(ExprState *state, ExprSetupInfo *info)
    2701             : {
    2702     2105630 :     ExprEvalStep scratch = {0};
    2703             :     ListCell   *lc;
    2704             : 
    2705     2105630 :     scratch.resvalue = NULL;
    2706     2105630 :     scratch.resnull = NULL;
    2707             : 
    2708             :     /*
    2709             :      * Add steps deforming the ExprState's inner/outer/scan slots as much as
    2710             :      * required by any Vars appearing in the expression.
    2711             :      */
    2712     2105630 :     if (info->last_inner > 0)
    2713             :     {
    2714      146506 :         scratch.opcode = EEOP_INNER_FETCHSOME;
    2715      146506 :         scratch.d.fetch.last_var = info->last_inner;
    2716      146506 :         scratch.d.fetch.fixed = false;
    2717      146506 :         scratch.d.fetch.kind = NULL;
    2718      146506 :         scratch.d.fetch.known_desc = NULL;
    2719      146506 :         if (ExecComputeSlotInfo(state, &scratch))
    2720      138836 :             ExprEvalPushStep(state, &scratch);
    2721             :     }
    2722     2105630 :     if (info->last_outer > 0)
    2723             :     {
    2724      289312 :         scratch.opcode = EEOP_OUTER_FETCHSOME;
    2725      289312 :         scratch.d.fetch.last_var = info->last_outer;
    2726      289312 :         scratch.d.fetch.fixed = false;
    2727      289312 :         scratch.d.fetch.kind = NULL;
    2728      289312 :         scratch.d.fetch.known_desc = NULL;
    2729      289312 :         if (ExecComputeSlotInfo(state, &scratch))
    2730      154024 :             ExprEvalPushStep(state, &scratch);
    2731             :     }
    2732     2105630 :     if (info->last_scan > 0)
    2733             :     {
    2734      524456 :         scratch.opcode = EEOP_SCAN_FETCHSOME;
    2735      524456 :         scratch.d.fetch.last_var = info->last_scan;
    2736      524456 :         scratch.d.fetch.fixed = false;
    2737      524456 :         scratch.d.fetch.kind = NULL;
    2738      524456 :         scratch.d.fetch.known_desc = NULL;
    2739      524456 :         if (ExecComputeSlotInfo(state, &scratch))
    2740      497756 :             ExprEvalPushStep(state, &scratch);
    2741             :     }
    2742             : 
    2743             :     /*
    2744             :      * Add steps to execute any MULTIEXPR SubPlans appearing in the
    2745             :      * expression.  We need to evaluate these before any of the Params
    2746             :      * referencing their outputs are used, but after we've prepared for any
    2747             :      * Var references they may contain.  (There cannot be cross-references
    2748             :      * between MULTIEXPR SubPlans, so we needn't worry about their order.)
    2749             :      */
    2750     2105750 :     foreach(lc, info->multiexpr_subplans)
    2751             :     {
    2752         120 :         SubPlan    *subplan = (SubPlan *) lfirst(lc);
    2753             :         SubPlanState *sstate;
    2754             : 
    2755             :         Assert(subplan->subLinkType == MULTIEXPR_SUBLINK);
    2756             : 
    2757             :         /* This should match what ExecInitExprRec does for other SubPlans: */
    2758             : 
    2759         120 :         if (!state->parent)
    2760           0 :             elog(ERROR, "SubPlan found with no parent plan");
    2761             : 
    2762         120 :         sstate = ExecInitSubPlan(subplan, state->parent);
    2763             : 
    2764             :         /* add SubPlanState nodes to state->parent->subPlan */
    2765         120 :         state->parent->subPlan = lappend(state->parent->subPlan,
    2766             :                                          sstate);
    2767             : 
    2768         120 :         scratch.opcode = EEOP_SUBPLAN;
    2769         120 :         scratch.d.subplan.sstate = sstate;
    2770             : 
    2771             :         /* The result can be ignored, but we better put it somewhere */
    2772         120 :         scratch.resvalue = &state->resvalue;
    2773         120 :         scratch.resnull = &state->resnull;
    2774             : 
    2775         120 :         ExprEvalPushStep(state, &scratch);
    2776             :     }
    2777     2105630 : }
    2778             : 
    2779             : /*
    2780             :  * expr_setup_walker: expression walker for ExecCreateExprSetupSteps
    2781             :  */
    2782             : static bool
    2783     9378076 : expr_setup_walker(Node *node, ExprSetupInfo *info)
    2784             : {
    2785     9378076 :     if (node == NULL)
    2786      338030 :         return false;
    2787     9040046 :     if (IsA(node, Var))
    2788             :     {
    2789     1920218 :         Var        *variable = (Var *) node;
    2790     1920218 :         AttrNumber  attnum = variable->varattno;
    2791             : 
    2792     1920218 :         switch (variable->varno)
    2793             :         {
    2794      262118 :             case INNER_VAR:
    2795      262118 :                 info->last_inner = Max(info->last_inner, attnum);
    2796      262118 :                 break;
    2797             : 
    2798      649902 :             case OUTER_VAR:
    2799      649902 :                 info->last_outer = Max(info->last_outer, attnum);
    2800      649902 :                 break;
    2801             : 
    2802             :                 /* INDEX_VAR is handled by default case */
    2803             : 
    2804     1008198 :             default:
    2805     1008198 :                 info->last_scan = Max(info->last_scan, attnum);
    2806     1008198 :                 break;
    2807             :         }
    2808     1920218 :         return false;
    2809             :     }
    2810             : 
    2811             :     /* Collect all MULTIEXPR SubPlans, too */
    2812     7119828 :     if (IsA(node, SubPlan))
    2813             :     {
    2814       22290 :         SubPlan    *subplan = (SubPlan *) node;
    2815             : 
    2816       22290 :         if (subplan->subLinkType == MULTIEXPR_SUBLINK)
    2817         120 :             info->multiexpr_subplans = lappend(info->multiexpr_subplans,
    2818             :                                                subplan);
    2819             :     }
    2820             : 
    2821             :     /*
    2822             :      * Don't examine the arguments or filters of Aggrefs or WindowFuncs,
    2823             :      * because those do not represent expressions to be evaluated within the
    2824             :      * calling expression's econtext.  GroupingFunc arguments are never
    2825             :      * evaluated at all.
    2826             :      */
    2827     7119828 :     if (IsA(node, Aggref))
    2828       45160 :         return false;
    2829     7074668 :     if (IsA(node, WindowFunc))
    2830        3066 :         return false;
    2831     7071602 :     if (IsA(node, GroupingFunc))
    2832         366 :         return false;
    2833     7071236 :     return expression_tree_walker(node, expr_setup_walker,
    2834             :                                   (void *) info);
    2835             : }
    2836             : 
    2837             : /*
    2838             :  * Compute additional information for EEOP_*_FETCHSOME ops.
    2839             :  *
    2840             :  * The goal is to determine whether a slot is 'fixed', that is, every
    2841             :  * evaluation of the expression will have the same type of slot, with an
    2842             :  * equivalent descriptor.
    2843             :  *
    2844             :  * Returns true if the deforming step is required, false otherwise.
    2845             :  */
    2846             : static bool
    2847      995714 : ExecComputeSlotInfo(ExprState *state, ExprEvalStep *op)
    2848             : {
    2849      995714 :     PlanState  *parent = state->parent;
    2850      995714 :     TupleDesc   desc = NULL;
    2851      995714 :     const TupleTableSlotOps *tts_ops = NULL;
    2852      995714 :     bool        isfixed = false;
    2853      995714 :     ExprEvalOp  opcode = op->opcode;
    2854             : 
    2855             :     Assert(opcode == EEOP_INNER_FETCHSOME ||
    2856             :            opcode == EEOP_OUTER_FETCHSOME ||
    2857             :            opcode == EEOP_SCAN_FETCHSOME);
    2858             : 
    2859      995714 :     if (op->d.fetch.known_desc != NULL)
    2860             :     {
    2861       35440 :         desc = op->d.fetch.known_desc;
    2862       35440 :         tts_ops = op->d.fetch.kind;
    2863       35440 :         isfixed = op->d.fetch.kind != NULL;
    2864             :     }
    2865      960274 :     else if (!parent)
    2866             :     {
    2867       14152 :         isfixed = false;
    2868             :     }
    2869      946122 :     else if (opcode == EEOP_INNER_FETCHSOME)
    2870             :     {
    2871      146394 :         PlanState  *is = innerPlanState(parent);
    2872             : 
    2873      146394 :         if (parent->inneropsset && !parent->inneropsfixed)
    2874             :         {
    2875           0 :             isfixed = false;
    2876             :         }
    2877      146394 :         else if (parent->inneropsset && parent->innerops)
    2878             :         {
    2879           0 :             isfixed = true;
    2880           0 :             tts_ops = parent->innerops;
    2881           0 :             desc = ExecGetResultType(is);
    2882             :         }
    2883      146394 :         else if (is)
    2884             :         {
    2885      144668 :             tts_ops = ExecGetResultSlotOps(is, &isfixed);
    2886      144668 :             desc = ExecGetResultType(is);
    2887             :         }
    2888             :     }
    2889      799728 :     else if (opcode == EEOP_OUTER_FETCHSOME)
    2890             :     {
    2891      289134 :         PlanState  *os = outerPlanState(parent);
    2892             : 
    2893      289134 :         if (parent->outeropsset && !parent->outeropsfixed)
    2894             :         {
    2895        4534 :             isfixed = false;
    2896             :         }
    2897      284600 :         else if (parent->outeropsset && parent->outerops)
    2898             :         {
    2899       35560 :             isfixed = true;
    2900       35560 :             tts_ops = parent->outerops;
    2901       35560 :             desc = ExecGetResultType(os);
    2902             :         }
    2903      249040 :         else if (os)
    2904             :         {
    2905      249028 :             tts_ops = ExecGetResultSlotOps(os, &isfixed);
    2906      249028 :             desc = ExecGetResultType(os);
    2907             :         }
    2908             :     }
    2909      510594 :     else if (opcode == EEOP_SCAN_FETCHSOME)
    2910             :     {
    2911      510594 :         desc = parent->scandesc;
    2912             : 
    2913      510594 :         if (parent->scanops)
    2914      491508 :             tts_ops = parent->scanops;
    2915             : 
    2916      510594 :         if (parent->scanopsset)
    2917      491508 :             isfixed = parent->scanopsfixed;
    2918             :     }
    2919             : 
    2920      995714 :     if (isfixed && desc != NULL && tts_ops != NULL)
    2921             :     {
    2922      933772 :         op->d.fetch.fixed = true;
    2923      933772 :         op->d.fetch.kind = tts_ops;
    2924      933772 :         op->d.fetch.known_desc = desc;
    2925             :     }
    2926             :     else
    2927             :     {
    2928       61942 :         op->d.fetch.fixed = false;
    2929       61942 :         op->d.fetch.kind = NULL;
    2930       61942 :         op->d.fetch.known_desc = NULL;
    2931             :     }
    2932             : 
    2933             :     /* if the slot is known to always virtual we never need to deform */
    2934      995714 :     if (op->d.fetch.fixed && op->d.fetch.kind == &TTSOpsVirtual)
    2935      171858 :         return false;
    2936             : 
    2937      823856 :     return true;
    2938             : }
    2939             : 
    2940             : /*
    2941             :  * Prepare step for the evaluation of a whole-row variable.
    2942             :  * The caller still has to push the step.
    2943             :  */
    2944             : static void
    2945        3540 : ExecInitWholeRowVar(ExprEvalStep *scratch, Var *variable, ExprState *state)
    2946             : {
    2947        3540 :     PlanState  *parent = state->parent;
    2948             : 
    2949             :     /* fill in all but the target */
    2950        3540 :     scratch->opcode = EEOP_WHOLEROW;
    2951        3540 :     scratch->d.wholerow.var = variable;
    2952        3540 :     scratch->d.wholerow.first = true;
    2953        3540 :     scratch->d.wholerow.slow = false;
    2954        3540 :     scratch->d.wholerow.tupdesc = NULL; /* filled at runtime */
    2955        3540 :     scratch->d.wholerow.junkFilter = NULL;
    2956             : 
    2957             :     /*
    2958             :      * If the input tuple came from a subquery, it might contain "resjunk"
    2959             :      * columns (such as GROUP BY or ORDER BY columns), which we don't want to
    2960             :      * keep in the whole-row result.  We can get rid of such columns by
    2961             :      * passing the tuple through a JunkFilter --- but to make one, we have to
    2962             :      * lay our hands on the subquery's targetlist.  Fortunately, there are not
    2963             :      * very many cases where this can happen, and we can identify all of them
    2964             :      * by examining our parent PlanState.  We assume this is not an issue in
    2965             :      * standalone expressions that don't have parent plans.  (Whole-row Vars
    2966             :      * can occur in such expressions, but they will always be referencing
    2967             :      * table rows.)
    2968             :      */
    2969        3540 :     if (parent)
    2970             :     {
    2971        3508 :         PlanState  *subplan = NULL;
    2972             : 
    2973        3508 :         switch (nodeTag(parent))
    2974             :         {
    2975         268 :             case T_SubqueryScanState:
    2976         268 :                 subplan = ((SubqueryScanState *) parent)->subplan;
    2977         268 :                 break;
    2978         166 :             case T_CteScanState:
    2979         166 :                 subplan = ((CteScanState *) parent)->cteplanstate;
    2980         166 :                 break;
    2981        3074 :             default:
    2982        3074 :                 break;
    2983             :         }
    2984             : 
    2985        3508 :         if (subplan)
    2986             :         {
    2987         434 :             bool        junk_filter_needed = false;
    2988             :             ListCell   *tlist;
    2989             : 
    2990             :             /* Detect whether subplan tlist actually has any junk columns */
    2991        1206 :             foreach(tlist, subplan->plan->targetlist)
    2992             :             {
    2993         784 :                 TargetEntry *tle = (TargetEntry *) lfirst(tlist);
    2994             : 
    2995         784 :                 if (tle->resjunk)
    2996             :                 {
    2997          12 :                     junk_filter_needed = true;
    2998          12 :                     break;
    2999             :                 }
    3000             :             }
    3001             : 
    3002             :             /* If so, build the junkfilter now */
    3003         434 :             if (junk_filter_needed)
    3004             :             {
    3005          12 :                 scratch->d.wholerow.junkFilter =
    3006          12 :                     ExecInitJunkFilter(subplan->plan->targetlist,
    3007             :                                        ExecInitExtraTupleSlot(parent->state, NULL,
    3008             :                                                               &TTSOpsVirtual));
    3009             :             }
    3010             :         }
    3011             :     }
    3012        3540 : }
    3013             : 
    3014             : /*
    3015             :  * Prepare evaluation of a SubscriptingRef expression.
    3016             :  */
    3017             : static void
    3018       21198 : ExecInitSubscriptingRef(ExprEvalStep *scratch, SubscriptingRef *sbsref,
    3019             :                         ExprState *state, Datum *resv, bool *resnull)
    3020             : {
    3021       21198 :     bool        isAssignment = (sbsref->refassgnexpr != NULL);
    3022       21198 :     int         nupper = list_length(sbsref->refupperindexpr);
    3023       21198 :     int         nlower = list_length(sbsref->reflowerindexpr);
    3024             :     const SubscriptRoutines *sbsroutines;
    3025             :     SubscriptingRefState *sbsrefstate;
    3026             :     SubscriptExecSteps methods;
    3027             :     char       *ptr;
    3028       21198 :     List       *adjust_jumps = NIL;
    3029             :     ListCell   *lc;
    3030             :     int         i;
    3031             : 
    3032             :     /* Look up the subscripting support methods */
    3033       21198 :     sbsroutines = getSubscriptingRoutines(sbsref->refcontainertype, NULL);
    3034       21198 :     if (!sbsroutines)
    3035           0 :         ereport(ERROR,
    3036             :                 (errcode(ERRCODE_DATATYPE_MISMATCH),
    3037             :                  errmsg("cannot subscript type %s because it does not support subscripting",
    3038             :                         format_type_be(sbsref->refcontainertype)),
    3039             :                  state->parent ?
    3040             :                  executor_errposition(state->parent->state,
    3041             :                                       exprLocation((Node *) sbsref)) : 0));
    3042             : 
    3043             :     /* Allocate sbsrefstate, with enough space for per-subscript arrays too */
    3044       21198 :     sbsrefstate = palloc0(MAXALIGN(sizeof(SubscriptingRefState)) +
    3045       21198 :                           (nupper + nlower) * (sizeof(Datum) +
    3046             :                                                2 * sizeof(bool)));
    3047             : 
    3048             :     /* Fill constant fields of SubscriptingRefState */
    3049       21198 :     sbsrefstate->isassignment = isAssignment;
    3050       21198 :     sbsrefstate->numupper = nupper;
    3051       21198 :     sbsrefstate->numlower = nlower;
    3052             :     /* Set up per-subscript arrays */
    3053       21198 :     ptr = ((char *) sbsrefstate) + MAXALIGN(sizeof(SubscriptingRefState));
    3054       21198 :     sbsrefstate->upperindex = (Datum *) ptr;
    3055       21198 :     ptr += nupper * sizeof(Datum);
    3056       21198 :     sbsrefstate->lowerindex = (Datum *) ptr;
    3057       21198 :     ptr += nlower * sizeof(Datum);
    3058       21198 :     sbsrefstate->upperprovided = (bool *) ptr;
    3059       21198 :     ptr += nupper * sizeof(bool);
    3060       21198 :     sbsrefstate->lowerprovided = (bool *) ptr;
    3061       21198 :     ptr += nlower * sizeof(bool);
    3062       21198 :     sbsrefstate->upperindexnull = (bool *) ptr;
    3063       21198 :     ptr += nupper * sizeof(bool);
    3064       21198 :     sbsrefstate->lowerindexnull = (bool *) ptr;
    3065             :     /* ptr += nlower * sizeof(bool); */
    3066             : 
    3067             :     /*
    3068             :      * Let the container-type-specific code have a chance.  It must fill the
    3069             :      * "methods" struct with function pointers for us to possibly use in
    3070             :      * execution steps below; and it can optionally set up some data pointed
    3071             :      * to by the workspace field.
    3072             :      */
    3073       21198 :     memset(&methods, 0, sizeof(methods));
    3074       21198 :     sbsroutines->exec_setup(sbsref, sbsrefstate, &methods);
    3075             : 
    3076             :     /*
    3077             :      * Evaluate array input.  It's safe to do so into resv/resnull, because we
    3078             :      * won't use that as target for any of the other subexpressions, and it'll
    3079             :      * be overwritten by the final EEOP_SBSREF_FETCH/ASSIGN step, which is
    3080             :      * pushed last.
    3081             :      */
    3082       21198 :     ExecInitExprRec(sbsref->refexpr, state, resv, resnull);
    3083             : 
    3084             :     /*
    3085             :      * If refexpr yields NULL, and the operation should be strict, then result
    3086             :      * is NULL.  We can implement this with just JUMP_IF_NULL, since we
    3087             :      * evaluated the array into the desired target location.
    3088             :      */
    3089       21198 :     if (!isAssignment && sbsroutines->fetch_strict)
    3090             :     {
    3091       20088 :         scratch->opcode = EEOP_JUMP_IF_NULL;
    3092       20088 :         scratch->d.jump.jumpdone = -1;   /* adjust later */
    3093       20088 :         ExprEvalPushStep(state, scratch);
    3094       20088 :         adjust_jumps = lappend_int(adjust_jumps,
    3095       20088 :                                    state->steps_len - 1);
    3096             :     }
    3097             : 
    3098             :     /* Evaluate upper subscripts */
    3099       21198 :     i = 0;
    3100       42980 :     foreach(lc, sbsref->refupperindexpr)
    3101             :     {
    3102       21782 :         Expr       *e = (Expr *) lfirst(lc);
    3103             : 
    3104             :         /* When slicing, individual subscript bounds can be omitted */
    3105       21782 :         if (!e)
    3106             :         {
    3107          78 :             sbsrefstate->upperprovided[i] = false;
    3108          78 :             sbsrefstate->upperindexnull[i] = true;
    3109             :         }
    3110             :         else
    3111             :         {
    3112       21704 :             sbsrefstate->upperprovided[i] = true;
    3113             :             /* Each subscript is evaluated into appropriate array entry */
    3114       21704 :             ExecInitExprRec(e, state,
    3115       21704 :                             &sbsrefstate->upperindex[i],
    3116       21704 :                             &sbsrefstate->upperindexnull[i]);
    3117             :         }
    3118       21782 :         i++;
    3119             :     }
    3120             : 
    3121             :     /* Evaluate lower subscripts similarly */
    3122       21198 :     i = 0;
    3123       21762 :     foreach(lc, sbsref->reflowerindexpr)
    3124             :     {
    3125         564 :         Expr       *e = (Expr *) lfirst(lc);
    3126             : 
    3127             :         /* When slicing, individual subscript bounds can be omitted */
    3128         564 :         if (!e)
    3129             :         {
    3130          78 :             sbsrefstate->lowerprovided[i] = false;
    3131          78 :             sbsrefstate->lowerindexnull[i] = true;
    3132             :         }
    3133             :         else
    3134             :         {
    3135         486 :             sbsrefstate->lowerprovided[i] = true;
    3136             :             /* Each subscript is evaluated into appropriate array entry */
    3137         486 :             ExecInitExprRec(e, state,
    3138         486 :                             &sbsrefstate->lowerindex[i],
    3139         486 :                             &sbsrefstate->lowerindexnull[i]);
    3140             :         }
    3141         564 :         i++;
    3142             :     }
    3143             : 
    3144             :     /* SBSREF_SUBSCRIPTS checks and converts all the subscripts at once */
    3145       21198 :     if (methods.sbs_check_subscripts)
    3146             :     {
    3147       21184 :         scratch->opcode = EEOP_SBSREF_SUBSCRIPTS;
    3148       21184 :         scratch->d.sbsref_subscript.subscriptfunc = methods.sbs_check_subscripts;
    3149       21184 :         scratch->d.sbsref_subscript.state = sbsrefstate;
    3150       21184 :         scratch->d.sbsref_subscript.jumpdone = -1;   /* adjust later */
    3151       21184 :         ExprEvalPushStep(state, scratch);
    3152       21184 :         adjust_jumps = lappend_int(adjust_jumps,
    3153       21184 :                                    state->steps_len - 1);
    3154             :     }
    3155             : 
    3156       21198 :     if (isAssignment)
    3157             :     {
    3158             :         Datum      *save_innermost_caseval;
    3159             :         bool       *save_innermost_casenull;
    3160             : 
    3161             :         /* Check for unimplemented methods */
    3162        1110 :         if (!methods.sbs_assign)
    3163           0 :             ereport(ERROR,
    3164             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    3165             :                      errmsg("type %s does not support subscripted assignment",
    3166             :                             format_type_be(sbsref->refcontainertype))));
    3167             : 
    3168             :         /*
    3169             :          * We might have a nested-assignment situation, in which the
    3170             :          * refassgnexpr is itself a FieldStore or SubscriptingRef that needs
    3171             :          * to obtain and modify the previous value of the array element or
    3172             :          * slice being replaced.  If so, we have to extract that value from
    3173             :          * the array and pass it down via the CaseTestExpr mechanism.  It's
    3174             :          * safe to reuse the CASE mechanism because there cannot be a CASE
    3175             :          * between here and where the value would be needed, and an array
    3176             :          * assignment can't be within a CASE either.  (So saving and restoring
    3177             :          * innermost_caseval is just paranoia, but let's do it anyway.)
    3178             :          *
    3179             :          * Since fetching the old element might be a nontrivial expense, do it
    3180             :          * only if the argument actually needs it.
    3181             :          */
    3182        1110 :         if (isAssignmentIndirectionExpr(sbsref->refassgnexpr))
    3183             :         {
    3184         150 :             if (!methods.sbs_fetch_old)
    3185           0 :                 ereport(ERROR,
    3186             :                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    3187             :                          errmsg("type %s does not support subscripted assignment",
    3188             :                                 format_type_be(sbsref->refcontainertype))));
    3189         150 :             scratch->opcode = EEOP_SBSREF_OLD;
    3190         150 :             scratch->d.sbsref.subscriptfunc = methods.sbs_fetch_old;
    3191         150 :             scratch->d.sbsref.state = sbsrefstate;
    3192         150 :             ExprEvalPushStep(state, scratch);
    3193             :         }
    3194             : 
    3195             :         /* SBSREF_OLD puts extracted value into prevvalue/prevnull */
    3196        1110 :         save_innermost_caseval = state->innermost_caseval;
    3197        1110 :         save_innermost_casenull = state->innermost_casenull;
    3198        1110 :         state->innermost_caseval = &sbsrefstate->prevvalue;
    3199        1110 :         state->innermost_casenull = &sbsrefstate->prevnull;
    3200             : 
    3201             :         /* evaluate replacement value into replacevalue/replacenull */
    3202        1110 :         ExecInitExprRec(sbsref->refassgnexpr, state,
    3203             :                         &sbsrefstate->replacevalue, &sbsrefstate->replacenull);
    3204             : 
    3205        1110 :         state->innermost_caseval = save_innermost_caseval;
    3206        1110 :         state->innermost_casenull = save_innermost_casenull;
    3207             : 
    3208             :         /* and perform the assignment */
    3209        1110 :         scratch->opcode = EEOP_SBSREF_ASSIGN;
    3210        1110 :         scratch->d.sbsref.subscriptfunc = methods.sbs_assign;
    3211        1110 :         scratch->d.sbsref.state = sbsrefstate;
    3212        1110 :         ExprEvalPushStep(state, scratch);
    3213             :     }
    3214             :     else
    3215             :     {
    3216             :         /* array fetch is much simpler */
    3217       20088 :         scratch->opcode = EEOP_SBSREF_FETCH;
    3218       20088 :         scratch->d.sbsref.subscriptfunc = methods.sbs_fetch;
    3219       20088 :         scratch->d.sbsref.state = sbsrefstate;
    3220       20088 :         ExprEvalPushStep(state, scratch);
    3221             :     }
    3222             : 
    3223             :     /* adjust jump targets */
    3224       62470 :     foreach(lc, adjust_jumps)
    3225             :     {
    3226       41272 :         ExprEvalStep *as = &state->steps[lfirst_int(lc)];
    3227             : 
    3228       41272 :         if (as->opcode == EEOP_SBSREF_SUBSCRIPTS)
    3229             :         {
    3230             :             Assert(as->d.sbsref_subscript.jumpdone == -1);
    3231       21184 :             as->d.sbsref_subscript.jumpdone = state->steps_len;
    3232             :         }
    3233             :         else
    3234             :         {
    3235             :             Assert(as->opcode == EEOP_JUMP_IF_NULL);
    3236             :             Assert(as->d.jump.jumpdone == -1);
    3237       20088 :             as->d.jump.jumpdone = state->steps_len;
    3238             :         }
    3239             :     }
    3240       21198 : }
    3241             : 
    3242             : /*
    3243             :  * Helper for preparing SubscriptingRef expressions for evaluation: is expr
    3244             :  * a nested FieldStore or SubscriptingRef that needs the old element value
    3245             :  * passed down?
    3246             :  *
    3247             :  * (We could use this in FieldStore too, but in that case passing the old
    3248             :  * value is so cheap there's no need.)
    3249             :  *
    3250             :  * Note: it might seem that this needs to recurse, but in most cases it does
    3251             :  * not; the CaseTestExpr, if any, will be directly the arg or refexpr of the
    3252             :  * top-level node.  Nested-assignment situations give rise to expression
    3253             :  * trees in which each level of assignment has its own CaseTestExpr, and the
    3254             :  * recursive structure appears within the newvals or refassgnexpr field.
    3255             :  * There is an exception, though: if the array is an array-of-domain, we will
    3256             :  * have a CoerceToDomain or RelabelType as the refassgnexpr, and we need to
    3257             :  * be able to look through that.
    3258             :  */
    3259             : static bool
    3260        1158 : isAssignmentIndirectionExpr(Expr *expr)
    3261             : {
    3262        1158 :     if (expr == NULL)
    3263           0 :         return false;           /* just paranoia */
    3264        1158 :     if (IsA(expr, FieldStore))
    3265             :     {
    3266         150 :         FieldStore *fstore = (FieldStore *) expr;
    3267             : 
    3268         150 :         if (fstore->arg && IsA(fstore->arg, CaseTestExpr))
    3269         150 :             return true;
    3270             :     }
    3271        1008 :     else if (IsA(expr, SubscriptingRef))
    3272             :     {
    3273          32 :         SubscriptingRef *sbsRef = (SubscriptingRef *) expr;
    3274             : 
    3275          32 :         if (sbsRef->refexpr && IsA(sbsRef->refexpr, CaseTestExpr))
    3276           0 :             return true;
    3277             :     }
    3278         976 :     else if (IsA(expr, CoerceToDomain))
    3279             :     {
    3280          30 :         CoerceToDomain *cd = (CoerceToDomain *) expr;
    3281             : 
    3282          30 :         return isAssignmentIndirectionExpr(cd->arg);
    3283             :     }
    3284         946 :     else if (IsA(expr, RelabelType))
    3285             :     {
    3286          18 :         RelabelType *r = (RelabelType *) expr;
    3287             : 
    3288          18 :         return isAssignmentIndirectionExpr(r->arg);
    3289             :     }
    3290         960 :     return false;
    3291             : }
    3292             : 
    3293             : /*
    3294             :  * Prepare evaluation of a CoerceToDomain expression.
    3295             :  */
    3296             : static void
    3297        6744 : ExecInitCoerceToDomain(ExprEvalStep *scratch, CoerceToDomain *ctest,
    3298             :                        ExprState *state, Datum *resv, bool *resnull)
    3299             : {
    3300             :     DomainConstraintRef *constraint_ref;
    3301        6744 :     Datum      *domainval = NULL;
    3302        6744 :     bool       *domainnull = NULL;
    3303             :     ListCell   *l;
    3304             : 
    3305        6744 :     scratch->d.domaincheck.resulttype = ctest->resulttype;
    3306             :     /* we'll allocate workspace only if needed */
    3307        6744 :     scratch->d.domaincheck.checkvalue = NULL;
    3308        6744 :     scratch->d.domaincheck.checknull = NULL;
    3309             : 
    3310             :     /*
    3311             :      * Evaluate argument - it's fine to directly store it into resv/resnull,
    3312             :      * if there's constraint failures there'll be errors, otherwise it's what
    3313             :      * needs to be returned.
    3314             :      */
    3315        6744 :     ExecInitExprRec(ctest->arg, state, resv, resnull);
    3316             : 
    3317             :     /*
    3318             :      * Note: if the argument is of varlena type, it could be a R/W expanded
    3319             :      * object.  We want to return the R/W pointer as the final result, but we
    3320             :      * have to pass a R/O pointer as the value to be tested by any functions
    3321             :      * in check expressions.  We don't bother to emit a MAKE_READONLY step
    3322             :      * unless there's actually at least one check expression, though.  Until
    3323             :      * we've tested that, domainval/domainnull are NULL.
    3324             :      */
    3325             : 
    3326             :     /*
    3327             :      * Collect the constraints associated with the domain.
    3328             :      *
    3329             :      * Note: before PG v10 we'd recheck the set of constraints during each
    3330             :      * evaluation of the expression.  Now we bake them into the ExprState
    3331             :      * during executor initialization.  That means we don't need typcache.c to
    3332             :      * provide compiled exprs.
    3333             :      */
    3334             :     constraint_ref = (DomainConstraintRef *)
    3335        6744 :         palloc(sizeof(DomainConstraintRef));
    3336        6744 :     InitDomainConstraintRef(ctest->resulttype,
    3337             :                             constraint_ref,
    3338             :                             CurrentMemoryContext,
    3339             :                             false);
    3340             : 
    3341             :     /*
    3342             :      * Compile code to check each domain constraint.  NOTNULL constraints can
    3343             :      * just be applied on the resv/resnull value, but for CHECK constraints we
    3344             :      * need more pushups.
    3345             :      */
    3346       14450 :     foreach(l, constraint_ref->constraints)
    3347             :     {
    3348        7706 :         DomainConstraintState *con = (DomainConstraintState *) lfirst(l);
    3349             :         Datum      *save_innermost_domainval;
    3350             :         bool       *save_innermost_domainnull;
    3351             : 
    3352        7706 :         scratch->d.domaincheck.constraintname = con->name;
    3353             : 
    3354        7706 :         switch (con->constrainttype)
    3355             :         {
    3356         372 :             case DOM_CONSTRAINT_NOTNULL:
    3357         372 :                 scratch->opcode = EEOP_DOMAIN_NOTNULL;
    3358         372 :                 ExprEvalPushStep(state, scratch);
    3359         372 :                 break;
    3360        7334 :             case DOM_CONSTRAINT_CHECK:
    3361             :                 /* Allocate workspace for CHECK output if we didn't yet */
    3362        7334 :                 if (scratch->d.domaincheck.checkvalue == NULL)
    3363             :                 {
    3364        6474 :                     scratch->d.domaincheck.checkvalue =
    3365        6474 :                         (Datum *) palloc(sizeof(Datum));
    3366        6474 :                     scratch->d.domaincheck.checknull =
    3367        6474 :                         (bool *) palloc(sizeof(bool));
    3368             :                 }
    3369             : 
    3370             :                 /*
    3371             :                  * If first time through, determine where CoerceToDomainValue
    3372             :                  * nodes should read from.
    3373             :                  */
    3374        7334 :                 if (domainval == NULL)
    3375             :                 {
    3376             :                     /*
    3377             :                      * Since value might be read multiple times, force to R/O
    3378             :                      * - but only if it could be an expanded datum.
    3379             :                      */
    3380        6474 :                     if (get_typlen(ctest->resulttype) == -1)
    3381             :                     {
    3382        2384 :                         ExprEvalStep scratch2 = {0};
    3383             : 
    3384             :                         /* Yes, so make output workspace for MAKE_READONLY */
    3385        2384 :                         domainval = (Datum *) palloc(sizeof(Datum));
    3386        2384 :                         domainnull = (bool *) palloc(sizeof(bool));
    3387             : 
    3388             :                         /* Emit MAKE_READONLY */
    3389        2384 :                         scratch2.opcode = EEOP_MAKE_READONLY;
    3390        2384 :                         scratch2.resvalue = domainval;
    3391        2384 :                         scratch2.resnull = domainnull;
    3392        2384 :                         scratch2.d.make_readonly.value = resv;
    3393        2384 :                         scratch2.d.make_readonly.isnull = resnull;
    3394        2384 :                         ExprEvalPushStep(state, &scratch2);
    3395             :                     }
    3396             :                     else
    3397             :                     {
    3398             :                         /* No, so it's fine to read from resv/resnull */
    3399        4090 :                         domainval = resv;
    3400        4090 :                         domainnull = resnull;
    3401             :                     }
    3402             :                 }
    3403             : 
    3404             :                 /*
    3405             :                  * Set up value to be returned by CoerceToDomainValue nodes.
    3406             :                  * We must save and restore innermost_domainval/null fields,
    3407             :                  * in case this node is itself within a check expression for
    3408             :                  * another domain.
    3409             :                  */
    3410        7334 :                 save_innermost_domainval = state->innermost_domainval;
    3411        7334 :                 save_innermost_domainnull = state->innermost_domainnull;
    3412        7334 :                 state->innermost_domainval = domainval;
    3413        7334 :                 state->innermost_domainnull = domainnull;
    3414             : 
    3415             :                 /* evaluate check expression value */
    3416        7334 :                 ExecInitExprRec(con->check_expr, state,
    3417             :                                 scratch->d.domaincheck.checkvalue,
    3418             :                                 scratch->d.domaincheck.checknull);
    3419             : 
    3420        7334 :                 state->innermost_domainval = save_innermost_domainval;
    3421        7334 :                 state->innermost_domainnull = save_innermost_domainnull;
    3422             : 
    3423             :                 /* now test result */
    3424        7334 :                 scratch->opcode = EEOP_DOMAIN_CHECK;
    3425        7334 :                 ExprEvalPushStep(state, scratch);
    3426             : 
    3427        7334 :                 break;
    3428           0 :             default:
    3429           0 :                 elog(ERROR, "unrecognized constraint type: %d",
    3430             :                      (int) con->constrainttype);
    3431             :                 break;
    3432             :         }
    3433             :     }
    3434        6744 : }
    3435             : 
    3436             : /*
    3437             :  * Build transition/combine function invocations for all aggregate transition
    3438             :  * / combination function invocations in a grouping sets phase. This has to
    3439             :  * invoke all sort based transitions in a phase (if doSort is true), all hash
    3440             :  * based transitions (if doHash is true), or both (both true).
    3441             :  *
    3442             :  * The resulting expression will, for each set of transition values, first
    3443             :  * check for filters, evaluate aggregate input, check that that input is not
    3444             :  * NULL for a strict transition function, and then finally invoke the
    3445             :  * transition for each of the concurrently computed grouping sets.
    3446             :  *
    3447             :  * If nullcheck is true, the generated code will check for a NULL pointer to
    3448             :  * the array of AggStatePerGroup, and skip evaluation if so.
    3449             :  */
    3450             : ExprState *
    3451       42416 : ExecBuildAggTrans(AggState *aggstate, AggStatePerPhase phase,
    3452             :                   bool doSort, bool doHash, bool nullcheck)
    3453             : {
    3454       42416 :     ExprState  *state = makeNode(ExprState);
    3455       42416 :     PlanState  *parent = &aggstate->ss.ps;
    3456       42416 :     ExprEvalStep scratch = {0};
    3457       42416 :     bool        isCombine = DO_AGGSPLIT_COMBINE(aggstate->aggsplit);
    3458       42416 :     ExprSetupInfo deform = {0, 0, 0, NIL};
    3459             : 
    3460       42416 :     state->expr = (Expr *) aggstate;
    3461       42416 :     state->parent = parent;
    3462             : 
    3463       42416 :     scratch.resvalue = &state->resvalue;
    3464       42416 :     scratch.resnull = &state->resnull;
    3465             : 
    3466             :     /*
    3467             :      * First figure out which slots, and how many columns from each, we're
    3468             :      * going to need.
    3469             :      */
    3470       87392 :     for (int transno = 0; transno < aggstate->numtrans; transno++)
    3471             :     {
    3472       44976 :         AggStatePerTrans pertrans = &aggstate->pertrans[transno];
    3473             : 
    3474       44976 :         expr_setup_walker((Node *) pertrans->aggref->aggdirectargs,
    3475             :                           &deform);
    3476       44976 :         expr_setup_walker((Node *) pertrans->aggref->args,
    3477             :                           &deform);
    3478       44976 :         expr_setup_walker((Node *) pertrans->aggref->aggorder,
    3479             :                           &deform);
    3480       44976 :         expr_setup_walker((Node *) pertrans->aggref->aggdistinct,
    3481             :                           &deform);
    3482       44976 :         expr_setup_walker((Node *) pertrans->aggref->aggfilter,
    3483             :                           &deform);
    3484             :     }
    3485       42416 :     ExecPushExprSetupSteps(state, &deform);
    3486             : 
    3487             :     /*
    3488             :      * Emit instructions for each transition value / grouping set combination.
    3489             :      */
    3490       87392 :     for (int transno = 0; transno < aggstate->numtrans; transno++)
    3491             :     {
    3492       44976 :         AggStatePerTrans pertrans = &aggstate->pertrans[transno];
    3493       44976 :         FunctionCallInfo trans_fcinfo = pertrans->transfn_fcinfo;
    3494       44976 :         List       *adjust_bailout = NIL;
    3495       44976 :         NullableDatum *strictargs = NULL;
    3496       44976 :         bool       *strictnulls = NULL;
    3497             :         int         argno;
    3498             :         ListCell   *bail;
    3499             : 
    3500             :         /*
    3501             :          * If filter present, emit. Do so before evaluating the input, to
    3502             :          * avoid potentially unneeded computations, or even worse, unintended
    3503             :          * side-effects.  When combining, all the necessary filtering has
    3504             :          * already been done.
    3505             :          */
    3506       44976 :         if (pertrans->aggref->aggfilter && !isCombine)
    3507             :         {
    3508             :             /* evaluate filter expression */
    3509         656 :             ExecInitExprRec(pertrans->aggref->aggfilter, state,
    3510             :                             &state->resvalue, &state->resnull);
    3511             :             /* and jump out if false */
    3512         656 :             scratch.opcode = EEOP_JUMP_IF_NOT_TRUE;
    3513         656 :             scratch.d.jump.jumpdone = -1;   /* adjust later */
    3514         656 :             ExprEvalPushStep(state, &scratch);
    3515         656 :             adjust_bailout = lappend_int(adjust_bailout,
    3516         656 :                                          state->steps_len - 1);
    3517             :         }
    3518             : 
    3519             :         /*
    3520             :          * Evaluate arguments to aggregate/combine function.
    3521             :          */
    3522       44976 :         argno = 0;
    3523       44976 :         if (isCombine)
    3524             :         {
    3525             :             /*
    3526             :              * Combining two aggregate transition values. Instead of directly
    3527             :              * coming from a tuple the input is a, potentially deserialized,
    3528             :              * transition value.
    3529             :              */
    3530             :             TargetEntry *source_tle;
    3531             : 
    3532             :             Assert(pertrans->numSortCols == 0);
    3533             :             Assert(list_length(pertrans->aggref->args) == 1);
    3534             : 
    3535        1340 :             strictargs = trans_fcinfo->args + 1;
    3536        1340 :             source_tle = (TargetEntry *) linitial(pertrans->aggref->args);
    3537             : 
    3538             :             /*
    3539             :              * deserialfn_oid will be set if we must deserialize the input
    3540             :              * state before calling the combine function.
    3541             :              */
    3542        1340 :             if (!OidIsValid(pertrans->deserialfn_oid))
    3543             :             {
    3544             :                 /*
    3545             :                  * Start from 1, since the 0th arg will be the transition
    3546             :                  * value
    3547             :                  */
    3548        1220 :                 ExecInitExprRec(source_tle->expr, state,
    3549        1220 :                                 &trans_fcinfo->args[argno + 1].value,
    3550        1220 :                                 &trans_fcinfo->args[argno + 1].isnull);
    3551             :             }
    3552             :             else
    3553             :             {
    3554         120 :                 FunctionCallInfo ds_fcinfo = pertrans->deserialfn_fcinfo;
    3555             : 
    3556             :                 /* evaluate argument */
    3557         120 :                 ExecInitExprRec(source_tle->expr, state,
    3558             :                                 &ds_fcinfo->args[0].value,
    3559             :                                 &ds_fcinfo->args[0].isnull);
    3560             : 
    3561             :                 /* Dummy second argument for type-safety reasons */
    3562         120 :                 ds_fcinfo->args[1].value = PointerGetDatum(NULL);
    3563         120 :                 ds_fcinfo->args[1].isnull = false;
    3564             : 
    3565             :                 /*
    3566             :                  * Don't call a strict deserialization function with NULL
    3567             :                  * input
    3568             :                  */
    3569         120 :                 if (pertrans->deserialfn.fn_strict)
    3570         120 :                     scratch.opcode = EEOP_AGG_STRICT_DESERIALIZE;
    3571             :                 else
    3572           0 :                     scratch.opcode = EEOP_AGG_DESERIALIZE;
    3573             : 
    3574         120 :                 scratch.d.agg_deserialize.fcinfo_data = ds_fcinfo;
    3575         120 :                 scratch.d.agg_deserialize.jumpnull = -1;    /* adjust later */
    3576         120 :                 scratch.resvalue = &trans_fcinfo->args[argno + 1].value;
    3577         120 :                 scratch.resnull = &trans_fcinfo->args[argno + 1].isnull;
    3578             : 
    3579         120 :                 ExprEvalPushStep(state, &scratch);
    3580             :                 /* don't add an adjustment unless the function is strict */
    3581         120 :                 if (pertrans->deserialfn.fn_strict)
    3582         120 :                     adjust_bailout = lappend_int(adjust_bailout,
    3583         120 :                                                  state->steps_len - 1);
    3584             : 
    3585             :                 /* restore normal settings of scratch fields */
    3586         120 :                 scratch.resvalue = &state->resvalue;
    3587         120 :                 scratch.resnull = &state->resnull;
    3588             :             }
    3589        1340 :             argno++;
    3590             : 
    3591             :             Assert(pertrans->numInputs == argno);
    3592             :         }
    3593       43636 :         else if (!pertrans->aggsortrequired)
    3594             :         {
    3595             :             ListCell   *arg;
    3596             : 
    3597             :             /*
    3598             :              * Normal transition function without ORDER BY / DISTINCT or with
    3599             :              * ORDER BY / DISTINCT but the planner has given us pre-sorted
    3600             :              * input.
    3601             :              */
    3602       43366 :             strictargs = trans_fcinfo->args + 1;
    3603             : 
    3604       77552 :             foreach(arg, pertrans->aggref->args)
    3605             :             {
    3606       35196 :                 TargetEntry *source_tle = (TargetEntry *) lfirst(arg);
    3607             : 
    3608             :                 /*
    3609             :                  * Don't initialize args for any ORDER BY clause that might
    3610             :                  * exist in a presorted aggregate.
    3611             :                  */
    3612       35196 :                 if (argno == pertrans->numTransInputs)
    3613        1010 :                     break;
    3614             : 
    3615             :                 /*
    3616             :                  * Start from 1, since the 0th arg will be the transition
    3617             :                  * value
    3618             :                  */
    3619       34186 :                 ExecInitExprRec(source_tle->expr, state,
    3620       34186 :                                 &trans_fcinfo->args[argno + 1].value,
    3621       34186 :                                 &trans_fcinfo->args[argno + 1].isnull);
    3622       34186 :                 argno++;
    3623             :             }
    3624             :             Assert(pertrans->numTransInputs == argno);
    3625             :         }
    3626         270 :         else if (pertrans->numInputs == 1)
    3627             :         {
    3628             :             /*
    3629             :              * Non-presorted DISTINCT and/or ORDER BY case, with a single
    3630             :              * column sorted on.
    3631             :              */
    3632         240 :             TargetEntry *source_tle =
    3633         240 :                 (TargetEntry *) linitial(pertrans->aggref->args);
    3634             : 
    3635             :             Assert(list_length(pertrans->aggref->args) == 1);
    3636             : 
    3637         240 :             ExecInitExprRec(source_tle->expr, state,
    3638             :                             &state->resvalue,
    3639             :                             &state->resnull);
    3640         240 :             strictnulls = &state->resnull;
    3641         240 :             argno++;
    3642             : 
    3643             :             Assert(pertrans->numInputs == argno);
    3644             :         }
    3645             :         else
    3646             :         {
    3647             :             /*
    3648             :              * Non-presorted DISTINCT and/or ORDER BY case, with multiple
    3649             :              * columns sorted on.
    3650             :              */
    3651          30 :             Datum      *values = pertrans->sortslot->tts_values;
    3652          30 :             bool       *nulls = pertrans->sortslot->tts_isnull;
    3653             :             ListCell   *arg;
    3654             : 
    3655          30 :             strictnulls = nulls;
    3656             : 
    3657         114 :             foreach(arg, pertrans->aggref->args)
    3658             :             {
    3659          84 :                 TargetEntry *source_tle = (TargetEntry *) lfirst(arg);
    3660             : 
    3661          84 :                 ExecInitExprRec(source_tle->expr, state,
    3662          84 :                                 &values[argno], &nulls[argno]);
    3663          84 :                 argno++;
    3664             :             }
    3665             :             Assert(pertrans->numInputs == argno);
    3666             :         }
    3667             : 
    3668             :         /*
    3669             :          * For a strict transfn, nothing happens when there's a NULL input; we
    3670             :          * just keep the prior transValue. This is true for both plain and
    3671             :          * sorted/distinct aggregates.
    3672             :          */
    3673       44976 :         if (trans_fcinfo->flinfo->fn_strict && pertrans->numTransInputs > 0)
    3674             :         {
    3675       10316 :             if (strictnulls)
    3676         162 :                 scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_NULLS;
    3677             :             else
    3678       10154 :                 scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_ARGS;
    3679       10316 :             scratch.d.agg_strict_input_check.nulls = strictnulls;
    3680       10316 :             scratch.d.agg_strict_input_check.args = strictargs;
    3681       10316 :             scratch.d.agg_strict_input_check.jumpnull = -1; /* adjust later */
    3682       10316 :             scratch.d.agg_strict_input_check.nargs = pertrans->numTransInputs;
    3683       10316 :             ExprEvalPushStep(state, &scratch);
    3684       10316 :             adjust_bailout = lappend_int(adjust_bailout,
    3685       10316 :                                          state->steps_len - 1);
    3686             :         }
    3687             : 
    3688             :         /* Handle DISTINCT aggregates which have pre-sorted input */
    3689       44976 :         if (pertrans->numDistinctCols > 0 && !pertrans->aggsortrequired)
    3690             :         {
    3691         390 :             if (pertrans->numDistinctCols > 1)
    3692          90 :                 scratch.opcode = EEOP_AGG_PRESORTED_DISTINCT_MULTI;
    3693             :             else
    3694         300 :                 scratch.opcode = EEOP_AGG_PRESORTED_DISTINCT_SINGLE;
    3695             : 
    3696         390 :             scratch.d.agg_presorted_distinctcheck.pertrans = pertrans;
    3697         390 :             scratch.d.agg_presorted_distinctcheck.jumpdistinct = -1;    /* adjust later */
    3698         390 :             ExprEvalPushStep(state, &scratch);
    3699         390 :             adjust_bailout = lappend_int(adjust_bailout,
    3700         390 :                                          state->steps_len - 1);
    3701             :         }
    3702             : 
    3703             :         /*
    3704             :          * Call transition function (once for each concurrently evaluated
    3705             :          * grouping set). Do so for both sort and hash based computations, as
    3706             :          * applicable.
    3707             :          */
    3708       44976 :         if (doSort)
    3709             :         {
    3710       38914 :             int         processGroupingSets = Max(phase->numsets, 1);
    3711       38914 :             int         setoff = 0;
    3712             : 
    3713       78938 :             for (int setno = 0; setno < processGroupingSets; setno++)
    3714             :             {
    3715       40024 :                 ExecBuildAggTransCall(state, aggstate, &scratch, trans_fcinfo,
    3716             :                                       pertrans, transno, setno, setoff, false,
    3717             :                                       nullcheck);
    3718       40024 :                 setoff++;
    3719             :             }
    3720             :         }
    3721             : 
    3722       44976 :         if (doHash)
    3723             :         {
    3724        6436 :             int         numHashes = aggstate->num_hashes;
    3725             :             int         setoff;
    3726             : 
    3727             :             /* in MIXED mode, there'll be preceding transition values */
    3728        6436 :             if (aggstate->aggstrategy != AGG_HASHED)
    3729         398 :                 setoff = aggstate->maxsets;
    3730             :             else
    3731        6038 :                 setoff = 0;
    3732             : 
    3733       14082 :             for (int setno = 0; setno < numHashes; setno++)
    3734             :             {
    3735        7646 :                 ExecBuildAggTransCall(state, aggstate, &scratch, trans_fcinfo,
    3736             :                                       pertrans, transno, setno, setoff, true,
    3737             :                                       nullcheck);
    3738        7646 :                 setoff++;
    3739             :             }
    3740             :         }
    3741             : 
    3742             :         /* adjust early bail out jump target(s) */
    3743       56458 :         foreach(bail, adjust_bailout)
    3744             :         {
    3745       11482 :             ExprEvalStep *as = &state->steps[lfirst_int(bail)];
    3746             : 
    3747       11482 :             if (as->opcode == EEOP_JUMP_IF_NOT_TRUE)
    3748             :             {
    3749             :                 Assert(as->d.jump.jumpdone == -1);
    3750         656 :                 as->d.jump.jumpdone = state->steps_len;
    3751             :             }
    3752       10826 :             else if (as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_ARGS ||
    3753         672 :                      as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_NULLS)
    3754             :             {
    3755             :                 Assert(as->d.agg_strict_input_check.jumpnull == -1);
    3756       10316 :                 as->d.agg_strict_input_check.jumpnull = state->steps_len;
    3757             :             }
    3758         510 :             else if (as->opcode == EEOP_AGG_STRICT_DESERIALIZE)
    3759             :             {
    3760             :                 Assert(as->d.agg_deserialize.jumpnull == -1);
    3761         120 :                 as->d.agg_deserialize.jumpnull = state->steps_len;
    3762             :             }
    3763         390 :             else if (as->opcode == EEOP_AGG_PRESORTED_DISTINCT_SINGLE ||
    3764          90 :                      as->opcode == EEOP_AGG_PRESORTED_DISTINCT_MULTI)
    3765             :             {
    3766             :                 Assert(as->d.agg_presorted_distinctcheck.jumpdistinct == -1);
    3767         390 :                 as->d.agg_presorted_distinctcheck.jumpdistinct = state->steps_len;
    3768             :             }
    3769             :             else
    3770             :                 Assert(false);
    3771             :         }
    3772             :     }
    3773             : 
    3774       42416 :     scratch.resvalue = NULL;
    3775       42416 :     scratch.resnull = NULL;
    3776       42416 :     scratch.opcode = EEOP_DONE;
    3777       42416 :     ExprEvalPushStep(state, &scratch);
    3778             : 
    3779       42416 :     ExecReadyExpr(state);
    3780             : 
    3781       42416 :     return state;
    3782             : }
    3783             : 
    3784             : /*
    3785             :  * Build transition/combine function invocation for a single transition
    3786             :  * value. This is separated from ExecBuildAggTrans() because there are
    3787             :  * multiple callsites (hash and sort in some grouping set cases).
    3788             :  */
    3789             : static void
    3790       47670 : ExecBuildAggTransCall(ExprState *state, AggState *aggstate,
    3791             :                       ExprEvalStep *scratch,
    3792             :                       FunctionCallInfo fcinfo, AggStatePerTrans pertrans,
    3793             :                       int transno, int setno, int setoff, bool ishash,
    3794             :                       bool nullcheck)
    3795             : {
    3796             :     ExprContext *aggcontext;
    3797       47670 :     int         adjust_jumpnull = -1;
    3798             : 
    3799       47670 :     if (ishash)
    3800        7646 :         aggcontext = aggstate->hashcontext;
    3801             :     else
    3802       40024 :         aggcontext = aggstate->aggcontexts[setno];
    3803             : 
    3804             :     /* add check for NULL pointer? */
    3805       47670 :     if (nullcheck)
    3806             :     {
    3807         408 :         scratch->opcode = EEOP_AGG_PLAIN_PERGROUP_NULLCHECK;
    3808         408 :         scratch->d.agg_plain_pergroup_nullcheck.setoff = setoff;
    3809             :         /* adjust later */
    3810         408 :         scratch->d.agg_plain_pergroup_nullcheck.jumpnull = -1;
    3811         408 :         ExprEvalPushStep(state, scratch);
    3812         408 :         adjust_jumpnull = state->steps_len - 1;
    3813             :     }
    3814             : 
    3815             :     /*
    3816             :      * Determine appropriate transition implementation.
    3817             :      *
    3818             :      * For non-ordered aggregates and ORDER BY / DISTINCT aggregates with
    3819             :      * presorted input:
    3820             :      *
    3821             :      * If the initial value for the transition state doesn't exist in the
    3822             :      * pg_aggregate table then we will let the first non-NULL value returned
    3823             :      * from the outer procNode become the initial value. (This is useful for
    3824             :      * aggregates like max() and min().) The noTransValue flag signals that we
    3825             :      * need to do so. If true, generate a
    3826             :      * EEOP_AGG_INIT_STRICT_PLAIN_TRANS{,_BYVAL} step. This step also needs to
    3827             :      * do the work described next:
    3828             :      *
    3829             :      * If the function is strict, but does have an initial value, choose
    3830             :      * EEOP_AGG_STRICT_PLAIN_TRANS{,_BYVAL}, which skips the transition
    3831             :      * function if the transition value has become NULL (because a previous
    3832             :      * transition function returned NULL). This step also needs to do the work
    3833             :      * described next:
    3834             :      *
    3835             :      * Otherwise we call EEOP_AGG_PLAIN_TRANS{,_BYVAL}, which does not have to
    3836             :      * perform either of the above checks.
    3837             :      *
    3838             :      * Having steps with overlapping responsibilities is not nice, but
    3839             :      * aggregations are very performance sensitive, making this worthwhile.
    3840             :      *
    3841             :      * For ordered aggregates:
    3842             :      *
    3843             :      * Only need to choose between the faster path for a single ordered
    3844             :      * column, and the one between multiple columns. Checking strictness etc
    3845             :      * is done when finalizing the aggregate. See
    3846             :      * process_ordered_aggregate_{single, multi} and
    3847             :      * advance_transition_function.
    3848             :      */
    3849       47670 :     if (!pertrans->aggsortrequired)
    3850             :     {
    3851       47352 :         if (pertrans->transtypeByVal)
    3852             :         {
    3853       43720 :             if (fcinfo->flinfo->fn_strict &&
    3854       22036 :                 pertrans->initValueIsNull)
    3855        4682 :                 scratch->opcode = EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL;
    3856       39038 :             else if (fcinfo->flinfo->fn_strict)
    3857       17354 :                 scratch->opcode = EEOP_AGG_PLAIN_TRANS_STRICT_BYVAL;
    3858             :             else
    3859       21684 :                 scratch->opcode = EEOP_AGG_PLAIN_TRANS_BYVAL;
    3860             :         }
    3861             :         else
    3862             :         {
    3863        3632 :             if (fcinfo->flinfo->fn_strict &&
    3864        3260 :                 pertrans->initValueIsNull)
    3865         900 :                 scratch->opcode = EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYREF;
    3866        2732 :             else if (fcinfo->flinfo->fn_strict)
    3867        2360 :                 scratch->opcode = EEOP_AGG_PLAIN_TRANS_STRICT_BYREF;
    3868             :             else
    3869         372 :                 scratch->opcode = EEOP_AGG_PLAIN_TRANS_BYREF;
    3870             :         }
    3871             :     }
    3872         318 :     else if (pertrans->numInputs == 1)
    3873         276 :         scratch->opcode = EEOP_AGG_ORDERED_TRANS_DATUM;
    3874             :     else
    3875          42 :         scratch->opcode = EEOP_AGG_ORDERED_TRANS_TUPLE;
    3876             : 
    3877       47670 :     scratch->d.agg_trans.pertrans = pertrans;
    3878       47670 :     scratch->d.agg_trans.setno = setno;
    3879       47670 :     scratch->d.agg_trans.setoff = setoff;
    3880       47670 :     scratch->d.agg_trans.transno = transno;
    3881       47670 :     scratch->d.agg_trans.aggcontext = aggcontext;
    3882       47670 :     ExprEvalPushStep(state, scratch);
    3883             : 
    3884             :     /* fix up jumpnull */
    3885       47670 :     if (adjust_jumpnull != -1)
    3886             :     {
    3887         408 :         ExprEvalStep *as = &state->steps[adjust_jumpnull];
    3888             : 
    3889             :         Assert(as->opcode == EEOP_AGG_PLAIN_PERGROUP_NULLCHECK);
    3890             :         Assert(as->d.agg_plain_pergroup_nullcheck.jumpnull == -1);
    3891         408 :         as->d.agg_plain_pergroup_nullcheck.jumpnull = state->steps_len;
    3892             :     }
    3893       47670 : }
    3894             : 
    3895             : /*
    3896             :  * Build equality expression that can be evaluated using ExecQual(), returning
    3897             :  * true if the expression context's inner/outer tuple are NOT DISTINCT. I.e
    3898             :  * two nulls match, a null and a not-null don't match.
    3899             :  *
    3900             :  * desc: tuple descriptor of the to-be-compared tuples
    3901             :  * numCols: the number of attributes to be examined
    3902             :  * keyColIdx: array of attribute column numbers
    3903             :  * eqFunctions: array of function oids of the equality functions to use
    3904             :  * parent: parent executor node
    3905             :  */
    3906             : ExprState *
    3907       16566 : ExecBuildGroupingEqual(TupleDesc ldesc, TupleDesc rdesc,
    3908             :                        const TupleTableSlotOps *lops, const TupleTableSlotOps *rops,
    3909             :                        int numCols,
    3910             :                        const AttrNumber *keyColIdx,
    3911             :                        const Oid *eqfunctions,
    3912             :                        const Oid *collations,
    3913             :                        PlanState *parent)
    3914             : {
    3915       16566 :     ExprState  *state = makeNode(ExprState);
    3916       16566 :     ExprEvalStep scratch = {0};
    3917       16566 :     int         maxatt = -1;
    3918       16566 :     List       *adjust_jumps = NIL;
    3919             :     ListCell   *lc;
    3920             : 
    3921             :     /*
    3922             :      * When no columns are actually compared, the result's always true. See
    3923             :      * special case in ExecQual().
    3924             :      */
    3925       16566 :     if (numCols == 0)
    3926          48 :         return NULL;
    3927             : 
    3928       16518 :     state->expr = NULL;
    3929       16518 :     state->flags = EEO_FLAG_IS_QUAL;
    3930       16518 :     state->parent = parent;
    3931             : 
    3932       16518 :     scratch.resvalue = &state->resvalue;
    3933       16518 :     scratch.resnull = &state->resnull;
    3934             : 
    3935             :     /* compute max needed attribute */
    3936       43754 :     for (int natt = 0; natt < numCols; natt++)
    3937             :     {
    3938       27236 :         int         attno = keyColIdx[natt];
    3939             : 
    3940       27236 :         if (attno > maxatt)
    3941       26996 :             maxatt = attno;
    3942             :     }
    3943             :     Assert(maxatt >= 0);
    3944             : 
    3945             :     /* push deform steps */
    3946       16518 :     scratch.opcode = EEOP_INNER_FETCHSOME;
    3947       16518 :     scratch.d.fetch.last_var = maxatt;
    3948       16518 :     scratch.d.fetch.fixed = false;
    3949       16518 :     scratch.d.fetch.known_desc = ldesc;
    3950       16518 :     scratch.d.fetch.kind = lops;
    3951       16518 :     if (ExecComputeSlotInfo(state, &scratch))
    3952       15520 :         ExprEvalPushStep(state, &scratch);
    3953             : 
    3954       16518 :     scratch.opcode = EEOP_OUTER_FETCHSOME;
    3955       16518 :     scratch.d.fetch.last_var = maxatt;
    3956       16518 :     scratch.d.fetch.fixed = false;
    3957       16518 :     scratch.d.fetch.known_desc = rdesc;
    3958       16518 :     scratch.d.fetch.kind = rops;
    3959       16518 :     if (ExecComputeSlotInfo(state, &scratch))
    3960       16518 :         ExprEvalPushStep(state, &scratch);
    3961             : 
    3962             :     /*
    3963             :      * Start comparing at the last field (least significant sort key). That's
    3964             :      * the most likely to be different if we are dealing with sorted input.
    3965             :      */
    3966       43754 :     for (int natt = numCols; --natt >= 0;)
    3967             :     {
    3968       27236 :         int         attno = keyColIdx[natt];
    3969       27236 :         Form_pg_attribute latt = TupleDescAttr(ldesc, attno - 1);
    3970       27236 :         Form_pg_attribute ratt = TupleDescAttr(rdesc, attno - 1);
    3971       27236 :         Oid         foid = eqfunctions[natt];
    3972       27236 :         Oid         collid = collations[natt];
    3973             :         FmgrInfo   *finfo;
    3974             :         FunctionCallInfo fcinfo;
    3975             :         AclResult   aclresult;
    3976             : 
    3977             :         /* Check permission to call function */
    3978       27236 :         aclresult = object_aclcheck(ProcedureRelationId, foid, GetUserId(), ACL_EXECUTE);
    3979       27236 :         if (aclresult != ACLCHECK_OK)
    3980           0 :             aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(foid));
    3981             : 
    3982       27236 :         InvokeFunctionExecuteHook(foid);
    3983             : 
    3984             :         /* Set up the primary fmgr lookup information */
    3985       27236 :         finfo = palloc0(sizeof(FmgrInfo));
    3986       27236 :         fcinfo = palloc0(SizeForFunctionCallInfo(2));
    3987       27236 :         fmgr_info(foid, finfo);
    3988       27236 :         fmgr_info_set_expr(NULL, finfo);
    3989       27236 :         InitFunctionCallInfoData(*fcinfo, finfo, 2,
    3990             :                                  collid, NULL, NULL);
    3991             : 
    3992             :         /* left arg */
    3993       27236 :         scratch.opcode = EEOP_INNER_VAR;
    3994       27236 :         scratch.d.var.attnum = attno - 1;
    3995       27236 :         scratch.d.var.vartype = latt->atttypid;
    3996       27236 :         scratch.resvalue = &fcinfo->args[0].value;
    3997       27236 :         scratch.resnull = &fcinfo->args[0].isnull;
    3998       27236 :         ExprEvalPushStep(state, &scratch);
    3999             : 
    4000             :         /* right arg */
    4001       27236 :         scratch.opcode = EEOP_OUTER_VAR;
    4002       27236 :         scratch.d.var.attnum = attno - 1;
    4003       27236 :         scratch.d.var.vartype = ratt->atttypid;
    4004       27236 :         scratch.resvalue = &fcinfo->args[1].value;
    4005       27236 :         scratch.resnull = &fcinfo->args[1].isnull;
    4006       27236 :         ExprEvalPushStep(state, &scratch);
    4007             : 
    4008             :         /* evaluate distinctness */
    4009       27236 :         scratch.opcode = EEOP_NOT_DISTINCT;
    4010       27236 :         scratch.d.func.finfo = finfo;
    4011       27236 :         scratch.d.func.fcinfo_data = fcinfo;
    4012       27236 :         scratch.d.func.fn_addr = finfo->fn_addr;
    4013       27236 :         scratch.d.func.nargs = 2;
    4014       27236 :         scratch.resvalue = &state->resvalue;
    4015       27236 :         scratch.resnull = &state->resnull;
    4016       27236 :         ExprEvalPushStep(state, &scratch);
    4017             : 
    4018             :         /* then emit EEOP_QUAL to detect if result is false (or null) */
    4019       27236 :         scratch.opcode = EEOP_QUAL;
    4020       27236 :         scratch.d.qualexpr.jumpdone = -1;
    4021       27236 :         scratch.resvalue = &state->resvalue;
    4022       27236 :         scratch.resnull = &state->resnull;
    4023       27236 :         ExprEvalPushStep(state, &scratch);
    4024       27236 :         adjust_jumps = lappend_int(adjust_jumps,
    4025       27236 :                                    state->steps_len - 1);
    4026             :     }
    4027             : 
    4028             :     /* adjust jump targets */
    4029       43754 :     foreach(lc, adjust_jumps)
    4030             :     {
    4031       27236 :         ExprEvalStep *as = &state->steps[lfirst_int(lc)];
    4032             : 
    4033             :         Assert(as->opcode == EEOP_QUAL);
    4034             :         Assert(as->d.qualexpr.jumpdone == -1);
    4035       27236 :         as->d.qualexpr.jumpdone = state->steps_len;
    4036             :     }
    4037             : 
    4038       16518 :     scratch.resvalue = NULL;
    4039       16518 :     scratch.resnull = NULL;
    4040       16518 :     scratch.opcode = EEOP_DONE;
    4041       16518 :     ExprEvalPushStep(state, &scratch);
    4042             : 
    4043       16518 :     ExecReadyExpr(state);
    4044             : 
    4045       16518 :     return state;
    4046             : }
    4047             : 
    4048             : /*
    4049             :  * Build equality expression that can be evaluated using ExecQual(), returning
    4050             :  * true if the expression context's inner/outer tuples are equal.  Datums in
    4051             :  * the inner/outer slots are assumed to be in the same order and quantity as
    4052             :  * the 'eqfunctions' parameter.  NULLs are treated as equal.
    4053             :  *
    4054             :  * desc: tuple descriptor of the to-be-compared tuples
    4055             :  * lops: the slot ops for the inner tuple slots
    4056             :  * rops: the slot ops for the outer tuple slots
    4057             :  * eqFunctions: array of function oids of the equality functions to use
    4058             :  * this must be the same length as the 'param_exprs' list.
    4059             :  * collations: collation Oids to use for equality comparison. Must be the
    4060             :  * same length as the 'param_exprs' list.
    4061             :  * parent: parent executor node
    4062             :  */
    4063             : ExprState *
    4064        1202 : ExecBuildParamSetEqual(TupleDesc desc,
    4065             :                        const TupleTableSlotOps *lops,
    4066             :                        const TupleTableSlotOps *rops,
    4067             :                        const Oid *eqfunctions,
    4068             :                        const Oid *collations,
    4069             :                        const List *param_exprs,
    4070             :                        PlanState *parent)
    4071             : {
    4072        1202 :     ExprState  *state = makeNode(ExprState);
    4073        1202 :     ExprEvalStep scratch = {0};
    4074        1202 :     int         maxatt = list_length(param_exprs);
    4075        1202 :     List       *adjust_jumps = NIL;
    4076             :     ListCell   *lc;
    4077             : 
    4078        1202 :     state->expr = NULL;
    4079        1202 :     state->flags = EEO_FLAG_IS_QUAL;
    4080        1202 :     state->parent = parent;
    4081             : 
    4082        1202 :     scratch.resvalue = &state->resvalue;
    4083        1202 :     scratch.resnull = &state->resnull;
    4084             : 
    4085             :     /* push deform steps */
    4086        1202 :     scratch.opcode = EEOP_INNER_FETCHSOME;
    4087        1202 :     scratch.d.fetch.last_var = maxatt;
    4088        1202 :     scratch.d.fetch.fixed = false;
    4089        1202 :     scratch.d.fetch.known_desc = desc;
    4090        1202 :     scratch.d.fetch.kind = lops;
    4091        1202 :     if (ExecComputeSlotInfo(state, &scratch))
    4092        1202 :         ExprEvalPushStep(state, &scratch);
    4093             : 
    4094        1202 :     scratch.opcode = EEOP_OUTER_FETCHSOME;
    4095        1202 :     scratch.d.fetch.last_var = maxatt;
    4096        1202 :     scratch.d.fetch.fixed = false;
    4097        1202 :     scratch.d.fetch.known_desc = desc;
    4098        1202 :     scratch.d.fetch.kind = rops;
    4099        1202 :     if (ExecComputeSlotInfo(state, &scratch))
    4100           0 :         ExprEvalPushStep(state, &scratch);
    4101             : 
    4102        2422 :     for (int attno = 0; attno < maxatt; attno++)
    4103             :     {
    4104        1220 :         Form_pg_attribute att = TupleDescAttr(desc, attno);
    4105        1220 :         Oid         foid = eqfunctions[attno];
    4106        1220 :         Oid         collid = collations[attno];
    4107             :         FmgrInfo   *finfo;
    4108             :         FunctionCallInfo fcinfo;
    4109             :         AclResult   aclresult;
    4110             : 
    4111             :         /* Check permission to call function */
    4112        1220 :         aclresult = object_aclcheck(ProcedureRelationId, foid, GetUserId(), ACL_EXECUTE);
    4113        1220 :         if (aclresult != ACLCHECK_OK)
    4114           0 :             aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(foid));
    4115             : 
    4116        1220 :         InvokeFunctionExecuteHook(foid);
    4117             : 
    4118             :         /* Set up the primary fmgr lookup information */
    4119        1220 :         finfo = palloc0(sizeof(FmgrInfo));
    4120        1220 :         fcinfo = palloc0(SizeForFunctionCallInfo(2));
    4121        1220 :         fmgr_info(foid, finfo);
    4122        1220 :         fmgr_info_set_expr(NULL, finfo);
    4123        1220 :         InitFunctionCallInfoData(*fcinfo, finfo, 2,
    4124             :                                  collid, NULL, NULL);
    4125             : 
    4126             :         /* left arg */
    4127        1220 :         scratch.opcode = EEOP_INNER_VAR;
    4128        1220 :         scratch.d.var.attnum = attno;
    4129        1220 :         scratch.d.var.vartype = att->atttypid;
    4130        1220 :         scratch.resvalue = &fcinfo->args[0].value;
    4131        1220 :         scratch.resnull = &fcinfo->args[0].isnull;
    4132        1220 :         ExprEvalPushStep(state, &scratch);
    4133             : 
    4134             :         /* right arg */
    4135        1220 :         scratch.opcode = EEOP_OUTER_VAR;
    4136        1220 :         scratch.d.var.attnum = attno;
    4137        1220 :         scratch.d.var.vartype = att->atttypid;
    4138        1220 :         scratch.resvalue = &fcinfo->args[1].value;
    4139        1220 :         scratch.resnull = &fcinfo->args[1].isnull;
    4140        1220 :         ExprEvalPushStep(state, &scratch);
    4141             : 
    4142             :         /* evaluate distinctness */
    4143        1220 :         scratch.opcode = EEOP_NOT_DISTINCT;
    4144        1220 :         scratch.d.func.finfo = finfo;
    4145        1220 :         scratch.d.func.fcinfo_data = fcinfo;
    4146        1220 :         scratch.d.func.fn_addr = finfo->fn_addr;
    4147        1220 :         scratch.d.func.nargs = 2;
    4148        1220 :         scratch.resvalue = &state->resvalue;
    4149        1220 :         scratch.resnull = &state->resnull;
    4150        1220 :         ExprEvalPushStep(state, &scratch);
    4151             : 
    4152             :         /* then emit EEOP_QUAL to detect if result is false (or null) */
    4153        1220 :         scratch.opcode = EEOP_QUAL;
    4154        1220 :         scratch.d.qualexpr.jumpdone = -1;
    4155        1220 :         scratch.resvalue = &state->resvalue;
    4156        1220 :         scratch.resnull = &state->resnull;
    4157        1220 :         ExprEvalPushStep(state, &scratch);
    4158        1220 :         adjust_jumps = lappend_int(adjust_jumps,
    4159        1220 :                                    state->steps_len - 1);
    4160             :     }
    4161             : 
    4162             :     /* adjust jump targets */
    4163        2422 :     foreach(lc, adjust_jumps)
    4164             :     {
    4165        1220 :         ExprEvalStep *as = &state->steps[lfirst_int(lc)];
    4166             : 
    4167             :         Assert(as->opcode == EEOP_QUAL);
    4168             :         Assert(as->d.qualexpr.jumpdone == -1);
    4169        1220 :         as->d.qualexpr.jumpdone = state->steps_len;
    4170             :     }
    4171             : 
    4172        1202 :     scratch.resvalue = NULL;
    4173        1202 :     scratch.resnull = NULL;
    4174        1202 :     scratch.opcode = EEOP_DONE;
    4175        1202 :     ExprEvalPushStep(state, &scratch);
    4176             : 
    4177        1202 :     ExecReadyExpr(state);
    4178             : 
    4179        1202 :     return state;
    4180             : }

Generated by: LCOV version 1.14