LCOV - code coverage report
Current view: top level - src/backend/executor - execMain.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 783 848 92.3 %
Date: 2019-09-19 02:07:14 Functions: 40 40 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * execMain.c
       4             :  *    top level executor interface routines
       5             :  *
       6             :  * INTERFACE ROUTINES
       7             :  *  ExecutorStart()
       8             :  *  ExecutorRun()
       9             :  *  ExecutorFinish()
      10             :  *  ExecutorEnd()
      11             :  *
      12             :  *  These four procedures are the external interface to the executor.
      13             :  *  In each case, the query descriptor is required as an argument.
      14             :  *
      15             :  *  ExecutorStart must be called at the beginning of execution of any
      16             :  *  query plan and ExecutorEnd must always be called at the end of
      17             :  *  execution of a plan (unless it is aborted due to error).
      18             :  *
      19             :  *  ExecutorRun accepts direction and count arguments that specify whether
      20             :  *  the plan is to be executed forwards, backwards, and for how many tuples.
      21             :  *  In some cases ExecutorRun may be called multiple times to process all
      22             :  *  the tuples for a plan.  It is also acceptable to stop short of executing
      23             :  *  the whole plan (but only if it is a SELECT).
      24             :  *
      25             :  *  ExecutorFinish must be called after the final ExecutorRun call and
      26             :  *  before ExecutorEnd.  This can be omitted only in case of EXPLAIN,
      27             :  *  which should also omit ExecutorRun.
      28             :  *
      29             :  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
      30             :  * Portions Copyright (c) 1994, Regents of the University of California
      31             :  *
      32             :  *
      33             :  * IDENTIFICATION
      34             :  *    src/backend/executor/execMain.c
      35             :  *
      36             :  *-------------------------------------------------------------------------
      37             :  */
      38             : #include "postgres.h"
      39             : 
      40             : #include "access/heapam.h"
      41             : #include "access/htup_details.h"
      42             : #include "access/sysattr.h"
      43             : #include "access/tableam.h"
      44             : #include "access/transam.h"
      45             : #include "access/xact.h"
      46             : #include "catalog/namespace.h"
      47             : #include "catalog/pg_publication.h"
      48             : #include "commands/matview.h"
      49             : #include "commands/trigger.h"
      50             : #include "executor/execdebug.h"
      51             : #include "executor/nodeSubplan.h"
      52             : #include "foreign/fdwapi.h"
      53             : #include "jit/jit.h"
      54             : #include "mb/pg_wchar.h"
      55             : #include "miscadmin.h"
      56             : #include "parser/parsetree.h"
      57             : #include "storage/bufmgr.h"
      58             : #include "storage/lmgr.h"
      59             : #include "tcop/utility.h"
      60             : #include "utils/acl.h"
      61             : #include "utils/lsyscache.h"
      62             : #include "utils/memutils.h"
      63             : #include "utils/partcache.h"
      64             : #include "utils/rls.h"
      65             : #include "utils/ruleutils.h"
      66             : #include "utils/snapmgr.h"
      67             : 
      68             : 
      69             : /* Hooks for plugins to get control in ExecutorStart/Run/Finish/End */
      70             : ExecutorStart_hook_type ExecutorStart_hook = NULL;
      71             : ExecutorRun_hook_type ExecutorRun_hook = NULL;
      72             : ExecutorFinish_hook_type ExecutorFinish_hook = NULL;
      73             : ExecutorEnd_hook_type ExecutorEnd_hook = NULL;
      74             : 
      75             : /* Hook for plugin to get control in ExecCheckRTPerms() */
      76             : ExecutorCheckPerms_hook_type ExecutorCheckPerms_hook = NULL;
      77             : 
      78             : /* decls for local routines only used within this module */
      79             : static void InitPlan(QueryDesc *queryDesc, int eflags);
      80             : static void CheckValidRowMarkRel(Relation rel, RowMarkType markType);
      81             : static void ExecPostprocessPlan(EState *estate);
      82             : static void ExecEndPlan(PlanState *planstate, EState *estate);
      83             : static void ExecutePlan(EState *estate, PlanState *planstate,
      84             :                         bool use_parallel_mode,
      85             :                         CmdType operation,
      86             :                         bool sendTuples,
      87             :                         uint64 numberTuples,
      88             :                         ScanDirection direction,
      89             :                         DestReceiver *dest,
      90             :                         bool execute_once);
      91             : static bool ExecCheckRTEPerms(RangeTblEntry *rte);
      92             : static bool ExecCheckRTEPermsModified(Oid relOid, Oid userid,
      93             :                                       Bitmapset *modifiedCols,
      94             :                                       AclMode requiredPerms);
      95             : static void ExecCheckXactReadOnly(PlannedStmt *plannedstmt);
      96             : static char *ExecBuildSlotValueDescription(Oid reloid,
      97             :                                            TupleTableSlot *slot,
      98             :                                            TupleDesc tupdesc,
      99             :                                            Bitmapset *modifiedCols,
     100             :                                            int maxfieldlen);
     101             : static void EvalPlanQualStart(EPQState *epqstate, Plan *planTree);
     102             : 
     103             : /*
     104             :  * Note that GetAllUpdatedColumns() also exists in commands/trigger.c.  There does
     105             :  * not appear to be any good header to put it into, given the structures that
     106             :  * it uses, so we let them be duplicated.  Be sure to update both if one needs
     107             :  * to be changed, however.
     108             :  */
     109             : #define GetInsertedColumns(relinfo, estate) \
     110             :     (exec_rt_fetch((relinfo)->ri_RangeTableIndex, estate)->insertedCols)
     111             : #define GetUpdatedColumns(relinfo, estate) \
     112             :     (exec_rt_fetch((relinfo)->ri_RangeTableIndex, estate)->updatedCols)
     113             : #define GetAllUpdatedColumns(relinfo, estate) \
     114             :     (bms_union(exec_rt_fetch((relinfo)->ri_RangeTableIndex, estate)->updatedCols, \
     115             :                exec_rt_fetch((relinfo)->ri_RangeTableIndex, estate)->extraUpdatedCols))
     116             : 
     117             : /* end of local decls */
     118             : 
     119             : 
     120             : /* ----------------------------------------------------------------
     121             :  *      ExecutorStart
     122             :  *
     123             :  *      This routine must be called at the beginning of any execution of any
     124             :  *      query plan
     125             :  *
     126             :  * Takes a QueryDesc previously created by CreateQueryDesc (which is separate
     127             :  * only because some places use QueryDescs for utility commands).  The tupDesc
     128             :  * field of the QueryDesc is filled in to describe the tuples that will be
     129             :  * returned, and the internal fields (estate and planstate) are set up.
     130             :  *
     131             :  * eflags contains flag bits as described in executor.h.
     132             :  *
     133             :  * NB: the CurrentMemoryContext when this is called will become the parent
     134             :  * of the per-query context used for this Executor invocation.
     135             :  *
     136             :  * We provide a function hook variable that lets loadable plugins
     137             :  * get control when ExecutorStart is called.  Such a plugin would
     138             :  * normally call standard_ExecutorStart().
     139             :  *
     140             :  * ----------------------------------------------------------------
     141             :  */
     142             : void
     143      351422 : ExecutorStart(QueryDesc *queryDesc, int eflags)
     144             : {
     145      351422 :     if (ExecutorStart_hook)
     146         184 :         (*ExecutorStart_hook) (queryDesc, eflags);
     147             :     else
     148      351238 :         standard_ExecutorStart(queryDesc, eflags);
     149      350924 : }
     150             : 
     151             : void
     152      351422 : standard_ExecutorStart(QueryDesc *queryDesc, int eflags)
     153             : {
     154             :     EState     *estate;
     155             :     MemoryContext oldcontext;
     156             : 
     157             :     /* sanity checks: queryDesc must not be started already */
     158             :     Assert(queryDesc != NULL);
     159             :     Assert(queryDesc->estate == NULL);
     160             : 
     161             :     /*
     162             :      * If the transaction is read-only, we need to check if any writes are
     163             :      * planned to non-temporary tables.  EXPLAIN is considered read-only.
     164             :      *
     165             :      * Don't allow writes in parallel mode.  Supporting UPDATE and DELETE
     166             :      * would require (a) storing the combocid hash in shared memory, rather
     167             :      * than synchronizing it just once at the start of parallelism, and (b) an
     168             :      * alternative to heap_update()'s reliance on xmax for mutual exclusion.
     169             :      * INSERT may have no such troubles, but we forbid it to simplify the
     170             :      * checks.
     171             :      *
     172             :      * We have lower-level defenses in CommandCounterIncrement and elsewhere
     173             :      * against performing unsafe operations in parallel mode, but this gives a
     174             :      * more user-friendly error message.
     175             :      */
     176      472410 :     if ((XactReadOnly || IsInParallelMode()) &&
     177      120988 :         !(eflags & EXEC_FLAG_EXPLAIN_ONLY))
     178      120988 :         ExecCheckXactReadOnly(queryDesc->plannedstmt);
     179             : 
     180             :     /*
     181             :      * Build EState, switch into per-query memory context for startup.
     182             :      */
     183      351410 :     estate = CreateExecutorState();
     184      351410 :     queryDesc->estate = estate;
     185             : 
     186      351410 :     oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
     187             : 
     188             :     /*
     189             :      * Fill in external parameters, if any, from queryDesc; and allocate
     190             :      * workspace for internal parameters
     191             :      */
     192      351410 :     estate->es_param_list_info = queryDesc->params;
     193             : 
     194      351410 :     if (queryDesc->plannedstmt->paramExecTypes != NIL)
     195             :     {
     196             :         int         nParamExec;
     197             : 
     198      120838 :         nParamExec = list_length(queryDesc->plannedstmt->paramExecTypes);
     199      120838 :         estate->es_param_exec_vals = (ParamExecData *)
     200      120838 :             palloc0(nParamExec * sizeof(ParamExecData));
     201             :     }
     202             : 
     203      351410 :     estate->es_sourceText = queryDesc->sourceText;
     204             : 
     205             :     /*
     206             :      * Fill in the query environment, if any, from queryDesc.
     207             :      */
     208      351410 :     estate->es_queryEnv = queryDesc->queryEnv;
     209             : 
     210             :     /*
     211             :      * If non-read-only query, set the command ID to mark output tuples with
     212             :      */
     213      351410 :     switch (queryDesc->operation)
     214             :     {
     215             :         case CMD_SELECT:
     216             : 
     217             :             /*
     218             :              * SELECT FOR [KEY] UPDATE/SHARE and modifying CTEs need to mark
     219             :              * tuples
     220             :              */
     221      543540 :             if (queryDesc->plannedstmt->rowMarks != NIL ||
     222      269238 :                 queryDesc->plannedstmt->hasModifyingCTE)
     223        5148 :                 estate->es_output_cid = GetCurrentCommandId(true);
     224             : 
     225             :             /*
     226             :              * A SELECT without modifying CTEs can't possibly queue triggers,
     227             :              * so force skip-triggers mode. This is just a marginal efficiency
     228             :              * hack, since AfterTriggerBeginQuery/AfterTriggerEndQuery aren't
     229             :              * all that expensive, but we might as well do it.
     230             :              */
     231      274302 :             if (!queryDesc->plannedstmt->hasModifyingCTE)
     232      274218 :                 eflags |= EXEC_FLAG_SKIP_TRIGGERS;
     233      274302 :             break;
     234             : 
     235             :         case CMD_INSERT:
     236             :         case CMD_DELETE:
     237             :         case CMD_UPDATE:
     238       77108 :             estate->es_output_cid = GetCurrentCommandId(true);
     239       77108 :             break;
     240             : 
     241             :         default:
     242           0 :             elog(ERROR, "unrecognized operation code: %d",
     243             :                  (int) queryDesc->operation);
     244             :             break;
     245             :     }
     246             : 
     247             :     /*
     248             :      * Copy other important information into the EState
     249             :      */
     250      351410 :     estate->es_snapshot = RegisterSnapshot(queryDesc->snapshot);
     251      351410 :     estate->es_crosscheck_snapshot = RegisterSnapshot(queryDesc->crosscheck_snapshot);
     252      351410 :     estate->es_top_eflags = eflags;
     253      351410 :     estate->es_instrument = queryDesc->instrument_options;
     254      351410 :     estate->es_jit_flags = queryDesc->plannedstmt->jitFlags;
     255             : 
     256             :     /*
     257             :      * Set up an AFTER-trigger statement context, unless told not to, or
     258             :      * unless it's EXPLAIN-only mode (when ExecutorFinish won't be called).
     259             :      */
     260      351410 :     if (!(eflags & (EXEC_FLAG_SKIP_TRIGGERS | EXEC_FLAG_EXPLAIN_ONLY)))
     261       76474 :         AfterTriggerBeginQuery();
     262             : 
     263             :     /*
     264             :      * Initialize the plan state tree
     265             :      */
     266      351410 :     InitPlan(queryDesc, eflags);
     267             : 
     268      350924 :     MemoryContextSwitchTo(oldcontext);
     269      350924 : }
     270             : 
     271             : /* ----------------------------------------------------------------
     272             :  *      ExecutorRun
     273             :  *
     274             :  *      This is the main routine of the executor module. It accepts
     275             :  *      the query descriptor from the traffic cop and executes the
     276             :  *      query plan.
     277             :  *
     278             :  *      ExecutorStart must have been called already.
     279             :  *
     280             :  *      If direction is NoMovementScanDirection then nothing is done
     281             :  *      except to start up/shut down the destination.  Otherwise,
     282             :  *      we retrieve up to 'count' tuples in the specified direction.
     283             :  *
     284             :  *      Note: count = 0 is interpreted as no portal limit, i.e., run to
     285             :  *      completion.  Also note that the count limit is only applied to
     286             :  *      retrieved tuples, not for instance to those inserted/updated/deleted
     287             :  *      by a ModifyTable plan node.
     288             :  *
     289             :  *      There is no return value, but output tuples (if any) are sent to
     290             :  *      the destination receiver specified in the QueryDesc; and the number
     291             :  *      of tuples processed at the top level can be found in
     292             :  *      estate->es_processed.
     293             :  *
     294             :  *      We provide a function hook variable that lets loadable plugins
     295             :  *      get control when ExecutorRun is called.  Such a plugin would
     296             :  *      normally call standard_ExecutorRun().
     297             :  *
     298             :  * ----------------------------------------------------------------
     299             :  */
     300             : void
     301      346958 : ExecutorRun(QueryDesc *queryDesc,
     302             :             ScanDirection direction, uint64 count,
     303             :             bool execute_once)
     304             : {
     305      346958 :     if (ExecutorRun_hook)
     306         184 :         (*ExecutorRun_hook) (queryDesc, direction, count, execute_once);
     307             :     else
     308      346774 :         standard_ExecutorRun(queryDesc, direction, count, execute_once);
     309      335364 : }
     310             : 
     311             : void
     312      346958 : standard_ExecutorRun(QueryDesc *queryDesc,
     313             :                      ScanDirection direction, uint64 count, bool execute_once)
     314             : {
     315             :     EState     *estate;
     316             :     CmdType     operation;
     317             :     DestReceiver *dest;
     318             :     bool        sendTuples;
     319             :     MemoryContext oldcontext;
     320             : 
     321             :     /* sanity checks */
     322             :     Assert(queryDesc != NULL);
     323             : 
     324      346958 :     estate = queryDesc->estate;
     325             : 
     326             :     Assert(estate != NULL);
     327             :     Assert(!(estate->es_top_eflags & EXEC_FLAG_EXPLAIN_ONLY));
     328             : 
     329             :     /*
     330             :      * Switch into per-query memory context
     331             :      */
     332      346958 :     oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
     333             : 
     334             :     /* Allow instrumentation of Executor overall runtime */
     335      346958 :     if (queryDesc->totaltime)
     336         168 :         InstrStartNode(queryDesc->totaltime);
     337             : 
     338             :     /*
     339             :      * extract information from the query descriptor and the query feature.
     340             :      */
     341      346958 :     operation = queryDesc->operation;
     342      346958 :     dest = queryDesc->dest;
     343             : 
     344             :     /*
     345             :      * startup tuple receiver, if we will be emitting tuples
     346             :      */
     347      346958 :     estate->es_processed = 0;
     348             : 
     349      423406 :     sendTuples = (operation == CMD_SELECT ||
     350       76448 :                   queryDesc->plannedstmt->hasReturning);
     351             : 
     352      346958 :     if (sendTuples)
     353      271884 :         dest->rStartup(dest, operation, queryDesc->tupDesc);
     354             : 
     355             :     /*
     356             :      * run plan
     357             :      */
     358      346910 :     if (!ScanDirectionIsNoMovement(direction))
     359             :     {
     360      345434 :         if (execute_once && queryDesc->already_executed)
     361           0 :             elog(ERROR, "can't re-execute query flagged for single execution");
     362      345434 :         queryDesc->already_executed = true;
     363             : 
     364      690868 :         ExecutePlan(estate,
     365             :                     queryDesc->planstate,
     366      345434 :                     queryDesc->plannedstmt->parallelModeNeeded,
     367             :                     operation,
     368             :                     sendTuples,
     369             :                     count,
     370             :                     direction,
     371             :                     dest,
     372             :                     execute_once);
     373             :     }
     374             : 
     375             :     /*
     376             :      * shutdown tuple receiver, if we started it
     377             :      */
     378      335364 :     if (sendTuples)
     379      261936 :         dest->rShutdown(dest);
     380             : 
     381      335364 :     if (queryDesc->totaltime)
     382         168 :         InstrStopNode(queryDesc->totaltime, estate->es_processed);
     383             : 
     384      335364 :     MemoryContextSwitchTo(oldcontext);
     385      335364 : }
     386             : 
     387             : /* ----------------------------------------------------------------
     388             :  *      ExecutorFinish
     389             :  *
     390             :  *      This routine must be called after the last ExecutorRun call.
     391             :  *      It performs cleanup such as firing AFTER triggers.  It is
     392             :  *      separate from ExecutorEnd because EXPLAIN ANALYZE needs to
     393             :  *      include these actions in the total runtime.
     394             :  *
     395             :  *      We provide a function hook variable that lets loadable plugins
     396             :  *      get control when ExecutorFinish is called.  Such a plugin would
     397             :  *      normally call standard_ExecutorFinish().
     398             :  *
     399             :  * ----------------------------------------------------------------
     400             :  */
     401             : void
     402      330508 : ExecutorFinish(QueryDesc *queryDesc)
     403             : {
     404      330508 :     if (ExecutorFinish_hook)
     405         184 :         (*ExecutorFinish_hook) (queryDesc);
     406             :     else
     407      330324 :         standard_ExecutorFinish(queryDesc);
     408      329996 : }
     409             : 
     410             : void
     411      330508 : standard_ExecutorFinish(QueryDesc *queryDesc)
     412             : {
     413             :     EState     *estate;
     414             :     MemoryContext oldcontext;
     415             : 
     416             :     /* sanity checks */
     417             :     Assert(queryDesc != NULL);
     418             : 
     419      330508 :     estate = queryDesc->estate;
     420             : 
     421             :     Assert(estate != NULL);
     422             :     Assert(!(estate->es_top_eflags & EXEC_FLAG_EXPLAIN_ONLY));
     423             : 
     424             :     /* This should be run once and only once per Executor instance */
     425             :     Assert(!estate->es_finished);
     426             : 
     427             :     /* Switch into per-query memory context */
     428      330508 :     oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
     429             : 
     430             :     /* Allow instrumentation of Executor overall runtime */
     431      330508 :     if (queryDesc->totaltime)
     432         168 :         InstrStartNode(queryDesc->totaltime);
     433             : 
     434             :     /* Run ModifyTable nodes to completion */
     435      330508 :     ExecPostprocessPlan(estate);
     436             : 
     437             :     /* Execute queued AFTER triggers, unless told not to */
     438      330508 :     if (!(estate->es_top_eflags & EXEC_FLAG_SKIP_TRIGGERS))
     439       74548 :         AfterTriggerEndQuery(estate);
     440             : 
     441      329996 :     if (queryDesc->totaltime)
     442         168 :         InstrStopNode(queryDesc->totaltime, 0);
     443             : 
     444      329996 :     MemoryContextSwitchTo(oldcontext);
     445             : 
     446      329996 :     estate->es_finished = true;
     447      329996 : }
     448             : 
     449             : /* ----------------------------------------------------------------
     450             :  *      ExecutorEnd
     451             :  *
     452             :  *      This routine must be called at the end of execution of any
     453             :  *      query plan
     454             :  *
     455             :  *      We provide a function hook variable that lets loadable plugins
     456             :  *      get control when ExecutorEnd is called.  Such a plugin would
     457             :  *      normally call standard_ExecutorEnd().
     458             :  *
     459             :  * ----------------------------------------------------------------
     460             :  */
     461             : void
     462      338590 : ExecutorEnd(QueryDesc *queryDesc)
     463             : {
     464      338590 :     if (ExecutorEnd_hook)
     465         184 :         (*ExecutorEnd_hook) (queryDesc);
     466             :     else
     467      338406 :         standard_ExecutorEnd(queryDesc);
     468      338590 : }
     469             : 
     470             : void
     471      338590 : standard_ExecutorEnd(QueryDesc *queryDesc)
     472             : {
     473             :     EState     *estate;
     474             :     MemoryContext oldcontext;
     475             : 
     476             :     /* sanity checks */
     477             :     Assert(queryDesc != NULL);
     478             : 
     479      338590 :     estate = queryDesc->estate;
     480             : 
     481             :     Assert(estate != NULL);
     482             : 
     483             :     /*
     484             :      * Check that ExecutorFinish was called, unless in EXPLAIN-only mode. This
     485             :      * Assert is needed because ExecutorFinish is new as of 9.1, and callers
     486             :      * might forget to call it.
     487             :      */
     488             :     Assert(estate->es_finished ||
     489             :            (estate->es_top_eflags & EXEC_FLAG_EXPLAIN_ONLY));
     490             : 
     491             :     /*
     492             :      * Switch into per-query memory context to run ExecEndPlan
     493             :      */
     494      338590 :     oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
     495             : 
     496      338590 :     ExecEndPlan(queryDesc->planstate, estate);
     497             : 
     498             :     /* do away with our snapshots */
     499      338590 :     UnregisterSnapshot(estate->es_snapshot);
     500      338590 :     UnregisterSnapshot(estate->es_crosscheck_snapshot);
     501             : 
     502             :     /*
     503             :      * Must switch out of context before destroying it
     504             :      */
     505      338590 :     MemoryContextSwitchTo(oldcontext);
     506             : 
     507             :     /*
     508             :      * Release EState and per-query memory context.  This should release
     509             :      * everything the executor has allocated.
     510             :      */
     511      338590 :     FreeExecutorState(estate);
     512             : 
     513             :     /* Reset queryDesc fields that no longer point to anything */
     514      338590 :     queryDesc->tupDesc = NULL;
     515      338590 :     queryDesc->estate = NULL;
     516      338590 :     queryDesc->planstate = NULL;
     517      338590 :     queryDesc->totaltime = NULL;
     518      338590 : }
     519             : 
     520             : /* ----------------------------------------------------------------
     521             :  *      ExecutorRewind
     522             :  *
     523             :  *      This routine may be called on an open queryDesc to rewind it
     524             :  *      to the start.
     525             :  * ----------------------------------------------------------------
     526             :  */
     527             : void
     528         124 : ExecutorRewind(QueryDesc *queryDesc)
     529             : {
     530             :     EState     *estate;
     531             :     MemoryContext oldcontext;
     532             : 
     533             :     /* sanity checks */
     534             :     Assert(queryDesc != NULL);
     535             : 
     536         124 :     estate = queryDesc->estate;
     537             : 
     538             :     Assert(estate != NULL);
     539             : 
     540             :     /* It's probably not sensible to rescan updating queries */
     541             :     Assert(queryDesc->operation == CMD_SELECT);
     542             : 
     543             :     /*
     544             :      * Switch into per-query memory context
     545             :      */
     546         124 :     oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
     547             : 
     548             :     /*
     549             :      * rescan plan
     550             :      */
     551         124 :     ExecReScan(queryDesc->planstate);
     552             : 
     553         124 :     MemoryContextSwitchTo(oldcontext);
     554         124 : }
     555             : 
     556             : 
     557             : /*
     558             :  * ExecCheckRTPerms
     559             :  *      Check access permissions for all relations listed in a range table.
     560             :  *
     561             :  * Returns true if permissions are adequate.  Otherwise, throws an appropriate
     562             :  * error if ereport_on_violation is true, or simply returns false otherwise.
     563             :  *
     564             :  * Note that this does NOT address row level security policies (aka: RLS).  If
     565             :  * rows will be returned to the user as a result of this permission check
     566             :  * passing, then RLS also needs to be consulted (and check_enable_rls()).
     567             :  *
     568             :  * See rewrite/rowsecurity.c.
     569             :  */
     570             : bool
     571      357108 : ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation)
     572             : {
     573             :     ListCell   *l;
     574      357108 :     bool        result = true;
     575             : 
     576     1053718 :     foreach(l, rangeTable)
     577             :     {
     578      697100 :         RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
     579             : 
     580      697100 :         result = ExecCheckRTEPerms(rte);
     581      697100 :         if (!result)
     582             :         {
     583             :             Assert(rte->rtekind == RTE_RELATION);
     584         490 :             if (ereport_on_violation)
     585         482 :                 aclcheck_error(ACLCHECK_NO_PRIV, get_relkind_objtype(get_rel_relkind(rte->relid)),
     586         482 :                                get_rel_name(rte->relid));
     587           8 :             return false;
     588             :         }
     589             :     }
     590             : 
     591      356618 :     if (ExecutorCheckPerms_hook)
     592           0 :         result = (*ExecutorCheckPerms_hook) (rangeTable,
     593             :                                              ereport_on_violation);
     594      356618 :     return result;
     595             : }
     596             : 
     597             : /*
     598             :  * ExecCheckRTEPerms
     599             :  *      Check access permissions for a single RTE.
     600             :  */
     601             : static bool
     602      697100 : ExecCheckRTEPerms(RangeTblEntry *rte)
     603             : {
     604             :     AclMode     requiredPerms;
     605             :     AclMode     relPerms;
     606             :     AclMode     remainingPerms;
     607             :     Oid         relOid;
     608             :     Oid         userid;
     609             : 
     610             :     /*
     611             :      * Only plain-relation RTEs need to be checked here.  Function RTEs are
     612             :      * checked when the function is prepared for execution.  Join, subquery,
     613             :      * and special RTEs need no checks.
     614             :      */
     615      697100 :     if (rte->rtekind != RTE_RELATION)
     616      341850 :         return true;
     617             : 
     618             :     /*
     619             :      * No work if requiredPerms is empty.
     620             :      */
     621      355250 :     requiredPerms = rte->requiredPerms;
     622      355250 :     if (requiredPerms == 0)
     623       35592 :         return true;
     624             : 
     625      319658 :     relOid = rte->relid;
     626             : 
     627             :     /*
     628             :      * userid to check as: current user unless we have a setuid indication.
     629             :      *
     630             :      * Note: GetUserId() is presently fast enough that there's no harm in
     631             :      * calling it separately for each RTE.  If that stops being true, we could
     632             :      * call it once in ExecCheckRTPerms and pass the userid down from there.
     633             :      * But for now, no need for the extra clutter.
     634             :      */
     635      319658 :     userid = rte->checkAsUser ? rte->checkAsUser : GetUserId();
     636             : 
     637             :     /*
     638             :      * We must have *all* the requiredPerms bits, but some of the bits can be
     639             :      * satisfied from column-level rather than relation-level permissions.
     640             :      * First, remove any bits that are satisfied by relation permissions.
     641             :      */
     642      319658 :     relPerms = pg_class_aclmask(relOid, userid, requiredPerms, ACLMASK_ALL);
     643      319658 :     remainingPerms = requiredPerms & ~relPerms;
     644      319658 :     if (remainingPerms != 0)
     645             :     {
     646         734 :         int         col = -1;
     647             : 
     648             :         /*
     649             :          * If we lack any permissions that exist only as relation permissions,
     650             :          * we can fail straight away.
     651             :          */
     652         734 :         if (remainingPerms & ~(ACL_SELECT | ACL_INSERT | ACL_UPDATE))
     653          36 :             return false;
     654             : 
     655             :         /*
     656             :          * Check to see if we have the needed privileges at column level.
     657             :          *
     658             :          * Note: failures just report a table-level error; it would be nicer
     659             :          * to report a column-level error if we have some but not all of the
     660             :          * column privileges.
     661             :          */
     662         698 :         if (remainingPerms & ACL_SELECT)
     663             :         {
     664             :             /*
     665             :              * When the query doesn't explicitly reference any columns (for
     666             :              * example, SELECT COUNT(*) FROM table), allow the query if we
     667             :              * have SELECT on any column of the rel, as per SQL spec.
     668             :              */
     669         478 :             if (bms_is_empty(rte->selectedCols))
     670             :             {
     671          12 :                 if (pg_attribute_aclcheck_all(relOid, userid, ACL_SELECT,
     672             :                                               ACLMASK_ANY) != ACLCHECK_OK)
     673           4 :                     return false;
     674             :             }
     675             : 
     676        1352 :             while ((col = bms_next_member(rte->selectedCols, col)) >= 0)
     677             :             {
     678             :                 /* bit #s are offset by FirstLowInvalidHeapAttributeNumber */
     679         674 :                 AttrNumber  attno = col + FirstLowInvalidHeapAttributeNumber;
     680             : 
     681         674 :                 if (attno == InvalidAttrNumber)
     682             :                 {
     683             :                     /* Whole-row reference, must have priv on all cols */
     684          28 :                     if (pg_attribute_aclcheck_all(relOid, userid, ACL_SELECT,
     685             :                                                   ACLMASK_ALL) != ACLCHECK_OK)
     686          12 :                         return false;
     687             :                 }
     688             :                 else
     689             :                 {
     690         646 :                     if (pg_attribute_aclcheck(relOid, attno, userid,
     691             :                                               ACL_SELECT) != ACLCHECK_OK)
     692         258 :                         return false;
     693             :                 }
     694             :             }
     695             :         }
     696             : 
     697             :         /*
     698             :          * Basically the same for the mod columns, for both INSERT and UPDATE
     699             :          * privilege as specified by remainingPerms.
     700             :          */
     701         424 :         if (remainingPerms & ACL_INSERT && !ExecCheckRTEPermsModified(relOid,
     702             :                                                                       userid,
     703             :                                                                       rte->insertedCols,
     704             :                                                                       ACL_INSERT))
     705          92 :             return false;
     706             : 
     707         332 :         if (remainingPerms & ACL_UPDATE && !ExecCheckRTEPermsModified(relOid,
     708             :                                                                       userid,
     709             :                                                                       rte->updatedCols,
     710             :                                                                       ACL_UPDATE))
     711          88 :             return false;
     712             :     }
     713      319168 :     return true;
     714             : }
     715             : 
     716             : /*
     717             :  * ExecCheckRTEPermsModified
     718             :  *      Check INSERT or UPDATE access permissions for a single RTE (these
     719             :  *      are processed uniformly).
     720             :  */
     721             : static bool
     722         308 : ExecCheckRTEPermsModified(Oid relOid, Oid userid, Bitmapset *modifiedCols,
     723             :                           AclMode requiredPerms)
     724             : {
     725         308 :     int         col = -1;
     726             : 
     727             :     /*
     728             :      * When the query doesn't explicitly update any columns, allow the query
     729             :      * if we have permission on any column of the rel.  This is to handle
     730             :      * SELECT FOR UPDATE as well as possible corner cases in UPDATE.
     731             :      */
     732         308 :     if (bms_is_empty(modifiedCols))
     733             :     {
     734          28 :         if (pg_attribute_aclcheck_all(relOid, userid, requiredPerms,
     735             :                                       ACLMASK_ANY) != ACLCHECK_OK)
     736          28 :             return false;
     737             :     }
     738             : 
     739         712 :     while ((col = bms_next_member(modifiedCols, col)) >= 0)
     740             :     {
     741             :         /* bit #s are offset by FirstLowInvalidHeapAttributeNumber */
     742         304 :         AttrNumber  attno = col + FirstLowInvalidHeapAttributeNumber;
     743             : 
     744         304 :         if (attno == InvalidAttrNumber)
     745             :         {
     746             :             /* whole-row reference can't happen here */
     747           0 :             elog(ERROR, "whole-row update is not implemented");
     748             :         }
     749             :         else
     750             :         {
     751         304 :             if (pg_attribute_aclcheck(relOid, attno, userid,
     752             :                                       requiredPerms) != ACLCHECK_OK)
     753         152 :                 return false;
     754             :         }
     755             :     }
     756         128 :     return true;
     757             : }
     758             : 
     759             : /*
     760             :  * Check that the query does not imply any writes to non-temp tables;
     761             :  * unless we're in parallel mode, in which case don't even allow writes
     762             :  * to temp tables.
     763             :  *
     764             :  * Note: in a Hot Standby this would need to reject writes to temp
     765             :  * tables just as we do in parallel mode; but an HS standby can't have created
     766             :  * any temp tables in the first place, so no need to check that.
     767             :  */
     768             : static void
     769      120988 : ExecCheckXactReadOnly(PlannedStmt *plannedstmt)
     770             : {
     771             :     ListCell   *l;
     772             : 
     773             :     /*
     774             :      * Fail if write permissions are requested in parallel mode for table
     775             :      * (temp or non-temp), otherwise fail for any non-temp table.
     776             :      */
     777      377070 :     foreach(l, plannedstmt->rtable)
     778             :     {
     779      256094 :         RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
     780             : 
     781      256094 :         if (rte->rtekind != RTE_RELATION)
     782      147008 :             continue;
     783             : 
     784      109086 :         if ((rte->requiredPerms & (~ACL_SELECT)) == 0)
     785      109066 :             continue;
     786             : 
     787          20 :         if (isTempNamespace(get_rel_namespace(rte->relid)))
     788           8 :             continue;
     789             : 
     790          12 :         PreventCommandIfReadOnly(CreateCommandTag((Node *) plannedstmt));
     791             :     }
     792             : 
     793      120976 :     if (plannedstmt->commandType != CMD_SELECT || plannedstmt->hasModifyingCTE)
     794           8 :         PreventCommandIfParallelMode(CreateCommandTag((Node *) plannedstmt));
     795      120976 : }
     796             : 
     797             : 
     798             : /* ----------------------------------------------------------------
     799             :  *      InitPlan
     800             :  *
     801             :  *      Initializes the query plan: open files, allocate storage
     802             :  *      and start up the rule manager
     803             :  * ----------------------------------------------------------------
     804             :  */
     805             : static void
     806      351410 : InitPlan(QueryDesc *queryDesc, int eflags)
     807             : {
     808      351410 :     CmdType     operation = queryDesc->operation;
     809      351410 :     PlannedStmt *plannedstmt = queryDesc->plannedstmt;
     810      351410 :     Plan       *plan = plannedstmt->planTree;
     811      351410 :     List       *rangeTable = plannedstmt->rtable;
     812      351410 :     EState     *estate = queryDesc->estate;
     813             :     PlanState  *planstate;
     814             :     TupleDesc   tupType;
     815             :     ListCell   *l;
     816             :     int         i;
     817             : 
     818             :     /*
     819             :      * Do permissions checks
     820             :      */
     821      351410 :     ExecCheckRTPerms(rangeTable, true);
     822             : 
     823             :     /*
     824             :      * initialize the node's execution state
     825             :      */
     826      350988 :     ExecInitRangeTable(estate, rangeTable);
     827             : 
     828      350988 :     estate->es_plannedstmt = plannedstmt;
     829             : 
     830             :     /*
     831             :      * Initialize ResultRelInfo data structures, and open the result rels.
     832             :      */
     833      350988 :     if (plannedstmt->resultRelations)
     834             :     {
     835       76984 :         List       *resultRelations = plannedstmt->resultRelations;
     836       76984 :         int         numResultRelations = list_length(resultRelations);
     837             :         ResultRelInfo *resultRelInfos;
     838             :         ResultRelInfo *resultRelInfo;
     839             : 
     840       76984 :         resultRelInfos = (ResultRelInfo *)
     841       76984 :             palloc(numResultRelations * sizeof(ResultRelInfo));
     842       76984 :         resultRelInfo = resultRelInfos;
     843      155220 :         foreach(l, resultRelations)
     844             :         {
     845       78236 :             Index       resultRelationIndex = lfirst_int(l);
     846             :             Relation    resultRelation;
     847             : 
     848       78236 :             resultRelation = ExecGetRangeTableRelation(estate,
     849             :                                                        resultRelationIndex);
     850       78236 :             InitResultRelInfo(resultRelInfo,
     851             :                               resultRelation,
     852             :                               resultRelationIndex,
     853             :                               NULL,
     854             :                               estate->es_instrument);
     855       78236 :             resultRelInfo++;
     856             :         }
     857       76984 :         estate->es_result_relations = resultRelInfos;
     858       76984 :         estate->es_num_result_relations = numResultRelations;
     859             : 
     860             :         /* es_result_relation_info is NULL except when within ModifyTable */
     861       76984 :         estate->es_result_relation_info = NULL;
     862             : 
     863             :         /*
     864             :          * In the partitioned result relation case, also build ResultRelInfos
     865             :          * for all the partitioned table roots, because we will need them to
     866             :          * fire statement-level triggers, if any.
     867             :          */
     868       76984 :         if (plannedstmt->rootResultRelations)
     869             :         {
     870        2090 :             int         num_roots = list_length(plannedstmt->rootResultRelations);
     871             : 
     872        2090 :             resultRelInfos = (ResultRelInfo *)
     873        2090 :                 palloc(num_roots * sizeof(ResultRelInfo));
     874        2090 :             resultRelInfo = resultRelInfos;
     875        4196 :             foreach(l, plannedstmt->rootResultRelations)
     876             :             {
     877        2106 :                 Index       resultRelIndex = lfirst_int(l);
     878             :                 Relation    resultRelDesc;
     879             : 
     880        2106 :                 resultRelDesc = ExecGetRangeTableRelation(estate,
     881             :                                                           resultRelIndex);
     882        2106 :                 InitResultRelInfo(resultRelInfo,
     883             :                                   resultRelDesc,
     884             :                                   resultRelIndex,
     885             :                                   NULL,
     886             :                                   estate->es_instrument);
     887        2106 :                 resultRelInfo++;
     888             :             }
     889             : 
     890        2090 :             estate->es_root_result_relations = resultRelInfos;
     891        2090 :             estate->es_num_root_result_relations = num_roots;
     892             :         }
     893             :         else
     894             :         {
     895       74894 :             estate->es_root_result_relations = NULL;
     896       74894 :             estate->es_num_root_result_relations = 0;
     897             :         }
     898             :     }
     899             :     else
     900             :     {
     901             :         /*
     902             :          * if no result relation, then set state appropriately
     903             :          */
     904      274004 :         estate->es_result_relations = NULL;
     905      274004 :         estate->es_num_result_relations = 0;
     906      274004 :         estate->es_result_relation_info = NULL;
     907      274004 :         estate->es_root_result_relations = NULL;
     908      274004 :         estate->es_num_root_result_relations = 0;
     909             :     }
     910             : 
     911             :     /*
     912             :      * Next, build the ExecRowMark array from the PlanRowMark(s), if any.
     913             :      */
     914      350988 :     if (plannedstmt->rowMarks)
     915             :     {
     916        5664 :         estate->es_rowmarks = (ExecRowMark **)
     917        5664 :             palloc0(estate->es_range_table_size * sizeof(ExecRowMark *));
     918       12502 :         foreach(l, plannedstmt->rowMarks)
     919             :         {
     920        6842 :             PlanRowMark *rc = (PlanRowMark *) lfirst(l);
     921             :             Oid         relid;
     922             :             Relation    relation;
     923             :             ExecRowMark *erm;
     924             : 
     925             :             /* ignore "parent" rowmarks; they are irrelevant at runtime */
     926        6842 :             if (rc->isParent)
     927         508 :                 continue;
     928             : 
     929             :             /* get relation's OID (will produce InvalidOid if subquery) */
     930        6334 :             relid = exec_rt_fetch(rc->rti, estate)->relid;
     931             : 
     932             :             /* open relation, if we need to access it for this mark type */
     933        6334 :             switch (rc->markType)
     934             :             {
     935             :                 case ROW_MARK_EXCLUSIVE:
     936             :                 case ROW_MARK_NOKEYEXCLUSIVE:
     937             :                 case ROW_MARK_SHARE:
     938             :                 case ROW_MARK_KEYSHARE:
     939             :                 case ROW_MARK_REFERENCE:
     940        6024 :                     relation = ExecGetRangeTableRelation(estate, rc->rti);
     941        6024 :                     break;
     942             :                 case ROW_MARK_COPY:
     943             :                     /* no physical table access is required */
     944         310 :                     relation = NULL;
     945         310 :                     break;
     946             :                 default:
     947           0 :                     elog(ERROR, "unrecognized markType: %d", rc->markType);
     948             :                     relation = NULL;    /* keep compiler quiet */
     949             :                     break;
     950             :             }
     951             : 
     952             :             /* Check that relation is a legal target for marking */
     953        6334 :             if (relation)
     954        6024 :                 CheckValidRowMarkRel(relation, rc->markType);
     955             : 
     956        6330 :             erm = (ExecRowMark *) palloc(sizeof(ExecRowMark));
     957        6330 :             erm->relation = relation;
     958        6330 :             erm->relid = relid;
     959        6330 :             erm->rti = rc->rti;
     960        6330 :             erm->prti = rc->prti;
     961        6330 :             erm->rowmarkId = rc->rowmarkId;
     962        6330 :             erm->markType = rc->markType;
     963        6330 :             erm->strength = rc->strength;
     964        6330 :             erm->waitPolicy = rc->waitPolicy;
     965        6330 :             erm->ermActive = false;
     966        6330 :             ItemPointerSetInvalid(&(erm->curCtid));
     967        6330 :             erm->ermExtra = NULL;
     968             : 
     969             :             Assert(erm->rti > 0 && erm->rti <= estate->es_range_table_size &&
     970             :                    estate->es_rowmarks[erm->rti - 1] == NULL);
     971             : 
     972        6330 :             estate->es_rowmarks[erm->rti - 1] = erm;
     973             :         }
     974             :     }
     975             : 
     976             :     /*
     977             :      * Initialize the executor's tuple table to empty.
     978             :      */
     979      350984 :     estate->es_tupleTable = NIL;
     980             : 
     981             :     /* signal that this EState is not used for EPQ */
     982      350984 :     estate->es_epq_active = NULL;
     983             : 
     984             :     /*
     985             :      * Initialize private state information for each SubPlan.  We must do this
     986             :      * before running ExecInitNode on the main query tree, since
     987             :      * ExecInitSubPlan expects to be able to find these entries.
     988             :      */
     989             :     Assert(estate->es_subplanstates == NIL);
     990      350984 :     i = 1;                      /* subplan indices count from 1 */
     991      400130 :     foreach(l, plannedstmt->subplans)
     992             :     {
     993       49146 :         Plan       *subplan = (Plan *) lfirst(l);
     994             :         PlanState  *subplanstate;
     995             :         int         sp_eflags;
     996             : 
     997             :         /*
     998             :          * A subplan will never need to do BACKWARD scan nor MARK/RESTORE. If
     999             :          * it is a parameterless subplan (not initplan), we suggest that it be
    1000             :          * prepared to handle REWIND efficiently; otherwise there is no need.
    1001             :          */
    1002       49146 :         sp_eflags = eflags
    1003             :             & (EXEC_FLAG_EXPLAIN_ONLY | EXEC_FLAG_WITH_NO_DATA);
    1004       49146 :         if (bms_is_member(i, plannedstmt->rewindPlanIDs))
    1005          12 :             sp_eflags |= EXEC_FLAG_REWIND;
    1006             : 
    1007       49146 :         subplanstate = ExecInitNode(subplan, estate, sp_eflags);
    1008             : 
    1009       49146 :         estate->es_subplanstates = lappend(estate->es_subplanstates,
    1010             :                                            subplanstate);
    1011             : 
    1012       49146 :         i++;
    1013             :     }
    1014             : 
    1015             :     /*
    1016             :      * Initialize the private state information for all the nodes in the query
    1017             :      * tree.  This opens files, allocates storage and leaves us ready to start
    1018             :      * processing tuples.
    1019             :      */
    1020      350984 :     planstate = ExecInitNode(plan, estate, eflags);
    1021             : 
    1022             :     /*
    1023             :      * Get the tuple descriptor describing the type of tuples to return.
    1024             :      */
    1025      350924 :     tupType = ExecGetResultType(planstate);
    1026             : 
    1027             :     /*
    1028             :      * Initialize the junk filter if needed.  SELECT queries need a filter if
    1029             :      * there are any junk attrs in the top-level tlist.
    1030             :      */
    1031      350924 :     if (operation == CMD_SELECT)
    1032             :     {
    1033      274034 :         bool        junk_filter_needed = false;
    1034             :         ListCell   *tlist;
    1035             : 
    1036      963938 :         foreach(tlist, plan->targetlist)
    1037             :         {
    1038      701548 :             TargetEntry *tle = (TargetEntry *) lfirst(tlist);
    1039             : 
    1040      701548 :             if (tle->resjunk)
    1041             :             {
    1042       11644 :                 junk_filter_needed = true;
    1043       11644 :                 break;
    1044             :             }
    1045             :         }
    1046             : 
    1047      274034 :         if (junk_filter_needed)
    1048             :         {
    1049             :             JunkFilter *j;
    1050             :             TupleTableSlot *slot;
    1051             : 
    1052       11644 :             slot = ExecInitExtraTupleSlot(estate, NULL, &TTSOpsVirtual);
    1053       11644 :             j = ExecInitJunkFilter(planstate->plan->targetlist,
    1054             :                                    slot);
    1055       11644 :             estate->es_junkFilter = j;
    1056             : 
    1057             :             /* Want to return the cleaned tuple type */
    1058       11644 :             tupType = j->jf_cleanTupType;
    1059             :         }
    1060             :     }
    1061             : 
    1062      350924 :     queryDesc->tupDesc = tupType;
    1063      350924 :     queryDesc->planstate = planstate;
    1064      350924 : }
    1065             : 
    1066             : /*
    1067             :  * Check that a proposed result relation is a legal target for the operation
    1068             :  *
    1069             :  * Generally the parser and/or planner should have noticed any such mistake
    1070             :  * already, but let's make sure.
    1071             :  *
    1072             :  * Note: when changing this function, you probably also need to look at
    1073             :  * CheckValidRowMarkRel.
    1074             :  */
    1075             : void
    1076       82342 : CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation)
    1077             : {
    1078       82342 :     Relation    resultRel = resultRelInfo->ri_RelationDesc;
    1079       82342 :     TriggerDesc *trigDesc = resultRel->trigdesc;
    1080             :     FdwRoutine *fdwroutine;
    1081             : 
    1082       82342 :     switch (resultRel->rd_rel->relkind)
    1083             :     {
    1084             :         case RELKIND_RELATION:
    1085             :         case RELKIND_PARTITIONED_TABLE:
    1086       81624 :             CheckCmdReplicaIdentity(resultRel, operation);
    1087       81624 :             break;
    1088             :         case RELKIND_SEQUENCE:
    1089           0 :             ereport(ERROR,
    1090             :                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
    1091             :                      errmsg("cannot change sequence \"%s\"",
    1092             :                             RelationGetRelationName(resultRel))));
    1093             :             break;
    1094             :         case RELKIND_TOASTVALUE:
    1095           0 :             ereport(ERROR,
    1096             :                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
    1097             :                      errmsg("cannot change TOAST relation \"%s\"",
    1098             :                             RelationGetRelationName(resultRel))));
    1099             :             break;
    1100             :         case RELKIND_VIEW:
    1101             : 
    1102             :             /*
    1103             :              * Okay only if there's a suitable INSTEAD OF trigger.  Messages
    1104             :              * here should match rewriteHandler.c's rewriteTargetView, except
    1105             :              * that we omit errdetail because we haven't got the information
    1106             :              * handy (and given that we really shouldn't get here anyway, it's
    1107             :              * not worth great exertion to get).
    1108             :              */
    1109         222 :             switch (operation)
    1110             :             {
    1111             :                 case CMD_INSERT:
    1112          90 :                     if (!trigDesc || !trigDesc->trig_insert_instead_row)
    1113           0 :                         ereport(ERROR,
    1114             :                                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
    1115             :                                  errmsg("cannot insert into view \"%s\"",
    1116             :                                         RelationGetRelationName(resultRel)),
    1117             :                                  errhint("To enable inserting into the view, provide an INSTEAD OF INSERT trigger or an unconditional ON INSERT DO INSTEAD rule.")));
    1118          90 :                     break;
    1119             :                 case CMD_UPDATE:
    1120          94 :                     if (!trigDesc || !trigDesc->trig_update_instead_row)
    1121           0 :                         ereport(ERROR,
    1122             :                                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
    1123             :                                  errmsg("cannot update view \"%s\"",
    1124             :                                         RelationGetRelationName(resultRel)),
    1125             :                                  errhint("To enable updating the view, provide an INSTEAD OF UPDATE trigger or an unconditional ON UPDATE DO INSTEAD rule.")));
    1126          94 :                     break;
    1127             :                 case CMD_DELETE:
    1128          38 :                     if (!trigDesc || !trigDesc->trig_delete_instead_row)
    1129           0 :                         ereport(ERROR,
    1130             :                                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
    1131             :                                  errmsg("cannot delete from view \"%s\"",
    1132             :                                         RelationGetRelationName(resultRel)),
    1133             :                                  errhint("To enable deleting from the view, provide an INSTEAD OF DELETE trigger or an unconditional ON DELETE DO INSTEAD rule.")));
    1134          38 :                     break;
    1135             :                 default:
    1136           0 :                     elog(ERROR, "unrecognized CmdType: %d", (int) operation);
    1137             :                     break;
    1138             :             }
    1139         222 :             break;
    1140             :         case RELKIND_MATVIEW:
    1141          44 :             if (!MatViewIncrementalMaintenanceIsEnabled())
    1142           0 :                 ereport(ERROR,
    1143             :                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
    1144             :                          errmsg("cannot change materialized view \"%s\"",
    1145             :                                 RelationGetRelationName(resultRel))));
    1146          44 :             break;
    1147             :         case RELKIND_FOREIGN_TABLE:
    1148             :             /* Okay only if the FDW supports it */
    1149         452 :             fdwroutine = resultRelInfo->ri_FdwRoutine;
    1150         452 :             switch (operation)
    1151             :             {
    1152             :                 case CMD_INSERT:
    1153         184 :                     if (fdwroutine->ExecForeignInsert == NULL)
    1154          10 :                         ereport(ERROR,
    1155             :                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1156             :                                  errmsg("cannot insert into foreign table \"%s\"",
    1157             :                                         RelationGetRelationName(resultRel))));
    1158         348 :                     if (fdwroutine->IsForeignRelUpdatable != NULL &&
    1159         174 :                         (fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
    1160           0 :                         ereport(ERROR,
    1161             :                                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
    1162             :                                  errmsg("foreign table \"%s\" does not allow inserts",
    1163             :                                         RelationGetRelationName(resultRel))));
    1164         174 :                     break;
    1165             :                 case CMD_UPDATE:
    1166         162 :                     if (fdwroutine->ExecForeignUpdate == NULL)
    1167           4 :                         ereport(ERROR,
    1168             :                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1169             :                                  errmsg("cannot update foreign table \"%s\"",
    1170             :                                         RelationGetRelationName(resultRel))));
    1171         316 :                     if (fdwroutine->IsForeignRelUpdatable != NULL &&
    1172         158 :                         (fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_UPDATE)) == 0)
    1173           0 :                         ereport(ERROR,
    1174             :                                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
    1175             :                                  errmsg("foreign table \"%s\" does not allow updates",
    1176             :                                         RelationGetRelationName(resultRel))));
    1177         158 :                     break;
    1178             :                 case CMD_DELETE:
    1179         106 :                     if (fdwroutine->ExecForeignDelete == NULL)
    1180           4 :                         ereport(ERROR,
    1181             :                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1182             :                                  errmsg("cannot delete from foreign table \"%s\"",
    1183             :                                         RelationGetRelationName(resultRel))));
    1184         204 :                     if (fdwroutine->IsForeignRelUpdatable != NULL &&
    1185         102 :                         (fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_DELETE)) == 0)
    1186           0 :                         ereport(ERROR,
    1187             :                                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
    1188             :                                  errmsg("foreign table \"%s\" does not allow deletes",
    1189             :                                         RelationGetRelationName(resultRel))));
    1190         102 :                     break;
    1191             :                 default:
    1192           0 :                     elog(ERROR, "unrecognized CmdType: %d", (int) operation);
    1193             :                     break;
    1194             :             }
    1195         434 :             break;
    1196             :         default:
    1197           0 :             ereport(ERROR,
    1198             :                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
    1199             :                      errmsg("cannot change relation \"%s\"",
    1200             :                             RelationGetRelationName(resultRel))));
    1201             :             break;
    1202             :     }
    1203       82324 : }
    1204             : 
    1205             : /*
    1206             :  * Check that a proposed rowmark target relation is a legal target
    1207             :  *
    1208             :  * In most cases parser and/or planner should have noticed this already, but
    1209             :  * they don't cover all cases.
    1210             :  */
    1211             : static void
    1212        6024 : CheckValidRowMarkRel(Relation rel, RowMarkType markType)
    1213             : {
    1214             :     FdwRoutine *fdwroutine;
    1215             : 
    1216        6024 :     switch (rel->rd_rel->relkind)
    1217             :     {
    1218             :         case RELKIND_RELATION:
    1219             :         case RELKIND_PARTITIONED_TABLE:
    1220             :             /* OK */
    1221        6016 :             break;
    1222             :         case RELKIND_SEQUENCE:
    1223             :             /* Must disallow this because we don't vacuum sequences */
    1224           0 :             ereport(ERROR,
    1225             :                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
    1226             :                      errmsg("cannot lock rows in sequence \"%s\"",
    1227             :                             RelationGetRelationName(rel))));
    1228             :             break;
    1229             :         case RELKIND_TOASTVALUE:
    1230             :             /* We could allow this, but there seems no good reason to */
    1231           0 :             ereport(ERROR,
    1232             :                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
    1233             :                      errmsg("cannot lock rows in TOAST relation \"%s\"",
    1234             :                             RelationGetRelationName(rel))));
    1235             :             break;
    1236             :         case RELKIND_VIEW:
    1237             :             /* Should not get here; planner should have expanded the view */
    1238           0 :             ereport(ERROR,
    1239             :                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
    1240             :                      errmsg("cannot lock rows in view \"%s\"",
    1241             :                             RelationGetRelationName(rel))));
    1242             :             break;
    1243             :         case RELKIND_MATVIEW:
    1244             :             /* Allow referencing a matview, but not actual locking clauses */
    1245           8 :             if (markType != ROW_MARK_REFERENCE)
    1246           4 :                 ereport(ERROR,
    1247             :                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
    1248             :                          errmsg("cannot lock rows in materialized view \"%s\"",
    1249             :                                 RelationGetRelationName(rel))));
    1250           4 :             break;
    1251             :         case RELKIND_FOREIGN_TABLE:
    1252             :             /* Okay only if the FDW supports it */
    1253           0 :             fdwroutine = GetFdwRoutineForRelation(rel, false);
    1254           0 :             if (fdwroutine->RefetchForeignRow == NULL)
    1255           0 :                 ereport(ERROR,
    1256             :                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1257             :                          errmsg("cannot lock rows in foreign table \"%s\"",
    1258             :                                 RelationGetRelationName(rel))));
    1259           0 :             break;
    1260             :         default:
    1261           0 :             ereport(ERROR,
    1262             :                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
    1263             :                      errmsg("cannot lock rows in relation \"%s\"",
    1264             :                             RelationGetRelationName(rel))));
    1265             :             break;
    1266             :     }
    1267        6020 : }
    1268             : 
    1269             : /*
    1270             :  * Initialize ResultRelInfo data for one result relation
    1271             :  *
    1272             :  * Caution: before Postgres 9.1, this function included the relkind checking
    1273             :  * that's now in CheckValidResultRel, and it also did ExecOpenIndices if
    1274             :  * appropriate.  Be sure callers cover those needs.
    1275             :  */
    1276             : void
    1277       87634 : InitResultRelInfo(ResultRelInfo *resultRelInfo,
    1278             :                   Relation resultRelationDesc,
    1279             :                   Index resultRelationIndex,
    1280             :                   Relation partition_root,
    1281             :                   int instrument_options)
    1282             : {
    1283       87634 :     List       *partition_check = NIL;
    1284             : 
    1285       87634 :     MemSet(resultRelInfo, 0, sizeof(ResultRelInfo));
    1286       87634 :     resultRelInfo->type = T_ResultRelInfo;
    1287       87634 :     resultRelInfo->ri_RangeTableIndex = resultRelationIndex;
    1288       87634 :     resultRelInfo->ri_RelationDesc = resultRelationDesc;
    1289       87634 :     resultRelInfo->ri_NumIndices = 0;
    1290       87634 :     resultRelInfo->ri_IndexRelationDescs = NULL;
    1291       87634 :     resultRelInfo->ri_IndexRelationInfo = NULL;
    1292             :     /* make a copy so as not to depend on relcache info not changing... */
    1293       87634 :     resultRelInfo->ri_TrigDesc = CopyTriggerDesc(resultRelationDesc->trigdesc);
    1294       87634 :     if (resultRelInfo->ri_TrigDesc)
    1295             :     {
    1296        8148 :         int         n = resultRelInfo->ri_TrigDesc->numtriggers;
    1297             : 
    1298        8148 :         resultRelInfo->ri_TrigFunctions = (FmgrInfo *)
    1299        8148 :             palloc0(n * sizeof(FmgrInfo));
    1300        8148 :         resultRelInfo->ri_TrigWhenExprs = (ExprState **)
    1301        8148 :             palloc0(n * sizeof(ExprState *));
    1302        8148 :         if (instrument_options)
    1303           0 :             resultRelInfo->ri_TrigInstrument = InstrAlloc(n, instrument_options);
    1304             :     }
    1305             :     else
    1306             :     {
    1307       79486 :         resultRelInfo->ri_TrigFunctions = NULL;
    1308       79486 :         resultRelInfo->ri_TrigWhenExprs = NULL;
    1309       79486 :         resultRelInfo->ri_TrigInstrument = NULL;
    1310             :     }
    1311       87634 :     if (resultRelationDesc->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
    1312         440 :         resultRelInfo->ri_FdwRoutine = GetFdwRoutineForRelation(resultRelationDesc, true);
    1313             :     else
    1314       87194 :         resultRelInfo->ri_FdwRoutine = NULL;
    1315             : 
    1316             :     /* The following fields are set later if needed */
    1317       87634 :     resultRelInfo->ri_FdwState = NULL;
    1318       87634 :     resultRelInfo->ri_usesFdwDirectModify = false;
    1319       87634 :     resultRelInfo->ri_ConstraintExprs = NULL;
    1320       87634 :     resultRelInfo->ri_GeneratedExprs = NULL;
    1321       87634 :     resultRelInfo->ri_junkFilter = NULL;
    1322       87634 :     resultRelInfo->ri_projectReturning = NULL;
    1323       87634 :     resultRelInfo->ri_onConflictArbiterIndexes = NIL;
    1324       87634 :     resultRelInfo->ri_onConflict = NULL;
    1325       87634 :     resultRelInfo->ri_ReturningSlot = NULL;
    1326       87634 :     resultRelInfo->ri_TrigOldSlot = NULL;
    1327       87634 :     resultRelInfo->ri_TrigNewSlot = NULL;
    1328             : 
    1329             :     /*
    1330             :      * Partition constraint, which also includes the partition constraint of
    1331             :      * all the ancestors that are partitions.  Note that it will be checked
    1332             :      * even in the case of tuple-routing where this table is the target leaf
    1333             :      * partition, if there any BR triggers defined on the table.  Although
    1334             :      * tuple-routing implicitly preserves the partition constraint of the
    1335             :      * target partition for a given row, the BR triggers may change the row
    1336             :      * such that the constraint is no longer satisfied, which we must fail for
    1337             :      * by checking it explicitly.
    1338             :      *
    1339             :      * If this is a partitioned table, the partition constraint (if any) of a
    1340             :      * given row will be checked just before performing tuple-routing.
    1341             :      */
    1342       87634 :     partition_check = RelationGetPartitionQual(resultRelationDesc);
    1343             : 
    1344       87634 :     resultRelInfo->ri_PartitionCheck = partition_check;
    1345       87634 :     resultRelInfo->ri_PartitionRoot = partition_root;
    1346       87634 :     resultRelInfo->ri_PartitionInfo = NULL; /* may be set later */
    1347       87634 :     resultRelInfo->ri_CopyMultiInsertBuffer = NULL;
    1348       87634 : }
    1349             : 
    1350             : /*
    1351             :  * ExecGetTriggerResultRel
    1352             :  *      Get a ResultRelInfo for a trigger target relation.
    1353             :  *
    1354             :  * Most of the time, triggers are fired on one of the result relations of the
    1355             :  * query, and so we can just return a member of the es_result_relations array,
    1356             :  * or the es_root_result_relations array (if any), or the
    1357             :  * es_tuple_routing_result_relations list (if any).  (Note: in self-join
    1358             :  * situations there might be multiple members with the same OID; if so it
    1359             :  * doesn't matter which one we pick.)
    1360             :  *
    1361             :  * However, it is sometimes necessary to fire triggers on other relations;
    1362             :  * this happens mainly when an RI update trigger queues additional triggers
    1363             :  * on other relations, which will be processed in the context of the outer
    1364             :  * query.  For efficiency's sake, we want to have a ResultRelInfo for those
    1365             :  * triggers too; that can avoid repeated re-opening of the relation.  (It
    1366             :  * also provides a way for EXPLAIN ANALYZE to report the runtimes of such
    1367             :  * triggers.)  So we make additional ResultRelInfo's as needed, and save them
    1368             :  * in es_trig_target_relations.
    1369             :  */
    1370             : ResultRelInfo *
    1371        4294 : ExecGetTriggerResultRel(EState *estate, Oid relid)
    1372             : {
    1373             :     ResultRelInfo *rInfo;
    1374             :     int         nr;
    1375             :     ListCell   *l;
    1376             :     Relation    rel;
    1377             :     MemoryContext oldcontext;
    1378             : 
    1379             :     /* First, search through the query result relations */
    1380        4294 :     rInfo = estate->es_result_relations;
    1381        4294 :     nr = estate->es_num_result_relations;
    1382        9200 :     while (nr > 0)
    1383             :     {
    1384        4410 :         if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
    1385        3798 :             return rInfo;
    1386         612 :         rInfo++;
    1387         612 :         nr--;
    1388             :     }
    1389             :     /* Second, search through the root result relations, if any */
    1390         496 :     rInfo = estate->es_root_result_relations;
    1391         496 :     nr = estate->es_num_root_result_relations;
    1392        1260 :     while (nr > 0)
    1393             :     {
    1394         316 :         if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
    1395          48 :             return rInfo;
    1396         268 :         rInfo++;
    1397         268 :         nr--;
    1398             :     }
    1399             : 
    1400             :     /*
    1401             :      * Third, search through the result relations that were created during
    1402             :      * tuple routing, if any.
    1403             :      */
    1404         536 :     foreach(l, estate->es_tuple_routing_result_relations)
    1405             :     {
    1406         332 :         rInfo = (ResultRelInfo *) lfirst(l);
    1407         332 :         if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
    1408         244 :             return rInfo;
    1409             :     }
    1410             : 
    1411             :     /* Nope, but maybe we already made an extra ResultRelInfo for it */
    1412         204 :     foreach(l, estate->es_trig_target_relations)
    1413             :     {
    1414           0 :         rInfo = (ResultRelInfo *) lfirst(l);
    1415           0 :         if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
    1416           0 :             return rInfo;
    1417             :     }
    1418             :     /* Nope, so we need a new one */
    1419             : 
    1420             :     /*
    1421             :      * Open the target relation's relcache entry.  We assume that an
    1422             :      * appropriate lock is still held by the backend from whenever the trigger
    1423             :      * event got queued, so we need take no new lock here.  Also, we need not
    1424             :      * recheck the relkind, so no need for CheckValidResultRel.
    1425             :      */
    1426         204 :     rel = table_open(relid, NoLock);
    1427             : 
    1428             :     /*
    1429             :      * Make the new entry in the right context.
    1430             :      */
    1431         204 :     oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
    1432         204 :     rInfo = makeNode(ResultRelInfo);
    1433         204 :     InitResultRelInfo(rInfo,
    1434             :                       rel,
    1435             :                       0,        /* dummy rangetable index */
    1436             :                       NULL,
    1437             :                       estate->es_instrument);
    1438         204 :     estate->es_trig_target_relations =
    1439         204 :         lappend(estate->es_trig_target_relations, rInfo);
    1440         204 :     MemoryContextSwitchTo(oldcontext);
    1441             : 
    1442             :     /*
    1443             :      * Currently, we don't need any index information in ResultRelInfos used
    1444             :      * only for triggers, so no need to call ExecOpenIndices.
    1445             :      */
    1446             : 
    1447         204 :     return rInfo;
    1448             : }
    1449             : 
    1450             : /*
    1451             :  * Close any relations that have been opened by ExecGetTriggerResultRel().
    1452             :  */
    1453             : void
    1454      340324 : ExecCleanUpTriggerState(EState *estate)
    1455             : {
    1456             :     ListCell   *l;
    1457             : 
    1458      340456 :     foreach(l, estate->es_trig_target_relations)
    1459             :     {
    1460         132 :         ResultRelInfo *resultRelInfo = (ResultRelInfo *) lfirst(l);
    1461             : 
    1462             :         /*
    1463             :          * Assert this is a "dummy" ResultRelInfo, see above.  Otherwise we
    1464             :          * might be issuing a duplicate close against a Relation opened by
    1465             :          * ExecGetRangeTableRelation.
    1466             :          */
    1467             :         Assert(resultRelInfo->ri_RangeTableIndex == 0);
    1468             : 
    1469             :         /*
    1470             :          * Since ExecGetTriggerResultRel doesn't call ExecOpenIndices for
    1471             :          * these rels, we needn't call ExecCloseIndices either.
    1472             :          */
    1473             :         Assert(resultRelInfo->ri_NumIndices == 0);
    1474             : 
    1475         132 :         table_close(resultRelInfo->ri_RelationDesc, NoLock);
    1476             :     }
    1477      340324 : }
    1478             : 
    1479             : /* ----------------------------------------------------------------
    1480             :  *      ExecPostprocessPlan
    1481             :  *
    1482             :  *      Give plan nodes a final chance to execute before shutdown
    1483             :  * ----------------------------------------------------------------
    1484             :  */
    1485             : static void
    1486      330508 : ExecPostprocessPlan(EState *estate)
    1487             : {
    1488             :     ListCell   *lc;
    1489             : 
    1490             :     /*
    1491             :      * Make sure nodes run forward.
    1492             :      */
    1493      330508 :     estate->es_direction = ForwardScanDirection;
    1494             : 
    1495             :     /*
    1496             :      * Run any secondary ModifyTable nodes to completion, in case the main
    1497             :      * query did not fetch all rows from them.  (We do this to ensure that
    1498             :      * such nodes have predictable results.)
    1499             :      */
    1500      331028 :     foreach(lc, estate->es_auxmodifytables)
    1501             :     {
    1502         520 :         PlanState  *ps = (PlanState *) lfirst(lc);
    1503             : 
    1504             :         for (;;)
    1505          92 :         {
    1506             :             TupleTableSlot *slot;
    1507             : 
    1508             :             /* Reset the per-output-tuple exprcontext each time */
    1509         612 :             ResetPerTupleExprContext(estate);
    1510             : 
    1511         612 :             slot = ExecProcNode(ps);
    1512             : 
    1513         612 :             if (TupIsNull(slot))
    1514             :                 break;
    1515             :         }
    1516             :     }
    1517      330508 : }
    1518             : 
    1519             : /* ----------------------------------------------------------------
    1520             :  *      ExecEndPlan
    1521             :  *
    1522             :  *      Cleans up the query plan -- closes files and frees up storage
    1523             :  *
    1524             :  * NOTE: we are no longer very worried about freeing storage per se
    1525             :  * in this code; FreeExecutorState should be guaranteed to release all
    1526             :  * memory that needs to be released.  What we are worried about doing
    1527             :  * is closing relations and dropping buffer pins.  Thus, for example,
    1528             :  * tuple tables must be cleared or dropped to ensure pins are released.
    1529             :  * ----------------------------------------------------------------
    1530             :  */
    1531             : static void
    1532      338590 : ExecEndPlan(PlanState *planstate, EState *estate)
    1533             : {
    1534             :     ResultRelInfo *resultRelInfo;
    1535             :     Index       num_relations;
    1536             :     Index       i;
    1537             :     ListCell   *l;
    1538             : 
    1539             :     /*
    1540             :      * shut down the node-type-specific query processing
    1541             :      */
    1542      338590 :     ExecEndNode(planstate);
    1543             : 
    1544             :     /*
    1545             :      * for subplans too
    1546             :      */
    1547      387452 :     foreach(l, estate->es_subplanstates)
    1548             :     {
    1549       48862 :         PlanState  *subplanstate = (PlanState *) lfirst(l);
    1550             : 
    1551       48862 :         ExecEndNode(subplanstate);
    1552             :     }
    1553             : 
    1554             :     /*
    1555             :      * destroy the executor's tuple table.  Actually we only care about
    1556             :      * releasing buffer pins and tupdesc refcounts; there's no need to pfree
    1557             :      * the TupleTableSlots, since the containing memory context is about to go
    1558             :      * away anyway.
    1559             :      */
    1560      338590 :     ExecResetTupleTable(estate->es_tupleTable, false);
    1561             : 
    1562             :     /*
    1563             :      * close indexes of result relation(s) if any.  (Rels themselves get
    1564             :      * closed next.)
    1565             :      */
    1566      338590 :     resultRelInfo = estate->es_result_relations;
    1567      414454 :     for (i = estate->es_num_result_relations; i > 0; i--)
    1568             :     {
    1569       75864 :         ExecCloseIndices(resultRelInfo);
    1570       75864 :         resultRelInfo++;
    1571             :     }
    1572             : 
    1573             :     /*
    1574             :      * close whatever rangetable Relations have been opened.  We do not
    1575             :      * release any locks we might hold on those rels.
    1576             :      */
    1577      338590 :     num_relations = estate->es_range_table_size;
    1578     1013202 :     for (i = 0; i < num_relations; i++)
    1579             :     {
    1580      674612 :         if (estate->es_relations[i])
    1581      291336 :             table_close(estate->es_relations[i], NoLock);
    1582             :     }
    1583             : 
    1584             :     /* likewise close any trigger target relations */
    1585      338590 :     ExecCleanUpTriggerState(estate);
    1586      338590 : }
    1587             : 
    1588             : /* ----------------------------------------------------------------
    1589             :  *      ExecutePlan
    1590             :  *
    1591             :  *      Processes the query plan until we have retrieved 'numberTuples' tuples,
    1592             :  *      moving in the specified direction.
    1593             :  *
    1594             :  *      Runs to completion if numberTuples is 0
    1595             :  *
    1596             :  * Note: the ctid attribute is a 'junk' attribute that is removed before the
    1597             :  * user can see it
    1598             :  * ----------------------------------------------------------------
    1599             :  */
    1600             : static void
    1601      345434 : ExecutePlan(EState *estate,
    1602             :             PlanState *planstate,
    1603             :             bool use_parallel_mode,
    1604             :             CmdType operation,
    1605             :             bool sendTuples,
    1606             :             uint64 numberTuples,
    1607             :             ScanDirection direction,
    1608             :             DestReceiver *dest,
    1609             :             bool execute_once)
    1610             : {
    1611             :     TupleTableSlot *slot;
    1612             :     uint64      current_tuple_count;
    1613             : 
    1614             :     /*
    1615             :      * initialize local variables
    1616             :      */
    1617      345434 :     current_tuple_count = 0;
    1618             : 
    1619             :     /*
    1620             :      * Set the direction.
    1621             :      */
    1622      345434 :     estate->es_direction = direction;
    1623             : 
    1624             :     /*
    1625             :      * If the plan might potentially be executed multiple times, we must force
    1626             :      * it to run without parallelism, because we might exit early.
    1627             :      */
    1628      345434 :     if (!execute_once)
    1629        9096 :         use_parallel_mode = false;
    1630             : 
    1631      345434 :     estate->es_use_parallel_mode = use_parallel_mode;
    1632      345434 :     if (use_parallel_mode)
    1633         394 :         EnterParallelMode();
    1634             : 
    1635             :     /*
    1636             :      * Loop until we've processed the proper number of tuples from the plan.
    1637             :      */
    1638             :     for (;;)
    1639             :     {
    1640             :         /* Reset the per-output-tuple exprcontext */
    1641     8824666 :         ResetPerTupleExprContext(estate);
    1642             : 
    1643             :         /*
    1644             :          * Execute the plan and obtain a tuple
    1645             :          */
    1646     4585050 :         slot = ExecProcNode(planstate);
    1647             : 
    1648             :         /*
    1649             :          * if the tuple is null, then we assume there is nothing more to
    1650             :          * process so we just end the loop...
    1651             :          */
    1652     4573504 :         if (TupIsNull(slot))
    1653             :         {
    1654             :             /*
    1655             :              * If we know we won't need to back up, we can release resources
    1656             :              * at this point.
    1657             :              */
    1658      276258 :             if (!(estate->es_top_eflags & EXEC_FLAG_BACKWARD))
    1659      274032 :                 (void) ExecShutdownNode(planstate);
    1660      276258 :             break;
    1661             :         }
    1662             : 
    1663             :         /*
    1664             :          * If we have a junk filter, then project a new tuple with the junk
    1665             :          * removed.
    1666             :          *
    1667             :          * Store this new "clean" tuple in the junkfilter's resultSlot.
    1668             :          * (Formerly, we stored it back over the "dirty" tuple, which is WRONG
    1669             :          * because that tuple slot has the wrong descriptor.)
    1670             :          */
    1671     4297246 :         if (estate->es_junkFilter != NULL)
    1672      151938 :             slot = ExecFilterJunk(estate->es_junkFilter, slot);
    1673             : 
    1674             :         /*
    1675             :          * If we are supposed to send the tuple somewhere, do so. (In
    1676             :          * practice, this is probably always the case at this point.)
    1677             :          */
    1678     4297246 :         if (sendTuples)
    1679             :         {
    1680             :             /*
    1681             :              * If we are not able to send the tuple, we assume the destination
    1682             :              * has closed and no more tuples can be sent. If that's the case,
    1683             :              * end the loop.
    1684             :              */
    1685     4297246 :             if (!dest->receiveSlot(slot, dest))
    1686           0 :                 break;
    1687             :         }
    1688             : 
    1689             :         /*
    1690             :          * Count tuples processed, if this is a SELECT.  (For other operation
    1691             :          * types, the ModifyTable plan node must count the appropriate
    1692             :          * events.)
    1693             :          */
    1694     4297246 :         if (operation == CMD_SELECT)
    1695     4294060 :             (estate->es_processed)++;
    1696             : 
    1697             :         /*
    1698             :          * check our tuple count.. if we've processed the proper number then
    1699             :          * quit, else loop again and process more tuples.  Zero numberTuples
    1700             :          * means no limit.
    1701             :          */
    1702     4297246 :         current_tuple_count++;
    1703     4297246 :         if (numberTuples && numberTuples == current_tuple_count)
    1704             :         {
    1705             :             /*
    1706             :              * If we know we won't need to back up, we can release resources
    1707             :              * at this point.
    1708             :              */
    1709       57630 :             if (!(estate->es_top_eflags & EXEC_FLAG_BACKWARD))
    1710       55708 :                 (void) ExecShutdownNode(planstate);
    1711       57630 :             break;
    1712             :         }
    1713             :     }
    1714             : 
    1715      333888 :     if (use_parallel_mode)
    1716         390 :         ExitParallelMode();
    1717      333888 : }
    1718             : 
    1719             : 
    1720             : /*
    1721             :  * ExecRelCheck --- check that tuple meets constraints for result relation
    1722             :  *
    1723             :  * Returns NULL if OK, else name of failed check constraint
    1724             :  */
    1725             : static const char *
    1726        1530 : ExecRelCheck(ResultRelInfo *resultRelInfo,
    1727             :              TupleTableSlot *slot, EState *estate)
    1728             : {
    1729        1530 :     Relation    rel = resultRelInfo->ri_RelationDesc;
    1730        1530 :     int         ncheck = rel->rd_att->constr->num_check;
    1731        1530 :     ConstrCheck *check = rel->rd_att->constr->check;
    1732             :     ExprContext *econtext;
    1733             :     MemoryContext oldContext;
    1734             :     int         i;
    1735             : 
    1736             :     /*
    1737             :      * If first time through for this result relation, build expression
    1738             :      * nodetrees for rel's constraint expressions.  Keep them in the per-query
    1739             :      * memory context so they'll survive throughout the query.
    1740             :      */
    1741        1530 :     if (resultRelInfo->ri_ConstraintExprs == NULL)
    1742             :     {
    1743         598 :         oldContext = MemoryContextSwitchTo(estate->es_query_cxt);
    1744         598 :         resultRelInfo->ri_ConstraintExprs =
    1745         598 :             (ExprState **) palloc(ncheck * sizeof(ExprState *));
    1746        1340 :         for (i = 0; i < ncheck; i++)
    1747             :         {
    1748             :             Expr       *checkconstr;
    1749             : 
    1750         742 :             checkconstr = stringToNode(check[i].ccbin);
    1751        1484 :             resultRelInfo->ri_ConstraintExprs[i] =
    1752         742 :                 ExecPrepareExpr(checkconstr, estate);
    1753             :         }
    1754         598 :         MemoryContextSwitchTo(oldContext);
    1755             :     }
    1756             : 
    1757             :     /*
    1758             :      * We will use the EState's per-tuple context for evaluating constraint
    1759             :      * expressions (creating it if it's not already there).
    1760             :      */
    1761        1530 :     econtext = GetPerTupleExprContext(estate);
    1762             : 
    1763             :     /* Arrange for econtext's scan tuple to be the tuple under test */
    1764        1530 :     econtext->ecxt_scantuple = slot;
    1765             : 
    1766             :     /* And evaluate the constraints */
    1767        3162 :     for (i = 0; i < ncheck; i++)
    1768             :     {
    1769        1850 :         ExprState  *checkconstr = resultRelInfo->ri_ConstraintExprs[i];
    1770             : 
    1771             :         /*
    1772             :          * NOTE: SQL specifies that a NULL result from a constraint expression
    1773             :          * is not to be treated as a failure.  Therefore, use ExecCheck not
    1774             :          * ExecQual.
    1775             :          */
    1776        1850 :         if (!ExecCheck(checkconstr, econtext))
    1777         218 :             return check[i].ccname;
    1778             :     }
    1779             : 
    1780             :     /* NULL result means no error */
    1781        1312 :     return NULL;
    1782             : }
    1783             : 
    1784             : /*
    1785             :  * ExecPartitionCheck --- check that tuple meets the partition constraint.
    1786             :  *
    1787             :  * Returns true if it meets the partition constraint.  If the constraint
    1788             :  * fails and we're asked to emit to error, do so and don't return; otherwise
    1789             :  * return false.
    1790             :  */
    1791             : bool
    1792        1330 : ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot,
    1793             :                    EState *estate, bool emitError)
    1794             : {
    1795             :     ExprContext *econtext;
    1796             :     bool        success;
    1797             : 
    1798             :     /*
    1799             :      * If first time through, build expression state tree for the partition
    1800             :      * check expression.  Keep it in the per-query memory context so they'll
    1801             :      * survive throughout the query.
    1802             :      */
    1803        1330 :     if (resultRelInfo->ri_PartitionCheckExpr == NULL)
    1804             :     {
    1805        1064 :         List       *qual = resultRelInfo->ri_PartitionCheck;
    1806             : 
    1807        1064 :         resultRelInfo->ri_PartitionCheckExpr = ExecPrepareCheck(qual, estate);
    1808             :     }
    1809             : 
    1810             :     /*
    1811             :      * We will use the EState's per-tuple context for evaluating constraint
    1812             :      * expressions (creating it if it's not already there).
    1813             :      */
    1814        1330 :     econtext = GetPerTupleExprContext(estate);
    1815             : 
    1816             :     /* Arrange for econtext's scan tuple to be the tuple under test */
    1817        1330 :     econtext->ecxt_scantuple = slot;
    1818             : 
    1819             :     /*
    1820             :      * As in case of the catalogued constraints, we treat a NULL result as
    1821             :      * success here, not a failure.
    1822             :      */
    1823        1330 :     success = ExecCheck(resultRelInfo->ri_PartitionCheckExpr, econtext);
    1824             : 
    1825             :     /* if asked to emit error, don't actually return on failure */
    1826        1330 :     if (!success && emitError)
    1827         116 :         ExecPartitionCheckEmitError(resultRelInfo, slot, estate);
    1828             : 
    1829        1214 :     return success;
    1830             : }
    1831             : 
    1832             : /*
    1833             :  * ExecPartitionCheckEmitError - Form and emit an error message after a failed
    1834             :  * partition constraint check.
    1835             :  */
    1836             : void
    1837         144 : ExecPartitionCheckEmitError(ResultRelInfo *resultRelInfo,
    1838             :                             TupleTableSlot *slot,
    1839             :                             EState *estate)
    1840             : {
    1841             :     Oid         root_relid;
    1842             :     TupleDesc   tupdesc;
    1843             :     char       *val_desc;
    1844             :     Bitmapset  *modifiedCols;
    1845             : 
    1846             :     /*
    1847             :      * If the tuple has been routed, it's been converted to the partition's
    1848             :      * rowtype, which might differ from the root table's.  We must convert it
    1849             :      * back to the root table's rowtype so that val_desc in the error message
    1850             :      * matches the input tuple.
    1851             :      */
    1852         144 :     if (resultRelInfo->ri_PartitionRoot)
    1853             :     {
    1854             :         TupleDesc   old_tupdesc;
    1855             :         AttrNumber *map;
    1856             : 
    1857          12 :         root_relid = RelationGetRelid(resultRelInfo->ri_PartitionRoot);
    1858          12 :         tupdesc = RelationGetDescr(resultRelInfo->ri_PartitionRoot);
    1859             : 
    1860          12 :         old_tupdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
    1861             :         /* a reverse map */
    1862          12 :         map = convert_tuples_by_name_map_if_req(old_tupdesc, tupdesc);
    1863             : 
    1864             :         /*
    1865             :          * Partition-specific slot's tupdesc can't be changed, so allocate a
    1866             :          * new one.
    1867             :          */
    1868          12 :         if (map != NULL)
    1869           4 :             slot = execute_attr_map_slot(map, slot,
    1870             :                                          MakeTupleTableSlot(tupdesc, &TTSOpsVirtual));
    1871             :     }
    1872             :     else
    1873             :     {
    1874         132 :         root_relid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
    1875         132 :         tupdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
    1876             :     }
    1877             : 
    1878         144 :     modifiedCols = bms_union(GetInsertedColumns(resultRelInfo, estate),
    1879         144 :                              GetUpdatedColumns(resultRelInfo, estate));
    1880             : 
    1881         144 :     val_desc = ExecBuildSlotValueDescription(root_relid,
    1882             :                                              slot,
    1883             :                                              tupdesc,
    1884             :                                              modifiedCols,
    1885             :                                              64);
    1886         144 :     ereport(ERROR,
    1887             :             (errcode(ERRCODE_CHECK_VIOLATION),
    1888             :              errmsg("new row for relation \"%s\" violates partition constraint",
    1889             :                     RelationGetRelationName(resultRelInfo->ri_RelationDesc)),
    1890             :              val_desc ? errdetail("Failing row contains %s.", val_desc) : 0));
    1891             : }
    1892             : 
    1893             : /*
    1894             :  * ExecConstraints - check constraints of the tuple in 'slot'
    1895             :  *
    1896             :  * This checks the traditional NOT NULL and check constraints.
    1897             :  *
    1898             :  * The partition constraint is *NOT* checked.
    1899             :  *
    1900             :  * Note: 'slot' contains the tuple to check the constraints of, which may
    1901             :  * have been converted from the original input tuple after tuple routing.
    1902             :  * 'resultRelInfo' is the final result relation, after tuple routing.
    1903             :  */
    1904             : void
    1905     6363354 : ExecConstraints(ResultRelInfo *resultRelInfo,
    1906             :                 TupleTableSlot *slot, EState *estate)
    1907             : {
    1908     6363354 :     Relation    rel = resultRelInfo->ri_RelationDesc;
    1909     6363354 :     TupleDesc   tupdesc = RelationGetDescr(rel);
    1910     6363354 :     TupleConstr *constr = tupdesc->constr;
    1911             :     Bitmapset  *modifiedCols;
    1912             :     Bitmapset  *insertedCols;
    1913             :     Bitmapset  *updatedCols;
    1914             : 
    1915             :     Assert(constr || resultRelInfo->ri_PartitionCheck);
    1916             : 
    1917     6363354 :     if (constr && constr->has_not_null)
    1918             :     {
    1919     6361628 :         int         natts = tupdesc->natts;
    1920             :         int         attrChk;
    1921             : 
    1922    33786098 :         for (attrChk = 1; attrChk <= natts; attrChk++)
    1923             :         {
    1924    27424608 :             Form_pg_attribute att = TupleDescAttr(tupdesc, attrChk - 1);
    1925             : 
    1926    27424608 :             if (att->attnotnull && slot_attisnull(slot, attrChk))
    1927             :             {
    1928             :                 char       *val_desc;
    1929         138 :                 Relation    orig_rel = rel;
    1930         138 :                 TupleDesc   orig_tupdesc = RelationGetDescr(rel);
    1931             : 
    1932             :                 /*
    1933             :                  * If the tuple has been routed, it's been converted to the
    1934             :                  * partition's rowtype, which might differ from the root
    1935             :                  * table's.  We must convert it back to the root table's
    1936             :                  * rowtype so that val_desc shown error message matches the
    1937             :                  * input tuple.
    1938             :                  */
    1939         138 :                 if (resultRelInfo->ri_PartitionRoot)
    1940             :                 {
    1941             :                     AttrNumber *map;
    1942             : 
    1943           4 :                     rel = resultRelInfo->ri_PartitionRoot;
    1944           4 :                     tupdesc = RelationGetDescr(rel);
    1945             :                     /* a reverse map */
    1946           4 :                     map = convert_tuples_by_name_map_if_req(orig_tupdesc,
    1947             :                                                             tupdesc);
    1948             : 
    1949             :                     /*
    1950             :                      * Partition-specific slot's tupdesc can't be changed, so
    1951             :                      * allocate a new one.
    1952             :                      */
    1953           4 :                     if (map != NULL)
    1954           0 :                         slot = execute_attr_map_slot(map, slot,
    1955             :                                                      MakeTupleTableSlot(tupdesc, &TTSOpsVirtual));
    1956             :                 }
    1957             : 
    1958         138 :                 insertedCols = GetInsertedColumns(resultRelInfo, estate);
    1959         138 :                 updatedCols = GetUpdatedColumns(resultRelInfo, estate);
    1960         138 :                 modifiedCols = bms_union(insertedCols, updatedCols);
    1961         138 :                 val_desc = ExecBuildSlotValueDescription(RelationGetRelid(rel),
    1962             :                                                          slot,
    1963             :                                                          tupdesc,
    1964             :                                                          modifiedCols,
    1965             :                                                          64);
    1966             : 
    1967         138 :                 ereport(ERROR,
    1968             :                         (errcode(ERRCODE_NOT_NULL_VIOLATION),
    1969             :                          errmsg("null value in column \"%s\" violates not-null constraint",
    1970             :                                 NameStr(att->attname)),
    1971             :                          val_desc ? errdetail("Failing row contains %s.", val_desc) : 0,
    1972             :                          errtablecol(orig_rel, attrChk)));
    1973             :             }
    1974             :         }
    1975             :     }
    1976             : 
    1977     6363216 :     if (constr && constr->num_check > 0)
    1978             :     {
    1979             :         const char *failed;
    1980             : 
    1981        1530 :         if ((failed = ExecRelCheck(resultRelInfo, slot, estate)) != NULL)
    1982             :         {
    1983             :             char       *val_desc;
    1984         218 :             Relation    orig_rel = rel;
    1985             : 
    1986             :             /* See the comment above. */
    1987         218 :             if (resultRelInfo->ri_PartitionRoot)
    1988             :             {
    1989           8 :                 TupleDesc   old_tupdesc = RelationGetDescr(rel);
    1990             :                 AttrNumber *map;
    1991             : 
    1992           8 :                 rel = resultRelInfo->ri_PartitionRoot;
    1993           8 :                 tupdesc = RelationGetDescr(rel);
    1994             :                 /* a reverse map */
    1995           8 :                 map = convert_tuples_by_name_map_if_req(old_tupdesc,
    1996             :                                                         tupdesc);
    1997             : 
    1998             :                 /*
    1999             :                  * Partition-specific slot's tupdesc can't be changed, so
    2000             :                  * allocate a new one.
    2001             :                  */
    2002           8 :                 if (map != NULL)
    2003           8 :                     slot = execute_attr_map_slot(map, slot,
    2004             :                                                  MakeTupleTableSlot(tupdesc, &TTSOpsVirtual));
    2005             :             }
    2006             : 
    2007         218 :             insertedCols = GetInsertedColumns(resultRelInfo, estate);
    2008         218 :             updatedCols = GetUpdatedColumns(resultRelInfo, estate);
    2009         218 :             modifiedCols = bms_union(insertedCols, updatedCols);
    2010         218 :             val_desc = ExecBuildSlotValueDescription(RelationGetRelid(rel),
    2011             :                                                      slot,
    2012             :                                                      tupdesc,
    2013             :                                                      modifiedCols,
    2014             :                                                      64);
    2015         218 :             ereport(ERROR,
    2016             :                     (errcode(ERRCODE_CHECK_VIOLATION),
    2017             :                      errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
    2018             :                             RelationGetRelationName(orig_rel), failed),
    2019             :                      val_desc ? errdetail("Failing row contains %s.", val_desc) : 0,
    2020             :                      errtableconstraint(orig_rel, failed)));
    2021             :         }
    2022             :     }
    2023     6362998 : }
    2024             : 
    2025             : /*
    2026             :  * ExecWithCheckOptions -- check that tuple satisfies any WITH CHECK OPTIONs
    2027             :  * of the specified kind.
    2028             :  *
    2029             :  * Note that this needs to be called multiple times to ensure that all kinds of
    2030             :  * WITH CHECK OPTIONs are handled (both those from views which have the WITH
    2031             :  * CHECK OPTION set and from row level security policies).  See ExecInsert()
    2032             :  * and ExecUpdate().
    2033             :  */
    2034             : void
    2035        1152 : ExecWithCheckOptions(WCOKind kind, ResultRelInfo *resultRelInfo,
    2036             :                      TupleTableSlot *slot, EState *estate)
    2037             : {
    2038        1152 :     Relation    rel = resultRelInfo->ri_RelationDesc;
    2039        1152 :     TupleDesc   tupdesc = RelationGetDescr(rel);
    2040             :     ExprContext *econtext;
    2041             :     ListCell   *l1,
    2042             :                *l2;
    2043             : 
    2044             :     /*
    2045             :      * We will use the EState's per-tuple context for evaluating constraint
    2046             :      * expressions (creating it if it's not already there).
    2047             :      */
    2048        1152 :     econtext = GetPerTupleExprContext(estate);
    2049             : 
    2050             :     /* Arrange for econtext's scan tuple to be the tuple under test */
    2051        1152 :     econtext->ecxt_scantuple = slot;
    2052             : 
    2053             :     /* Check each of the constraints */
    2054        2468 :     forboth(l1, resultRelInfo->ri_WithCheckOptions,
    2055             :             l2, resultRelInfo->ri_WithCheckOptionExprs)
    2056             :     {
    2057        1604 :         WithCheckOption *wco = (WithCheckOption *) lfirst(l1);
    2058        1604 :         ExprState  *wcoExpr = (ExprState *) lfirst(l2);
    2059             : 
    2060             :         /*
    2061             :          * Skip any WCOs which are not the kind we are looking for at this
    2062             :          * time.
    2063             :          */
    2064        1604 :         if (wco->kind != kind)
    2065         788 :             continue;
    2066             : 
    2067             :         /*
    2068             :          * WITH CHECK OPTION checks are intended to ensure that the new tuple
    2069             :          * is visible (in the case of a view) or that it passes the
    2070             :          * 'with-check' policy (in the case of row security). If the qual
    2071             :          * evaluates to NULL or FALSE, then the new tuple won't be included in
    2072             :          * the view or doesn't pass the 'with-check' policy for the table.
    2073             :          */
    2074         816 :         if (!ExecQual(wcoExpr, econtext))
    2075             :         {
    2076             :             char       *val_desc;
    2077             :             Bitmapset  *modifiedCols;
    2078             :             Bitmapset  *insertedCols;
    2079             :             Bitmapset  *updatedCols;
    2080             : 
    2081         288 :             switch (wco->kind)
    2082             :             {
    2083             :                     /*
    2084             :                      * For WITH CHECK OPTIONs coming from views, we might be
    2085             :                      * able to provide the details on the row, depending on
    2086             :                      * the permissions on the relation (that is, if the user
    2087             :                      * could view it directly anyway).  For RLS violations, we
    2088             :                      * don't include the data since we don't know if the user
    2089             :                      * should be able to view the tuple as that depends on the
    2090             :                      * USING policy.
    2091             :                      */
    2092             :                 case WCO_VIEW_CHECK:
    2093             :                     /* See the comment in ExecConstraints(). */
    2094         132 :                     if (resultRelInfo->ri_PartitionRoot)
    2095             :                     {
    2096          22 :                         TupleDesc   old_tupdesc = RelationGetDescr(rel);
    2097             :                         AttrNumber *map;
    2098             : 
    2099          22 :                         rel = resultRelInfo->ri_PartitionRoot;
    2100          22 :                         tupdesc = RelationGetDescr(rel);
    2101             :                         /* a reverse map */
    2102          22 :                         map = convert_tuples_by_name_map_if_req(old_tupdesc,
    2103             :                                                                 tupdesc);
    2104             : 
    2105             :                         /*
    2106             :                          * Partition-specific slot's tupdesc can't be changed,
    2107             :                          * so allocate a new one.
    2108             :                          */
    2109          22 :                         if (map != NULL)
    2110          12 :                             slot = execute_attr_map_slot(map, slot,
    2111             :                                                          MakeTupleTableSlot(tupdesc, &TTSOpsVirtual));
    2112             :                     }
    2113             : 
    2114         132 :                     insertedCols = GetInsertedColumns(resultRelInfo, estate);
    2115         132 :                     updatedCols = GetUpdatedColumns(resultRelInfo, estate);
    2116         132 :                     modifiedCols = bms_union(insertedCols, updatedCols);
    2117         132 :                     val_desc = ExecBuildSlotValueDescription(RelationGetRelid(rel),
    2118             :                                                              slot,
    2119             :                                                              tupdesc,
    2120             :                                                              modifiedCols,
    2121             :                                                              64);
    2122             : 
    2123         132 :                     ereport(ERROR,
    2124             :                             (errcode(ERRCODE_WITH_CHECK_OPTION_VIOLATION),
    2125             :                              errmsg("new row violates check option for view \"%s\"",
    2126             :                                     wco->relname),
    2127             :                              val_desc ? errdetail("Failing row contains %s.",
    2128             :                                                   val_desc) : 0));
    2129             :                     break;
    2130             :                 case WCO_RLS_INSERT_CHECK:
    2131             :                 case WCO_RLS_UPDATE_CHECK:
    2132         140 :                     if (wco->polname != NULL)
    2133          34 :                         ereport(ERROR,
    2134             :                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
    2135             :                                  errmsg("new row violates row-level security policy \"%s\" for table \"%s\"",
    2136             :                                         wco->polname, wco->relname)));
    2137             :                     else
    2138         106 :                         ereport(ERROR,
    2139             :                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
    2140             :                                  errmsg("new row violates row-level security policy for table \"%s\"",
    2141             :                                         wco->relname)));
    2142             :                     break;
    2143             :                 case WCO_RLS_CONFLICT_CHECK:
    2144          16 :                     if (wco->polname != NULL)
    2145           0 :                         ereport(ERROR,
    2146             :                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
    2147             :                                  errmsg("new row violates row-level security policy \"%s\" (USING expression) for table \"%s\"",
    2148             :                                         wco->polname, wco->relname)));
    2149             :                     else
    2150          16 :                         ereport(ERROR,
    2151             :                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
    2152             :                                  errmsg("new row violates row-level security policy (USING expression) for table \"%s\"",
    2153             :                                         wco->relname)));
    2154             :                     break;
    2155             :                 default:
    2156           0 :                     elog(ERROR, "unrecognized WCO kind: %u", wco->kind);
    2157             :                     break;
    2158             :             }
    2159             :         }
    2160             :     }
    2161         864 : }
    2162             : 
    2163             : /*
    2164             :  * ExecBuildSlotValueDescription -- construct a string representing a tuple
    2165             :  *
    2166             :  * This is intentionally very similar to BuildIndexValueDescription, but
    2167             :  * unlike that function, we truncate long field values (to at most maxfieldlen
    2168             :  * bytes).  That seems necessary here since heap field values could be very
    2169             :  * long, whereas index entries typically aren't so wide.
    2170             :  *
    2171             :  * Also, unlike the case with index entries, we need to be prepared to ignore
    2172             :  * dropped columns.  We used to use the slot's tuple descriptor to decode the
    2173             :  * data, but the slot's descriptor doesn't identify dropped columns, so we
    2174             :  * now need to be passed the relation's descriptor.
    2175             :  *
    2176             :  * Note that, like BuildIndexValueDescription, if the user does not have
    2177             :  * permission to view any of the columns involved, a NULL is returned.  Unlike
    2178             :  * BuildIndexValueDescription, if the user has access to view a subset of the
    2179             :  * column involved, that subset will be returned with a key identifying which
    2180             :  * columns they are.
    2181             :  */
    2182             : static char *
    2183         632 : ExecBuildSlotValueDescription(Oid reloid,
    2184             :                               TupleTableSlot *slot,
    2185             :                               TupleDesc tupdesc,
    2186             :                               Bitmapset *modifiedCols,
    2187             :                               int maxfieldlen)
    2188             : {
    2189             :     StringInfoData buf;
    2190             :     StringInfoData collist;
    2191         632 :     bool        write_comma = false;
    2192         632 :     bool        write_comma_collist = false;
    2193             :     int         i;
    2194             :     AclResult   aclresult;
    2195         632 :     bool        table_perm = false;
    2196         632 :     bool        any_perm = false;
    2197             : 
    2198             :     /*
    2199             :      * Check if RLS is enabled and should be active for the relation; if so,
    2200             :      * then don't return anything.  Otherwise, go through normal permission
    2201             :      * checks.
    2202             :      */
    2203         632 :     if (check_enable_rls(reloid, InvalidOid, true) == RLS_ENABLED)
    2204           0 :         return NULL;
    2205             : 
    2206         632 :     initStringInfo(&buf);
    2207             : 
    2208         632 :     appendStringInfoChar(&buf, '(');
    2209             : 
    2210             :     /*
    2211             :      * Check if the user has permissions to see the row.  Table-level SELECT
    2212             :      * allows access to all columns.  If the user does not have table-level
    2213             :      * SELECT then we check each column and include those the user has SELECT
    2214             :      * rights on.  Additionally, we always include columns the user provided
    2215             :      * data for.
    2216             :      */
    2217         632 :     aclresult = pg_class_aclcheck(reloid, GetUserId(), ACL_SELECT);
    2218         632 :     if (aclresult != ACLCHECK_OK)
    2219             :     {
    2220             :         /* Set up the buffer for the column list */
    2221          20 :         initStringInfo(&collist);
    2222          20 :         appendStringInfoChar(&collist, '(');
    2223             :     }
    2224             :     else
    2225         612 :         table_perm = any_perm = true;
    2226             : 
    2227             :     /* Make sure the tuple is fully deconstructed */
    2228         632 :     slot_getallattrs(slot);
    2229             : 
    2230        2250 :     for (i = 0; i < tupdesc->natts; i++)
    2231             :     {
    2232        1618 :         bool        column_perm = false;
    2233             :         char       *val;
    2234             :         int         vallen;
    2235        1618 :         Form_pg_attribute att = TupleDescAttr(tupdesc, i);
    2236             : 
    2237             :         /* ignore dropped columns */
    2238        1618 :         if (att->attisdropped)
    2239          24 :             continue;
    2240             : 
    2241        1594 :         if (!table_perm)
    2242             :         {
    2243             :             /*
    2244             :              * No table-level SELECT, so need to make sure they either have
    2245             :              * SELECT rights on the column or that they have provided the data
    2246             :              * for the column.  If not, omit this column from the error
    2247             :              * message.
    2248             :              */
    2249          56 :             aclresult = pg_attribute_aclcheck(reloid, att->attnum,
    2250             :                                               GetUserId(), ACL_SELECT);
    2251          56 :             if (bms_is_member(att->attnum - FirstLowInvalidHeapAttributeNumber,
    2252          28 :                               modifiedCols) || aclresult == ACLCHECK_OK)
    2253             :             {
    2254          36 :                 column_perm = any_perm = true;
    2255             : 
    2256          36 :                 if (write_comma_collist)
    2257          16 :                     appendStringInfoString(&collist, ", ");
    2258             :                 else
    2259          20 :                     write_comma_collist = true;
    2260             : 
    2261          36 :                 appendStringInfoString(&collist, NameStr(att->attname));
    2262             :             }
    2263             :         }
    2264             : 
    2265        1594 :         if (table_perm || column_perm)
    2266             :         {
    2267        1574 :             if (slot->tts_isnull[i])
    2268         314 :                 val = "null";
    2269             :             else
    2270             :             {
    2271             :                 Oid         foutoid;
    2272             :                 bool        typisvarlena;
    2273             : 
    2274        1260 :                 getTypeOutputInfo(att->atttypid,
    2275             :                                   &foutoid, &typisvarlena);
    2276        1260 :                 val = OidOutputFunctionCall(foutoid, slot->tts_values[i]);
    2277             :             }
    2278             : 
    2279        1574 :             if (write_comma)
    2280         942 :                 appendStringInfoString(&buf, ", ");
    2281             :             else
    2282         632 :                 write_comma = true;
    2283             : 
    2284             :             /* truncate if needed */
    2285        1574 :             vallen = strlen(val);
    2286        1574 :             if (vallen <= maxfieldlen)
    2287        1574 :                 appendBinaryStringInfo(&buf, val, vallen);
    2288             :             else
    2289             :             {
    2290           0 :                 vallen = pg_mbcliplen(val, vallen, maxfieldlen);
    2291           0 :                 appendBinaryStringInfo(&buf, val, vallen);
    2292           0 :                 appendStringInfoString(&buf, "...");
    2293             :             }
    2294             :         }
    2295             :     }
    2296             : 
    2297             :     /* If we end up with zero columns being returned, then return NULL. */
    2298         632 :     if (!any_perm)
    2299           0 :         return NULL;
    2300             : 
    2301         632 :     appendStringInfoChar(&buf, ')');
    2302             : 
    2303         632 :     if (!table_perm)
    2304             :     {
    2305          20 :         appendStringInfoString(&collist, ") = ");
    2306          20 :         appendBinaryStringInfo(&collist, buf.data, buf.len);
    2307             : 
    2308          20 :         return collist.data;
    2309             :     }
    2310             : 
    2311         612 :     return buf.data;
    2312             : }
    2313             : 
    2314             : 
    2315             : /*
    2316             :  * ExecUpdateLockMode -- find the appropriate UPDATE tuple lock mode for a
    2317             :  * given ResultRelInfo
    2318             :  */
    2319             : LockTupleMode
    2320        6764 : ExecUpdateLockMode(EState *estate, ResultRelInfo *relinfo)
    2321             : {
    2322             :     Bitmapset  *keyCols;
    2323             :     Bitmapset  *updatedCols;
    2324             : 
    2325             :     /*
    2326             :      * Compute lock mode to use.  If columns that are part of the key have not
    2327             :      * been modified, then we can use a weaker lock, allowing for better
    2328             :      * concurrency.
    2329             :      */
    2330        6764 :     updatedCols = GetAllUpdatedColumns(relinfo, estate);
    2331        6764 :     keyCols = RelationGetIndexAttrBitmap(relinfo->ri_RelationDesc,
    2332             :                                          INDEX_ATTR_BITMAP_KEY);
    2333             : 
    2334        6764 :     if (bms_overlap(keyCols, updatedCols))
    2335         126 :         return LockTupleExclusive;
    2336             : 
    2337        6638 :     return LockTupleNoKeyExclusive;
    2338             : }
    2339             : 
    2340             : /*
    2341             :  * ExecFindRowMark -- find the ExecRowMark struct for given rangetable index
    2342             :  *
    2343             :  * If no such struct, either return NULL or throw error depending on missing_ok
    2344             :  */
    2345             : ExecRowMark *
    2346        6310 : ExecFindRowMark(EState *estate, Index rti, bool missing_ok)
    2347             : {
    2348       12620 :     if (rti > 0 && rti <= estate->es_range_table_size &&
    2349        6310 :         estate->es_rowmarks != NULL)
    2350             :     {
    2351        6310 :         ExecRowMark *erm = estate->es_rowmarks[rti - 1];
    2352             : 
    2353        6310 :         if (erm)
    2354        6310 :             return erm;
    2355             :     }
    2356           0 :     if (!missing_ok)
    2357           0 :         elog(ERROR, "failed to find ExecRowMark for rangetable index %u", rti);
    2358           0 :     return NULL;
    2359             : }
    2360             : 
    2361             : /*
    2362             :  * ExecBuildAuxRowMark -- create an ExecAuxRowMark struct
    2363             :  *
    2364             :  * Inputs are the underlying ExecRowMark struct and the targetlist of the
    2365             :  * input plan node (not planstate node!).  We need the latter to find out
    2366             :  * the column numbers of the resjunk columns.
    2367             :  */
    2368             : ExecAuxRowMark *
    2369        6638 : ExecBuildAuxRowMark(ExecRowMark *erm, List *targetlist)
    2370             : {
    2371        6638 :     ExecAuxRowMark *aerm = (ExecAuxRowMark *) palloc0(sizeof(ExecAuxRowMark));
    2372             :     char        resname[32];
    2373             : 
    2374        6638 :     aerm->rowmark = erm;
    2375             : 
    2376             :     /* Look up the resjunk columns associated with this rowmark */
    2377        6638 :     if (erm->markType != ROW_MARK_COPY)
    2378             :     {
    2379             :         /* need ctid for all methods other than COPY */
    2380        6216 :         snprintf(resname, sizeof(resname), "ctid%u", erm->rowmarkId);
    2381        6216 :         aerm->ctidAttNo = ExecFindJunkAttributeInTlist(targetlist,
    2382             :                                                        resname);
    2383        6216 :         if (!AttributeNumberIsValid(aerm->ctidAttNo))
    2384           0 :             elog(ERROR, "could not find junk %s column", resname);
    2385             :     }
    2386             :     else
    2387             :     {
    2388             :         /* need wholerow if COPY */
    2389         422 :         snprintf(resname, sizeof(resname), "wholerow%u", erm->rowmarkId);
    2390         422 :         aerm->wholeAttNo = ExecFindJunkAttributeInTlist(targetlist,
    2391             :                                                         resname);
    2392         422 :         if (!AttributeNumberIsValid(aerm->wholeAttNo))
    2393           0 :             elog(ERROR, "could not find junk %s column", resname);
    2394             :     }
    2395             : 
    2396             :     /* if child rel, need tableoid */
    2397        6638 :     if (erm->rti != erm->prti)
    2398             :     {
    2399         710 :         snprintf(resname, sizeof(resname), "tableoid%u", erm->rowmarkId);
    2400         710 :         aerm->toidAttNo = ExecFindJunkAttributeInTlist(targetlist,
    2401             :                                                        resname);
    2402         710 :         if (!AttributeNumberIsValid(aerm->toidAttNo))
    2403           0 :             elog(ERROR, "could not find junk %s column", resname);
    2404             :     }
    2405             : 
    2406        6638 :     return aerm;
    2407             : }
    2408             : 
    2409             : 
    2410             : /*
    2411             :  * EvalPlanQual logic --- recheck modified tuple(s) to see if we want to
    2412             :  * process the updated version under READ COMMITTED rules.
    2413             :  *
    2414             :  * See backend/executor/README for some info about how this works.
    2415             :  */
    2416             : 
    2417             : 
    2418             : /*
    2419             :  * Check the updated version of a tuple to see if we want to process it under
    2420             :  * READ COMMITTED rules.
    2421             :  *
    2422             :  *  epqstate - state for EvalPlanQual rechecking
    2423             :  *  relation - table containing tuple
    2424             :  *  rti - rangetable index of table containing tuple
    2425             :  *  inputslot - tuple for processing - this can be the slot from
    2426             :  *      EvalPlanQualSlot(), for the increased efficiency.
    2427             :  *
    2428             :  * This tests whether the tuple in inputslot still matches the relevant
    2429             :  * quals. For that result to be useful, typically the input tuple has to be
    2430             :  * last row version (otherwise the result isn't particularly useful) and
    2431             :  * locked (otherwise the result might be out of date). That's typically
    2432             :  * achieved by using table_tuple_lock() with the
    2433             :  * TUPLE_LOCK_FLAG_FIND_LAST_VERSION flag.
    2434             :  *
    2435             :  * Returns a slot containing the new candidate update/delete tuple, or
    2436             :  * NULL if we determine we shouldn't process the row.
    2437             :  */
    2438             : TupleTableSlot *
    2439          88 : EvalPlanQual(EPQState *epqstate, Relation relation,
    2440             :              Index rti, TupleTableSlot *inputslot)
    2441             : {
    2442             :     TupleTableSlot *slot;
    2443             :     TupleTableSlot *testslot;
    2444             : 
    2445             :     Assert(rti > 0);
    2446             : 
    2447             :     /*
    2448             :      * Need to run a recheck subquery.  Initialize or reinitialize EPQ state.
    2449             :      */
    2450          88 :     EvalPlanQualBegin(epqstate);
    2451             : 
    2452             :     /*
    2453             :      * Callers will often use the EvalPlanQualSlot to store the tuple to avoid
    2454             :      * an unnecessary copy.
    2455             :      */
    2456          88 :     testslot = EvalPlanQualSlot(epqstate, relation, rti);
    2457          88 :     if (testslot != inputslot)
    2458           4 :         ExecCopySlot(testslot, inputslot);
    2459             : 
    2460             :     /*
    2461             :      * Run the EPQ query.  We assume it will return at most one tuple.
    2462             :      */
    2463          88 :     slot = EvalPlanQualNext(epqstate);
    2464             : 
    2465             :     /*
    2466             :      * If we got a tuple, force the slot to materialize the tuple so that it
    2467             :      * is not dependent on any local state in the EPQ query (in particular,
    2468             :      * it's highly likely that the slot contains references to any pass-by-ref
    2469             :      * datums that may be present in copyTuple).  As with the next step, this
    2470             :      * is to guard against early re-use of the EPQ query.
    2471             :      */
    2472          88 :     if (!TupIsNull(slot))
    2473          76 :         ExecMaterializeSlot(slot);
    2474             : 
    2475             :     /*
    2476             :      * Clear out the test tuple.  This is needed in case the EPQ query is
    2477             :      * re-used to test a tuple for a different relation.  (Not clear that can
    2478             :      * really happen, but let's be safe.)
    2479             :      */
    2480          88 :     ExecClearTuple(testslot);
    2481             : 
    2482          88 :     return slot;
    2483             : }
    2484             : 
    2485             : /*
    2486             :  * EvalPlanQualInit -- initialize during creation of a plan state node
    2487             :  * that might need to invoke EPQ processing.
    2488             :  *
    2489             :  * Note: subplan/auxrowmarks can be NULL/NIL if they will be set later
    2490             :  * with EvalPlanQualSetPlan.
    2491             :  */
    2492             : void
    2493       82716 : EvalPlanQualInit(EPQState *epqstate, EState *parentestate,
    2494             :                  Plan *subplan, List *auxrowmarks, int epqParam)
    2495             : {
    2496       82716 :     Index       rtsize = parentestate->es_range_table_size;
    2497             : 
    2498             :     /* initialize data not changing over EPQState's lifetime */
    2499       82716 :     epqstate->parentestate = parentestate;
    2500       82716 :     epqstate->epqParam = epqParam;
    2501             : 
    2502             :     /*
    2503             :      * Allocate space to reference a slot for each potential rti - do so now
    2504             :      * rather than in EvalPlanQualBegin(), as done for other dynamically
    2505             :      * allocated resources, so EvalPlanQualSlot() can be used to hold tuples
    2506             :      * that *may* need EPQ later, without forcing the overhead of
    2507             :      * EvalPlanQualBegin().
    2508             :      */
    2509       82716 :     epqstate->tuple_table = NIL;
    2510       82716 :     epqstate->relsubs_slot = (TupleTableSlot **)
    2511       82716 :         palloc0(rtsize * sizeof(TupleTableSlot *));
    2512             : 
    2513             :     /* ... and remember data that EvalPlanQualBegin will need */
    2514       82716 :     epqstate->plan = subplan;
    2515       82716 :     epqstate->arowMarks = auxrowmarks;
    2516             : 
    2517             :     /* ... and mark the EPQ state inactive */
    2518       82716 :     epqstate->origslot = NULL;
    2519       82716 :     epqstate->recheckestate = NULL;
    2520       82716 :     epqstate->recheckplanstate = NULL;
    2521       82716 :     epqstate->relsubs_rowmark = NULL;
    2522       82716 :     epqstate->relsubs_done = NULL;
    2523       82716 : }
    2524             : 
    2525             : /*
    2526             :  * EvalPlanQualSetPlan -- set or change subplan of an EPQState.
    2527             :  *
    2528             :  * We need this so that ModifyTable can deal with multiple subplans.
    2529             :  */
    2530             : void
    2531       77990 : EvalPlanQualSetPlan(EPQState *epqstate, Plan *subplan, List *auxrowmarks)
    2532             : {
    2533             :     /* If we have a live EPQ query, shut it down */
    2534       77990 :     EvalPlanQualEnd(epqstate);
    2535             :     /* And set/change the plan pointer */
    2536       77990 :     epqstate->plan = subplan;
    2537             :     /* The rowmarks depend on the plan, too */
    2538       77990 :     epqstate->arowMarks = auxrowmarks;
    2539       77990 : }
    2540             : 
    2541             : /*
    2542             :  * Return, and create if necessary, a slot for an EPQ test tuple.
    2543             :  *
    2544             :  * Note this only requires EvalPlanQualInit() to have been called,
    2545             :  * EvalPlanQualBegin() is not necessary.
    2546             :  */
    2547             : TupleTableSlot *
    2548       10944 : EvalPlanQualSlot(EPQState *epqstate,
    2549             :                  Relation relation, Index rti)
    2550             : {
    2551             :     TupleTableSlot **slot;
    2552             : 
    2553             :     Assert(relation);
    2554             :     Assert(rti > 0 && rti <= epqstate->parentestate->es_range_table_size);
    2555       10944 :     slot = &epqstate->relsubs_slot[rti - 1];
    2556             : 
    2557       10944 :     if (*slot == NULL)
    2558             :     {
    2559             :         MemoryContext oldcontext;
    2560             : 
    2561        3898 :         oldcontext = MemoryContextSwitchTo(epqstate->parentestate->es_query_cxt);
    2562        3898 :         *slot = table_slot_create(relation, &epqstate->tuple_table);
    2563        3898 :         MemoryContextSwitchTo(oldcontext);
    2564             :     }
    2565             : 
    2566       10944 :     return *slot;
    2567             : }
    2568             : 
    2569             : /*
    2570             :  * Fetch the current row value for a non-locked relation, identified by rti,
    2571             :  * that needs to be scanned by an EvalPlanQual operation.  origslot must have
    2572             :  * been set to contain the current result row (top-level row) that we need to
    2573             :  * recheck.  Returns true if a substitution tuple was found, false if not.
    2574             :  */
    2575             : bool
    2576          14 : EvalPlanQualFetchRowMark(EPQState *epqstate, Index rti, TupleTableSlot *slot)
    2577             : {
    2578          14 :     ExecAuxRowMark *earm = epqstate->relsubs_rowmark[rti - 1];
    2579          14 :     ExecRowMark *erm = earm->rowmark;
    2580             :     Datum       datum;
    2581             :     bool        isNull;
    2582             : 
    2583             :     Assert(earm != NULL);
    2584             :     Assert(epqstate->origslot != NULL);
    2585             : 
    2586          14 :     if (RowMarkRequiresRowShareLock(erm->markType))
    2587           0 :         elog(ERROR, "EvalPlanQual doesn't support locking rowmarks");
    2588             : 
    2589             :     /* if child rel, must check whether it produced this row */
    2590          14 :     if (erm->rti != erm->prti)
    2591             :     {
    2592             :         Oid         tableoid;
    2593             : 
    2594           0 :         datum = ExecGetJunkAttribute(epqstate->origslot,
    2595           0 :                                      earm->toidAttNo,
    2596             :                                      &isNull);
    2597             :         /* non-locked rels could be on the inside of outer joins */
    2598           0 :         if (isNull)
    2599           0 :             return false;
    2600             : 
    2601           0 :         tableoid = DatumGetObjectId(datum);
    2602             : 
    2603             :         Assert(OidIsValid(erm->relid));
    2604           0 :         if (tableoid != erm->relid)
    2605             :         {
    2606             :             /* this child is inactive right now */
    2607           0 :             return false;
    2608             :         }
    2609             :     }
    2610             : 
    2611          14 :     if (erm->markType == ROW_MARK_REFERENCE)
    2612             :     {
    2613             :         Assert(erm->relation != NULL);
    2614             : 
    2615             :         /* fetch the tuple's ctid */
    2616           8 :         datum = ExecGetJunkAttribute(epqstate->origslot,
    2617           8 :                                      earm->ctidAttNo,
    2618             :                                      &isNull);
    2619             :         /* non-locked rels could be on the inside of outer joins */
    2620           8 :         if (isNull)
    2621           0 :             return false;
    2622             : 
    2623             :         /* fetch requests on foreign tables must be passed to their FDW */
    2624           8 :         if (erm->relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
    2625             :         {
    2626             :             FdwRoutine *fdwroutine;
    2627           0 :             bool        updated = false;
    2628             : 
    2629           0 :             fdwroutine = GetFdwRoutineForRelation(erm->relation, false);
    2630             :             /* this should have been checked already, but let's be safe */
    2631           0 :             if (fdwroutine->RefetchForeignRow == NULL)
    2632           0 :                 ereport(ERROR,
    2633             :                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    2634             :                          errmsg("cannot lock rows in foreign table \"%s\"",
    2635             :                                 RelationGetRelationName(erm->relation))));
    2636             : 
    2637           0 :             fdwroutine->RefetchForeignRow(epqstate->recheckestate,
    2638             :                                           erm,
    2639             :                                           datum,
    2640             :                                           slot,
    2641             :                                           &updated);
    2642           0 :             if (TupIsNull(slot))
    2643           0 :                 elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck");
    2644             : 
    2645             :             /*
    2646             :              * Ideally we'd insist on updated == false here, but that assumes
    2647             :              * that FDWs can track that exactly, which they might not be able
    2648             :              * to.  So just ignore the flag.
    2649             :              */
    2650           0 :             return true;
    2651             :         }
    2652             :         else
    2653             :         {
    2654             :             /* ordinary table, fetch the tuple */
    2655           8 :             if (!table_tuple_fetch_row_version(erm->relation,
    2656             :                                                (ItemPointer) DatumGetPointer(datum),
    2657             :                                                SnapshotAny, slot))
    2658           0 :                 elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck");
    2659           8 :             return true;
    2660             :         }
    2661             :     }
    2662             :     else
    2663             :     {
    2664             :         Assert(erm->markType == ROW_MARK_COPY);
    2665             : 
    2666             :         /* fetch the whole-row Var for the relation */
    2667           6 :         datum = ExecGetJunkAttribute(epqstate->origslot,
    2668           6 :                                      earm->wholeAttNo,
    2669             :                                      &isNull);
    2670             :         /* non-locked rels could be on the inside of outer joins */
    2671           6 :         if (isNull)
    2672           0 :             return false;
    2673             : 
    2674           6 :         ExecStoreHeapTupleDatum(datum, slot);
    2675           6 :         return true;
    2676             :     }
    2677             : }
    2678             : 
    2679             : /*
    2680             :  * Fetch the next row (if any) from EvalPlanQual testing
    2681             :  *
    2682             :  * (In practice, there should never be more than one row...)
    2683             :  */
    2684             : TupleTableSlot *
    2685         140 : EvalPlanQualNext(EPQState *epqstate)
    2686             : {
    2687             :     MemoryContext oldcontext;
    2688             :     TupleTableSlot *slot;
    2689             : 
    2690         140 :     oldcontext = MemoryContextSwitchTo(epqstate->recheckestate->es_query_cxt);
    2691         140 :     slot = ExecProcNode(epqstate->recheckplanstate);
    2692         140 :     MemoryContextSwitchTo(oldcontext);
    2693             : 
    2694         140 :     return slot;
    2695             : }
    2696             : 
    2697             : /*
    2698             :  * Initialize or reset an EvalPlanQual state tree
    2699             :  */
    2700             : void
    2701         158 : EvalPlanQualBegin(EPQState *epqstate)
    2702             : {
    2703         158 :     EState     *parentestate = epqstate->parentestate;
    2704         158 :     EState     *recheckestate = epqstate->recheckestate;
    2705             : 
    2706         158 :     if (recheckestate == NULL)
    2707             :     {
    2708             :         /* First time through, so create a child EState */
    2709         140 :         EvalPlanQualStart(epqstate, epqstate->plan);
    2710             :     }
    2711             :     else
    2712             :     {
    2713             :         /*
    2714             :          * We already have a suitable child EPQ tree, so just reset it.
    2715             :          */
    2716          18 :         Index       rtsize = parentestate->es_range_table_size;
    2717          18 :         PlanState  *rcplanstate = epqstate->recheckplanstate;
    2718             : 
    2719          18 :         MemSet(epqstate->relsubs_done, 0, rtsize * sizeof(bool));
    2720             : 
    2721             :         /* Recopy current values of parent parameters */
    2722          18 :         if (parentestate->es_plannedstmt->paramExecTypes != NIL)
    2723             :         {
    2724             :             int         i;
    2725             : 
    2726             :             /*
    2727             :              * Force evaluation of any InitPlan outputs that could be needed
    2728             :              * by the subplan, just in case they got reset since
    2729             :              * EvalPlanQualStart (see comments therein).
    2730             :              */
    2731          18 :             ExecSetParamPlanMulti(rcplanstate->plan->extParam,
    2732          18 :                                   GetPerTupleExprContext(parentestate));
    2733             : 
    2734          18 :             i = list_length(parentestate->es_plannedstmt->paramExecTypes);
    2735             : 
    2736          64 :             while (--i >= 0)
    2737             :             {
    2738             :                 /* copy value if any, but not execPlan link */
    2739          56 :                 recheckestate->es_param_exec_vals[i].value =
    2740          28 :                     parentestate->es_param_exec_vals[i].value;
    2741          56 :                 recheckestate->es_param_exec_vals[i].isnull =
    2742          28 :                     parentestate->es_param_exec_vals[i].isnull;
    2743             :             }
    2744             :         }
    2745             : 
    2746             :         /*
    2747             :          * Mark child plan tree as needing rescan at all scan nodes.  The
    2748             :          * first ExecProcNode will take care of actually doing the rescan.
    2749             :          */
    2750          18 :         rcplanstate->chgParam = bms_add_member(rcplanstate->chgParam,
    2751             :                                                epqstate->epqParam);
    2752             :     }
    2753         158 : }
    2754             : 
    2755             : /*
    2756             :  * Start execution of an EvalPlanQual plan tree.
    2757             :  *
    2758             :  * This is a cut-down version of ExecutorStart(): we copy some state from
    2759             :  * the top-level estate rather than initializing it fresh.
    2760             :  */
    2761             : static void
    2762         140 : EvalPlanQualStart(EPQState *epqstate, Plan *planTree)
    2763             : {
    2764         140 :     EState     *parentestate = epqstate->parentestate;
    2765         140 :     Index       rtsize = parentestate->es_range_table_size;
    2766             :     EState     *rcestate;
    2767             :     MemoryContext oldcontext;
    2768             :     ListCell   *l;
    2769             : 
    2770         140 :     epqstate->recheckestate = rcestate = CreateExecutorState();
    2771             : 
    2772         140 :     oldcontext = MemoryContextSwitchTo(rcestate->es_query_cxt);
    2773             : 
    2774             :     /* signal that this is an EState for executing EPQ */
    2775         140 :     rcestate->es_epq_active = epqstate;
    2776             : 
    2777             :     /*
    2778             :      * Child EPQ EStates share the parent's copy of unchanging state such as
    2779             :      * the snapshot, rangetable, result-rel info, and external Param info.
    2780             :      * They need their own copies of local state, including a tuple table,
    2781             :      * es_param_exec_vals, etc.
    2782             :      *
    2783             :      * The ResultRelInfo array management is trickier than it looks.  We
    2784             :      * create fresh arrays for the child but copy all the content from the
    2785             :      * parent.  This is because it's okay for the child to share any
    2786             :      * per-relation state the parent has already created --- but if the child
    2787             :      * sets up any ResultRelInfo fields, such as its own junkfilter, that
    2788             :      * state must *not* propagate back to the parent.  (For one thing, the
    2789             :      * pointed-to data is in a memory context that won't last long enough.)
    2790             :      */
    2791         140 :     rcestate->es_direction = ForwardScanDirection;
    2792         140 :     rcestate->es_snapshot = parentestate->es_snapshot;
    2793         140 :     rcestate->es_crosscheck_snapshot = parentestate->es_crosscheck_snapshot;
    2794         140 :     rcestate->es_range_table = parentestate->es_range_table;
    2795         140 :     rcestate->es_range_table_size = parentestate->es_range_table_size;
    2796         140 :     rcestate->es_relations = parentestate->es_relations;
    2797         140 :     rcestate->es_queryEnv = parentestate->es_queryEnv;
    2798         140 :     rcestate->es_rowmarks = parentestate->es_rowmarks;
    2799         140 :     rcestate->es_plannedstmt = parentestate->es_plannedstmt;
    2800         140 :     rcestate->es_junkFilter = parentestate->es_junkFilter;
    2801         140 :     rcestate->es_output_cid = parentestate->es_output_cid;
    2802         140 :     if (parentestate->es_num_result_relations > 0)
    2803             :     {
    2804         102 :         int         numResultRelations = parentestate->es_num_result_relations;
    2805         102 :         int         numRootResultRels = parentestate->es_num_root_result_relations;
    2806             :         ResultRelInfo *resultRelInfos;
    2807             : 
    2808         102 :         resultRelInfos = (ResultRelInfo *)
    2809         102 :             palloc(numResultRelations * sizeof(ResultRelInfo));
    2810         102 :         memcpy(resultRelInfos, parentestate->es_result_relations,
    2811             :                numResultRelations * sizeof(ResultRelInfo));
    2812         102 :         rcestate->es_result_relations = resultRelInfos;
    2813         102 :         rcestate->es_num_result_relations = numResultRelations;
    2814             : 
    2815             :         /* Also transfer partitioned root result relations. */
    2816         102 :         if (numRootResultRels > 0)
    2817             :         {
    2818          16 :             resultRelInfos = (ResultRelInfo *)
    2819          16 :                 palloc(numRootResultRels * sizeof(ResultRelInfo));
    2820          16 :             memcpy(resultRelInfos, parentestate->es_root_result_relations,
    2821             :                    numRootResultRels * sizeof(ResultRelInfo));
    2822          16 :             rcestate->es_root_result_relations = resultRelInfos;
    2823          16 :             rcestate->es_num_root_result_relations = numRootResultRels;
    2824             :         }
    2825             :     }
    2826             :     /* es_result_relation_info must NOT be copied */
    2827             :     /* es_trig_target_relations must NOT be copied */
    2828         140 :     rcestate->es_top_eflags = parentestate->es_top_eflags;
    2829         140 :     rcestate->es_instrument = parentestate->es_instrument;
    2830             :     /* es_auxmodifytables must NOT be copied */
    2831             : 
    2832             :     /*
    2833             :      * The external param list is simply shared from parent.  The internal
    2834             :      * param workspace has to be local state, but we copy the initial values
    2835             :      * from the parent, so as to have access to any param values that were
    2836             :      * already set from other parts of the parent's plan tree.
    2837             :      */
    2838         140 :     rcestate->es_param_list_info = parentestate->es_param_list_info;
    2839         140 :     if (parentestate->es_plannedstmt->paramExecTypes != NIL)
    2840             :     {
    2841             :         int         i;
    2842             : 
    2843             :         /*
    2844             :          * Force evaluation of any InitPlan outputs that could be needed by
    2845             :          * the subplan.  (With more complexity, maybe we could postpone this
    2846             :          * till the subplan actually demands them, but it doesn't seem worth
    2847             :          * the trouble; this is a corner case already, since usually the
    2848             :          * InitPlans would have been evaluated before reaching EvalPlanQual.)
    2849             :          *
    2850             :          * This will not touch output params of InitPlans that occur somewhere
    2851             :          * within the subplan tree, only those that are attached to the
    2852             :          * ModifyTable node or above it and are referenced within the subplan.
    2853             :          * That's OK though, because the planner would only attach such
    2854             :          * InitPlans to a lower-level SubqueryScan node, and EPQ execution
    2855             :          * will not descend into a SubqueryScan.
    2856             :          *
    2857             :          * The EState's per-output-tuple econtext is sufficiently short-lived
    2858             :          * for this, since it should get reset before there is any chance of
    2859             :          * doing EvalPlanQual again.
    2860             :          */
    2861         140 :         ExecSetParamPlanMulti(planTree->extParam,
    2862         140 :                               GetPerTupleExprContext(parentestate));
    2863             : 
    2864             :         /* now make the internal param workspace ... */
    2865         140 :         i = list_length(parentestate->es_plannedstmt->paramExecTypes);
    2866         140 :         rcestate->es_param_exec_vals = (ParamExecData *)
    2867         140 :             palloc0(i * sizeof(ParamExecData));
    2868             :         /* ... and copy down all values, whether really needed or not */
    2869         516 :         while (--i >= 0)
    2870             :         {
    2871             :             /* copy value if any, but not execPlan link */
    2872         472 :             rcestate->es_param_exec_vals[i].value =
    2873         236 :                 parentestate->es_param_exec_vals[i].value;
    2874         472 :             rcestate->es_param_exec_vals[i].isnull =
    2875         236 :                 parentestate->es_param_exec_vals[i].isnull;
    2876             :         }
    2877             :     }
    2878             : 
    2879             :     /*
    2880             :      * Initialize private state information for each SubPlan.  We must do this
    2881             :      * before running ExecInitNode on the main query tree, since
    2882             :      * ExecInitSubPlan expects to be able to find these entries. Some of the
    2883             :      * SubPlans might not be used in the part of the plan tree we intend to
    2884             :      * run, but since it's not easy to tell which, we just initialize them
    2885             :      * all.
    2886             :      */
    2887             :     Assert(rcestate->es_subplanstates == NIL);
    2888         196 :     foreach(l, parentestate->es_plannedstmt->subplans)
    2889             :     {
    2890          56 :         Plan       *subplan = (Plan *) lfirst(l);
    2891             :         PlanState  *subplanstate;
    2892             : 
    2893          56 :         subplanstate = ExecInitNode(subplan, rcestate, 0);
    2894          56 :         rcestate->es_subplanstates = lappend(rcestate->es_subplanstates,
    2895             :                                              subplanstate);
    2896             :     }
    2897             : 
    2898             :     /*
    2899             :      * These arrays are reused across different plans set with
    2900             :      * EvalPlanQualSetPlan(), which is safe because they all use the same
    2901             :      * parent EState. Therefore we can reuse if already allocated.
    2902             :      */
    2903         140 :     if (epqstate->relsubs_rowmark == NULL)
    2904             :     {
    2905             :         Assert(epqstate->relsubs_done == NULL);
    2906         140 :         epqstate->relsubs_rowmark = (ExecAuxRowMark **)
    2907         140 :             palloc0(rtsize * sizeof(ExecAuxRowMark *));
    2908         140 :         epqstate->relsubs_done = (bool *)
    2909         140 :             palloc0(rtsize * sizeof(bool));
    2910             :     }
    2911             :     else
    2912             :     {
    2913             :         Assert(epqstate->relsubs_done != NULL);
    2914           0 :         memset(epqstate->relsubs_rowmark, 0,
    2915             :                rtsize * sizeof(ExecAuxRowMark *));
    2916           0 :         memset(epqstate->relsubs_done, 0,
    2917             :                rtsize * sizeof(bool));
    2918             :     }
    2919             : 
    2920             :     /*
    2921             :      * Build an RTI indexed array of rowmarks, so that
    2922             :      * EvalPlanQualFetchRowMark() can efficiently access the to be fetched
    2923             :      * rowmark.
    2924             :      */
    2925         156 :     foreach(l, epqstate->arowMarks)
    2926             :     {
    2927          16 :         ExecAuxRowMark *earm = (ExecAuxRowMark *) lfirst(l);
    2928             : 
    2929          16 :         epqstate->relsubs_rowmark[earm->rowmark->rti - 1] = earm;
    2930             :     }
    2931             : 
    2932             :     /*
    2933             :      * Initialize the private state information for all the nodes in the part
    2934             :      * of the plan tree we need to run.  This opens files, allocates storage
    2935             :      * and leaves us ready to start processing tuples.
    2936             :      */
    2937         140 :     epqstate->recheckplanstate = ExecInitNode(planTree, rcestate, 0);
    2938             : 
    2939         140 :     MemoryContextSwitchTo(oldcontext);
    2940         140 : }
    2941             : 
    2942             : /*
    2943             :  * EvalPlanQualEnd -- shut down at termination of parent plan state node,
    2944             :  * or if we are done with the current EPQ child.
    2945             :  *
    2946             :  * This is a cut-down version of ExecutorEnd(); basically we want to do most
    2947             :  * of the normal cleanup, but *not* close result relations (which we are
    2948             :  * just sharing from the outer query).  We do, however, have to close any
    2949             :  * trigger target relations that got opened, since those are not shared.
    2950             :  * (There probably shouldn't be any of the latter, but just in case...)
    2951             :  */
    2952             : void
    2953      158384 : EvalPlanQualEnd(EPQState *epqstate)
    2954             : {
    2955      158384 :     EState     *estate = epqstate->recheckestate;
    2956             :     Index       rtsize;
    2957             :     MemoryContext oldcontext;
    2958             :     ListCell   *l;
    2959             : 
    2960      158384 :     rtsize = epqstate->parentestate->es_range_table_size;
    2961             : 
    2962             :     /*
    2963             :      * We may have a tuple table, even if EPQ wasn't started, because we allow
    2964             :      * use of EvalPlanQualSlot() without calling EvalPlanQualBegin().
    2965             :      */
    2966      158384 :     if (epqstate->tuple_table != NIL)
    2967             :     {
    2968        3752 :         memset(epqstate->relsubs_slot, 0,
    2969             :                rtsize * sizeof(TupleTableSlot *));
    2970        3752 :         ExecResetTupleTable(epqstate->tuple_table, true);
    2971        3752 :         epqstate->tuple_table = NIL;
    2972             :     }
    2973             : 
    2974             :     /* EPQ wasn't started, nothing further to do */
    2975      158384 :     if (estate == NULL)
    2976      158252 :         return;
    2977             : 
    2978         132 :     oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
    2979             : 
    2980         132 :     ExecEndNode(epqstate->recheckplanstate);
    2981             : 
    2982         182 :     foreach(l, estate->es_subplanstates)
    2983             :     {
    2984          50 :         PlanState  *subplanstate = (PlanState *) lfirst(l);
    2985             : 
    2986          50 :         ExecEndNode(subplanstate);
    2987             :     }
    2988             : 
    2989             :     /* throw away the per-estate tuple table, some node may have used it */
    2990         132 :     ExecResetTupleTable(estate->es_tupleTable, false);
    2991             : 
    2992             :     /* close any trigger target relations attached to this EState */
    2993         132 :     ExecCleanUpTriggerState(estate);
    2994             : 
    2995         132 :     MemoryContextSwitchTo(oldcontext);
    2996             : 
    2997         132 :     FreeExecutorState(estate);
    2998             : 
    2999             :     /* Mark EPQState idle */
    3000         132 :     epqstate->recheckestate = NULL;
    3001         132 :     epqstate->recheckplanstate = NULL;
    3002         132 :     epqstate->origslot = NULL;
    3003             : }

Generated by: LCOV version 1.13