LCOV - code coverage report
Current view: top level - src/backend/utils/mmgr - portalmem.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13beta1 Lines: 296 321 92.2 %
Date: 2020-06-03 10:06:28 Functions: 26 26 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * portalmem.c
       4             :  *    backend portal memory management
       5             :  *
       6             :  * Portals are objects representing the execution state of a query.
       7             :  * This module provides memory management services for portals, but it
       8             :  * doesn't actually run the executor for them.
       9             :  *
      10             :  *
      11             :  * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
      12             :  * Portions Copyright (c) 1994, Regents of the University of California
      13             :  *
      14             :  * IDENTIFICATION
      15             :  *    src/backend/utils/mmgr/portalmem.c
      16             :  *
      17             :  *-------------------------------------------------------------------------
      18             :  */
      19             : #include "postgres.h"
      20             : 
      21             : #include "access/xact.h"
      22             : #include "catalog/pg_type.h"
      23             : #include "commands/portalcmds.h"
      24             : #include "miscadmin.h"
      25             : #include "storage/ipc.h"
      26             : #include "utils/builtins.h"
      27             : #include "utils/memutils.h"
      28             : #include "utils/snapmgr.h"
      29             : #include "utils/timestamp.h"
      30             : 
      31             : /*
      32             :  * Estimate of the maximum number of open portals a user would have,
      33             :  * used in initially sizing the PortalHashTable in EnablePortalManager().
      34             :  * Since the hash table can expand, there's no need to make this overly
      35             :  * generous, and keeping it small avoids unnecessary overhead in the
      36             :  * hash_seq_search() calls executed during transaction end.
      37             :  */
      38             : #define PORTALS_PER_USER       16
      39             : 
      40             : 
      41             : /* ----------------
      42             :  *      Global state
      43             :  * ----------------
      44             :  */
      45             : 
      46             : #define MAX_PORTALNAME_LEN      NAMEDATALEN
      47             : 
      48             : typedef struct portalhashent
      49             : {
      50             :     char        portalname[MAX_PORTALNAME_LEN];
      51             :     Portal      portal;
      52             : } PortalHashEnt;
      53             : 
      54             : static HTAB *PortalHashTable = NULL;
      55             : 
      56             : #define PortalHashTableLookup(NAME, PORTAL) \
      57             : do { \
      58             :     PortalHashEnt *hentry; \
      59             :     \
      60             :     hentry = (PortalHashEnt *) hash_search(PortalHashTable, \
      61             :                                            (NAME), HASH_FIND, NULL); \
      62             :     if (hentry) \
      63             :         PORTAL = hentry->portal; \
      64             :     else \
      65             :         PORTAL = NULL; \
      66             : } while(0)
      67             : 
      68             : #define PortalHashTableInsert(PORTAL, NAME) \
      69             : do { \
      70             :     PortalHashEnt *hentry; bool found; \
      71             :     \
      72             :     hentry = (PortalHashEnt *) hash_search(PortalHashTable, \
      73             :                                            (NAME), HASH_ENTER, &found); \
      74             :     if (found) \
      75             :         elog(ERROR, "duplicate portal name"); \
      76             :     hentry->portal = PORTAL; \
      77             :     /* To avoid duplicate storage, make PORTAL->name point to htab entry */ \
      78             :     PORTAL->name = hentry->portalname; \
      79             : } while(0)
      80             : 
      81             : #define PortalHashTableDelete(PORTAL) \
      82             : do { \
      83             :     PortalHashEnt *hentry; \
      84             :     \
      85             :     hentry = (PortalHashEnt *) hash_search(PortalHashTable, \
      86             :                                            PORTAL->name, HASH_REMOVE, NULL); \
      87             :     if (hentry == NULL) \
      88             :         elog(WARNING, "trying to delete portal name that does not exist"); \
      89             : } while(0)
      90             : 
      91             : static MemoryContext TopPortalContext = NULL;
      92             : 
      93             : 
      94             : /* ----------------------------------------------------------------
      95             :  *                 public portal interface functions
      96             :  * ----------------------------------------------------------------
      97             :  */
      98             : 
      99             : /*
     100             :  * EnablePortalManager
     101             :  *      Enables the portal management module at backend startup.
     102             :  */
     103             : void
     104       11154 : EnablePortalManager(void)
     105             : {
     106             :     HASHCTL     ctl;
     107             : 
     108             :     Assert(TopPortalContext == NULL);
     109             : 
     110       11154 :     TopPortalContext = AllocSetContextCreate(TopMemoryContext,
     111             :                                              "TopPortalContext",
     112             :                                              ALLOCSET_DEFAULT_SIZES);
     113             : 
     114       11154 :     ctl.keysize = MAX_PORTALNAME_LEN;
     115       11154 :     ctl.entrysize = sizeof(PortalHashEnt);
     116             : 
     117             :     /*
     118             :      * use PORTALS_PER_USER as a guess of how many hash table entries to
     119             :      * create, initially
     120             :      */
     121       11154 :     PortalHashTable = hash_create("Portal hash", PORTALS_PER_USER,
     122             :                                   &ctl, HASH_ELEM);
     123       11154 : }
     124             : 
     125             : /*
     126             :  * GetPortalByName
     127             :  *      Returns a portal given a portal name, or NULL if name not found.
     128             :  */
     129             : Portal
     130      624614 : GetPortalByName(const char *name)
     131             : {
     132             :     Portal      portal;
     133             : 
     134      624614 :     if (PointerIsValid(name))
     135      624614 :         PortalHashTableLookup(name, portal);
     136             :     else
     137           0 :         portal = NULL;
     138             : 
     139      624614 :     return portal;
     140             : }
     141             : 
     142             : /*
     143             :  * PortalGetPrimaryStmt
     144             :  *      Get the "primary" stmt within a portal, ie, the one marked canSetTag.
     145             :  *
     146             :  * Returns NULL if no such stmt.  If multiple PlannedStmt structs within the
     147             :  * portal are marked canSetTag, returns the first one.  Neither of these
     148             :  * cases should occur in present usages of this function.
     149             :  */
     150             : PlannedStmt *
     151      180688 : PortalGetPrimaryStmt(Portal portal)
     152             : {
     153             :     ListCell   *lc;
     154             : 
     155      180688 :     foreach(lc, portal->stmts)
     156             :     {
     157      180688 :         PlannedStmt *stmt = lfirst_node(PlannedStmt, lc);
     158             : 
     159      180688 :         if (stmt->canSetTag)
     160      180688 :             return stmt;
     161             :     }
     162           0 :     return NULL;
     163             : }
     164             : 
     165             : /*
     166             :  * CreatePortal
     167             :  *      Returns a new portal given a name.
     168             :  *
     169             :  * allowDup: if true, automatically drop any pre-existing portal of the
     170             :  * same name (if false, an error is raised).
     171             :  *
     172             :  * dupSilent: if true, don't even emit a WARNING.
     173             :  */
     174             : Portal
     175      542368 : CreatePortal(const char *name, bool allowDup, bool dupSilent)
     176             : {
     177             :     Portal      portal;
     178             : 
     179             :     AssertArg(PointerIsValid(name));
     180             : 
     181      542368 :     portal = GetPortalByName(name);
     182      542368 :     if (PortalIsValid(portal))
     183             :     {
     184        5884 :         if (!allowDup)
     185           0 :             ereport(ERROR,
     186             :                     (errcode(ERRCODE_DUPLICATE_CURSOR),
     187             :                      errmsg("cursor \"%s\" already exists", name)));
     188        5884 :         if (!dupSilent)
     189           0 :             ereport(WARNING,
     190             :                     (errcode(ERRCODE_DUPLICATE_CURSOR),
     191             :                      errmsg("closing existing cursor \"%s\"",
     192             :                             name)));
     193        5884 :         PortalDrop(portal, false);
     194             :     }
     195             : 
     196             :     /* make new portal structure */
     197      542368 :     portal = (Portal) MemoryContextAllocZero(TopPortalContext, sizeof *portal);
     198             : 
     199             :     /* initialize portal context; typically it won't store much */
     200      542368 :     portal->portalContext = AllocSetContextCreate(TopPortalContext,
     201             :                                                   "PortalContext",
     202             :                                                   ALLOCSET_SMALL_SIZES);
     203             : 
     204             :     /* create a resource owner for the portal */
     205      542368 :     portal->resowner = ResourceOwnerCreate(CurTransactionResourceOwner,
     206             :                                            "Portal");
     207             : 
     208             :     /* initialize portal fields that don't start off zero */
     209      542368 :     portal->status = PORTAL_NEW;
     210      542368 :     portal->cleanup = PortalCleanup;
     211      542368 :     portal->createSubid = GetCurrentSubTransactionId();
     212      542368 :     portal->activeSubid = portal->createSubid;
     213      542368 :     portal->strategy = PORTAL_MULTI_QUERY;
     214      542368 :     portal->cursorOptions = CURSOR_OPT_NO_SCROLL;
     215      542368 :     portal->atStart = true;
     216      542368 :     portal->atEnd = true;        /* disallow fetches until query is set */
     217      542368 :     portal->visible = true;
     218      542368 :     portal->creation_time = GetCurrentStatementStartTimestamp();
     219             : 
     220             :     /* put portal in table (sets portal->name) */
     221      542368 :     PortalHashTableInsert(portal, name);
     222             : 
     223             :     /* reuse portal->name copy */
     224      542368 :     MemoryContextSetIdentifier(portal->portalContext, portal->name);
     225             : 
     226      542368 :     return portal;
     227             : }
     228             : 
     229             : /*
     230             :  * CreateNewPortal
     231             :  *      Create a new portal, assigning it a random nonconflicting name.
     232             :  */
     233             : Portal
     234        6152 : CreateNewPortal(void)
     235             : {
     236             :     static unsigned int unnamed_portal_count = 0;
     237             : 
     238             :     char        portalname[MAX_PORTALNAME_LEN];
     239             : 
     240             :     /* Select a nonconflicting name */
     241             :     for (;;)
     242             :     {
     243           0 :         unnamed_portal_count++;
     244        6152 :         sprintf(portalname, "<unnamed portal %u>", unnamed_portal_count);
     245        6152 :         if (GetPortalByName(portalname) == NULL)
     246        6152 :             break;
     247             :     }
     248             : 
     249        6152 :     return CreatePortal(portalname, false, false);
     250             : }
     251             : 
     252             : /*
     253             :  * PortalDefineQuery
     254             :  *      A simple subroutine to establish a portal's query.
     255             :  *
     256             :  * Notes: as of PG 8.4, caller MUST supply a sourceText string; it is not
     257             :  * allowed anymore to pass NULL.  (If you really don't have source text,
     258             :  * you can pass a constant string, perhaps "(query not available)".)
     259             :  *
     260             :  * commandTag shall be NULL if and only if the original query string
     261             :  * (before rewriting) was an empty string.  Also, the passed commandTag must
     262             :  * be a pointer to a constant string, since it is not copied.
     263             :  *
     264             :  * If cplan is provided, then it is a cached plan containing the stmts, and
     265             :  * the caller must have done GetCachedPlan(), causing a refcount increment.
     266             :  * The refcount will be released when the portal is destroyed.
     267             :  *
     268             :  * If cplan is NULL, then it is the caller's responsibility to ensure that
     269             :  * the passed plan trees have adequate lifetime.  Typically this is done by
     270             :  * copying them into the portal's context.
     271             :  *
     272             :  * The caller is also responsible for ensuring that the passed prepStmtName
     273             :  * (if not NULL) and sourceText have adequate lifetime.
     274             :  *
     275             :  * NB: this function mustn't do much beyond storing the passed values; in
     276             :  * particular don't do anything that risks elog(ERROR).  If that were to
     277             :  * happen here before storing the cplan reference, we'd leak the plancache
     278             :  * refcount that the caller is trying to hand off to us.
     279             :  */
     280             : void
     281      542348 : PortalDefineQuery(Portal portal,
     282             :                   const char *prepStmtName,
     283             :                   const char *sourceText,
     284             :                   CommandTag commandTag,
     285             :                   List *stmts,
     286             :                   CachedPlan *cplan)
     287             : {
     288             :     AssertArg(PortalIsValid(portal));
     289             :     AssertState(portal->status == PORTAL_NEW);
     290             : 
     291             :     AssertArg(sourceText != NULL);
     292             :     AssertArg(commandTag != CMDTAG_UNKNOWN || stmts == NIL);
     293             : 
     294      542348 :     portal->prepStmtName = prepStmtName;
     295      542348 :     portal->sourceText = sourceText;
     296      542348 :     portal->qc.commandTag = commandTag;
     297      542348 :     portal->qc.nprocessed = 0;
     298      542348 :     portal->commandTag = commandTag;
     299      542348 :     portal->stmts = stmts;
     300      542348 :     portal->cplan = cplan;
     301      542348 :     portal->status = PORTAL_DEFINED;
     302      542348 : }
     303             : 
     304             : /*
     305             :  * PortalReleaseCachedPlan
     306             :  *      Release a portal's reference to its cached plan, if any.
     307             :  */
     308             : static void
     309      555730 : PortalReleaseCachedPlan(Portal portal)
     310             : {
     311      555730 :     if (portal->cplan)
     312             :     {
     313       29006 :         ReleaseCachedPlan(portal->cplan, false);
     314       29006 :         portal->cplan = NULL;
     315             : 
     316             :         /*
     317             :          * We must also clear portal->stmts which is now a dangling reference
     318             :          * to the cached plan's plan list.  This protects any code that might
     319             :          * try to examine the Portal later.
     320             :          */
     321       29006 :         portal->stmts = NIL;
     322             :     }
     323      555730 : }
     324             : 
     325             : /*
     326             :  * PortalCreateHoldStore
     327             :  *      Create the tuplestore for a portal.
     328             :  */
     329             : void
     330       17326 : PortalCreateHoldStore(Portal portal)
     331             : {
     332             :     MemoryContext oldcxt;
     333             : 
     334             :     Assert(portal->holdContext == NULL);
     335             :     Assert(portal->holdStore == NULL);
     336             :     Assert(portal->holdSnapshot == NULL);
     337             : 
     338             :     /*
     339             :      * Create the memory context that is used for storage of the tuple set.
     340             :      * Note this is NOT a child of the portal's portalContext.
     341             :      */
     342       17326 :     portal->holdContext =
     343       17326 :         AllocSetContextCreate(TopPortalContext,
     344             :                               "PortalHoldContext",
     345             :                               ALLOCSET_DEFAULT_SIZES);
     346             : 
     347             :     /*
     348             :      * Create the tuple store, selecting cross-transaction temp files, and
     349             :      * enabling random access only if cursor requires scrolling.
     350             :      *
     351             :      * XXX: Should maintenance_work_mem be used for the portal size?
     352             :      */
     353       17326 :     oldcxt = MemoryContextSwitchTo(portal->holdContext);
     354             : 
     355       17326 :     portal->holdStore =
     356       17326 :         tuplestore_begin_heap(portal->cursorOptions & CURSOR_OPT_SCROLL,
     357             :                               true, work_mem);
     358             : 
     359       17326 :     MemoryContextSwitchTo(oldcxt);
     360       17326 : }
     361             : 
     362             : /*
     363             :  * PinPortal
     364             :  *      Protect a portal from dropping.
     365             :  *
     366             :  * A pinned portal is still unpinned and dropped at transaction or
     367             :  * subtransaction abort.
     368             :  */
     369             : void
     370        4308 : PinPortal(Portal portal)
     371             : {
     372        4308 :     if (portal->portalPinned)
     373           0 :         elog(ERROR, "portal already pinned");
     374             : 
     375        4308 :     portal->portalPinned = true;
     376        4308 : }
     377             : 
     378             : void
     379        4272 : UnpinPortal(Portal portal)
     380             : {
     381        4272 :     if (!portal->portalPinned)
     382           0 :         elog(ERROR, "portal not pinned");
     383             : 
     384        4272 :     portal->portalPinned = false;
     385        4272 : }
     386             : 
     387             : /*
     388             :  * MarkPortalActive
     389             :  *      Transition a portal from READY to ACTIVE state.
     390             :  *
     391             :  * NOTE: never set portal->status = PORTAL_ACTIVE directly; call this instead.
     392             :  */
     393             : void
     394      549834 : MarkPortalActive(Portal portal)
     395             : {
     396             :     /* For safety, this is a runtime test not just an Assert */
     397      549834 :     if (portal->status != PORTAL_READY)
     398          12 :         ereport(ERROR,
     399             :                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
     400             :                  errmsg("portal \"%s\" cannot be run", portal->name)));
     401             :     /* Perform the state transition */
     402      549822 :     portal->status = PORTAL_ACTIVE;
     403      549822 :     portal->activeSubid = GetCurrentSubTransactionId();
     404      549822 : }
     405             : 
     406             : /*
     407             :  * MarkPortalDone
     408             :  *      Transition a portal from ACTIVE to DONE state.
     409             :  *
     410             :  * NOTE: never set portal->status = PORTAL_DONE directly; call this instead.
     411             :  */
     412             : void
     413      364740 : MarkPortalDone(Portal portal)
     414             : {
     415             :     /* Perform the state transition */
     416             :     Assert(portal->status == PORTAL_ACTIVE);
     417      364740 :     portal->status = PORTAL_DONE;
     418             : 
     419             :     /*
     420             :      * Allow portalcmds.c to clean up the state it knows about.  We might as
     421             :      * well do that now, since the portal can't be executed any more.
     422             :      *
     423             :      * In some cases involving execution of a ROLLBACK command in an already
     424             :      * aborted transaction, this is necessary, or we'd reach AtCleanup_Portals
     425             :      * with the cleanup hook still unexecuted.
     426             :      */
     427      364740 :     if (PointerIsValid(portal->cleanup))
     428             :     {
     429      364704 :         portal->cleanup(portal);
     430      364704 :         portal->cleanup = NULL;
     431             :     }
     432      364740 : }
     433             : 
     434             : /*
     435             :  * MarkPortalFailed
     436             :  *      Transition a portal into FAILED state.
     437             :  *
     438             :  * NOTE: never set portal->status = PORTAL_FAILED directly; call this instead.
     439             :  */
     440             : void
     441       13154 : MarkPortalFailed(Portal portal)
     442             : {
     443             :     /* Perform the state transition */
     444             :     Assert(portal->status != PORTAL_DONE);
     445       13154 :     portal->status = PORTAL_FAILED;
     446             : 
     447             :     /*
     448             :      * Allow portalcmds.c to clean up the state it knows about.  We might as
     449             :      * well do that now, since the portal can't be executed any more.
     450             :      *
     451             :      * In some cases involving cleanup of an already aborted transaction, this
     452             :      * is necessary, or we'd reach AtCleanup_Portals with the cleanup hook
     453             :      * still unexecuted.
     454             :      */
     455       13154 :     if (PointerIsValid(portal->cleanup))
     456             :     {
     457       13154 :         portal->cleanup(portal);
     458       13154 :         portal->cleanup = NULL;
     459             :     }
     460       13154 : }
     461             : 
     462             : /*
     463             :  * PortalDrop
     464             :  *      Destroy the portal.
     465             :  */
     466             : void
     467      542360 : PortalDrop(Portal portal, bool isTopCommit)
     468             : {
     469             :     AssertArg(PortalIsValid(portal));
     470             : 
     471             :     /*
     472             :      * Don't allow dropping a pinned portal, it's still needed by whoever
     473             :      * pinned it.
     474             :      */
     475      542360 :     if (portal->portalPinned)
     476           0 :         ereport(ERROR,
     477             :                 (errcode(ERRCODE_INVALID_CURSOR_STATE),
     478             :                  errmsg("cannot drop pinned portal \"%s\"", portal->name)));
     479             : 
     480             :     /*
     481             :      * Not sure if the PORTAL_ACTIVE case can validly happen or not...
     482             :      */
     483      542360 :     if (portal->status == PORTAL_ACTIVE)
     484           0 :         ereport(ERROR,
     485             :                 (errcode(ERRCODE_INVALID_CURSOR_STATE),
     486             :                  errmsg("cannot drop active portal \"%s\"", portal->name)));
     487             : 
     488             :     /*
     489             :      * Allow portalcmds.c to clean up the state it knows about, in particular
     490             :      * shutting down the executor if still active.  This step potentially runs
     491             :      * user-defined code so failure has to be expected.  It's the cleanup
     492             :      * hook's responsibility to not try to do that more than once, in the case
     493             :      * that failure occurs and then we come back to drop the portal again
     494             :      * during transaction abort.
     495             :      *
     496             :      * Note: in most paths of control, this will have been done already in
     497             :      * MarkPortalDone or MarkPortalFailed.  We're just making sure.
     498             :      */
     499      542360 :     if (PointerIsValid(portal->cleanup))
     500             :     {
     501      164444 :         portal->cleanup(portal);
     502      164444 :         portal->cleanup = NULL;
     503             :     }
     504             : 
     505             :     /*
     506             :      * Remove portal from hash table.  Because we do this here, we will not
     507             :      * come back to try to remove the portal again if there's any error in the
     508             :      * subsequent steps.  Better to leak a little memory than to get into an
     509             :      * infinite error-recovery loop.
     510             :      */
     511      542360 :     PortalHashTableDelete(portal);
     512             : 
     513             :     /* drop cached plan reference, if any */
     514      542360 :     PortalReleaseCachedPlan(portal);
     515             : 
     516             :     /*
     517             :      * If portal has a snapshot protecting its data, release that.  This needs
     518             :      * a little care since the registration will be attached to the portal's
     519             :      * resowner; if the portal failed, we will already have released the
     520             :      * resowner (and the snapshot) during transaction abort.
     521             :      */
     522      542360 :     if (portal->holdSnapshot)
     523             :     {
     524       12502 :         if (portal->resowner)
     525       12356 :             UnregisterSnapshotFromOwner(portal->holdSnapshot,
     526             :                                         portal->resowner);
     527       12502 :         portal->holdSnapshot = NULL;
     528             :     }
     529             : 
     530             :     /*
     531             :      * Release any resources still attached to the portal.  There are several
     532             :      * cases being covered here:
     533             :      *
     534             :      * Top transaction commit (indicated by isTopCommit): normally we should
     535             :      * do nothing here and let the regular end-of-transaction resource
     536             :      * releasing mechanism handle these resources too.  However, if we have a
     537             :      * FAILED portal (eg, a cursor that got an error), we'd better clean up
     538             :      * its resources to avoid resource-leakage warning messages.
     539             :      *
     540             :      * Sub transaction commit: never comes here at all, since we don't kill
     541             :      * any portals in AtSubCommit_Portals().
     542             :      *
     543             :      * Main or sub transaction abort: we will do nothing here because
     544             :      * portal->resowner was already set NULL; the resources were already
     545             :      * cleaned up in transaction abort.
     546             :      *
     547             :      * Ordinary portal drop: must release resources.  However, if the portal
     548             :      * is not FAILED then we do not release its locks.  The locks become the
     549             :      * responsibility of the transaction's ResourceOwner (since it is the
     550             :      * parent of the portal's owner) and will be released when the transaction
     551             :      * eventually ends.
     552             :      */
     553      542360 :     if (portal->resowner &&
     554      524262 :         (!isTopCommit || portal->status == PORTAL_FAILED))
     555             :     {
     556      503170 :         bool        isCommit = (portal->status != PORTAL_FAILED);
     557             : 
     558      503170 :         ResourceOwnerRelease(portal->resowner,
     559             :                              RESOURCE_RELEASE_BEFORE_LOCKS,
     560             :                              isCommit, false);
     561      503170 :         ResourceOwnerRelease(portal->resowner,
     562             :                              RESOURCE_RELEASE_LOCKS,
     563             :                              isCommit, false);
     564      503170 :         ResourceOwnerRelease(portal->resowner,
     565             :                              RESOURCE_RELEASE_AFTER_LOCKS,
     566             :                              isCommit, false);
     567      503170 :         ResourceOwnerDelete(portal->resowner);
     568             :     }
     569      542360 :     portal->resowner = NULL;
     570             : 
     571             :     /*
     572             :      * Delete tuplestore if present.  We should do this even under error
     573             :      * conditions; since the tuplestore would have been using cross-
     574             :      * transaction storage, its temp files need to be explicitly deleted.
     575             :      */
     576      542360 :     if (portal->holdStore)
     577             :     {
     578             :         MemoryContext oldcontext;
     579             : 
     580       17318 :         oldcontext = MemoryContextSwitchTo(portal->holdContext);
     581       17318 :         tuplestore_end(portal->holdStore);
     582       17318 :         MemoryContextSwitchTo(oldcontext);
     583       17318 :         portal->holdStore = NULL;
     584             :     }
     585             : 
     586             :     /* delete tuplestore storage, if any */
     587      542360 :     if (portal->holdContext)
     588       17318 :         MemoryContextDelete(portal->holdContext);
     589             : 
     590             :     /* release subsidiary storage */
     591      542360 :     MemoryContextDelete(portal->portalContext);
     592             : 
     593             :     /* release portal struct (it's in TopPortalContext) */
     594      542360 :     pfree(portal);
     595      542360 : }
     596             : 
     597             : /*
     598             :  * Delete all declared cursors.
     599             :  *
     600             :  * Used by commands: CLOSE ALL, DISCARD ALL
     601             :  */
     602             : void
     603          12 : PortalHashTableDeleteAll(void)
     604             : {
     605             :     HASH_SEQ_STATUS status;
     606             :     PortalHashEnt *hentry;
     607             : 
     608          12 :     if (PortalHashTable == NULL)
     609           0 :         return;
     610             : 
     611          12 :     hash_seq_init(&status, PortalHashTable);
     612          48 :     while ((hentry = hash_seq_search(&status)) != NULL)
     613             :     {
     614          36 :         Portal      portal = hentry->portal;
     615             : 
     616             :         /* Can't close the active portal (the one running the command) */
     617          36 :         if (portal->status == PORTAL_ACTIVE)
     618          20 :             continue;
     619             : 
     620          16 :         PortalDrop(portal, false);
     621             : 
     622             :         /* Restart the iteration in case that led to other drops */
     623          16 :         hash_seq_term(&status);
     624          16 :         hash_seq_init(&status, PortalHashTable);
     625             :     }
     626             : }
     627             : 
     628             : /*
     629             :  * "Hold" a portal.  Prepare it for access by later transactions.
     630             :  */
     631             : static void
     632          48 : HoldPortal(Portal portal)
     633             : {
     634             :     /*
     635             :      * Note that PersistHoldablePortal() must release all resources used by
     636             :      * the portal that are local to the creating transaction.
     637             :      */
     638          48 :     PortalCreateHoldStore(portal);
     639          48 :     PersistHoldablePortal(portal);
     640             : 
     641             :     /* drop cached plan reference, if any */
     642          44 :     PortalReleaseCachedPlan(portal);
     643             : 
     644             :     /*
     645             :      * Any resources belonging to the portal will be released in the upcoming
     646             :      * transaction-wide cleanup; the portal will no longer have its own
     647             :      * resources.
     648             :      */
     649          44 :     portal->resowner = NULL;
     650             : 
     651             :     /*
     652             :      * Having successfully exported the holdable cursor, mark it as not
     653             :      * belonging to this transaction.
     654             :      */
     655          44 :     portal->createSubid = InvalidSubTransactionId;
     656          44 :     portal->activeSubid = InvalidSubTransactionId;
     657          44 : }
     658             : 
     659             : /*
     660             :  * Pre-commit processing for portals.
     661             :  *
     662             :  * Holdable cursors created in this transaction need to be converted to
     663             :  * materialized form, since we are going to close down the executor and
     664             :  * release locks.  Non-holdable portals created in this transaction are
     665             :  * simply removed.  Portals remaining from prior transactions should be
     666             :  * left untouched.
     667             :  *
     668             :  * Returns true if any portals changed state (possibly causing user-defined
     669             :  * code to be run), false if not.
     670             :  */
     671             : bool
     672      496794 : PreCommit_Portals(bool isPrepare)
     673             : {
     674      496794 :     bool        result = false;
     675             :     HASH_SEQ_STATUS status;
     676             :     PortalHashEnt *hentry;
     677             : 
     678      496794 :     hash_seq_init(&status, PortalHashTable);
     679             : 
     680      599634 :     while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
     681             :     {
     682      102840 :         Portal      portal = hentry->portal;
     683             : 
     684             :         /*
     685             :          * There should be no pinned portals anymore. Complain if someone
     686             :          * leaked one. Auto-held portals are allowed; we assume that whoever
     687             :          * pinned them is managing them.
     688             :          */
     689      102840 :         if (portal->portalPinned && !portal->autoHeld)
     690           0 :             elog(ERROR, "cannot commit while a portal is pinned");
     691             : 
     692             :         /*
     693             :          * Do not touch active portals --- this can only happen in the case of
     694             :          * a multi-transaction utility command, such as VACUUM, or a commit in
     695             :          * a procedure.
     696             :          *
     697             :          * Note however that any resource owner attached to such a portal is
     698             :          * still going to go away, so don't leave a dangling pointer.  Also
     699             :          * unregister any snapshots held by the portal, mainly to avoid
     700             :          * snapshot leak warnings from ResourceOwnerRelease().
     701             :          */
     702      102840 :         if (portal->status == PORTAL_ACTIVE)
     703             :         {
     704       81448 :             if (portal->holdSnapshot)
     705             :             {
     706           2 :                 if (portal->resowner)
     707           2 :                     UnregisterSnapshotFromOwner(portal->holdSnapshot,
     708             :                                                 portal->resowner);
     709           2 :                 portal->holdSnapshot = NULL;
     710             :             }
     711       81448 :             portal->resowner = NULL;
     712       81448 :             continue;
     713             :         }
     714             : 
     715             :         /* Is it a holdable portal created in the current xact? */
     716       21392 :         if ((portal->cursorOptions & CURSOR_OPT_HOLD) &&
     717         240 :             portal->createSubid != InvalidSubTransactionId &&
     718          20 :             portal->status == PORTAL_READY)
     719             :         {
     720             :             /*
     721             :              * We are exiting the transaction that created a holdable cursor.
     722             :              * Instead of dropping the portal, prepare it for access by later
     723             :              * transactions.
     724             :              *
     725             :              * However, if this is PREPARE TRANSACTION rather than COMMIT,
     726             :              * refuse PREPARE, because the semantics seem pretty unclear.
     727             :              */
     728          20 :             if (isPrepare)
     729           0 :                 ereport(ERROR,
     730             :                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     731             :                          errmsg("cannot PREPARE a transaction that has created a cursor WITH HOLD")));
     732             : 
     733          20 :             HoldPortal(portal);
     734             : 
     735             :             /* Report we changed state */
     736          20 :             result = true;
     737             :         }
     738       21372 :         else if (portal->createSubid == InvalidSubTransactionId)
     739             :         {
     740             :             /*
     741             :              * Do nothing to cursors held over from a previous transaction
     742             :              * (including ones we just froze in a previous cycle of this loop)
     743             :              */
     744         280 :             continue;
     745             :         }
     746             :         else
     747             :         {
     748             :             /* Zap all non-holdable portals */
     749       21092 :             PortalDrop(portal, true);
     750             : 
     751             :             /* Report we changed state */
     752       21092 :             result = true;
     753             :         }
     754             : 
     755             :         /*
     756             :          * After either freezing or dropping a portal, we have to restart the
     757             :          * iteration, because we could have invoked user-defined code that
     758             :          * caused a drop of the next portal in the hash chain.
     759             :          */
     760       21112 :         hash_seq_term(&status);
     761       21112 :         hash_seq_init(&status, PortalHashTable);
     762             :     }
     763             : 
     764      496794 :     return result;
     765             : }
     766             : 
     767             : /*
     768             :  * Abort processing for portals.
     769             :  *
     770             :  * At this point we run the cleanup hook if present, but we can't release the
     771             :  * portal's memory until the cleanup call.
     772             :  */
     773             : void
     774       20420 : AtAbort_Portals(void)
     775             : {
     776             :     HASH_SEQ_STATUS status;
     777             :     PortalHashEnt *hentry;
     778             : 
     779       20420 :     hash_seq_init(&status, PortalHashTable);
     780             : 
     781       33720 :     while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
     782             :     {
     783       13300 :         Portal      portal = hentry->portal;
     784             : 
     785             :         /*
     786             :          * When elog(FATAL) is progress, we need to set the active portal to
     787             :          * failed, so that PortalCleanup() doesn't run the executor shutdown.
     788             :          */
     789       13300 :         if (portal->status == PORTAL_ACTIVE && shmem_exit_inprogress)
     790           0 :             MarkPortalFailed(portal);
     791             : 
     792             :         /*
     793             :          * Do nothing else to cursors held over from a previous transaction.
     794             :          */
     795       13300 :         if (portal->createSubid == InvalidSubTransactionId)
     796         102 :             continue;
     797             : 
     798             :         /*
     799             :          * Do nothing to auto-held cursors.  This is similar to the case of a
     800             :          * cursor from a previous transaction, but it could also be that the
     801             :          * cursor was auto-held in this transaction, so it wants to live on.
     802             :          */
     803       13198 :         if (portal->autoHeld)
     804           0 :             continue;
     805             : 
     806             :         /*
     807             :          * If it was created in the current transaction, we can't do normal
     808             :          * shutdown on a READY portal either; it might refer to objects
     809             :          * created in the failed transaction.  See comments in
     810             :          * AtSubAbort_Portals.
     811             :          */
     812       13198 :         if (portal->status == PORTAL_READY)
     813         212 :             MarkPortalFailed(portal);
     814             : 
     815             :         /*
     816             :          * Allow portalcmds.c to clean up the state it knows about, if we
     817             :          * haven't already.
     818             :          */
     819       13198 :         if (PointerIsValid(portal->cleanup))
     820             :         {
     821          58 :             portal->cleanup(portal);
     822          58 :             portal->cleanup = NULL;
     823             :         }
     824             : 
     825             :         /* drop cached plan reference, if any */
     826       13198 :         PortalReleaseCachedPlan(portal);
     827             : 
     828             :         /*
     829             :          * Any resources belonging to the portal will be released in the
     830             :          * upcoming transaction-wide cleanup; they will be gone before we run
     831             :          * PortalDrop.
     832             :          */
     833       13198 :         portal->resowner = NULL;
     834             : 
     835             :         /*
     836             :          * Although we can't delete the portal data structure proper, we can
     837             :          * release any memory in subsidiary contexts, such as executor state.
     838             :          * The cleanup hook was the last thing that might have needed data
     839             :          * there.  But leave active portals alone.
     840             :          */
     841       13198 :         if (portal->status != PORTAL_ACTIVE)
     842       13054 :             MemoryContextDeleteChildren(portal->portalContext);
     843             :     }
     844       20420 : }
     845             : 
     846             : /*
     847             :  * Post-abort cleanup for portals.
     848             :  *
     849             :  * Delete all portals not held over from prior transactions.  */
     850             : void
     851       20408 : AtCleanup_Portals(void)
     852             : {
     853             :     HASH_SEQ_STATUS status;
     854             :     PortalHashEnt *hentry;
     855             : 
     856       20408 :     hash_seq_init(&status, PortalHashTable);
     857             : 
     858       32910 :     while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
     859             :     {
     860       12502 :         Portal      portal = hentry->portal;
     861             : 
     862             :         /*
     863             :          * Do not touch active portals --- this can only happen in the case of
     864             :          * a multi-transaction command.
     865             :          */
     866       12502 :         if (portal->status == PORTAL_ACTIVE)
     867         144 :             continue;
     868             : 
     869             :         /*
     870             :          * Do nothing to cursors held over from a previous transaction or
     871             :          * auto-held ones.
     872             :          */
     873       12358 :         if (portal->createSubid == InvalidSubTransactionId || portal->autoHeld)
     874             :         {
     875             :             Assert(portal->status != PORTAL_ACTIVE);
     876             :             Assert(portal->resowner == NULL);
     877         102 :             continue;
     878             :         }
     879             : 
     880             :         /*
     881             :          * If a portal is still pinned, forcibly unpin it. PortalDrop will not
     882             :          * let us drop the portal otherwise. Whoever pinned the portal was
     883             :          * interrupted by the abort too and won't try to use it anymore.
     884             :          */
     885       12256 :         if (portal->portalPinned)
     886          26 :             portal->portalPinned = false;
     887             : 
     888             :         /*
     889             :          * We had better not call any user-defined code during cleanup, so if
     890             :          * the cleanup hook hasn't been run yet, too bad; we'll just skip it.
     891             :          */
     892       12256 :         if (PointerIsValid(portal->cleanup))
     893             :         {
     894           0 :             elog(WARNING, "skipping cleanup for portal \"%s\"", portal->name);
     895           0 :             portal->cleanup = NULL;
     896             :         }
     897             : 
     898             :         /* Zap it. */
     899       12256 :         PortalDrop(portal, false);
     900             :     }
     901       20408 : }
     902             : 
     903             : /*
     904             :  * Portal-related cleanup when we return to the main loop on error.
     905             :  *
     906             :  * This is different from the cleanup at transaction abort.  Auto-held portals
     907             :  * are cleaned up on error but not on transaction abort.
     908             :  */
     909             : void
     910       18938 : PortalErrorCleanup(void)
     911             : {
     912             :     HASH_SEQ_STATUS status;
     913             :     PortalHashEnt *hentry;
     914             : 
     915       18938 :     hash_seq_init(&status, PortalHashTable);
     916             : 
     917       20030 :     while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
     918             :     {
     919        1092 :         Portal      portal = hentry->portal;
     920             : 
     921        1092 :         if (portal->autoHeld)
     922             :         {
     923           4 :             portal->portalPinned = false;
     924           4 :             PortalDrop(portal, false);
     925             :         }
     926             :     }
     927       18938 : }
     928             : 
     929             : /*
     930             :  * Pre-subcommit processing for portals.
     931             :  *
     932             :  * Reassign portals created or used in the current subtransaction to the
     933             :  * parent subtransaction.
     934             :  */
     935             : void
     936        4714 : AtSubCommit_Portals(SubTransactionId mySubid,
     937             :                     SubTransactionId parentSubid,
     938             :                     ResourceOwner parentXactOwner)
     939             : {
     940             :     HASH_SEQ_STATUS status;
     941             :     PortalHashEnt *hentry;
     942             : 
     943        4714 :     hash_seq_init(&status, PortalHashTable);
     944             : 
     945        9132 :     while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
     946             :     {
     947        4418 :         Portal      portal = hentry->portal;
     948             : 
     949        4418 :         if (portal->createSubid == mySubid)
     950             :         {
     951          58 :             portal->createSubid = parentSubid;
     952          58 :             if (portal->resowner)
     953          58 :                 ResourceOwnerNewParent(portal->resowner, parentXactOwner);
     954             :         }
     955        4418 :         if (portal->activeSubid == mySubid)
     956         208 :             portal->activeSubid = parentSubid;
     957             :     }
     958        4714 : }
     959             : 
     960             : /*
     961             :  * Subtransaction abort handling for portals.
     962             :  *
     963             :  * Deactivate portals created or used during the failed subtransaction.
     964             :  * Note that per AtSubCommit_Portals, this will catch portals created/used
     965             :  * in descendants of the subtransaction too.
     966             :  *
     967             :  * We don't destroy any portals here; that's done in AtSubCleanup_Portals.
     968             :  */
     969             : void
     970        2966 : AtSubAbort_Portals(SubTransactionId mySubid,
     971             :                    SubTransactionId parentSubid,
     972             :                    ResourceOwner myXactOwner,
     973             :                    ResourceOwner parentXactOwner)
     974             : {
     975             :     HASH_SEQ_STATUS status;
     976             :     PortalHashEnt *hentry;
     977             : 
     978        2966 :     hash_seq_init(&status, PortalHashTable);
     979             : 
     980        7872 :     while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
     981             :     {
     982        4906 :         Portal      portal = hentry->portal;
     983             : 
     984             :         /* Was it created in this subtransaction? */
     985        4906 :         if (portal->createSubid != mySubid)
     986             :         {
     987             :             /* No, but maybe it was used in this subtransaction? */
     988        4778 :             if (portal->activeSubid == mySubid)
     989             :             {
     990             :                 /* Maintain activeSubid until the portal is removed */
     991          28 :                 portal->activeSubid = parentSubid;
     992             : 
     993             :                 /*
     994             :                  * A MarkPortalActive() caller ran an upper-level portal in
     995             :                  * this subtransaction and left the portal ACTIVE.  This can't
     996             :                  * happen, but force the portal into FAILED state for the same
     997             :                  * reasons discussed below.
     998             :                  *
     999             :                  * We assume we can get away without forcing upper-level READY
    1000             :                  * portals to fail, even if they were run and then suspended.
    1001             :                  * In theory a suspended upper-level portal could have
    1002             :                  * acquired some references to objects that are about to be
    1003             :                  * destroyed, but there should be sufficient defenses against
    1004             :                  * such cases: the portal's original query cannot contain such
    1005             :                  * references, and any references within, say, cached plans of
    1006             :                  * PL/pgSQL functions are not from active queries and should
    1007             :                  * be protected by revalidation logic.
    1008             :                  */
    1009          28 :                 if (portal->status == PORTAL_ACTIVE)
    1010           0 :                     MarkPortalFailed(portal);
    1011             : 
    1012             :                 /*
    1013             :                  * Also, if we failed it during the current subtransaction
    1014             :                  * (either just above, or earlier), reattach its resource
    1015             :                  * owner to the current subtransaction's resource owner, so
    1016             :                  * that any resources it still holds will be released while
    1017             :                  * cleaning up this subtransaction.  This prevents some corner
    1018             :                  * cases wherein we might get Asserts or worse while cleaning
    1019             :                  * up objects created during the current subtransaction
    1020             :                  * (because they're still referenced within this portal).
    1021             :                  */
    1022          28 :                 if (portal->status == PORTAL_FAILED && portal->resowner)
    1023             :                 {
    1024           8 :                     ResourceOwnerNewParent(portal->resowner, myXactOwner);
    1025           8 :                     portal->resowner = NULL;
    1026             :                 }
    1027             :             }
    1028             :             /* Done if it wasn't created in this subtransaction */
    1029        4778 :             continue;
    1030             :         }
    1031             : 
    1032             :         /*
    1033             :          * Force any live portals of my own subtransaction into FAILED state.
    1034             :          * We have to do this because they might refer to objects created or
    1035             :          * changed in the failed subtransaction, leading to crashes within
    1036             :          * ExecutorEnd when portalcmds.c tries to close down the portal.
    1037             :          * Currently, every MarkPortalActive() caller ensures it updates the
    1038             :          * portal status again before relinquishing control, so ACTIVE can't
    1039             :          * happen here.  If it does happen, dispose the portal like existing
    1040             :          * MarkPortalActive() callers would.
    1041             :          */
    1042         128 :         if (portal->status == PORTAL_READY ||
    1043         118 :             portal->status == PORTAL_ACTIVE)
    1044          10 :             MarkPortalFailed(portal);
    1045             : 
    1046             :         /*
    1047             :          * Allow portalcmds.c to clean up the state it knows about, if we
    1048             :          * haven't already.
    1049             :          */
    1050         128 :         if (PointerIsValid(portal->cleanup))
    1051             :         {
    1052           0 :             portal->cleanup(portal);
    1053           0 :             portal->cleanup = NULL;
    1054             :         }
    1055             : 
    1056             :         /* drop cached plan reference, if any */
    1057         128 :         PortalReleaseCachedPlan(portal);
    1058             : 
    1059             :         /*
    1060             :          * Any resources belonging to the portal will be released in the
    1061             :          * upcoming transaction-wide cleanup; they will be gone before we run
    1062             :          * PortalDrop.
    1063             :          */
    1064         128 :         portal->resowner = NULL;
    1065             : 
    1066             :         /*
    1067             :          * Although we can't delete the portal data structure proper, we can
    1068             :          * release any memory in subsidiary contexts, such as executor state.
    1069             :          * The cleanup hook was the last thing that might have needed data
    1070             :          * there.
    1071             :          */
    1072         128 :         MemoryContextDeleteChildren(portal->portalContext);
    1073             :     }
    1074        2966 : }
    1075             : 
    1076             : /*
    1077             :  * Post-subabort cleanup for portals.
    1078             :  *
    1079             :  * Drop all portals created in the failed subtransaction (but note that
    1080             :  * we will not drop any that were reassigned to the parent above).
    1081             :  */
    1082             : void
    1083        2966 : AtSubCleanup_Portals(SubTransactionId mySubid)
    1084             : {
    1085             :     HASH_SEQ_STATUS status;
    1086             :     PortalHashEnt *hentry;
    1087             : 
    1088        2966 :     hash_seq_init(&status, PortalHashTable);
    1089             : 
    1090        7756 :     while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
    1091             :     {
    1092        4790 :         Portal      portal = hentry->portal;
    1093             : 
    1094        4790 :         if (portal->createSubid != mySubid)
    1095        4778 :             continue;
    1096             : 
    1097             :         /*
    1098             :          * If a portal is still pinned, forcibly unpin it. PortalDrop will not
    1099             :          * let us drop the portal otherwise. Whoever pinned the portal was
    1100             :          * interrupted by the abort too and won't try to use it anymore.
    1101             :          */
    1102          12 :         if (portal->portalPinned)
    1103           6 :             portal->portalPinned = false;
    1104             : 
    1105             :         /*
    1106             :          * We had better not call any user-defined code during cleanup, so if
    1107             :          * the cleanup hook hasn't been run yet, too bad; we'll just skip it.
    1108             :          */
    1109          12 :         if (PointerIsValid(portal->cleanup))
    1110             :         {
    1111           0 :             elog(WARNING, "skipping cleanup for portal \"%s\"", portal->name);
    1112           0 :             portal->cleanup = NULL;
    1113             :         }
    1114             : 
    1115             :         /* Zap it. */
    1116          12 :         PortalDrop(portal, false);
    1117             :     }
    1118        2966 : }
    1119             : 
    1120             : /* Find all available cursors */
    1121             : Datum
    1122          82 : pg_cursor(PG_FUNCTION_ARGS)
    1123             : {
    1124          82 :     ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    1125             :     TupleDesc   tupdesc;
    1126             :     Tuplestorestate *tupstore;
    1127             :     MemoryContext per_query_ctx;
    1128             :     MemoryContext oldcontext;
    1129             :     HASH_SEQ_STATUS hash_seq;
    1130             :     PortalHashEnt *hentry;
    1131             : 
    1132             :     /* check to see if caller supports us returning a tuplestore */
    1133          82 :     if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
    1134           0 :         ereport(ERROR,
    1135             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1136             :                  errmsg("set-valued function called in context that cannot accept a set")));
    1137          82 :     if (!(rsinfo->allowedModes & SFRM_Materialize))
    1138           0 :         ereport(ERROR,
    1139             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1140             :                  errmsg("materialize mode required, but it is not allowed in this context")));
    1141             : 
    1142             :     /* need to build tuplestore in query context */
    1143          82 :     per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
    1144          82 :     oldcontext = MemoryContextSwitchTo(per_query_ctx);
    1145             : 
    1146             :     /*
    1147             :      * build tupdesc for result tuples. This must match the definition of the
    1148             :      * pg_cursors view in system_views.sql
    1149             :      */
    1150          82 :     tupdesc = CreateTemplateTupleDesc(6);
    1151          82 :     TupleDescInitEntry(tupdesc, (AttrNumber) 1, "name",
    1152             :                        TEXTOID, -1, 0);
    1153          82 :     TupleDescInitEntry(tupdesc, (AttrNumber) 2, "statement",
    1154             :                        TEXTOID, -1, 0);
    1155          82 :     TupleDescInitEntry(tupdesc, (AttrNumber) 3, "is_holdable",
    1156             :                        BOOLOID, -1, 0);
    1157          82 :     TupleDescInitEntry(tupdesc, (AttrNumber) 4, "is_binary",
    1158             :                        BOOLOID, -1, 0);
    1159          82 :     TupleDescInitEntry(tupdesc, (AttrNumber) 5, "is_scrollable",
    1160             :                        BOOLOID, -1, 0);
    1161          82 :     TupleDescInitEntry(tupdesc, (AttrNumber) 6, "creation_time",
    1162             :                        TIMESTAMPTZOID, -1, 0);
    1163             : 
    1164             :     /*
    1165             :      * We put all the tuples into a tuplestore in one scan of the hashtable.
    1166             :      * This avoids any issue of the hashtable possibly changing between calls.
    1167             :      */
    1168             :     tupstore =
    1169          82 :         tuplestore_begin_heap(rsinfo->allowedModes & SFRM_Materialize_Random,
    1170             :                               false, work_mem);
    1171             : 
    1172             :     /* generate junk in short-term context */
    1173          82 :     MemoryContextSwitchTo(oldcontext);
    1174             : 
    1175          82 :     hash_seq_init(&hash_seq, PortalHashTable);
    1176         248 :     while ((hentry = hash_seq_search(&hash_seq)) != NULL)
    1177             :     {
    1178         166 :         Portal      portal = hentry->portal;
    1179             :         Datum       values[6];
    1180             :         bool        nulls[6];
    1181             : 
    1182             :         /* report only "visible" entries */
    1183         166 :         if (!portal->visible)
    1184          86 :             continue;
    1185             : 
    1186          80 :         MemSet(nulls, 0, sizeof(nulls));
    1187             : 
    1188          80 :         values[0] = CStringGetTextDatum(portal->name);
    1189          80 :         values[1] = CStringGetTextDatum(portal->sourceText);
    1190          80 :         values[2] = BoolGetDatum(portal->cursorOptions & CURSOR_OPT_HOLD);
    1191          80 :         values[3] = BoolGetDatum(portal->cursorOptions & CURSOR_OPT_BINARY);
    1192          80 :         values[4] = BoolGetDatum(portal->cursorOptions & CURSOR_OPT_SCROLL);
    1193          80 :         values[5] = TimestampTzGetDatum(portal->creation_time);
    1194             : 
    1195          80 :         tuplestore_putvalues(tupstore, tupdesc, values, nulls);
    1196             :     }
    1197             : 
    1198             :     /* clean up and return the tuplestore */
    1199             :     tuplestore_donestoring(tupstore);
    1200             : 
    1201          82 :     rsinfo->returnMode = SFRM_Materialize;
    1202          82 :     rsinfo->setResult = tupstore;
    1203          82 :     rsinfo->setDesc = tupdesc;
    1204             : 
    1205          82 :     return (Datum) 0;
    1206             : }
    1207             : 
    1208             : bool
    1209          28 : ThereAreNoReadyPortals(void)
    1210             : {
    1211             :     HASH_SEQ_STATUS status;
    1212             :     PortalHashEnt *hentry;
    1213             : 
    1214          28 :     hash_seq_init(&status, PortalHashTable);
    1215             : 
    1216          56 :     while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
    1217             :     {
    1218          28 :         Portal      portal = hentry->portal;
    1219             : 
    1220          28 :         if (portal->status == PORTAL_READY)
    1221           0 :             return false;
    1222             :     }
    1223             : 
    1224          28 :     return true;
    1225             : }
    1226             : 
    1227             : /*
    1228             :  * Hold all pinned portals.
    1229             :  *
    1230             :  * When initiating a COMMIT or ROLLBACK inside a procedure, this must be
    1231             :  * called to protect internally-generated cursors from being dropped during
    1232             :  * the transaction shutdown.  Currently, SPI calls this automatically; PLs
    1233             :  * that initiate COMMIT or ROLLBACK some other way are on the hook to do it
    1234             :  * themselves.  (Note that we couldn't do this in, say, AtAbort_Portals
    1235             :  * because we need to run user-defined code while persisting a portal.
    1236             :  * It's too late to do that once transaction abort has started.)
    1237             :  *
    1238             :  * We protect such portals by converting them to held cursors.  We mark them
    1239             :  * as "auto-held" so that exception exit knows to clean them up.  (In normal,
    1240             :  * non-exception code paths, the PL needs to clean such portals itself, since
    1241             :  * transaction end won't do it anymore; but that should be normal practice
    1242             :  * anyway.)
    1243             :  */
    1244             : void
    1245        4330 : HoldPinnedPortals(void)
    1246             : {
    1247             :     HASH_SEQ_STATUS status;
    1248             :     PortalHashEnt *hentry;
    1249             : 
    1250        4330 :     hash_seq_init(&status, PortalHashTable);
    1251             : 
    1252        8756 :     while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
    1253             :     {
    1254        4432 :         Portal      portal = hentry->portal;
    1255             : 
    1256        4432 :         if (portal->portalPinned && !portal->autoHeld)
    1257             :         {
    1258             :             /*
    1259             :              * Doing transaction control, especially abort, inside a cursor
    1260             :              * loop that is not read-only, for example using UPDATE ...
    1261             :              * RETURNING, has weird semantics issues.  Also, this
    1262             :              * implementation wouldn't work, because such portals cannot be
    1263             :              * held.  (The core grammar enforces that only SELECT statements
    1264             :              * can drive a cursor, but for example PL/pgSQL does not restrict
    1265             :              * it.)
    1266             :              */
    1267          30 :             if (portal->strategy != PORTAL_ONE_SELECT)
    1268           2 :                 ereport(ERROR,
    1269             :                         (errcode(ERRCODE_INVALID_TRANSACTION_TERMINATION),
    1270             :                          errmsg("cannot perform transaction commands inside a cursor loop that is not read-only")));
    1271             : 
    1272             :             /* Verify it's in a suitable state to be held */
    1273          28 :             if (portal->status != PORTAL_READY)
    1274           0 :                 elog(ERROR, "pinned portal is not ready to be auto-held");
    1275             : 
    1276          28 :             HoldPortal(portal);
    1277          24 :             portal->autoHeld = true;
    1278             :         }
    1279             :     }
    1280        4324 : }

Generated by: LCOV version 1.13