xid8funcs.c File Reference

#include "postgres.h"
#include "access/clog.h"
#include "access/transam.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "funcapi.h"
#include "lib/qunique.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "postmaster/postmaster.h"
#include "storage/lwlock.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/snapmgr.h"
#include "utils/xid8.h"

Include dependency graph for xid8funcs.c:

Go to the source code of this file.

Data Structures
struct	pg_snapshot

Macros
#define	USE_BSEARCH_IF_NXIP_GREATER   30
#define	PG_SNAPSHOT_SIZE(nxip)   (offsetof(pg_snapshot, xip) + sizeof(FullTransactionId) * (nxip))
#define	PG_SNAPSHOT_MAX_NXIP   ((MaxAllocSize - offsetof(pg_snapshot, xip)) / sizeof(FullTransactionId))

Functions
static bool	TransactionIdInRecentPast (FullTransactionId fxid, TransactionId *extracted_xid)
static FullTransactionId	widen_snapshot_xid (TransactionId xid, FullTransactionId next_fxid)
static int	cmp_fxid (const void *aa, const void *bb)
static void	sort_snapshot (pg_snapshot *snap)
static bool	is_visible_fxid (FullTransactionId value, const pg_snapshot *snap)
static StringInfo	buf_init (FullTransactionId xmin, FullTransactionId xmax)
static void	buf_add_txid (StringInfo buf, FullTransactionId fxid)
static pg_snapshot *	buf_finalize (StringInfo buf)
static pg_snapshot *	parse_snapshot (const char *str)
Datum	pg_current_xact_id (PG_FUNCTION_ARGS)
Datum	pg_current_xact_id_if_assigned (PG_FUNCTION_ARGS)
Datum	pg_current_snapshot (PG_FUNCTION_ARGS)
Datum	pg_snapshot_in (PG_FUNCTION_ARGS)
Datum	pg_snapshot_out (PG_FUNCTION_ARGS)
Datum	pg_snapshot_recv (PG_FUNCTION_ARGS)
Datum	pg_snapshot_send (PG_FUNCTION_ARGS)
Datum	pg_visible_in_snapshot (PG_FUNCTION_ARGS)
Datum	pg_snapshot_xmin (PG_FUNCTION_ARGS)
Datum	pg_snapshot_xmax (PG_FUNCTION_ARGS)
Datum	pg_snapshot_xip (PG_FUNCTION_ARGS)
Datum	pg_xact_status (PG_FUNCTION_ARGS)

Macro Definition Documentation

PG_SNAPSHOT_MAX_NXIP

#define PG_SNAPSHOT_MAX_NXIP   ((MaxAllocSize - offsetof(pg_snapshot, xip)) / sizeof(FullTransactionId))

Definition at line 73 of file xid8funcs.c.

Referenced by pg_current_snapshot(), and pg_snapshot_recv().

PG_SNAPSHOT_SIZE

#define PG_SNAPSHOT_SIZE

(

nxip

)

(offsetof(pg_snapshot, xip) + sizeof(FullTransactionId) * (nxip))

Definition at line 71 of file xid8funcs.c.

Referenced by buf_init(), pg_current_snapshot(), and pg_snapshot_recv().

USE_BSEARCH_IF_NXIP_GREATER

#define USE_BSEARCH_IF_NXIP_GREATER   30

Definition at line 49 of file xid8funcs.c.

Referenced by is_visible_fxid().

Function Documentation

buf_add_txid()

static void buf_add_txid ( StringInfo  buf, FullTransactionId  fxid  )

static

Definition at line 260 of file xid8funcs.c.

References appendBinaryStringInfo(), StringInfoData::data, and pg_snapshot::nxip.

Referenced by parse_snapshot().

{
    pg_snapshot *snap = (pg_snapshot *) buf->data;

    /* do this before possible realloc */
    snap->nxip++;

    appendBinaryStringInfo(buf, (char *) &fxid, sizeof(fxid));
}

buf_finalize()

static pg_snapshot* buf_finalize ( StringInfo  buf )

static

Definition at line 271 of file xid8funcs.c.

References StringInfoData::data, StringInfoData::len, pfree(), and SET_VARSIZE.

Referenced by parse_snapshot().

{
    pg_snapshot *snap = (pg_snapshot *) buf->data;

    SET_VARSIZE(snap, buf->len);

    /* buf is not needed anymore */
    buf->data = NULL;
    pfree(buf);

    return snap;
}

buf_init()

static StringInfo buf_init ( FullTransactionId  xmin, FullTransactionId  xmax  )

static

Definition at line 245 of file xid8funcs.c.

References appendBinaryStringInfo(), buf, makeStringInfo(), pg_snapshot::nxip, PG_SNAPSHOT_SIZE, pg_snapshot::xmax, and pg_snapshot::xmin.

Referenced by parse_snapshot().

{
    pg_snapshot snap;
    StringInfo  buf;

    snap.xmin = xmin;
    snap.xmax = xmax;
    snap.nxip = 0;

    buf = makeStringInfo();
    appendBinaryStringInfo(buf, (char *) &snap, PG_SNAPSHOT_SIZE(0));
    return buf;
}

cmp_fxid()

static int cmp_fxid ( const void *  aa, const void *  bb  )

static

Definition at line 176 of file xid8funcs.c.

References FullTransactionIdPrecedes.

Referenced by is_visible_fxid(), and sort_snapshot().

{
    FullTransactionId a = *(const FullTransactionId *) aa;
    FullTransactionId b = *(const FullTransactionId *) bb;

    if (FullTransactionIdPrecedes(a, b))
        return -1;
    if (FullTransactionIdPrecedes(b, a))
        return 1;
    return 0;
}

is_visible_fxid()

static bool is_visible_fxid ( FullTransactionId  value, const pg_snapshot *  snap  )

static

Definition at line 210 of file xid8funcs.c.

References cmp_fxid(), false, FullTransactionIdEquals, FullTransactionIdPrecedes, i, pg_snapshot::nxip, USE_BSEARCH_IF_NXIP_GREATER, pg_snapshot::xip, pg_snapshot::xmax, and pg_snapshot::xmin.

Referenced by pg_visible_in_snapshot().

{
    if (FullTransactionIdPrecedes(value, snap->xmin))
        return true;
    else if (!FullTransactionIdPrecedes(value, snap->xmax))
        return false;
#ifdef USE_BSEARCH_IF_NXIP_GREATER
    else if (snap->nxip > USE_BSEARCH_IF_NXIP_GREATER)
    {
        void       *res;

        res = bsearch(&value, snap->xip, snap->nxip, sizeof(FullTransactionId),
                      cmp_fxid);
        /* if found, transaction is still in progress */
        return (res) ? false : true;
    }
#endif
    else
    {
        uint32      i;

        for (i = 0; i < snap->nxip; i++)
        {
            if (FullTransactionIdEquals(value, snap->xip[i]))
                return false;
        }
        return true;
    }
}

parse_snapshot()

static pg_snapshot* parse_snapshot ( const char *  str )

static

Definition at line 288 of file xid8funcs.c.

References buf, buf_add_txid(), buf_finalize(), buf_init(), ereport, errcode(), errmsg(), ERROR, FullTransactionIdEquals, FullTransactionIdFollowsOrEquals, FullTransactionIdFromU64(), FullTransactionIdIsValid, FullTransactionIdPrecedes, InvalidFullTransactionId, pg_strtouint64(), generate_unaccent_rules::str, and val.

Referenced by pg_snapshot_in().

{
    FullTransactionId xmin;
    FullTransactionId xmax;
    FullTransactionId last_val = InvalidFullTransactionId;
    FullTransactionId val;
    const char *str_start = str;
    char       *endp;
    StringInfo  buf;

    xmin = FullTransactionIdFromU64(pg_strtouint64(str, &endp, 10));
    if (*endp != ':')
        goto bad_format;
    str = endp + 1;

    xmax = FullTransactionIdFromU64(pg_strtouint64(str, &endp, 10));
    if (*endp != ':')
        goto bad_format;
    str = endp + 1;

    /* it should look sane */
    if (!FullTransactionIdIsValid(xmin) ||
        !FullTransactionIdIsValid(xmax) ||
        FullTransactionIdPrecedes(xmax, xmin))
        goto bad_format;

    /* allocate buffer */
    buf = buf_init(xmin, xmax);

    /* loop over values */
    while (*str != '\0')
    {
        /* read next value */
        val = FullTransactionIdFromU64(pg_strtouint64(str, &endp, 10));
        str = endp;

        /* require the input to be in order */
        if (FullTransactionIdPrecedes(val, xmin) ||
            FullTransactionIdFollowsOrEquals(val, xmax) ||
            FullTransactionIdPrecedes(val, last_val))
            goto bad_format;

        /* skip duplicates */
        if (!FullTransactionIdEquals(val, last_val))
            buf_add_txid(buf, val);
        last_val = val;

        if (*str == ',')
            str++;
        else if (*str != '\0')
            goto bad_format;
    }

    return buf_finalize(buf);

bad_format:
    ereport(ERROR,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    "pg_snapshot", str_start)));
    return NULL;                /* keep compiler quiet */
}

pg_current_snapshot()

Datum pg_current_snapshot

(

PG_FUNCTION_ARGS

)

Definition at line 394 of file xid8funcs.c.

References cur, elog, ERROR, GetActiveSnapshot(), i, MAX_BACKENDS, pg_snapshot::nxip, palloc(), PG_RETURN_POINTER, PG_SNAPSHOT_MAX_NXIP, PG_SNAPSHOT_SIZE, ReadNextFullTransactionId(), SET_VARSIZE, sort_snapshot(), StaticAssertStmt, widen_snapshot_xid(), SnapshotData::xcnt, pg_snapshot::xip, SnapshotData::xip, pg_snapshot::xmax, SnapshotData::xmax, pg_snapshot::xmin, and SnapshotData::xmin.

{
    pg_snapshot *snap;
    uint32      nxip,
                i;
    Snapshot    cur;
    FullTransactionId next_fxid = ReadNextFullTransactionId();

    cur = GetActiveSnapshot();
    if (cur == NULL)
        elog(ERROR, "no active snapshot set");

    /*
     * Compile-time limits on the procarray (MAX_BACKENDS processes plus
     * MAX_BACKENDS prepared transactions) guarantee nxip won't be too large.
     */
    StaticAssertStmt(MAX_BACKENDS * 2 <= PG_SNAPSHOT_MAX_NXIP,
                     "possible overflow in pg_current_snapshot()");

    /* allocate */
    nxip = cur->xcnt;
    snap = palloc(PG_SNAPSHOT_SIZE(nxip));

    /* fill */
    snap->xmin = widen_snapshot_xid(cur->xmin, next_fxid);
    snap->xmax = widen_snapshot_xid(cur->xmax, next_fxid);
    snap->nxip = nxip;
    for (i = 0; i < nxip; i++)
        snap->xip[i] = widen_snapshot_xid(cur->xip[i], next_fxid);

    /*
     * We want them guaranteed to be in ascending order.  This also removes
     * any duplicate xids.  Normally, an XID can only be assigned to one
     * backend, but when preparing a transaction for two-phase commit, there
     * is a transient state when both the original backend and the dummy
     * PGPROC entry reserved for the prepared transaction hold the same XID.
     */
    sort_snapshot(snap);

    /* set size after sorting, because it may have removed duplicate xips */
    SET_VARSIZE(snap, PG_SNAPSHOT_SIZE(snap->nxip));

    PG_RETURN_POINTER(snap);
}

pg_current_xact_id()

Datum pg_current_xact_id

(

PG_FUNCTION_ARGS

)

Definition at line 358 of file xid8funcs.c.

References GetTopFullTransactionId(), PG_RETURN_FULLTRANSACTIONID, and PreventCommandDuringRecovery().

{
    /*
     * Must prevent during recovery because if an xid is not assigned we try
     * to assign one, which would fail. Programs already rely on this function
     * to always return a valid current xid, so we should not change this to
     * return NULL or similar invalid xid.
     */
    PreventCommandDuringRecovery("pg_current_xact_id()");

    PG_RETURN_FULLTRANSACTIONID(GetTopFullTransactionId());
}

pg_current_xact_id_if_assigned()

Datum pg_current_xact_id_if_assigned

(

PG_FUNCTION_ARGS

)

Definition at line 376 of file xid8funcs.c.

References FullTransactionIdIsValid, GetTopFullTransactionIdIfAny(), PG_RETURN_FULLTRANSACTIONID, and PG_RETURN_NULL.

{
    FullTransactionId topfxid = GetTopFullTransactionIdIfAny();

    if (!FullTransactionIdIsValid(topfxid))
        PG_RETURN_NULL();

    PG_RETURN_FULLTRANSACTIONID(topfxid);
}

pg_snapshot_in()

Datum pg_snapshot_in

(

PG_FUNCTION_ARGS

)

Definition at line 445 of file xid8funcs.c.

References parse_snapshot(), PG_GETARG_CSTRING, PG_RETURN_POINTER, and generate_unaccent_rules::str.

{
    char       *str = PG_GETARG_CSTRING(0);
    pg_snapshot *snap;

    snap = parse_snapshot(str);

    PG_RETURN_POINTER(snap);
}

pg_snapshot_out()

Datum pg_snapshot_out

(

PG_FUNCTION_ARGS

)

Definition at line 461 of file xid8funcs.c.

References appendStringInfo(), appendStringInfoChar(), StringInfoData::data, i, initStringInfo(), pg_snapshot::nxip, PG_GETARG_VARLENA_P, PG_RETURN_CSTRING, generate_unaccent_rules::str, U64FromFullTransactionId, UINT64_FORMAT, pg_snapshot::xip, pg_snapshot::xmax, and pg_snapshot::xmin.

{
    pg_snapshot *snap = (pg_snapshot *) PG_GETARG_VARLENA_P(0);
    StringInfoData str;
    uint32      i;

    initStringInfo(&str);

    appendStringInfo(&str, UINT64_FORMAT ":",
                     U64FromFullTransactionId(snap->xmin));
    appendStringInfo(&str, UINT64_FORMAT ":",
                     U64FromFullTransactionId(snap->xmax));

    for (i = 0; i < snap->nxip; i++)
    {
        if (i > 0)
            appendStringInfoChar(&str, ',');
        appendStringInfo(&str, UINT64_FORMAT,
                         U64FromFullTransactionId(snap->xip[i]));
    }

    PG_RETURN_CSTRING(str.data);
}

pg_snapshot_recv()

Datum pg_snapshot_recv

(

PG_FUNCTION_ARGS

)

Definition at line 493 of file xid8funcs.c.

References buf, cur, ereport, errcode(), errmsg(), ERROR, FullTransactionIdEquals, FullTransactionIdFromU64(), FullTransactionIdIsValid, FullTransactionIdPrecedes, i, InvalidFullTransactionId, pg_snapshot::nxip, palloc(), PG_GETARG_POINTER, PG_RETURN_POINTER, PG_SNAPSHOT_MAX_NXIP, PG_SNAPSHOT_SIZE, pq_getmsgint(), pq_getmsgint64(), SET_VARSIZE, pg_snapshot::xip, pg_snapshot::xmax, and pg_snapshot::xmin.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    pg_snapshot *snap;
    FullTransactionId last = InvalidFullTransactionId;
    int         nxip;
    int         i;
    FullTransactionId xmin;
    FullTransactionId xmax;

    /* load and validate nxip */
    nxip = pq_getmsgint(buf, 4);
    if (nxip < 0 || nxip > PG_SNAPSHOT_MAX_NXIP)
        goto bad_format;

    xmin = FullTransactionIdFromU64((uint64) pq_getmsgint64(buf));
    xmax = FullTransactionIdFromU64((uint64) pq_getmsgint64(buf));
    if (!FullTransactionIdIsValid(xmin) ||
        !FullTransactionIdIsValid(xmax) ||
        FullTransactionIdPrecedes(xmax, xmin))
        goto bad_format;

    snap = palloc(PG_SNAPSHOT_SIZE(nxip));
    snap->xmin = xmin;
    snap->xmax = xmax;

    for (i = 0; i < nxip; i++)
    {
        FullTransactionId cur =
        FullTransactionIdFromU64((uint64) pq_getmsgint64(buf));

        if (FullTransactionIdPrecedes(cur, last) ||
            FullTransactionIdPrecedes(cur, xmin) ||
            FullTransactionIdPrecedes(xmax, cur))
            goto bad_format;

        /* skip duplicate xips */
        if (FullTransactionIdEquals(cur, last))
        {
            i--;
            nxip--;
            continue;
        }

        snap->xip[i] = cur;
        last = cur;
    }
    snap->nxip = nxip;
    SET_VARSIZE(snap, PG_SNAPSHOT_SIZE(nxip));
    PG_RETURN_POINTER(snap);

bad_format:
    ereport(ERROR,
            (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
             errmsg("invalid external pg_snapshot data")));
    PG_RETURN_POINTER(NULL);    /* keep compiler quiet */
}

pg_snapshot_send()

Datum pg_snapshot_send

(

PG_FUNCTION_ARGS

)

Definition at line 559 of file xid8funcs.c.

References buf, i, pg_snapshot::nxip, PG_GETARG_VARLENA_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint32(), pq_sendint64(), U64FromFullTransactionId, pg_snapshot::xip, pg_snapshot::xmax, and pg_snapshot::xmin.

{
    pg_snapshot *snap = (pg_snapshot *) PG_GETARG_VARLENA_P(0);
    StringInfoData buf;
    uint32      i;

    pq_begintypsend(&buf);
    pq_sendint32(&buf, snap->nxip);
    pq_sendint64(&buf, (int64) U64FromFullTransactionId(snap->xmin));
    pq_sendint64(&buf, (int64) U64FromFullTransactionId(snap->xmax));
    for (i = 0; i < snap->nxip; i++)
        pq_sendint64(&buf, (int64) U64FromFullTransactionId(snap->xip[i]));
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

pg_snapshot_xip()

Datum pg_snapshot_xip

(

PG_FUNCTION_ARGS

)

Definition at line 620 of file xid8funcs.c.

References arg, FuncCallContext::call_cntr, FullTransactionIdGetDatum, MemoryContextAlloc(), FuncCallContext::multi_call_memory_ctx, pg_snapshot::nxip, PG_GETARG_VARLENA_P, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, FuncCallContext::user_fctx, value, VARSIZE, and pg_snapshot::xip.

{
    FuncCallContext *fctx;
    pg_snapshot *snap;
    FullTransactionId value;

    /* on first call initialize fctx and get copy of snapshot */
    if (SRF_IS_FIRSTCALL())
    {
        pg_snapshot *arg = (pg_snapshot *) PG_GETARG_VARLENA_P(0);

        fctx = SRF_FIRSTCALL_INIT();

        /* make a copy of user snapshot */
        snap = MemoryContextAlloc(fctx->multi_call_memory_ctx, VARSIZE(arg));
        memcpy(snap, arg, VARSIZE(arg));

        fctx->user_fctx = snap;
    }

    /* return values one-by-one */
    fctx = SRF_PERCALL_SETUP();
    snap = fctx->user_fctx;
    if (fctx->call_cntr < snap->nxip)
    {
        value = snap->xip[fctx->call_cntr];
        SRF_RETURN_NEXT(fctx, FullTransactionIdGetDatum(value));
    }
    else
    {
        SRF_RETURN_DONE(fctx);
    }
}

pg_snapshot_xmax()

Datum pg_snapshot_xmax

(

PG_FUNCTION_ARGS

)

Definition at line 607 of file xid8funcs.c.

References PG_GETARG_VARLENA_P, PG_RETURN_FULLTRANSACTIONID, and pg_snapshot::xmax.

{
    pg_snapshot *snap = (pg_snapshot *) PG_GETARG_VARLENA_P(0);

    PG_RETURN_FULLTRANSACTIONID(snap->xmax);
}

pg_snapshot_xmin()

Datum pg_snapshot_xmin

(

PG_FUNCTION_ARGS

)

Definition at line 594 of file xid8funcs.c.

References PG_GETARG_VARLENA_P, PG_RETURN_FULLTRANSACTIONID, and pg_snapshot::xmin.

{
    pg_snapshot *snap = (pg_snapshot *) PG_GETARG_VARLENA_P(0);

    PG_RETURN_FULLTRANSACTIONID(snap->xmin);
}

pg_visible_in_snapshot()

Datum pg_visible_in_snapshot

(

PG_FUNCTION_ARGS

)

Definition at line 580 of file xid8funcs.c.

References is_visible_fxid(), PG_GETARG_FULLTRANSACTIONID, PG_GETARG_VARLENA_P, PG_RETURN_BOOL, and value.

{
    FullTransactionId value = PG_GETARG_FULLTRANSACTIONID(0);
    pg_snapshot *snap = (pg_snapshot *) PG_GETARG_VARLENA_P(1);

    PG_RETURN_BOOL(is_visible_fxid(value, snap));
}

pg_xact_status()

Datum pg_xact_status

(

PG_FUNCTION_ARGS

)

Definition at line 665 of file xid8funcs.c.

References Assert, cstring_to_text(), GetActiveSnapshot(), LW_SHARED, LWLockAcquire(), LWLockRelease(), PG_GETARG_FULLTRANSACTIONID, PG_RETURN_NULL, PG_RETURN_TEXT_P, status(), TransactionIdDidAbort(), TransactionIdDidCommit(), TransactionIdInRecentPast(), TransactionIdIsCurrentTransactionId(), TransactionIdIsValid, and TransactionIdPrecedes().

{
    const char *status;
    FullTransactionId fxid = PG_GETARG_FULLTRANSACTIONID(0);
    TransactionId xid;

    /*
     * We must protect against concurrent truncation of clog entries to avoid
     * an I/O error on SLRU lookup.
     */
    LWLockAcquire(XactTruncationLock, LW_SHARED);
    if (TransactionIdInRecentPast(fxid, &xid))
    {
        Assert(TransactionIdIsValid(xid));

        if (TransactionIdIsCurrentTransactionId(xid))
            status = "in progress";
        else if (TransactionIdDidCommit(xid))
            status = "committed";
        else if (TransactionIdDidAbort(xid))
            status = "aborted";
        else
        {
            /*
             * The xact is not marked as either committed or aborted in clog.
             *
             * It could be a transaction that ended without updating clog or
             * writing an abort record due to a crash. We can safely assume
             * it's aborted if it isn't committed and is older than our
             * snapshot xmin.
             *
             * Otherwise it must be in-progress (or have been at the time we
             * checked commit/abort status).
             */
            if (TransactionIdPrecedes(xid, GetActiveSnapshot()->xmin))
                status = "aborted";
            else
                status = "in progress";
        }
    }
    else
    {
        status = NULL;
    }
    LWLockRelease(XactTruncationLock);

    if (status == NULL)
        PG_RETURN_NULL();
    else
        PG_RETURN_TEXT_P(cstring_to_text(status));
}

sort_snapshot()

static void sort_snapshot ( pg_snapshot *  snap )

static

Definition at line 196 of file xid8funcs.c.

References cmp_fxid(), pg_snapshot::nxip, qsort, qunique(), and pg_snapshot::xip.

Referenced by pg_current_snapshot().

{
    if (snap->nxip > 1)
    {
        qsort(snap->xip, snap->nxip, sizeof(FullTransactionId), cmp_fxid);
        snap->nxip = qunique(snap->xip, snap->nxip, sizeof(FullTransactionId),
                             cmp_fxid);
    }
}

TransactionIdInRecentPast()

static bool TransactionIdInRecentPast ( FullTransactionId  fxid, TransactionId *  extracted_xid  )

static

Definition at line 90 of file xid8funcs.c.

References Assert, EpochFromFullTransactionId, ereport, errcode(), errmsg(), ERROR, FullTransactionIdPrecedes, LWLockHeldByMe(), VariableCacheData::oldestClogXid, psprintf(), ReadNextFullTransactionId(), ShmemVariableCache, TransactionIdIsNormal, TransactionIdIsValid, TransactionIdPrecedes(), U64FromFullTransactionId, UINT64_FORMAT, and XidFromFullTransactionId.

Referenced by pg_xact_status().

{
    uint32      xid_epoch = EpochFromFullTransactionId(fxid);
    TransactionId xid = XidFromFullTransactionId(fxid);
    uint32      now_epoch;
    TransactionId now_epoch_next_xid;
    FullTransactionId now_fullxid;

    now_fullxid = ReadNextFullTransactionId();
    now_epoch_next_xid = XidFromFullTransactionId(now_fullxid);
    now_epoch = EpochFromFullTransactionId(now_fullxid);

    if (extracted_xid != NULL)
        *extracted_xid = xid;

    if (!TransactionIdIsValid(xid))
        return false;

    /* For non-normal transaction IDs, we can ignore the epoch. */
    if (!TransactionIdIsNormal(xid))
        return true;

    /* If the transaction ID is in the future, throw an error. */
    if (!FullTransactionIdPrecedes(fxid, now_fullxid))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("transaction ID %s is in the future",
                        psprintf(UINT64_FORMAT,
                                 U64FromFullTransactionId(fxid)))));

    /*
     * ShmemVariableCache->oldestClogXid is protected by XactTruncationLock,
     * but we don't acquire that lock here.  Instead, we require the caller to
     * acquire it, because the caller is presumably going to look up the
     * returned XID.  If we took and released the lock within this function, a
     * CLOG truncation could occur before the caller finished with the XID.
     */
    Assert(LWLockHeldByMe(XactTruncationLock));

    /*
     * If the transaction ID has wrapped around, it's definitely too old to
     * determine the commit status.  Otherwise, we can compare it to
     * ShmemVariableCache->oldestClogXid to determine whether the relevant
     * CLOG entry is guaranteed to still exist.
     */
    if (xid_epoch + 1 < now_epoch
        || (xid_epoch + 1 == now_epoch && xid < now_epoch_next_xid)
        || TransactionIdPrecedes(xid, ShmemVariableCache->oldestClogXid))
        return false;

    return true;
}

widen_snapshot_xid()

static FullTransactionId widen_snapshot_xid ( TransactionId  xid, FullTransactionId  next_fxid  )

static

Definition at line 150 of file xid8funcs.c.

References epoch, EpochFromFullTransactionId, FullTransactionIdFromEpochAndXid(), TransactionIdIsNormal, and XidFromFullTransactionId.

Referenced by pg_current_snapshot().

{
    TransactionId next_xid = XidFromFullTransactionId(next_fxid);
    uint32      epoch = EpochFromFullTransactionId(next_fxid);

    /* Special transaction ID. */
    if (!TransactionIdIsNormal(xid))
        return FullTransactionIdFromEpochAndXid(0, xid);

    /*
     * The 64 bit result must be <= next_fxid, since next_fxid hadn't been
     * issued yet when the snapshot was created.  Every TransactionId in the
     * snapshot must therefore be from the same epoch as next_fxid, or the
     * epoch before.  We know this because next_fxid is never allow to get
     * more than one epoch ahead of the TransactionIds in any snapshot.
     */
    if (xid > next_xid)
        epoch--;

    return FullTransactionIdFromEpochAndXid(epoch, xid);
}