#include "nodes/parsenodes.h"
#include "utils/portal.h"

Include dependency graph for pquery.h:

This graph shows which files directly or indirectly include this file:

Functions
PortalStrategy	ChoosePortalStrategy (List *stmts)

List *	FetchPortalTargetList (Portal portal)

List *	FetchStatementTargetList (Node *stmt)

void	PortalStart (Portal portal, ParamListInfo params, int eflags, Snapshot snapshot)

void	PortalSetResultFormat (Portal portal, int nFormats, int16 *formats)

bool	PortalRun (Portal portal, long count, bool isTopLevel, bool run_once, DestReceiver dest, DestReceiver altdest, QueryCompletion *qc)

uint64	PortalRunFetch (Portal portal, FetchDirection fdirection, long count, DestReceiver *dest)

bool	PlannedStmtRequiresSnapshot (struct PlannedStmt *pstmt)

void	EnsurePortalSnapshotExists (void)

Variables
PGDLLIMPORT Portal	ActivePortal

Function Documentation

◆ ChoosePortalStrategy()

PortalStrategy ChoosePortalStrategy ( List * stmts )

Definition at line 209 of file pquery.c.

 {
     int         nSetTag;
     ListCell   *lc;
  
     /*
      * PORTAL_ONE_SELECT and PORTAL_UTIL_SELECT need only consider the
      * single-statement case, since there are no rewrite rules that can add
      * auxiliary queries to a SELECT or a utility command. PORTAL_ONE_MOD_WITH
      * likewise allows only one top-level statement.
      */
     if (list_length(stmts) == 1)
     {
         Node       *stmt = (Node *) linitial(stmts);
  
         if (IsA(stmt, Query))
         {
             Query      *query = (Query *) stmt;
  
             if (query->canSetTag)
             {
                 if (query->commandType == CMD_SELECT)
                 {
                     if (query->hasModifyingCTE)
                         return PORTAL_ONE_MOD_WITH;
                     else
                         return PORTAL_ONE_SELECT;
                 }
                 if (query->commandType == CMD_UTILITY)
                 {
                     if (UtilityReturnsTuples(query->utilityStmt))
                         return PORTAL_UTIL_SELECT;
                     /* it can't be ONE_RETURNING, so give up */
                     return PORTAL_MULTI_QUERY;
                 }
             }
         }
         else if (IsA(stmt, PlannedStmt))
         {
             PlannedStmt *pstmt = (PlannedStmt *) stmt;
  
             if (pstmt->canSetTag)
             {
                 if (pstmt->commandType == CMD_SELECT)
                 {
                     if (pstmt->hasModifyingCTE)
                         return PORTAL_ONE_MOD_WITH;
                     else
                         return PORTAL_ONE_SELECT;
                 }
                 if (pstmt->commandType == CMD_UTILITY)
                 {
                     if (UtilityReturnsTuples(pstmt->utilityStmt))
                         return PORTAL_UTIL_SELECT;
                     /* it can't be ONE_RETURNING, so give up */
                     return PORTAL_MULTI_QUERY;
                 }
             }
         }
         else
             elog(ERROR, "unrecognized node type: %d", (int) nodeTag(stmt));
     }
  
     /*
      * PORTAL_ONE_RETURNING has to allow auxiliary queries added by rewrite.
      * Choose PORTAL_ONE_RETURNING if there is exactly one canSetTag query and
      * it has a RETURNING list.
      */
     nSetTag = 0;
     foreach(lc, stmts)
     {
         Node       *stmt = (Node *) lfirst(lc);
  
         if (IsA(stmt, Query))
         {
             Query      *query = (Query *) stmt;
  
             if (query->canSetTag)
             {
                 if (++nSetTag > 1)
                     return PORTAL_MULTI_QUERY;  /* no need to look further */
                 if (query->commandType == CMD_UTILITY ||
                     query->returningList == NIL)
                     return PORTAL_MULTI_QUERY;  /* no need to look further */
             }
         }
         else if (IsA(stmt, PlannedStmt))
         {
             PlannedStmt *pstmt = (PlannedStmt *) stmt;
  
             if (pstmt->canSetTag)
             {
                 if (++nSetTag > 1)
                     return PORTAL_MULTI_QUERY;  /* no need to look further */
                 if (pstmt->commandType == CMD_UTILITY ||
                     !pstmt->hasReturning)
                     return PORTAL_MULTI_QUERY;  /* no need to look further */
             }
         }
         else
             elog(ERROR, "unrecognized node type: %d", (int) nodeTag(stmt));
     }
     if (nSetTag == 1)
         return PORTAL_ONE_RETURNING;
  
     /* Else, it's the general case... */
     return PORTAL_MULTI_QUERY;
 }

References PlannedStmt::canSetTag, CMD_SELECT, CMD_UTILITY, Query::commandType, PlannedStmt::commandType, elog, ERROR, PlannedStmt::hasModifyingCTE, PlannedStmt::hasReturning, IsA, lfirst, linitial, list_length(), NIL, nodeTag, PORTAL_MULTI_QUERY, PORTAL_ONE_MOD_WITH, PORTAL_ONE_RETURNING, PORTAL_ONE_SELECT, PORTAL_UTIL_SELECT, Query::returningList, stmt, UtilityReturnsTuples(), Query::utilityStmt, and PlannedStmt::utilityStmt.

Referenced by PlanCacheComputeResultDesc(), and PortalStart().

◆ EnsurePortalSnapshotExists()

void EnsurePortalSnapshotExists ( void )

Definition at line 1780 of file pquery.c.

 {
     Portal      portal;
  
     /*
      * Nothing to do if a snapshot is set.  (We take it on faith that the
      * outermost active snapshot belongs to some Portal; or if there is no
      * Portal, it's somebody else's responsibility to manage things.)
      */
     if (ActiveSnapshotSet())
         return;
  
     /* Otherwise, we'd better have an active Portal */
     portal = ActivePortal;
     if (unlikely(portal == NULL))
         elog(ERROR, "cannot execute SQL without an outer snapshot or portal");
     Assert(portal->portalSnapshot == NULL);
  
     /*
      * Create a new snapshot, make it active, and remember it in portal.
      * Because the portal now references the snapshot, we must tell snapmgr.c
      * that the snapshot belongs to the portal's transaction level, else we
      * risk portalSnapshot becoming a dangling pointer.
      */
     PushActiveSnapshotWithLevel(GetTransactionSnapshot(), portal->createLevel);
     /* PushActiveSnapshotWithLevel might have copied the snapshot */
     portal->portalSnapshot = GetActiveSnapshot();
 }

References ActivePortal, ActiveSnapshotSet(), Assert, PortalData::createLevel, elog, ERROR, GetActiveSnapshot(), GetTransactionSnapshot(), PortalData::portalSnapshot, PushActiveSnapshotWithLevel(), and unlikely.

Referenced by _SPI_execute_plan(), exec_eval_simple_expr(), and ExecuteCallStmt().

◆ FetchPortalTargetList()

List* FetchPortalTargetList ( Portal portal )

Definition at line 326 of file pquery.c.

 {
     /* no point in looking if we determined it doesn't return tuples */
     if (portal->strategy == PORTAL_MULTI_QUERY)
         return NIL;
     /* get the primary statement and find out what it returns */
     return FetchStatementTargetList((Node *) PortalGetPrimaryStmt(portal));
 }

References FetchStatementTargetList(), NIL, PORTAL_MULTI_QUERY, PortalGetPrimaryStmt(), and PortalData::strategy.

Referenced by exec_describe_portal_message(), FetchStatementTargetList(), and printtup_startup().

◆ FetchStatementTargetList()

List* FetchStatementTargetList ( Node * stmt )

Definition at line 348 of file pquery.c.

 {
     if (stmt == NULL)
         return NIL;
     if (IsA(stmt, Query))
     {
         Query      *query = (Query *) stmt;
  
         if (query->commandType == CMD_UTILITY)
         {
             /* transfer attention to utility statement */
             stmt = query->utilityStmt;
         }
         else
         {
             if (query->commandType == CMD_SELECT)
                 return query->targetList;
             if (query->returningList)
                 return query->returningList;
             return NIL;
         }
     }
     if (IsA(stmt, PlannedStmt))
     {
         PlannedStmt *pstmt = (PlannedStmt *) stmt;
  
         if (pstmt->commandType == CMD_UTILITY)
         {
             /* transfer attention to utility statement */
             stmt = pstmt->utilityStmt;
         }
         else
         {
             if (pstmt->commandType == CMD_SELECT)
                 return pstmt->planTree->targetlist;
             if (pstmt->hasReturning)
                 return pstmt->planTree->targetlist;
             return NIL;
         }
     }
     if (IsA(stmt, FetchStmt))
     {
         FetchStmt  *fstmt = (FetchStmt *) stmt;
         Portal      subportal;
  
         Assert(!fstmt->ismove);
         subportal = GetPortalByName(fstmt->portalname);
         Assert(PortalIsValid(subportal));
         return FetchPortalTargetList(subportal);
     }
     if (IsA(stmt, ExecuteStmt))
     {
         ExecuteStmt *estmt = (ExecuteStmt *) stmt;
         PreparedStatement *entry;
  
         entry = FetchPreparedStatement(estmt->name, true);
         return FetchPreparedStatementTargetList(entry);
     }
     return NIL;
 }

References Assert, CMD_SELECT, CMD_UTILITY, Query::commandType, PlannedStmt::commandType, FetchPortalTargetList(), FetchPreparedStatement(), FetchPreparedStatementTargetList(), GetPortalByName(), PlannedStmt::hasReturning, IsA, FetchStmt::ismove, ExecuteStmt::name, NIL, PlannedStmt::planTree, PortalIsValid, FetchStmt::portalname, Query::returningList, stmt, Query::targetList, Plan::targetlist, Query::utilityStmt, and PlannedStmt::utilityStmt.

Referenced by CachedPlanGetTargetList(), and FetchPortalTargetList().

◆ PlannedStmtRequiresSnapshot()

bool PlannedStmtRequiresSnapshot ( struct PlannedStmt * pstmt )

Definition at line 1732 of file pquery.c.

 {
     Node       *utilityStmt = pstmt->utilityStmt;
  
     /* If it's not a utility statement, it definitely needs a snapshot */
     if (utilityStmt == NULL)
         return true;
  
     /*
      * Most utility statements need a snapshot, and the default presumption
      * about new ones should be that they do too.  Hence, enumerate those that
      * do not need one.
      *
      * Transaction control, LOCK, and SET must *not* set a snapshot, since
      * they need to be executable at the start of a transaction-snapshot-mode
      * transaction without freezing a snapshot.  By extension we allow SHOW
      * not to set a snapshot.  The other stmts listed are just efficiency
      * hacks.  Beware of listing anything that can modify the database --- if,
      * say, it has to update an index with expressions that invoke
      * user-defined functions, then it had better have a snapshot.
      */
     if (IsA(utilityStmt, TransactionStmt) ||
         IsA(utilityStmt, LockStmt) ||
         IsA(utilityStmt, VariableSetStmt) ||
         IsA(utilityStmt, VariableShowStmt) ||
         IsA(utilityStmt, ConstraintsSetStmt) ||
     /* efficiency hacks from here down */
         IsA(utilityStmt, FetchStmt) ||
         IsA(utilityStmt, ListenStmt) ||
         IsA(utilityStmt, NotifyStmt) ||
         IsA(utilityStmt, UnlistenStmt) ||
         IsA(utilityStmt, CheckPointStmt))
         return false;
  
     return true;
 }

References IsA, and PlannedStmt::utilityStmt.

Referenced by _SPI_execute_plan(), and PortalRunUtility().

◆ PortalRun()

bool PortalRun	(	Portal	portal,
		long	count,
		bool	isTopLevel,
		bool	run_once,
		DestReceiver *	dest,
		DestReceiver *	altdest,
		QueryCompletion *	qc
	)

Definition at line 684 of file pquery.c.

 {
     bool        result;
     uint64      nprocessed;
     ResourceOwner saveTopTransactionResourceOwner;
     MemoryContext saveTopTransactionContext;
     Portal      saveActivePortal;
     ResourceOwner saveResourceOwner;
     MemoryContext savePortalContext;
     MemoryContext saveMemoryContext;
  
     Assert(PortalIsValid(portal));
  
     TRACE_POSTGRESQL_QUERY_EXECUTE_START();
  
     /* Initialize empty completion data */
     if (qc)
         InitializeQueryCompletion(qc);
  
     if (log_executor_stats && portal->strategy != PORTAL_MULTI_QUERY)
     {
         elog(DEBUG3, "PortalRun");
         /* PORTAL_MULTI_QUERY logs its own stats per query */
         ResetUsage();
     }
  
     /*
      * Check for improper portal use, and mark portal active.
      */
     MarkPortalActive(portal);
  
     /* Set run_once flag.  Shouldn't be clear if previously set. */
     Assert(!portal->run_once || run_once);
     portal->run_once = run_once;
  
     /*
      * Set up global portal context pointers.
      *
      * We have to play a special game here to support utility commands like
      * VACUUM and CLUSTER, which internally start and commit transactions.
      * When we are called to execute such a command, CurrentResourceOwner will
      * be pointing to the TopTransactionResourceOwner --- which will be
      * destroyed and replaced in the course of the internal commit and
      * restart.  So we need to be prepared to restore it as pointing to the
      * exit-time TopTransactionResourceOwner.  (Ain't that ugly?  This idea of
      * internally starting whole new transactions is not good.)
      * CurrentMemoryContext has a similar problem, but the other pointers we
      * save here will be NULL or pointing to longer-lived objects.
      */
     saveTopTransactionResourceOwner = TopTransactionResourceOwner;
     saveTopTransactionContext = TopTransactionContext;
     saveActivePortal = ActivePortal;
     saveResourceOwner = CurrentResourceOwner;
     savePortalContext = PortalContext;
     saveMemoryContext = CurrentMemoryContext;
     PG_TRY();
     {
         ActivePortal = portal;
         if (portal->resowner)
             CurrentResourceOwner = portal->resowner;
         PortalContext = portal->portalContext;
  
         MemoryContextSwitchTo(PortalContext);
  
         switch (portal->strategy)
         {
             case PORTAL_ONE_SELECT:
             case PORTAL_ONE_RETURNING:
             case PORTAL_ONE_MOD_WITH:
             case PORTAL_UTIL_SELECT:
  
                 /*
                  * If we have not yet run the command, do so, storing its
                  * results in the portal's tuplestore.  But we don't do that
                  * for the PORTAL_ONE_SELECT case.
                  */
                 if (portal->strategy != PORTAL_ONE_SELECT && !portal->holdStore)
                     FillPortalStore(portal, isTopLevel);
  
                 /*
                  * Now fetch desired portion of results.
                  */
                 nprocessed = PortalRunSelect(portal, true, count, dest);
  
                 /*
                  * If the portal result contains a command tag and the caller
                  * gave us a pointer to store it, copy it and update the
                  * rowcount.
                  */
                 if (qc && portal->qc.commandTag != CMDTAG_UNKNOWN)
                 {
                     CopyQueryCompletion(qc, &portal->qc);
                     qc->nprocessed = nprocessed;
                 }
  
                 /* Mark portal not active */
                 portal->status = PORTAL_READY;
  
                 /*
                  * Since it's a forward fetch, say DONE iff atEnd is now true.
                  */
                 result = portal->atEnd;
                 break;
  
             case PORTAL_MULTI_QUERY:
                 PortalRunMulti(portal, isTopLevel, false,
                                dest, altdest, qc);
  
                 /* Prevent portal's commands from being re-executed */
                 MarkPortalDone(portal);
  
                 /* Always complete at end of RunMulti */
                 result = true;
                 break;
  
             default:
                 elog(ERROR, "unrecognized portal strategy: %d",
                      (int) portal->strategy);
                 result = false; /* keep compiler quiet */
                 break;
         }
     }
     PG_CATCH();
     {
         /* Uncaught error while executing portal: mark it dead */
         MarkPortalFailed(portal);
  
         /* Restore global vars and propagate error */
         if (saveMemoryContext == saveTopTransactionContext)
             MemoryContextSwitchTo(TopTransactionContext);
         else
             MemoryContextSwitchTo(saveMemoryContext);
         ActivePortal = saveActivePortal;
         if (saveResourceOwner == saveTopTransactionResourceOwner)
             CurrentResourceOwner = TopTransactionResourceOwner;
         else
             CurrentResourceOwner = saveResourceOwner;
         PortalContext = savePortalContext;
  
         PG_RE_THROW();
     }
     PG_END_TRY();
  
     if (saveMemoryContext == saveTopTransactionContext)
         MemoryContextSwitchTo(TopTransactionContext);
     else
         MemoryContextSwitchTo(saveMemoryContext);
     ActivePortal = saveActivePortal;
     if (saveResourceOwner == saveTopTransactionResourceOwner)
         CurrentResourceOwner = TopTransactionResourceOwner;
     else
         CurrentResourceOwner = saveResourceOwner;
     PortalContext = savePortalContext;
  
     if (log_executor_stats && portal->strategy != PORTAL_MULTI_QUERY)
         ShowUsage("EXECUTOR STATISTICS");
  
     TRACE_POSTGRESQL_QUERY_EXECUTE_DONE();
  
     return result;
 }

References ActivePortal, Assert, PortalData::atEnd, QueryCompletion::commandTag, CopyQueryCompletion(), CurrentMemoryContext, CurrentResourceOwner, DEBUG3, generate_unaccent_rules::dest, elog, ERROR, FillPortalStore(), PortalData::holdStore, InitializeQueryCompletion(), log_executor_stats, MarkPortalActive(), MarkPortalDone(), MarkPortalFailed(), MemoryContextSwitchTo(), QueryCompletion::nprocessed, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PORTAL_MULTI_QUERY, PORTAL_ONE_MOD_WITH, PORTAL_ONE_RETURNING, PORTAL_ONE_SELECT, PORTAL_READY, PORTAL_UTIL_SELECT, PortalContext, PortalData::portalContext, PortalIsValid, PortalRunMulti(), PortalRunSelect(), PortalData::qc, ResetUsage(), PortalData::resowner, PortalData::run_once, ShowUsage(), PortalData::status, PortalData::strategy, TopTransactionContext, and TopTransactionResourceOwner.

Referenced by exec_execute_message(), exec_simple_query(), and ExecuteQuery().

◆ PortalRunFetch()

uint64 PortalRunFetch	(	Portal	portal,
		FetchDirection	fdirection,
		long	count,
		DestReceiver *	dest
	)

Definition at line 1391 of file pquery.c.

 {
     uint64      result;
     Portal      saveActivePortal;
     ResourceOwner saveResourceOwner;
     MemoryContext savePortalContext;
     MemoryContext oldContext;
  
     Assert(PortalIsValid(portal));
  
     /*
      * Check for improper portal use, and mark portal active.
      */
     MarkPortalActive(portal);
  
     /* If supporting FETCH, portal can't be run-once. */
     Assert(!portal->run_once);
  
     /*
      * Set up global portal context pointers.
      */
     saveActivePortal = ActivePortal;
     saveResourceOwner = CurrentResourceOwner;
     savePortalContext = PortalContext;
     PG_TRY();
     {
         ActivePortal = portal;
         if (portal->resowner)
             CurrentResourceOwner = portal->resowner;
         PortalContext = portal->portalContext;
  
         oldContext = MemoryContextSwitchTo(PortalContext);
  
         switch (portal->strategy)
         {
             case PORTAL_ONE_SELECT:
                 result = DoPortalRunFetch(portal, fdirection, count, dest);
                 break;
  
             case PORTAL_ONE_RETURNING:
             case PORTAL_ONE_MOD_WITH:
             case PORTAL_UTIL_SELECT:
  
                 /*
                  * If we have not yet run the command, do so, storing its
                  * results in the portal's tuplestore.
                  */
                 if (!portal->holdStore)
                     FillPortalStore(portal, false /* isTopLevel */ );
  
                 /*
                  * Now fetch desired portion of results.
                  */
                 result = DoPortalRunFetch(portal, fdirection, count, dest);
                 break;
  
             default:
                 elog(ERROR, "unsupported portal strategy");
                 result = 0;     /* keep compiler quiet */
                 break;
         }
     }
     PG_CATCH();
     {
         /* Uncaught error while executing portal: mark it dead */
         MarkPortalFailed(portal);
  
         /* Restore global vars and propagate error */
         ActivePortal = saveActivePortal;
         CurrentResourceOwner = saveResourceOwner;
         PortalContext = savePortalContext;
  
         PG_RE_THROW();
     }
     PG_END_TRY();
  
     MemoryContextSwitchTo(oldContext);
  
     /* Mark portal not active */
     portal->status = PORTAL_READY;
  
     ActivePortal = saveActivePortal;
     CurrentResourceOwner = saveResourceOwner;
     PortalContext = savePortalContext;
  
     return result;
 }

References ActivePortal, Assert, CurrentResourceOwner, generate_unaccent_rules::dest, DoPortalRunFetch(), elog, ERROR, FillPortalStore(), PortalData::holdStore, MarkPortalActive(), MarkPortalFailed(), MemoryContextSwitchTo(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PORTAL_ONE_MOD_WITH, PORTAL_ONE_RETURNING, PORTAL_ONE_SELECT, PORTAL_READY, PORTAL_UTIL_SELECT, PortalContext, PortalData::portalContext, PortalIsValid, PortalData::resowner, PortalData::run_once, PortalData::status, and PortalData::strategy.

Referenced by _SPI_cursor_operation(), and PerformPortalFetch().

◆ PortalSetResultFormat()

void PortalSetResultFormat	(	Portal	portal,
		int	nFormats,
		int16 *	formats
	)

Definition at line 623 of file pquery.c.

 {
     int         natts;
     int         i;
  
     /* Do nothing if portal won't return tuples */
     if (portal->tupDesc == NULL)
         return;
     natts = portal->tupDesc->natts;
     portal->formats = (int16 *)
         MemoryContextAlloc(portal->portalContext,
                            natts * sizeof(int16));
     if (nFormats > 1)
     {
         /* format specified for each column */
         if (nFormats != natts)
             ereport(ERROR,
                     (errcode(ERRCODE_PROTOCOL_VIOLATION),
                      errmsg("bind message has %d result formats but query has %d columns",
                             nFormats, natts)));
         memcpy(portal->formats, formats, natts * sizeof(int16));
     }
     else if (nFormats > 0)
     {
         /* single format specified, use for all columns */
         int16       format1 = formats[0];
  
         for (i = 0; i < natts; i++)
             portal->formats[i] = format1;
     }
     else
     {
         /* use default format for all columns */
         for (i = 0; i < natts; i++)
             portal->formats[i] = 0;
     }
 }

References ereport, errcode(), errmsg(), ERROR, PortalData::formats, i, MemoryContextAlloc(), TupleDescData::natts, PortalData::portalContext, and PortalData::tupDesc.

Referenced by exec_bind_message(), and exec_simple_query().

◆ PortalStart()

void PortalStart	(	Portal	portal,
		ParamListInfo	params,
		int	eflags,
		Snapshot	snapshot
	)

Definition at line 433 of file pquery.c.

 {
     Portal      saveActivePortal;
     ResourceOwner saveResourceOwner;
     MemoryContext savePortalContext;
     MemoryContext oldContext;
     QueryDesc  *queryDesc;
     int         myeflags;
  
     Assert(PortalIsValid(portal));
     Assert(portal->status == PORTAL_DEFINED);
  
     /*
      * Set up global portal context pointers.
      */
     saveActivePortal = ActivePortal;
     saveResourceOwner = CurrentResourceOwner;
     savePortalContext = PortalContext;
     PG_TRY();
     {
         ActivePortal = portal;
         if (portal->resowner)
             CurrentResourceOwner = portal->resowner;
         PortalContext = portal->portalContext;
  
         oldContext = MemoryContextSwitchTo(PortalContext);
  
         /* Must remember portal param list, if any */
         portal->portalParams = params;
  
         /*
          * Determine the portal execution strategy
          */
         portal->strategy = ChoosePortalStrategy(portal->stmts);
  
         /*
          * Fire her up according to the strategy
          */
         switch (portal->strategy)
         {
             case PORTAL_ONE_SELECT:
  
                 /* Must set snapshot before starting executor. */
                 if (snapshot)
                     PushActiveSnapshot(snapshot);
                 else
                     PushActiveSnapshot(GetTransactionSnapshot());
  
                 /*
                  * We could remember the snapshot in portal->portalSnapshot,
                  * but presently there seems no need to, as this code path
                  * cannot be used for non-atomic execution.  Hence there can't
                  * be any commit/abort that might destroy the snapshot.  Since
                  * we don't do that, there's also no need to force a
                  * non-default nesting level for the snapshot.
                  */
  
                 /*
                  * Create QueryDesc in portal's context; for the moment, set
                  * the destination to DestNone.
                  */
                 queryDesc = CreateQueryDesc(linitial_node(PlannedStmt, portal->stmts),
                                             portal->sourceText,
                                             GetActiveSnapshot(),
                                             InvalidSnapshot,
                                             None_Receiver,
                                             params,
                                             portal->queryEnv,
                                             0);
  
                 /*
                  * If it's a scrollable cursor, executor needs to support
                  * REWIND and backwards scan, as well as whatever the caller
                  * might've asked for.
                  */
                 if (portal->cursorOptions & CURSOR_OPT_SCROLL)
                     myeflags = eflags | EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD;
                 else
                     myeflags = eflags;
  
                 /*
                  * Call ExecutorStart to prepare the plan for execution
                  */
                 ExecutorStart(queryDesc, myeflags);
  
                 /*
                  * This tells PortalCleanup to shut down the executor
                  */
                 portal->queryDesc = queryDesc;
  
                 /*
                  * Remember tuple descriptor (computed by ExecutorStart)
                  */
                 portal->tupDesc = queryDesc->tupDesc;
  
                 /*
                  * Reset cursor position data to "start of query"
                  */
                 portal->atStart = true;
                 portal->atEnd = false;  /* allow fetches */
                 portal->portalPos = 0;
  
                 PopActiveSnapshot();
                 break;
  
             case PORTAL_ONE_RETURNING:
             case PORTAL_ONE_MOD_WITH:
  
                 /*
                  * We don't start the executor until we are told to run the
                  * portal.  We do need to set up the result tupdesc.
                  */
                 {
                     PlannedStmt *pstmt;
  
                     pstmt = PortalGetPrimaryStmt(portal);
                     portal->tupDesc =
                         ExecCleanTypeFromTL(pstmt->planTree->targetlist);
                 }
  
                 /*
                  * Reset cursor position data to "start of query"
                  */
                 portal->atStart = true;
                 portal->atEnd = false;  /* allow fetches */
                 portal->portalPos = 0;
                 break;
  
             case PORTAL_UTIL_SELECT:
  
                 /*
                  * We don't set snapshot here, because PortalRunUtility will
                  * take care of it if needed.
                  */
                 {
                     PlannedStmt *pstmt = PortalGetPrimaryStmt(portal);
  
                     Assert(pstmt->commandType == CMD_UTILITY);
                     portal->tupDesc = UtilityTupleDescriptor(pstmt->utilityStmt);
                 }
  
                 /*
                  * Reset cursor position data to "start of query"
                  */
                 portal->atStart = true;
                 portal->atEnd = false;  /* allow fetches */
                 portal->portalPos = 0;
                 break;
  
             case PORTAL_MULTI_QUERY:
                 /* Need do nothing now */
                 portal->tupDesc = NULL;
                 break;
         }
     }
     PG_CATCH();
     {
         /* Uncaught error while executing portal: mark it dead */
         MarkPortalFailed(portal);
  
         /* Restore global vars and propagate error */
         ActivePortal = saveActivePortal;
         CurrentResourceOwner = saveResourceOwner;
         PortalContext = savePortalContext;
  
         PG_RE_THROW();
     }
     PG_END_TRY();
  
     MemoryContextSwitchTo(oldContext);
  
     ActivePortal = saveActivePortal;
     CurrentResourceOwner = saveResourceOwner;
     PortalContext = savePortalContext;
  
     portal->status = PORTAL_READY;
 }