sequence.h File Reference

#include "access/xlogreader.h"
#include "catalog/objectaddress.h"
#include "fmgr.h"
#include "lib/stringinfo.h"
#include "nodes/parsenodes.h"
#include "parser/parse_node.h"
#include "storage/relfilenode.h"

Include dependency graph for sequence.h:

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

Go to the source code of this file.

Data Structures
struct	FormData_pg_sequence_data
struct	xl_seq_rec

Macros
#define	SEQ_COL_LASTVAL   1
#define	SEQ_COL_LOG   2
#define	SEQ_COL_CALLED   3
#define	SEQ_COL_FIRSTCOL   SEQ_COL_LASTVAL
#define	SEQ_COL_LASTCOL   SEQ_COL_CALLED
#define	XLOG_SEQ_LOG   0x00

Typedefs
typedef struct FormData_pg_sequence_data	FormData_pg_sequence_data
typedef FormData_pg_sequence_data *	Form_pg_sequence_data
typedef struct xl_seq_rec	xl_seq_rec

Functions
int64	nextval_internal (Oid relid, bool check_permissions)
Datum	nextval (PG_FUNCTION_ARGS)
List *	sequence_options (Oid relid)
ObjectAddress	DefineSequence (ParseState *pstate, CreateSeqStmt *stmt)
ObjectAddress	AlterSequence (ParseState *pstate, AlterSeqStmt *stmt)
void	DeleteSequenceTuple (Oid relid)
void	ResetSequence (Oid seq_relid)
void	ResetSequenceCaches (void)
void	seq_redo (XLogReaderState *rptr)
void	seq_desc (StringInfo buf, XLogReaderState *rptr)
const char *	seq_identify (uint8 info)
void	seq_mask (char *pagedata, BlockNumber blkno)

Macro Definition Documentation

SEQ_COL_CALLED

#define SEQ_COL_CALLED   3

Definition at line 40 of file sequence.h.

Referenced by DefineSequence().

SEQ_COL_FIRSTCOL

#define SEQ_COL_FIRSTCOL   SEQ_COL_LASTVAL

Definition at line 42 of file sequence.h.

Referenced by DefineSequence().

SEQ_COL_LASTCOL

#define SEQ_COL_LASTCOL   SEQ_COL_CALLED

Definition at line 43 of file sequence.h.

Referenced by DefineSequence().

SEQ_COL_LASTVAL

#define SEQ_COL_LASTVAL   1

Definition at line 38 of file sequence.h.

Referenced by DefineSequence().

SEQ_COL_LOG

#define SEQ_COL_LOG   2

Definition at line 39 of file sequence.h.

Referenced by DefineSequence().

XLOG_SEQ_LOG

#define XLOG_SEQ_LOG   0x00

Definition at line 46 of file sequence.h.

Referenced by do_setval(), fill_seq_with_data(), nextval_internal(), seq_desc(), seq_identify(), and seq_redo().

Typedef Documentation

Form_pg_sequence_data

typedef FormData_pg_sequence_data* Form_pg_sequence_data

Definition at line 32 of file sequence.h.

FormData_pg_sequence_data

typedef struct FormData_pg_sequence_data FormData_pg_sequence_data

xl_seq_rec

typedef struct xl_seq_rec xl_seq_rec

Function Documentation

AlterSequence()

ObjectAddress AlterSequence	(	ParseState *	pstate,
		AlterSeqStmt *	stmt
	)

Definition at line 422 of file sequence.c.

References Assert, buf, SeqTableData::cached, CatalogTupleUpdate(), elog, ereport, errmsg(), ERROR, fill_seq_with_data(), AlterSeqStmt::for_identity, GETSTRUCT, GetTopTransactionId(), heap_copytuple(), HeapTupleIsValid, init_params(), init_sequence(), InvalidMultiXactId, InvalidObjectAddress, InvalidOid, InvalidTransactionId, InvokeObjectPostAlterHook, SeqTableData::last, AlterSeqStmt::missing_ok, NoLock, NOTICE, ObjectAddressSet, ObjectIdGetDatum, AlterSeqStmt::options, process_owned_by(), RangeVarCallbackOwnsRelation(), RangeVarGetRelidExtended(), RelationData::rd_rel, read_seq_tuple(), relation_close(), RelationNeedsWAL, RelationSetNewRelfilenode(), RangeVar::relname, RowExclusiveLock, RVR_MISSING_OK, SearchSysCacheCopy1, SEQRELID, AlterSeqStmt::sequence, ShareRowExclusiveLock, HeapTupleData::t_self, table_close(), table_open(), and UnlockReleaseBuffer().

Referenced by ProcessUtilitySlow().

{
    Oid         relid;
    SeqTable    elm;
    Relation    seqrel;
    Buffer      buf;
    HeapTupleData datatuple;
    Form_pg_sequence seqform;
    Form_pg_sequence_data newdataform;
    bool        need_seq_rewrite;
    List       *owned_by;
    ObjectAddress address;
    Relation    rel;
    HeapTuple   seqtuple;
    HeapTuple   newdatatuple;

    /* Open and lock sequence, and check for ownership along the way. */
    relid = RangeVarGetRelidExtended(stmt->sequence,
                                     ShareRowExclusiveLock,
                                     stmt->missing_ok ? RVR_MISSING_OK : 0,
                                     RangeVarCallbackOwnsRelation,
                                     NULL);
    if (relid == InvalidOid)
    {
        ereport(NOTICE,
                (errmsg("relation \"%s\" does not exist, skipping",
                        stmt->sequence->relname)));
        return InvalidObjectAddress;
    }

    init_sequence(relid, &elm, &seqrel);

    rel = table_open(SequenceRelationId, RowExclusiveLock);
    seqtuple = SearchSysCacheCopy1(SEQRELID,
                                   ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(seqtuple))
        elog(ERROR, "cache lookup failed for sequence %u",
             relid);

    seqform = (Form_pg_sequence) GETSTRUCT(seqtuple);

    /* lock page's buffer and read tuple into new sequence structure */
    (void) read_seq_tuple(seqrel, &buf, &datatuple);

    /* copy the existing sequence data tuple, so it can be modified locally */
    newdatatuple = heap_copytuple(&datatuple);
    newdataform = (Form_pg_sequence_data) GETSTRUCT(newdatatuple);

    UnlockReleaseBuffer(buf);

    /* Check and set new values */
    init_params(pstate, stmt->options, stmt->for_identity, false,
                seqform, newdataform,
                &need_seq_rewrite, &owned_by);

    /* Clear local cache so that we don't think we have cached numbers */
    /* Note that we do not change the currval() state */
    elm->cached = elm->last;

    /* If needed, rewrite the sequence relation itself */
    if (need_seq_rewrite)
    {
        /* check the comment above nextval_internal()'s equivalent call. */
        if (RelationNeedsWAL(seqrel))
            GetTopTransactionId();

        /*
         * Create a new storage file for the sequence, making the state
         * changes transactional.
         */
        RelationSetNewRelfilenode(seqrel, seqrel->rd_rel->relpersistence);

        /*
         * Ensure sequence's relfrozenxid is at 0, since it won't contain any
         * unfrozen XIDs.  Same with relminmxid, since a sequence will never
         * contain multixacts.
         */
        Assert(seqrel->rd_rel->relfrozenxid == InvalidTransactionId);
        Assert(seqrel->rd_rel->relminmxid == InvalidMultiXactId);

        /*
         * Insert the modified tuple into the new storage file.
         */
        fill_seq_with_data(seqrel, newdatatuple);
    }

    /* process OWNED BY if given */
    if (owned_by)
        process_owned_by(seqrel, owned_by, stmt->for_identity);

    /* update the pg_sequence tuple (we could skip this in some cases...) */
    CatalogTupleUpdate(rel, &seqtuple->t_self, seqtuple);

    InvokeObjectPostAlterHook(RelationRelationId, relid, 0);

    ObjectAddressSet(address, RelationRelationId, relid);

    table_close(rel, RowExclusiveLock);
    relation_close(seqrel, NoLock);

    return address;
}

DefineSequence()

ObjectAddress DefineSequence	(	ParseState *	pstate,
		CreateSeqStmt *	stmt
	)

Definition at line 118 of file sequence.c.

References AccessExclusiveLock, Assert, BoolGetDatum, CatalogTupleInsert(), ColumnDef::collClause, ColumnDef::collOid, ColumnDef::colname, ColumnDef::constraints, CreateStmt::constraints, ColumnDef::cooked_default, DefineRelation(), ereport, errcode(), errmsg(), ERROR, fill_seq_with_data(), CreateSeqStmt::for_identity, FormData_pg_sequence, heap_form_tuple(), heap_freetuple(), i, CreateStmt::if_not_exists, CreateSeqStmt::if_not_exists, ColumnDef::inhcount, CreateStmt::inhRelations, init_params(), Int64GetDatum(), Int64GetDatumFast, InvalidObjectAddress, InvalidOid, ColumnDef::is_from_type, ColumnDef::is_local, ColumnDef::is_not_null, lappend(), FormData_pg_sequence_data::last_value, ColumnDef::location, makeNode, makeTypeNameFromOid(), NIL, NoLock, NOTICE, ObjectAddress::objectId, ObjectIdGetDatum, OidIsValid, CreateStmt::oncommit, ONCOMMIT_NOOP, CreateStmt::options, CreateSeqStmt::options, CreateSeqStmt::ownerId, process_owned_by(), RangeVarGetAndCheckCreationNamespace(), ColumnDef::raw_default, CreateStmt::relation, RelationGetDescr, RangeVar::relname, RangeVar::relpersistence, RowExclusiveLock, SEQ_COL_CALLED, SEQ_COL_FIRSTCOL, SEQ_COL_LASTCOL, SEQ_COL_LASTVAL, SEQ_COL_LOG, CreateSeqStmt::sequence, ColumnDef::storage, table_close(), table_open(), CreateStmt::tableElts, CreateStmt::tablespacename, ColumnDef::typeName, and value.

Referenced by ProcessUtilitySlow().

{
    FormData_pg_sequence seqform;
    FormData_pg_sequence_data seqdataform;
    bool        need_seq_rewrite;
    List       *owned_by;
    CreateStmt *stmt = makeNode(CreateStmt);
    Oid         seqoid;
    ObjectAddress address;
    Relation    rel;
    HeapTuple   tuple;
    TupleDesc   tupDesc;
    Datum       value[SEQ_COL_LASTCOL];
    bool        null[SEQ_COL_LASTCOL];
    Datum       pgs_values[Natts_pg_sequence];
    bool        pgs_nulls[Natts_pg_sequence];
    int         i;

    /* Unlogged sequences are not implemented -- not clear if useful. */
    if (seq->sequence->relpersistence == RELPERSISTENCE_UNLOGGED)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("unlogged sequences are not supported")));

    /*
     * If if_not_exists was given and a relation with the same name already
     * exists, bail out. (Note: we needn't check this when not if_not_exists,
     * because DefineRelation will complain anyway.)
     */
    if (seq->if_not_exists)
    {
        RangeVarGetAndCheckCreationNamespace(seq->sequence, NoLock, &seqoid);
        if (OidIsValid(seqoid))
        {
            ereport(NOTICE,
                    (errcode(ERRCODE_DUPLICATE_TABLE),
                     errmsg("relation \"%s\" already exists, skipping",
                            seq->sequence->relname)));
            return InvalidObjectAddress;
        }
    }

    /* Check and set all option values */
    init_params(pstate, seq->options, seq->for_identity, true,
                &seqform, &seqdataform,
                &need_seq_rewrite, &owned_by);

    /*
     * Create relation (and fill value[] and null[] for the tuple)
     */
    stmt->tableElts = NIL;
    for (i = SEQ_COL_FIRSTCOL; i <= SEQ_COL_LASTCOL; i++)
    {
        ColumnDef  *coldef = makeNode(ColumnDef);

        coldef->inhcount = 0;
        coldef->is_local = true;
        coldef->is_not_null = true;
        coldef->is_from_type = false;
        coldef->storage = 0;
        coldef->raw_default = NULL;
        coldef->cooked_default = NULL;
        coldef->collClause = NULL;
        coldef->collOid = InvalidOid;
        coldef->constraints = NIL;
        coldef->location = -1;

        null[i - 1] = false;

        switch (i)
        {
            case SEQ_COL_LASTVAL:
                coldef->typeName = makeTypeNameFromOid(INT8OID, -1);
                coldef->colname = "last_value";
                value[i - 1] = Int64GetDatumFast(seqdataform.last_value);
                break;
            case SEQ_COL_LOG:
                coldef->typeName = makeTypeNameFromOid(INT8OID, -1);
                coldef->colname = "log_cnt";
                value[i - 1] = Int64GetDatum((int64) 0);
                break;
            case SEQ_COL_CALLED:
                coldef->typeName = makeTypeNameFromOid(BOOLOID, -1);
                coldef->colname = "is_called";
                value[i - 1] = BoolGetDatum(false);
                break;
        }
        stmt->tableElts = lappend(stmt->tableElts, coldef);
    }

    stmt->relation = seq->sequence;
    stmt->inhRelations = NIL;
    stmt->constraints = NIL;
    stmt->options = NIL;
    stmt->oncommit = ONCOMMIT_NOOP;
    stmt->tablespacename = NULL;
    stmt->if_not_exists = seq->if_not_exists;

    address = DefineRelation(stmt, RELKIND_SEQUENCE, seq->ownerId, NULL, NULL);
    seqoid = address.objectId;
    Assert(seqoid != InvalidOid);

    rel = table_open(seqoid, AccessExclusiveLock);
    tupDesc = RelationGetDescr(rel);

    /* now initialize the sequence's data */
    tuple = heap_form_tuple(tupDesc, value, null);
    fill_seq_with_data(rel, tuple);

    /* process OWNED BY if given */
    if (owned_by)
        process_owned_by(rel, owned_by, seq->for_identity);

    table_close(rel, NoLock);

    /* fill in pg_sequence */
    rel = table_open(SequenceRelationId, RowExclusiveLock);
    tupDesc = RelationGetDescr(rel);

    memset(pgs_nulls, 0, sizeof(pgs_nulls));

    pgs_values[Anum_pg_sequence_seqrelid - 1] = ObjectIdGetDatum(seqoid);
    pgs_values[Anum_pg_sequence_seqtypid - 1] = ObjectIdGetDatum(seqform.seqtypid);
    pgs_values[Anum_pg_sequence_seqstart - 1] = Int64GetDatumFast(seqform.seqstart);
    pgs_values[Anum_pg_sequence_seqincrement - 1] = Int64GetDatumFast(seqform.seqincrement);
    pgs_values[Anum_pg_sequence_seqmax - 1] = Int64GetDatumFast(seqform.seqmax);
    pgs_values[Anum_pg_sequence_seqmin - 1] = Int64GetDatumFast(seqform.seqmin);
    pgs_values[Anum_pg_sequence_seqcache - 1] = Int64GetDatumFast(seqform.seqcache);
    pgs_values[Anum_pg_sequence_seqcycle - 1] = BoolGetDatum(seqform.seqcycle);

    tuple = heap_form_tuple(tupDesc, pgs_values, pgs_nulls);
    CatalogTupleInsert(rel, tuple);

    heap_freetuple(tuple);
    table_close(rel, RowExclusiveLock);

    return address;
}

DeleteSequenceTuple()

void DeleteSequenceTuple

(

Oid

relid

)

Definition at line 526 of file sequence.c.

References CatalogTupleDelete(), elog, ERROR, HeapTupleIsValid, ObjectIdGetDatum, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), SEQRELID, HeapTupleData::t_self, table_close(), and table_open().

Referenced by doDeletion().

{
    Relation    rel;
    HeapTuple   tuple;

    rel = table_open(SequenceRelationId, RowExclusiveLock);

    tuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for sequence %u", relid);

    CatalogTupleDelete(rel, &tuple->t_self);

    ReleaseSysCache(tuple);
    table_close(rel, RowExclusiveLock);
}

nextval()

Datum nextval

(

PG_FUNCTION_ARGS

)

Definition at line 549 of file sequence.c.

References makeRangeVarFromNameList(), nextval_internal(), NoLock, PG_GETARG_TEXT_PP, PG_RETURN_INT64, RangeVarGetRelid, and textToQualifiedNameList().

Referenced by autoinc(), and ttdummy().

{
    text       *seqin = PG_GETARG_TEXT_PP(0);
    RangeVar   *sequence;
    Oid         relid;

    sequence = makeRangeVarFromNameList(textToQualifiedNameList(seqin));

    /*
     * XXX: This is not safe in the presence of concurrent DDL, but acquiring
     * a lock here is more expensive than letting nextval_internal do it,
     * since the latter maintains a cache that keeps us from hitting the lock
     * manager more than once per transaction.  It's not clear whether the
     * performance penalty is material in practice, but for now, we do it this
     * way.
     */
    relid = RangeVarGetRelid(sequence, NoLock, false);

    PG_RETURN_INT64(nextval_internal(relid, true));
}

nextval_internal()

int64 nextval_internal	(	Oid	relid,
		bool	check_permissions
	)

Definition at line 579 of file sequence.c.

References ACL_UPDATE, ACL_USAGE, ACLCHECK_OK, Assert, buf, BufferGetPage, SeqTableData::cached, elog, END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, GetRedoRecPtr(), GETSTRUCT, GetTopTransactionId(), GetUserId(), HeapTupleIsValid, SeqTableData::increment, init_sequence(), INT64_FORMAT, FormData_pg_sequence_data::is_called, SeqTableData::last, SeqTableData::last_valid, FormData_pg_sequence_data::last_value, FormData_pg_sequence_data::log_cnt, MarkBufferDirty(), next, xl_seq_rec::node, NoLock, ObjectIdGetDatum, PageGetLSN, PageSetLSN, pg_class_aclcheck(), PreventCommandIfParallelMode(), PreventCommandIfReadOnly(), RelationData::rd_islocaltemp, RelationData::rd_node, read_seq_tuple(), REGBUF_WILL_INIT, relation_close(), RelationGetRelationName, RelationNeedsWAL, ReleaseSysCache(), SeqTableData::relid, SearchSysCache1(), SEQ_LOG_VALS, SEQRELID, snprintf, START_CRIT_SECTION, HeapTupleData::t_data, HeapTupleData::t_len, UnlockReleaseBuffer(), XLOG_SEQ_LOG, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by ExecEvalNextValueExpr(), nextval(), and nextval_oid().

{
    SeqTable    elm;
    Relation    seqrel;
    Buffer      buf;
    Page        page;
    HeapTuple   pgstuple;
    Form_pg_sequence pgsform;
    HeapTupleData seqdatatuple;
    Form_pg_sequence_data seq;
    int64       incby,
                maxv,
                minv,
                cache,
                log,
                fetch,
                last;
    int64       result,
                next,
                rescnt = 0;
    bool        cycle;
    bool        logit = false;

    /* open and lock sequence */
    init_sequence(relid, &elm, &seqrel);

    if (check_permissions &&
        pg_class_aclcheck(elm->relid, GetUserId(),
                          ACL_USAGE | ACL_UPDATE) != ACLCHECK_OK)
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied for sequence %s",
                        RelationGetRelationName(seqrel))));

    /* read-only transactions may only modify temp sequences */
    if (!seqrel->rd_islocaltemp)
        PreventCommandIfReadOnly("nextval()");

    /*
     * Forbid this during parallel operation because, to make it work, the
     * cooperating backends would need to share the backend-local cached
     * sequence information.  Currently, we don't support that.
     */
    PreventCommandIfParallelMode("nextval()");

    if (elm->last != elm->cached)   /* some numbers were cached */
    {
        Assert(elm->last_valid);
        Assert(elm->increment != 0);
        elm->last += elm->increment;
        relation_close(seqrel, NoLock);
        last_used_seq = elm;
        return elm->last;
    }

    pgstuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(pgstuple))
        elog(ERROR, "cache lookup failed for sequence %u", relid);
    pgsform = (Form_pg_sequence) GETSTRUCT(pgstuple);
    incby = pgsform->seqincrement;
    maxv = pgsform->seqmax;
    minv = pgsform->seqmin;
    cache = pgsform->seqcache;
    cycle = pgsform->seqcycle;
    ReleaseSysCache(pgstuple);

    /* lock page' buffer and read tuple */
    seq = read_seq_tuple(seqrel, &buf, &seqdatatuple);
    page = BufferGetPage(buf);

    elm->increment = incby;
    last = next = result = seq->last_value;
    fetch = cache;
    log = seq->log_cnt;

    if (!seq->is_called)
    {
        rescnt++;               /* return last_value if not is_called */
        fetch--;
    }

    /*
     * Decide whether we should emit a WAL log record.  If so, force up the
     * fetch count to grab SEQ_LOG_VALS more values than we actually need to
     * cache.  (These will then be usable without logging.)
     *
     * If this is the first nextval after a checkpoint, we must force a new
     * WAL record to be written anyway, else replay starting from the
     * checkpoint would fail to advance the sequence past the logged values.
     * In this case we may as well fetch extra values.
     */
    if (log < fetch || !seq->is_called)
    {
        /* forced log to satisfy local demand for values */
        fetch = log = fetch + SEQ_LOG_VALS;
        logit = true;
    }
    else
    {
        XLogRecPtr  redoptr = GetRedoRecPtr();

        if (PageGetLSN(page) <= redoptr)
        {
            /* last update of seq was before checkpoint */
            fetch = log = fetch + SEQ_LOG_VALS;
            logit = true;
        }
    }

    while (fetch)               /* try to fetch cache [+ log ] numbers */
    {
        /*
         * Check MAXVALUE for ascending sequences and MINVALUE for descending
         * sequences
         */
        if (incby > 0)
        {
            /* ascending sequence */
            if ((maxv >= 0 && next > maxv - incby) ||
                (maxv < 0 && next + incby > maxv))
            {
                if (rescnt > 0)
                    break;      /* stop fetching */
                if (!cycle)
                {
                    char        buf[100];

                    snprintf(buf, sizeof(buf), INT64_FORMAT, maxv);
                    ereport(ERROR,
                            (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
                             errmsg("nextval: reached maximum value of sequence \"%s\" (%s)",
                                    RelationGetRelationName(seqrel), buf)));
                }
                next = minv;
            }
            else
                next += incby;
        }
        else
        {
            /* descending sequence */
            if ((minv < 0 && next < minv - incby) ||
                (minv >= 0 && next + incby < minv))
            {
                if (rescnt > 0)
                    break;      /* stop fetching */
                if (!cycle)
                {
                    char        buf[100];

                    snprintf(buf, sizeof(buf), INT64_FORMAT, minv);
                    ereport(ERROR,
                            (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
                             errmsg("nextval: reached minimum value of sequence \"%s\" (%s)",
                                    RelationGetRelationName(seqrel), buf)));
                }
                next = maxv;
            }
            else
                next += incby;
        }
        fetch--;
        if (rescnt < cache)
        {
            log--;
            rescnt++;
            last = next;
            if (rescnt == 1)    /* if it's first result - */
                result = next;  /* it's what to return */
        }
    }

    log -= fetch;               /* adjust for any unfetched numbers */
    Assert(log >= 0);

    /* save info in local cache */
    elm->last = result;         /* last returned number */
    elm->cached = last;         /* last fetched number */
    elm->last_valid = true;

    last_used_seq = elm;

    /*
     * If something needs to be WAL logged, acquire an xid, so this
     * transaction's commit will trigger a WAL flush and wait for syncrep.
     * It's sufficient to ensure the toplevel transaction has an xid, no need
     * to assign xids subxacts, that'll already trigger an appropriate wait.
     * (Have to do that here, so we're outside the critical section)
     */
    if (logit && RelationNeedsWAL(seqrel))
        GetTopTransactionId();

    /* ready to change the on-disk (or really, in-buffer) tuple */
    START_CRIT_SECTION();

    /*
     * We must mark the buffer dirty before doing XLogInsert(); see notes in
     * SyncOneBuffer().  However, we don't apply the desired changes just yet.
     * This looks like a violation of the buffer update protocol, but it is in
     * fact safe because we hold exclusive lock on the buffer.  Any other
     * process, including a checkpoint, that tries to examine the buffer
     * contents will block until we release the lock, and then will see the
     * final state that we install below.
     */
    MarkBufferDirty(buf);

    /* XLOG stuff */
    if (logit && RelationNeedsWAL(seqrel))
    {
        xl_seq_rec  xlrec;
        XLogRecPtr  recptr;

        /*
         * We don't log the current state of the tuple, but rather the state
         * as it would appear after "log" more fetches.  This lets us skip
         * that many future WAL records, at the cost that we lose those
         * sequence values if we crash.
         */
        XLogBeginInsert();
        XLogRegisterBuffer(0, buf, REGBUF_WILL_INIT);

        /* set values that will be saved in xlog */
        seq->last_value = next;
        seq->is_called = true;
        seq->log_cnt = 0;

        xlrec.node = seqrel->rd_node;

        XLogRegisterData((char *) &xlrec, sizeof(xl_seq_rec));
        XLogRegisterData((char *) seqdatatuple.t_data, seqdatatuple.t_len);

        recptr = XLogInsert(RM_SEQ_ID, XLOG_SEQ_LOG);

        PageSetLSN(page, recptr);
    }

    /* Now update sequence tuple to the intended final state */
    seq->last_value = last;     /* last fetched number */
    seq->is_called = true;
    seq->log_cnt = log;         /* how much is logged */

    END_CRIT_SECTION();

    UnlockReleaseBuffer(buf);

    relation_close(seqrel, NoLock);

    return result;
}

ResetSequence()

void ResetSequence

(

Oid

seq_relid

)

Definition at line 270 of file sequence.c.

References Assert, buf, SeqTableData::cached, elog, ERROR, fill_seq_with_data(), GETSTRUCT, heap_copytuple(), HeapTupleIsValid, init_sequence(), InvalidMultiXactId, InvalidTransactionId, FormData_pg_sequence_data::is_called, SeqTableData::last, FormData_pg_sequence_data::last_value, FormData_pg_sequence_data::log_cnt, NoLock, ObjectIdGetDatum, RelationData::rd_rel, read_seq_tuple(), relation_close(), RelationSetNewRelfilenode(), ReleaseSysCache(), SearchSysCache1(), SEQRELID, and UnlockReleaseBuffer().

Referenced by ExecuteTruncateGuts().

{
    Relation    seq_rel;
    SeqTable    elm;
    Form_pg_sequence_data seq;
    Buffer      buf;
    HeapTupleData seqdatatuple;
    HeapTuple   tuple;
    HeapTuple   pgstuple;
    Form_pg_sequence pgsform;
    int64       startv;

    /*
     * Read the old sequence.  This does a bit more work than really
     * necessary, but it's simple, and we do want to double-check that it's
     * indeed a sequence.
     */
    init_sequence(seq_relid, &elm, &seq_rel);
    (void) read_seq_tuple(seq_rel, &buf, &seqdatatuple);

    pgstuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(seq_relid));
    if (!HeapTupleIsValid(pgstuple))
        elog(ERROR, "cache lookup failed for sequence %u", seq_relid);
    pgsform = (Form_pg_sequence) GETSTRUCT(pgstuple);
    startv = pgsform->seqstart;
    ReleaseSysCache(pgstuple);

    /*
     * Copy the existing sequence tuple.
     */
    tuple = heap_copytuple(&seqdatatuple);

    /* Now we're done with the old page */
    UnlockReleaseBuffer(buf);

    /*
     * Modify the copied tuple to execute the restart (compare the RESTART
     * action in AlterSequence)
     */
    seq = (Form_pg_sequence_data) GETSTRUCT(tuple);
    seq->last_value = startv;
    seq->is_called = false;
    seq->log_cnt = 0;

    /*
     * Create a new storage file for the sequence.
     */
    RelationSetNewRelfilenode(seq_rel, seq_rel->rd_rel->relpersistence);

    /*
     * Ensure sequence's relfrozenxid is at 0, since it won't contain any
     * unfrozen XIDs.  Same with relminmxid, since a sequence will never
     * contain multixacts.
     */
    Assert(seq_rel->rd_rel->relfrozenxid == InvalidTransactionId);
    Assert(seq_rel->rd_rel->relminmxid == InvalidMultiXactId);

    /*
     * Insert the modified tuple into the new storage file.
     */
    fill_seq_with_data(seq_rel, tuple);

    /* Clear local cache so that we don't think we have cached numbers */
    /* Note that we do not change the currval() state */
    elm->cached = elm->last;

    relation_close(seq_rel, NoLock);
}

ResetSequenceCaches()

void ResetSequenceCaches

(

void

)

Definition at line 1909 of file sequence.c.

References hash_destroy().

Referenced by DiscardAll(), and DiscardCommand().

{
    if (seqhashtab)
    {
        hash_destroy(seqhashtab);
        seqhashtab = NULL;
    }

    last_used_seq = NULL;
}

seq_desc()

void seq_desc	(	StringInfo	buf,
		XLogReaderState *	rptr
	)

Definition at line 21 of file seqdesc.c.

References appendStringInfo(), RelFileNode::dbNode, xl_seq_rec::node, RelFileNode::relNode, RelFileNode::spcNode, XLOG_SEQ_LOG, XLogRecGetData, XLogRecGetInfo, and XLR_INFO_MASK.

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
    xl_seq_rec *xlrec = (xl_seq_rec *) rec;

    if (info == XLOG_SEQ_LOG)
        appendStringInfo(buf, "rel %u/%u/%u",
                         xlrec->node.spcNode, xlrec->node.dbNode,
                         xlrec->node.relNode);
}

seq_identify()

const char* seq_identify

(

uint8

info

)

Definition at line 34 of file seqdesc.c.

References XLOG_SEQ_LOG, and XLR_INFO_MASK.

{
    const char *id = NULL;

    switch (info & ~XLR_INFO_MASK)
    {
        case XLOG_SEQ_LOG:
            id = "LOG";
            break;
    }

    return id;
}

seq_mask()

void seq_mask	(	char *	pagedata,
		BlockNumber	blkno
	)

Definition at line 1924 of file sequence.c.

References mask_page_lsn_and_checksum(), and mask_unused_space().

{
    mask_page_lsn_and_checksum(page);

    mask_unused_space(page);
}

seq_redo()

void seq_redo

(

XLogReaderState *

rptr

)

Definition at line 1856 of file sequence.c.

References BufferGetPage, BufferGetPageSize, elog, XLogReaderState::EndRecPtr, FirstOffsetNumber, InvalidOffsetNumber, sequence_magic::magic, MarkBufferDirty(), PageAddItem, PageGetSpecialPointer, PageInit(), PageSetLSN, palloc(), PANIC, pfree(), SEQ_MAGIC, UnlockReleaseBuffer(), XLOG_SEQ_LOG, XLogInitBufferForRedo(), XLogRecGetData, XLogRecGetDataLen, XLogRecGetInfo, and XLR_INFO_MASK.

{
    XLogRecPtr  lsn = record->EndRecPtr;
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
    Buffer      buffer;
    Page        page;
    Page        localpage;
    char       *item;
    Size        itemsz;
    xl_seq_rec *xlrec = (xl_seq_rec *) XLogRecGetData(record);
    sequence_magic *sm;

    if (info != XLOG_SEQ_LOG)
        elog(PANIC, "seq_redo: unknown op code %u", info);

    buffer = XLogInitBufferForRedo(record, 0);
    page = (Page) BufferGetPage(buffer);

    /*
     * We always reinit the page.  However, since this WAL record type is also
     * used for updating sequences, it's possible that a hot-standby backend
     * is examining the page concurrently; so we mustn't transiently trash the
     * buffer.  The solution is to build the correct new page contents in
     * local workspace and then memcpy into the buffer.  Then only bytes that
     * are supposed to change will change, even transiently. We must palloc
     * the local page for alignment reasons.
     */
    localpage = (Page) palloc(BufferGetPageSize(buffer));

    PageInit(localpage, BufferGetPageSize(buffer), sizeof(sequence_magic));
    sm = (sequence_magic *) PageGetSpecialPointer(localpage);
    sm->magic = SEQ_MAGIC;

    item = (char *) xlrec + sizeof(xl_seq_rec);
    itemsz = XLogRecGetDataLen(record) - sizeof(xl_seq_rec);

    if (PageAddItem(localpage, (Item) item, itemsz,
                    FirstOffsetNumber, false, false) == InvalidOffsetNumber)
        elog(PANIC, "seq_redo: failed to add item to page");

    PageSetLSN(localpage, lsn);

    memcpy(page, localpage, BufferGetPageSize(buffer));
    MarkBufferDirty(buffer);
    UnlockReleaseBuffer(buffer);

    pfree(localpage);
}

sequence_options()

List* sequence_options

(

Oid

relid

)

Definition at line 1727 of file sequence.c.

References elog, ERROR, GETSTRUCT, HeapTupleIsValid, INT64_FORMAT, lappend(), makeDefElem(), makeFloat(), makeInteger(), NIL, options, psprintf(), ReleaseSysCache(), SearchSysCache1(), and SEQRELID.

Referenced by transformTableLikeClause().

{
    HeapTuple   pgstuple;
    Form_pg_sequence pgsform;
    List       *options = NIL;

    pgstuple = SearchSysCache1(SEQRELID, relid);
    if (!HeapTupleIsValid(pgstuple))
        elog(ERROR, "cache lookup failed for sequence %u", relid);
    pgsform = (Form_pg_sequence) GETSTRUCT(pgstuple);

    /* Use makeFloat() for 64-bit integers, like gram.y does. */
    options = lappend(options,
                      makeDefElem("cache", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqcache)), -1));
    options = lappend(options,
                      makeDefElem("cycle", (Node *) makeInteger(pgsform->seqcycle), -1));
    options = lappend(options,
                      makeDefElem("increment", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqincrement)), -1));
    options = lappend(options,
                      makeDefElem("maxvalue", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqmax)), -1));
    options = lappend(options,
                      makeDefElem("minvalue", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqmin)), -1));
    options = lappend(options,
                      makeDefElem("start", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqstart)), -1));

    ReleaseSysCache(pgstuple);

    return options;
}