portalmem.c File Reference

#include "postgres.h"
#include "access/xact.h"
#include "commands/portalcmds.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "storage/ipc.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/snapmgr.h"
#include "utils/timestamp.h"

Include dependency graph for portalmem.c:

Go to the source code of this file.

Data Structures
struct	portalhashent

Macros
#define	PORTALS_PER_USER   16
#define	MAX_PORTALNAME_LEN   NAMEDATALEN
#define	PortalHashTableLookup(NAME, PORTAL)
#define	PortalHashTableInsert(PORTAL, NAME)
#define	PortalHashTableDelete(PORTAL)

Typedefs
typedef struct portalhashent	PortalHashEnt

Functions
void	EnablePortalManager (void)
Portal	GetPortalByName (const char *name)
PlannedStmt *	PortalGetPrimaryStmt (Portal portal)
Portal	CreatePortal (const char *name, bool allowDup, bool dupSilent)
Portal	CreateNewPortal (void)
void	PortalDefineQuery (Portal portal, const char *prepStmtName, const char *sourceText, CommandTag commandTag, List *stmts, CachedPlan *cplan)
static void	PortalReleaseCachedPlan (Portal portal)
void	PortalCreateHoldStore (Portal portal)
void	PinPortal (Portal portal)
void	UnpinPortal (Portal portal)
void	MarkPortalActive (Portal portal)
void	MarkPortalDone (Portal portal)
void	MarkPortalFailed (Portal portal)
void	PortalDrop (Portal portal, bool isTopCommit)
void	PortalHashTableDeleteAll (void)
static void	HoldPortal (Portal portal)
bool	PreCommit_Portals (bool isPrepare)
void	AtAbort_Portals (void)
void	AtCleanup_Portals (void)
void	PortalErrorCleanup (void)
void	AtSubCommit_Portals (SubTransactionId mySubid, SubTransactionId parentSubid, int parentLevel, ResourceOwner parentXactOwner)
void	AtSubAbort_Portals (SubTransactionId mySubid, SubTransactionId parentSubid, ResourceOwner myXactOwner, ResourceOwner parentXactOwner)
void	AtSubCleanup_Portals (SubTransactionId mySubid)
Datum	pg_cursor (PG_FUNCTION_ARGS)
bool	ThereAreNoReadyPortals (void)
void	HoldPinnedPortals (void)
void	ForgetPortalSnapshots (void)

Variables
static HTAB *	PortalHashTable = NULL
static MemoryContext	TopPortalContext = NULL

Macro Definition Documentation

MAX_PORTALNAME_LEN

#define MAX_PORTALNAME_LEN   NAMEDATALEN

Definition at line 46 of file portalmem.c.

PortalHashTableDelete

#define PortalHashTableDelete

(

PORTAL

)

Value:

do { \
    PortalHashEnt *hentry; \
    \
    hentry = (PortalHashEnt *) hash_search(PortalHashTable, \
                                           PORTAL->name, HASH_REMOVE, NULL); \
    if (hentry == NULL) \
        elog(WARNING, "trying to delete portal name that does not exist"); \
} while(0)

Definition at line 81 of file portalmem.c.

PortalHashTableInsert

#define PortalHashTableInsert	(		PORTAL,
			NAME
	)

Value:

do { \
    PortalHashEnt *hentry; bool found; \
    \
    hentry = (PortalHashEnt *) hash_search(PortalHashTable, \
                                           (NAME), HASH_ENTER, &found); \
    if (found) \
        elog(ERROR, "duplicate portal name"); \
    hentry->portal = PORTAL; \
    /* To avoid duplicate storage, make PORTAL->name point to htab entry */ \
    PORTAL->name = hentry->portalname; \
} while(0)

Definition at line 68 of file portalmem.c.

PortalHashTableLookup

#define PortalHashTableLookup	(		NAME,
			PORTAL
	)

Value:

do { \
    PortalHashEnt *hentry; \
    \
    hentry = (PortalHashEnt *) hash_search(PortalHashTable, \
                                           (NAME), HASH_FIND, NULL); \
    if (hentry) \
        PORTAL = hentry->portal; \
    else \
        PORTAL = NULL; \
} while(0)

Definition at line 56 of file portalmem.c.

PORTALS_PER_USER

#define PORTALS_PER_USER   16

Definition at line 38 of file portalmem.c.

Typedef Documentation

PortalHashEnt

typedef struct portalhashent PortalHashEnt

Function Documentation

AtAbort_Portals()

void AtAbort_Portals

(

void

)

Definition at line 781 of file portalmem.c.

{
    HASH_SEQ_STATUS status;
    PortalHashEnt *hentry;
 
    hash_seq_init(&status, PortalHashTable);
 
    while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
    {
        Portal      portal = hentry->portal;
 
        /*
         * When elog(FATAL) is progress, we need to set the active portal to
         * failed, so that PortalCleanup() doesn't run the executor shutdown.
         */
        if (portal->status == PORTAL_ACTIVE && shmem_exit_inprogress)
            MarkPortalFailed(portal);
 
        /*
         * Do nothing else to cursors held over from a previous transaction.
         */
        if (portal->createSubid == InvalidSubTransactionId)
            continue;
 
        /*
         * Do nothing to auto-held cursors.  This is similar to the case of a
         * cursor from a previous transaction, but it could also be that the
         * cursor was auto-held in this transaction, so it wants to live on.
         */
        if (portal->autoHeld)
            continue;
 
        /*
         * If it was created in the current transaction, we can't do normal
         * shutdown on a READY portal either; it might refer to objects
         * created in the failed transaction.  See comments in
         * AtSubAbort_Portals.
         */
        if (portal->status == PORTAL_READY)
            MarkPortalFailed(portal);
 
        /*
         * Allow portalcmds.c to clean up the state it knows about, if we
         * haven't already.
         */
        if (PointerIsValid(portal->cleanup))
        {
            portal->cleanup(portal);
            portal->cleanup = NULL;
        }
 
        /* drop cached plan reference, if any */
        PortalReleaseCachedPlan(portal);
 
        /*
         * Any resources belonging to the portal will be released in the
         * upcoming transaction-wide cleanup; they will be gone before we run
         * PortalDrop.
         */
        portal->resowner = NULL;
 
        /*
         * Although we can't delete the portal data structure proper, we can
         * release any memory in subsidiary contexts, such as executor state.
         * The cleanup hook was the last thing that might have needed data
         * there.  But leave active portals alone.
         */
        if (portal->status != PORTAL_ACTIVE)
            MemoryContextDeleteChildren(portal->portalContext);
    }
}

References PortalData::autoHeld, PortalData::cleanup, PortalData::createSubid, hash_seq_init(), hash_seq_search(), InvalidSubTransactionId, MarkPortalFailed(), MemoryContextDeleteChildren(), PointerIsValid, portalhashent::portal, PORTAL_ACTIVE, PORTAL_READY, PortalData::portalContext, PortalHashTable, PortalReleaseCachedPlan(), PortalData::resowner, shmem_exit_inprogress, and PortalData::status.

Referenced by AbortOutOfAnyTransaction(), and AbortTransaction().

AtCleanup_Portals()

void AtCleanup_Portals

(

void

)

Definition at line 858 of file portalmem.c.

{
    HASH_SEQ_STATUS status;
    PortalHashEnt *hentry;
 
    hash_seq_init(&status, PortalHashTable);
 
    while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
    {
        Portal      portal = hentry->portal;
 
        /*
         * Do not touch active portals --- this can only happen in the case of
         * a multi-transaction command.
         */
        if (portal->status == PORTAL_ACTIVE)
            continue;
 
        /*
         * Do nothing to cursors held over from a previous transaction or
         * auto-held ones.
         */
        if (portal->createSubid == InvalidSubTransactionId || portal->autoHeld)
        {
            Assert(portal->status != PORTAL_ACTIVE);
            Assert(portal->resowner == NULL);
            continue;
        }
 
        /*
         * If a portal is still pinned, forcibly unpin it. PortalDrop will not
         * let us drop the portal otherwise. Whoever pinned the portal was
         * interrupted by the abort too and won't try to use it anymore.
         */
        if (portal->portalPinned)
            portal->portalPinned = false;
 
        /*
         * We had better not call any user-defined code during cleanup, so if
         * the cleanup hook hasn't been run yet, too bad; we'll just skip it.
         */
        if (PointerIsValid(portal->cleanup))
        {
            elog(WARNING, "skipping cleanup for portal \"%s\"", portal->name);
            portal->cleanup = NULL;
        }
 
        /* Zap it. */
        PortalDrop(portal, false);
    }
}

References Assert, PortalData::autoHeld, PortalData::cleanup, PortalData::createSubid, elog, hash_seq_init(), hash_seq_search(), InvalidSubTransactionId, PortalData::name, PointerIsValid, portalhashent::portal, PORTAL_ACTIVE, PortalDrop(), PortalHashTable, PortalData::portalPinned, PortalData::resowner, PortalData::status, and WARNING.

Referenced by CleanupTransaction().

AtSubAbort_Portals()

void AtSubAbort_Portals	(	SubTransactionId	mySubid,
		SubTransactionId	parentSubid,
		ResourceOwner	myXactOwner,
		ResourceOwner	parentXactOwner
	)

Definition at line 979 of file portalmem.c.

{
    HASH_SEQ_STATUS status;
    PortalHashEnt *hentry;
 
    hash_seq_init(&status, PortalHashTable);
 
    while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
    {
        Portal      portal = hentry->portal;
 
        /* Was it created in this subtransaction? */
        if (portal->createSubid != mySubid)
        {
            /* No, but maybe it was used in this subtransaction? */
            if (portal->activeSubid == mySubid)
            {
                /* Maintain activeSubid until the portal is removed */
                portal->activeSubid = parentSubid;
 
                /*
                 * A MarkPortalActive() caller ran an upper-level portal in
                 * this subtransaction and left the portal ACTIVE.  This can't
                 * happen, but force the portal into FAILED state for the same
                 * reasons discussed below.
                 *
                 * We assume we can get away without forcing upper-level READY
                 * portals to fail, even if they were run and then suspended.
                 * In theory a suspended upper-level portal could have
                 * acquired some references to objects that are about to be
                 * destroyed, but there should be sufficient defenses against
                 * such cases: the portal's original query cannot contain such
                 * references, and any references within, say, cached plans of
                 * PL/pgSQL functions are not from active queries and should
                 * be protected by revalidation logic.
                 */
                if (portal->status == PORTAL_ACTIVE)
                    MarkPortalFailed(portal);
 
                /*
                 * Also, if we failed it during the current subtransaction
                 * (either just above, or earlier), reattach its resource
                 * owner to the current subtransaction's resource owner, so
                 * that any resources it still holds will be released while
                 * cleaning up this subtransaction.  This prevents some corner
                 * cases wherein we might get Asserts or worse while cleaning
                 * up objects created during the current subtransaction
                 * (because they're still referenced within this portal).
                 */
                if (portal->status == PORTAL_FAILED && portal->resowner)
                {
                    ResourceOwnerNewParent(portal->resowner, myXactOwner);
                    portal->resowner = NULL;
                }
            }
            /* Done if it wasn't created in this subtransaction */
            continue;
        }
 
        /*
         * Force any live portals of my own subtransaction into FAILED state.
         * We have to do this because they might refer to objects created or
         * changed in the failed subtransaction, leading to crashes within
         * ExecutorEnd when portalcmds.c tries to close down the portal.
         * Currently, every MarkPortalActive() caller ensures it updates the
         * portal status again before relinquishing control, so ACTIVE can't
         * happen here.  If it does happen, dispose the portal like existing
         * MarkPortalActive() callers would.
         */
        if (portal->status == PORTAL_READY ||
            portal->status == PORTAL_ACTIVE)
            MarkPortalFailed(portal);
 
        /*
         * Allow portalcmds.c to clean up the state it knows about, if we
         * haven't already.
         */
        if (PointerIsValid(portal->cleanup))
        {
            portal->cleanup(portal);
            portal->cleanup = NULL;
        }
 
        /* drop cached plan reference, if any */
        PortalReleaseCachedPlan(portal);
 
        /*
         * Any resources belonging to the portal will be released in the
         * upcoming transaction-wide cleanup; they will be gone before we run
         * PortalDrop.
         */
        portal->resowner = NULL;
 
        /*
         * Although we can't delete the portal data structure proper, we can
         * release any memory in subsidiary contexts, such as executor state.
         * The cleanup hook was the last thing that might have needed data
         * there.
         */
        MemoryContextDeleteChildren(portal->portalContext);
    }
}

References PortalData::activeSubid, PortalData::cleanup, PortalData::createSubid, hash_seq_init(), hash_seq_search(), MarkPortalFailed(), MemoryContextDeleteChildren(), PointerIsValid, portalhashent::portal, PORTAL_ACTIVE, PORTAL_FAILED, PORTAL_READY, PortalData::portalContext, PortalHashTable, PortalReleaseCachedPlan(), ResourceOwnerNewParent(), PortalData::resowner, and PortalData::status.

Referenced by AbortOutOfAnyTransaction(), and AbortSubTransaction().

AtSubCleanup_Portals()

void AtSubCleanup_Portals

(

SubTransactionId

mySubid

)

Definition at line 1092 of file portalmem.c.

{
    HASH_SEQ_STATUS status;
    PortalHashEnt *hentry;
 
    hash_seq_init(&status, PortalHashTable);
 
    while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
    {
        Portal      portal = hentry->portal;
 
        if (portal->createSubid != mySubid)
            continue;
 
        /*
         * If a portal is still pinned, forcibly unpin it. PortalDrop will not
         * let us drop the portal otherwise. Whoever pinned the portal was
         * interrupted by the abort too and won't try to use it anymore.
         */
        if (portal->portalPinned)
            portal->portalPinned = false;
 
        /*
         * We had better not call any user-defined code during cleanup, so if
         * the cleanup hook hasn't been run yet, too bad; we'll just skip it.
         */
        if (PointerIsValid(portal->cleanup))
        {
            elog(WARNING, "skipping cleanup for portal \"%s\"", portal->name);
            portal->cleanup = NULL;
        }
 
        /* Zap it. */
        PortalDrop(portal, false);
    }
}

References PortalData::cleanup, PortalData::createSubid, elog, hash_seq_init(), hash_seq_search(), PortalData::name, PointerIsValid, portalhashent::portal, PortalDrop(), PortalHashTable, PortalData::portalPinned, and WARNING.

Referenced by CleanupSubTransaction().

AtSubCommit_Portals()

void AtSubCommit_Portals	(	SubTransactionId	mySubid,
		SubTransactionId	parentSubid,
		int	parentLevel,
		ResourceOwner	parentXactOwner
	)

Definition at line 943 of file portalmem.c.

{
    HASH_SEQ_STATUS status;
    PortalHashEnt *hentry;
 
    hash_seq_init(&status, PortalHashTable);
 
    while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
    {
        Portal      portal = hentry->portal;
 
        if (portal->createSubid == mySubid)
        {
            portal->createSubid = parentSubid;
            portal->createLevel = parentLevel;
            if (portal->resowner)
                ResourceOwnerNewParent(portal->resowner, parentXactOwner);
        }
        if (portal->activeSubid == mySubid)
            portal->activeSubid = parentSubid;
    }
}

References PortalData::activeSubid, PortalData::createLevel, PortalData::createSubid, hash_seq_init(), hash_seq_search(), portalhashent::portal, PortalHashTable, ResourceOwnerNewParent(), and PortalData::resowner.

Referenced by CommitSubTransaction().

CreateNewPortal()

Portal CreateNewPortal

(

void

)

Definition at line 235 of file portalmem.c.

{
    static unsigned int unnamed_portal_count = 0;
 
    char        portalname[MAX_PORTALNAME_LEN];
 
    /* Select a nonconflicting name */
    for (;;)
    {
        unnamed_portal_count++;
        sprintf(portalname, "<unnamed portal %u>", unnamed_portal_count);
        if (GetPortalByName(portalname) == NULL)
            break;
    }
 
    return CreatePortal(portalname, false, false);
}

References CreatePortal(), GetPortalByName(), MAX_PORTALNAME_LEN, and sprintf.

Referenced by ExecuteQuery(), and SPI_cursor_open_internal().

CreatePortal()

Portal CreatePortal	(	const char *	name,
		bool	allowDup,
		bool	dupSilent
	)

Definition at line 175 of file portalmem.c.

{
    Portal      portal;
 
    Assert(PointerIsValid(name));
 
    portal = GetPortalByName(name);
    if (PortalIsValid(portal))
    {
        if (!allowDup)
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_CURSOR),
                     errmsg("cursor \"%s\" already exists", name)));
        if (!dupSilent)
            ereport(WARNING,
                    (errcode(ERRCODE_DUPLICATE_CURSOR),
                     errmsg("closing existing cursor \"%s\"",
                            name)));
        PortalDrop(portal, false);
    }
 
    /* make new portal structure */
    portal = (Portal) MemoryContextAllocZero(TopPortalContext, sizeof *portal);
 
    /* initialize portal context; typically it won't store much */
    portal->portalContext = AllocSetContextCreate(TopPortalContext,
                                                  "PortalContext",
                                                  ALLOCSET_SMALL_SIZES);
 
    /* create a resource owner for the portal */
    portal->resowner = ResourceOwnerCreate(CurTransactionResourceOwner,
                                           "Portal");
 
    /* initialize portal fields that don't start off zero */
    portal->status = PORTAL_NEW;
    portal->cleanup = PortalCleanup;
    portal->createSubid = GetCurrentSubTransactionId();
    portal->activeSubid = portal->createSubid;
    portal->createLevel = GetCurrentTransactionNestLevel();
    portal->strategy = PORTAL_MULTI_QUERY;
    portal->cursorOptions = CURSOR_OPT_NO_SCROLL;
    portal->atStart = true;
    portal->atEnd = true;       /* disallow fetches until query is set */
    portal->visible = true;
    portal->creation_time = GetCurrentStatementStartTimestamp();
 
    /* put portal in table (sets portal->name) */
    PortalHashTableInsert(portal, name);
 
    /* for named portals reuse portal->name copy */
    MemoryContextSetIdentifier(portal->portalContext, portal->name[0] ? portal->name : "<unnamed>");
 
    return portal;
}

References PortalData::activeSubid, ALLOCSET_SMALL_SIZES, AllocSetContextCreate, Assert, PortalData::atEnd, PortalData::atStart, PortalData::cleanup, PortalData::createLevel, PortalData::createSubid, PortalData::creation_time, CURSOR_OPT_NO_SCROLL, PortalData::cursorOptions, CurTransactionResourceOwner, ereport, errcode(), errmsg(), ERROR, GetCurrentStatementStartTimestamp(), GetCurrentSubTransactionId(), GetCurrentTransactionNestLevel(), GetPortalByName(), MemoryContextAllocZero(), MemoryContextSetIdentifier(), name, PortalData::name, PointerIsValid, PORTAL_MULTI_QUERY, PORTAL_NEW, PortalCleanup(), PortalData::portalContext, PortalDrop(), PortalHashTableInsert, PortalIsValid, ResourceOwnerCreate(), PortalData::resowner, PortalData::status, PortalData::strategy, TopPortalContext, PortalData::visible, and WARNING.

Referenced by CreateNewPortal(), exec_bind_message(), exec_simple_query(), PerformCursorOpen(), and SPI_cursor_open_internal().

EnablePortalManager()

void EnablePortalManager

(

void

)

Definition at line 104 of file portalmem.c.

{
    HASHCTL     ctl;
 
    Assert(TopPortalContext == NULL);
 
    TopPortalContext = AllocSetContextCreate(TopMemoryContext,
                                             "TopPortalContext",
                                             ALLOCSET_DEFAULT_SIZES);
 
    ctl.keysize = MAX_PORTALNAME_LEN;
    ctl.entrysize = sizeof(PortalHashEnt);
 
    /*
     * use PORTALS_PER_USER as a guess of how many hash table entries to
     * create, initially
     */
    PortalHashTable = hash_create("Portal hash", PORTALS_PER_USER,
                                  &ctl, HASH_ELEM | HASH_STRINGS);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, ctl, hash_create(), HASH_ELEM, HASH_STRINGS, MAX_PORTALNAME_LEN, PortalHashTable, PORTALS_PER_USER, TopMemoryContext, and TopPortalContext.

Referenced by InitPostgres().

ForgetPortalSnapshots()

void ForgetPortalSnapshots

(

void

)

Definition at line 1253 of file portalmem.c.

{
    HASH_SEQ_STATUS status;
    PortalHashEnt *hentry;
    int         numPortalSnaps = 0;
    int         numActiveSnaps = 0;
 
    /* First, scan PortalHashTable and clear portalSnapshot fields */
    hash_seq_init(&status, PortalHashTable);
 
    while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
    {
        Portal      portal = hentry->portal;
 
        if (portal->portalSnapshot != NULL)
        {
            portal->portalSnapshot = NULL;
            numPortalSnaps++;
        }
        /* portal->holdSnapshot will be cleaned up in PreCommit_Portals */
    }
 
    /*
     * Now, pop all the active snapshots, which should be just those that were
     * portal snapshots.  Ideally we'd drive this directly off the portal
     * scan, but there's no good way to visit the portals in the correct
     * order.  So just cross-check after the fact.
     */
    while (ActiveSnapshotSet())
    {
        PopActiveSnapshot();
        numActiveSnaps++;
    }
 
    if (numPortalSnaps != numActiveSnaps)
        elog(ERROR, "portal snapshots (%d) did not account for all active snapshots (%d)",
             numPortalSnaps, numActiveSnaps);
}

References ActiveSnapshotSet(), elog, ERROR, hash_seq_init(), hash_seq_search(), PopActiveSnapshot(), portalhashent::portal, PortalHashTable, and PortalData::portalSnapshot.

Referenced by _SPI_commit(), and _SPI_rollback().

GetPortalByName()

Portal GetPortalByName

(

const char *

name

)

Definition at line 130 of file portalmem.c.

{
    Portal      portal;
 
    if (PointerIsValid(name))
        PortalHashTableLookup(name, portal);
    else
        portal = NULL;
 
    return portal;
}

References name, PointerIsValid, and PortalHashTableLookup.

Referenced by CreateNewPortal(), CreatePortal(), exec_describe_portal_message(), exec_execute_message(), exec_simple_query(), execCurrentOf(), FetchStatementTargetList(), PerformPortalClose(), PerformPortalFetch(), PLy_cursor_close(), PLy_cursor_dealloc(), PLy_cursor_fetch(), PLy_cursor_iternext(), PostgresMain(), SPI_cursor_find(), UtilityReturnsTuples(), and UtilityTupleDescriptor().

HoldPinnedPortals()

void HoldPinnedPortals

(

void

)

Definition at line 1204 of file portalmem.c.

{
    HASH_SEQ_STATUS status;
    PortalHashEnt *hentry;
 
    hash_seq_init(&status, PortalHashTable);
 
    while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
    {
        Portal      portal = hentry->portal;
 
        if (portal->portalPinned && !portal->autoHeld)
        {
            /*
             * Doing transaction control, especially abort, inside a cursor
             * loop that is not read-only, for example using UPDATE ...
             * RETURNING, has weird semantics issues.  Also, this
             * implementation wouldn't work, because such portals cannot be
             * held.  (The core grammar enforces that only SELECT statements
             * can drive a cursor, but for example PL/pgSQL does not restrict
             * it.)
             */
            if (portal->strategy != PORTAL_ONE_SELECT)
                ereport(ERROR,
                        (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                         errmsg("cannot perform transaction commands inside a cursor loop that is not read-only")));
 
            /* Verify it's in a suitable state to be held */
            if (portal->status != PORTAL_READY)
                elog(ERROR, "pinned portal is not ready to be auto-held");
 
            HoldPortal(portal);
            portal->autoHeld = true;
        }
    }
}

References PortalData::autoHeld, elog, ereport, errcode(), errmsg(), ERROR, hash_seq_init(), hash_seq_search(), HoldPortal(), portalhashent::portal, PORTAL_ONE_SELECT, PORTAL_READY, PortalHashTable, PortalData::portalPinned, PortalData::status, and PortalData::strategy.

Referenced by _SPI_commit(), and _SPI_rollback().

HoldPortal()

static void HoldPortal ( Portal  portal )

static

Definition at line 636 of file portalmem.c.

{
    /*
     * Note that PersistHoldablePortal() must release all resources used by
     * the portal that are local to the creating transaction.
     */
    PortalCreateHoldStore(portal);
    PersistHoldablePortal(portal);
 
    /* drop cached plan reference, if any */
    PortalReleaseCachedPlan(portal);
 
    /*
     * Any resources belonging to the portal will be released in the upcoming
     * transaction-wide cleanup; the portal will no longer have its own
     * resources.
     */
    portal->resowner = NULL;
 
    /*
     * Having successfully exported the holdable cursor, mark it as not
     * belonging to this transaction.
     */
    portal->createSubid = InvalidSubTransactionId;
    portal->activeSubid = InvalidSubTransactionId;
    portal->createLevel = 0;
}

References PortalData::activeSubid, PortalData::createLevel, PortalData::createSubid, InvalidSubTransactionId, PersistHoldablePortal(), PortalCreateHoldStore(), PortalReleaseCachedPlan(), and PortalData::resowner.

Referenced by HoldPinnedPortals(), and PreCommit_Portals().

MarkPortalActive()

void MarkPortalActive

(

Portal

portal

)

Definition at line 395 of file portalmem.c.

{
    /* For safety, this is a runtime test not just an Assert */
    if (portal->status != PORTAL_READY)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("portal \"%s\" cannot be run", portal->name)));
    /* Perform the state transition */
    portal->status = PORTAL_ACTIVE;
    portal->activeSubid = GetCurrentSubTransactionId();
}

References PortalData::activeSubid, ereport, errcode(), errmsg(), ERROR, GetCurrentSubTransactionId(), PortalData::name, PORTAL_ACTIVE, PORTAL_READY, and PortalData::status.

Referenced by PersistHoldablePortal(), PortalRun(), and PortalRunFetch().

MarkPortalDone()

void MarkPortalDone

(

Portal

portal

)

Definition at line 414 of file portalmem.c.

{
    /* Perform the state transition */
    Assert(portal->status == PORTAL_ACTIVE);
    portal->status = PORTAL_DONE;
 
    /*
     * Allow portalcmds.c to clean up the state it knows about.  We might as
     * well do that now, since the portal can't be executed any more.
     *
     * In some cases involving execution of a ROLLBACK command in an already
     * aborted transaction, this is necessary, or we'd reach AtCleanup_Portals
     * with the cleanup hook still unexecuted.
     */
    if (PointerIsValid(portal->cleanup))
    {
        portal->cleanup(portal);
        portal->cleanup = NULL;
    }
}

References Assert, PortalData::cleanup, PointerIsValid, PORTAL_ACTIVE, PORTAL_DONE, and PortalData::status.

Referenced by PortalRun().

MarkPortalFailed()

void MarkPortalFailed

(

Portal

portal

)

Definition at line 442 of file portalmem.c.

{
    /* Perform the state transition */
    Assert(portal->status != PORTAL_DONE);
    portal->status = PORTAL_FAILED;
 
    /*
     * Allow portalcmds.c to clean up the state it knows about.  We might as
     * well do that now, since the portal can't be executed any more.
     *
     * In some cases involving cleanup of an already aborted transaction, this
     * is necessary, or we'd reach AtCleanup_Portals with the cleanup hook
     * still unexecuted.
     */
    if (PointerIsValid(portal->cleanup))
    {
        portal->cleanup(portal);
        portal->cleanup = NULL;
    }
}

References Assert, PortalData::cleanup, PointerIsValid, PORTAL_DONE, PORTAL_FAILED, and PortalData::status.

Referenced by AtAbort_Portals(), AtSubAbort_Portals(), PersistHoldablePortal(), PortalRun(), PortalRunFetch(), and PortalStart().

pg_cursor()

Datum pg_cursor

(

PG_FUNCTION_ARGS

)

Definition at line 1131 of file portalmem.c.

{
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    HASH_SEQ_STATUS hash_seq;
    PortalHashEnt *hentry;
 
    /*
     * We put all the tuples into a tuplestore in one scan of the hashtable.
     * This avoids any issue of the hashtable possibly changing between calls.
     */
    InitMaterializedSRF(fcinfo, 0);
 
    hash_seq_init(&hash_seq, PortalHashTable);
    while ((hentry = hash_seq_search(&hash_seq)) != NULL)
    {
        Portal      portal = hentry->portal;
        Datum       values[6];
        bool        nulls[6] = {0};
 
        /* report only "visible" entries */
        if (!portal->visible)
            continue;
 
        values[0] = CStringGetTextDatum(portal->name);
        values[1] = CStringGetTextDatum(portal->sourceText);
        values[2] = BoolGetDatum(portal->cursorOptions & CURSOR_OPT_HOLD);
        values[3] = BoolGetDatum(portal->cursorOptions & CURSOR_OPT_BINARY);
        values[4] = BoolGetDatum(portal->cursorOptions & CURSOR_OPT_SCROLL);
        values[5] = TimestampTzGetDatum(portal->creation_time);
 
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
    }
 
    return (Datum) 0;
}

References BoolGetDatum(), PortalData::creation_time, CStringGetTextDatum, CURSOR_OPT_BINARY, CURSOR_OPT_HOLD, CURSOR_OPT_SCROLL, PortalData::cursorOptions, hash_seq_init(), hash_seq_search(), InitMaterializedSRF(), PortalData::name, PortalHashTable, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, PortalData::sourceText, TimestampTzGetDatum(), tuplestore_putvalues(), values, and PortalData::visible.

PinPortal()

void PinPortal

(

Portal

portal

)

Definition at line 371 of file portalmem.c.

{
    if (portal->portalPinned)
        elog(ERROR, "portal already pinned");
 
    portal->portalPinned = true;
}

References elog, ERROR, and PortalData::portalPinned.

Referenced by exec_for_query(), plperl_spi_query(), plperl_spi_query_prepared(), PLy_cursor_plan(), and PLy_cursor_query().

PortalCreateHoldStore()

void PortalCreateHoldStore

(

Portal

portal

)

Definition at line 331 of file portalmem.c.

{
    MemoryContext oldcxt;
 
    Assert(portal->holdContext == NULL);
    Assert(portal->holdStore == NULL);
    Assert(portal->holdSnapshot == NULL);
 
    /*
     * Create the memory context that is used for storage of the tuple set.
     * Note this is NOT a child of the portal's portalContext.
     */
    portal->holdContext =
        AllocSetContextCreate(TopPortalContext,
                              "PortalHoldContext",
                              ALLOCSET_DEFAULT_SIZES);
 
    /*
     * Create the tuple store, selecting cross-transaction temp files, and
     * enabling random access only if cursor requires scrolling.
     *
     * XXX: Should maintenance_work_mem be used for the portal size?
     */
    oldcxt = MemoryContextSwitchTo(portal->holdContext);
 
    portal->holdStore =
        tuplestore_begin_heap(portal->cursorOptions & CURSOR_OPT_SCROLL,
                              true, work_mem);
 
    MemoryContextSwitchTo(oldcxt);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, CURSOR_OPT_SCROLL, PortalData::cursorOptions, PortalData::holdContext, PortalData::holdSnapshot, PortalData::holdStore, MemoryContextSwitchTo(), TopPortalContext, tuplestore_begin_heap(), and work_mem.

Referenced by FillPortalStore(), and HoldPortal().

PortalDefineQuery()

void PortalDefineQuery	(	Portal	portal,
		const char *	prepStmtName,
		const char *	sourceText,
		CommandTag	commandTag,
		List *	stmts,
		CachedPlan *	cplan
	)

Definition at line 282 of file portalmem.c.

{
    Assert(PortalIsValid(portal));
    Assert(portal->status == PORTAL_NEW);
 
    Assert(sourceText != NULL);
    Assert(commandTag != CMDTAG_UNKNOWN || stmts == NIL);
 
    portal->prepStmtName = prepStmtName;
    portal->sourceText = sourceText;
    portal->qc.commandTag = commandTag;
    portal->qc.nprocessed = 0;
    portal->commandTag = commandTag;
    portal->stmts = stmts;
    portal->cplan = cplan;
    portal->status = PORTAL_DEFINED;
}

References Assert, QueryCompletion::commandTag, PortalData::commandTag, PortalData::cplan, NIL, QueryCompletion::nprocessed, PORTAL_DEFINED, PORTAL_NEW, PortalIsValid, PortalData::prepStmtName, PortalData::qc, PortalData::sourceText, PortalData::status, and PortalData::stmts.

Referenced by exec_bind_message(), exec_simple_query(), ExecuteQuery(), PerformCursorOpen(), and SPI_cursor_open_internal().

PortalDrop()

void PortalDrop	(	Portal	portal,
		bool	isTopCommit
	)

Definition at line 468 of file portalmem.c.

{
    Assert(PortalIsValid(portal));
 
    /*
     * Don't allow dropping a pinned portal, it's still needed by whoever
     * pinned it.
     */
    if (portal->portalPinned)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_CURSOR_STATE),
                 errmsg("cannot drop pinned portal \"%s\"", portal->name)));
 
    /*
     * Not sure if the PORTAL_ACTIVE case can validly happen or not...
     */
    if (portal->status == PORTAL_ACTIVE)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_CURSOR_STATE),
                 errmsg("cannot drop active portal \"%s\"", portal->name)));
 
    /*
     * Allow portalcmds.c to clean up the state it knows about, in particular
     * shutting down the executor if still active.  This step potentially runs
     * user-defined code so failure has to be expected.  It's the cleanup
     * hook's responsibility to not try to do that more than once, in the case
     * that failure occurs and then we come back to drop the portal again
     * during transaction abort.
     *
     * Note: in most paths of control, this will have been done already in
     * MarkPortalDone or MarkPortalFailed.  We're just making sure.
     */
    if (PointerIsValid(portal->cleanup))
    {
        portal->cleanup(portal);
        portal->cleanup = NULL;
    }
 
    /* There shouldn't be an active snapshot anymore, except after error */
    Assert(portal->portalSnapshot == NULL || !isTopCommit);
 
    /*
     * Remove portal from hash table.  Because we do this here, we will not
     * come back to try to remove the portal again if there's any error in the
     * subsequent steps.  Better to leak a little memory than to get into an
     * infinite error-recovery loop.
     */
    PortalHashTableDelete(portal);
 
    /* drop cached plan reference, if any */
    PortalReleaseCachedPlan(portal);
 
    /*
     * If portal has a snapshot protecting its data, release that.  This needs
     * a little care since the registration will be attached to the portal's
     * resowner; if the portal failed, we will already have released the
     * resowner (and the snapshot) during transaction abort.
     */
    if (portal->holdSnapshot)
    {
        if (portal->resowner)
            UnregisterSnapshotFromOwner(portal->holdSnapshot,
                                        portal->resowner);
        portal->holdSnapshot = NULL;
    }
 
    /*
     * Release any resources still attached to the portal.  There are several
     * cases being covered here:
     *
     * Top transaction commit (indicated by isTopCommit): normally we should
     * do nothing here and let the regular end-of-transaction resource
     * releasing mechanism handle these resources too.  However, if we have a
     * FAILED portal (eg, a cursor that got an error), we'd better clean up
     * its resources to avoid resource-leakage warning messages.
     *
     * Sub transaction commit: never comes here at all, since we don't kill
     * any portals in AtSubCommit_Portals().
     *
     * Main or sub transaction abort: we will do nothing here because
     * portal->resowner was already set NULL; the resources were already
     * cleaned up in transaction abort.
     *
     * Ordinary portal drop: must release resources.  However, if the portal
     * is not FAILED then we do not release its locks.  The locks become the
     * responsibility of the transaction's ResourceOwner (since it is the
     * parent of the portal's owner) and will be released when the transaction
     * eventually ends.
     */
    if (portal->resowner &&
        (!isTopCommit || portal->status == PORTAL_FAILED))
    {
        bool        isCommit = (portal->status != PORTAL_FAILED);
 
        ResourceOwnerRelease(portal->resowner,
                             RESOURCE_RELEASE_BEFORE_LOCKS,
                             isCommit, false);
        ResourceOwnerRelease(portal->resowner,
                             RESOURCE_RELEASE_LOCKS,
                             isCommit, false);
        ResourceOwnerRelease(portal->resowner,
                             RESOURCE_RELEASE_AFTER_LOCKS,
                             isCommit, false);
        ResourceOwnerDelete(portal->resowner);
    }
    portal->resowner = NULL;
 
    /*
     * Delete tuplestore if present.  We should do this even under error
     * conditions; since the tuplestore would have been using cross-
     * transaction storage, its temp files need to be explicitly deleted.
     */
    if (portal->holdStore)
    {
        MemoryContext oldcontext;
 
        oldcontext = MemoryContextSwitchTo(portal->holdContext);
        tuplestore_end(portal->holdStore);
        MemoryContextSwitchTo(oldcontext);
        portal->holdStore = NULL;
    }
 
    /* delete tuplestore storage, if any */
    if (portal->holdContext)
        MemoryContextDelete(portal->holdContext);
 
    /* release subsidiary storage */
    MemoryContextDelete(portal->portalContext);
 
    /* release portal struct (it's in TopPortalContext) */
    pfree(portal);
}

References Assert, PortalData::cleanup, ereport, errcode(), errmsg(), ERROR, PortalData::holdContext, PortalData::holdSnapshot, PortalData::holdStore, MemoryContextDelete(), MemoryContextSwitchTo(), PortalData::name, pfree(), PointerIsValid, PORTAL_ACTIVE, PORTAL_FAILED, PortalData::portalContext, PortalHashTableDelete, PortalIsValid, PortalData::portalPinned, PortalReleaseCachedPlan(), PortalData::portalSnapshot, RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, ResourceOwnerDelete(), ResourceOwnerRelease(), PortalData::resowner, PortalData::status, tuplestore_end(), and UnregisterSnapshotFromOwner().

Referenced by AtCleanup_Portals(), AtSubCleanup_Portals(), CreatePortal(), exec_simple_query(), ExecuteQuery(), PerformPortalClose(), PortalErrorCleanup(), PortalHashTableDeleteAll(), PostgresMain(), PreCommit_Portals(), and SPI_cursor_close().

PortalErrorCleanup()

void PortalErrorCleanup

(

void

)

Definition at line 917 of file portalmem.c.

{
    HASH_SEQ_STATUS status;
    PortalHashEnt *hentry;
 
    hash_seq_init(&status, PortalHashTable);
 
    while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
    {
        Portal      portal = hentry->portal;
 
        if (portal->autoHeld)
        {
            portal->portalPinned = false;
            PortalDrop(portal, false);
        }
    }
}

References PortalData::autoHeld, hash_seq_init(), hash_seq_search(), portalhashent::portal, PortalDrop(), PortalHashTable, and PortalData::portalPinned.

Referenced by PostgresMain().

PortalGetPrimaryStmt()

PlannedStmt* PortalGetPrimaryStmt

(

Portal

portal

)

Definition at line 151 of file portalmem.c.

{
    ListCell   *lc;
 
    foreach(lc, portal->stmts)
    {
        PlannedStmt *stmt = lfirst_node(PlannedStmt, lc);
 
        if (stmt->canSetTag)
            return stmt;
    }
    return NULL;
}

References lfirst_node, stmt, and PortalData::stmts.

Referenced by FetchPortalTargetList(), and PortalStart().

PortalHashTableDeleteAll()

void PortalHashTableDeleteAll

(

void

)

Definition at line 607 of file portalmem.c.

{
    HASH_SEQ_STATUS status;
    PortalHashEnt *hentry;
 
    if (PortalHashTable == NULL)
        return;
 
    hash_seq_init(&status, PortalHashTable);
    while ((hentry = hash_seq_search(&status)) != NULL)
    {
        Portal      portal = hentry->portal;
 
        /* Can't close the active portal (the one running the command) */
        if (portal->status == PORTAL_ACTIVE)
            continue;
 
        PortalDrop(portal, false);
 
        /* Restart the iteration in case that led to other drops */
        hash_seq_term(&status);
        hash_seq_init(&status, PortalHashTable);
    }
}

References hash_seq_init(), hash_seq_search(), hash_seq_term(), portalhashent::portal, PORTAL_ACTIVE, PortalDrop(), PortalHashTable, and PortalData::status.

Referenced by DiscardAll(), and PerformPortalClose().

PortalReleaseCachedPlan()

static void PortalReleaseCachedPlan ( Portal  portal )

static

Definition at line 310 of file portalmem.c.

{
    if (portal->cplan)
    {
        ReleaseCachedPlan(portal->cplan, NULL);
        portal->cplan = NULL;
 
        /*
         * We must also clear portal->stmts which is now a dangling reference
         * to the cached plan's plan list.  This protects any code that might
         * try to examine the Portal later.
         */
        portal->stmts = NIL;
    }
}

References PortalData::cplan, NIL, ReleaseCachedPlan(), and PortalData::stmts.

Referenced by AtAbort_Portals(), AtSubAbort_Portals(), HoldPortal(), and PortalDrop().

PreCommit_Portals()

bool PreCommit_Portals

(

bool

isPrepare

)

Definition at line 677 of file portalmem.c.

{
    bool        result = false;
    HASH_SEQ_STATUS status;
    PortalHashEnt *hentry;
 
    hash_seq_init(&status, PortalHashTable);
 
    while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
    {
        Portal      portal = hentry->portal;
 
        /*
         * There should be no pinned portals anymore. Complain if someone
         * leaked one. Auto-held portals are allowed; we assume that whoever
         * pinned them is managing them.
         */
        if (portal->portalPinned && !portal->autoHeld)
            elog(ERROR, "cannot commit while a portal is pinned");
 
        /*
         * Do not touch active portals --- this can only happen in the case of
         * a multi-transaction utility command, such as VACUUM, or a commit in
         * a procedure.
         *
         * Note however that any resource owner attached to such a portal is
         * still going to go away, so don't leave a dangling pointer.  Also
         * unregister any snapshots held by the portal, mainly to avoid
         * snapshot leak warnings from ResourceOwnerRelease().
         */
        if (portal->status == PORTAL_ACTIVE)
        {
            if (portal->holdSnapshot)
            {
                if (portal->resowner)
                    UnregisterSnapshotFromOwner(portal->holdSnapshot,
                                                portal->resowner);
                portal->holdSnapshot = NULL;
            }
            portal->resowner = NULL;
            /* Clear portalSnapshot too, for cleanliness */
            portal->portalSnapshot = NULL;
            continue;
        }
 
        /* Is it a holdable portal created in the current xact? */
        if ((portal->cursorOptions & CURSOR_OPT_HOLD) &&
            portal->createSubid != InvalidSubTransactionId &&
            portal->status == PORTAL_READY)
        {
            /*
             * We are exiting the transaction that created a holdable cursor.
             * Instead of dropping the portal, prepare it for access by later
             * transactions.
             *
             * However, if this is PREPARE TRANSACTION rather than COMMIT,
             * refuse PREPARE, because the semantics seem pretty unclear.
             */
            if (isPrepare)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot PREPARE a transaction that has created a cursor WITH HOLD")));
 
            HoldPortal(portal);
 
            /* Report we changed state */
            result = true;
        }
        else if (portal->createSubid == InvalidSubTransactionId)
        {
            /*
             * Do nothing to cursors held over from a previous transaction
             * (including ones we just froze in a previous cycle of this loop)
             */
            continue;
        }
        else
        {
            /* Zap all non-holdable portals */
            PortalDrop(portal, true);
 
            /* Report we changed state */
            result = true;
        }
 
        /*
         * After either freezing or dropping a portal, we have to restart the
         * iteration, because we could have invoked user-defined code that
         * caused a drop of the next portal in the hash chain.
         */
        hash_seq_term(&status);
        hash_seq_init(&status, PortalHashTable);
    }
 
    return result;
}

References PortalData::autoHeld, PortalData::createSubid, CURSOR_OPT_HOLD, PortalData::cursorOptions, elog, ereport, errcode(), errmsg(), ERROR, hash_seq_init(), hash_seq_search(), hash_seq_term(), HoldPortal(), PortalData::holdSnapshot, InvalidSubTransactionId, portalhashent::portal, PORTAL_ACTIVE, PORTAL_READY, PortalDrop(), PortalHashTable, PortalData::portalPinned, PortalData::portalSnapshot, PortalData::resowner, PortalData::status, and UnregisterSnapshotFromOwner().

Referenced by CommitTransaction(), and PrepareTransaction().

ThereAreNoReadyPortals()

bool ThereAreNoReadyPortals

(

void

)

Definition at line 1168 of file portalmem.c.

{
    HASH_SEQ_STATUS status;
    PortalHashEnt *hentry;
 
    hash_seq_init(&status, PortalHashTable);
 
    while ((hentry = (PortalHashEnt *) hash_seq_search(&status)) != NULL)
    {
        Portal      portal = hentry->portal;
 
        if (portal->status == PORTAL_READY)
            return false;
    }
 
    return true;
}

References hash_seq_init(), hash_seq_search(), portalhashent::portal, PORTAL_READY, PortalHashTable, and PortalData::status.

Referenced by CopyFrom().

UnpinPortal()

void UnpinPortal

(

Portal

portal

)

Definition at line 380 of file portalmem.c.

{
    if (!portal->portalPinned)
        elog(ERROR, "portal not pinned");
 
    portal->portalPinned = false;
}

References elog, ERROR, and PortalData::portalPinned.

Referenced by exec_for_query(), plperl_spi_cursor_close(), plperl_spi_fetchrow(), PLy_cursor_close(), and PLy_cursor_dealloc().

Variable Documentation

PortalHashTable

HTAB* PortalHashTable = NULL

static

Definition at line 54 of file portalmem.c.

Referenced by AtAbort_Portals(), AtCleanup_Portals(), AtSubAbort_Portals(), AtSubCleanup_Portals(), AtSubCommit_Portals(), EnablePortalManager(), ForgetPortalSnapshots(), HoldPinnedPortals(), pg_cursor(), PortalErrorCleanup(), PortalHashTableDeleteAll(), PreCommit_Portals(), and ThereAreNoReadyPortals().

TopPortalContext

MemoryContext TopPortalContext = NULL

static

Definition at line 91 of file portalmem.c.

Referenced by CreatePortal(), EnablePortalManager(), and PortalCreateHoldStore().