sequence.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/multixact.h"
#include "access/relation.h"
#include "access/sequence.h"
#include "access/table.h"
#include "access/transam.h"
#include "access/xact.h"
#include "access/xloginsert.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_sequence.h"
#include "catalog/pg_type.h"
#include "catalog/storage_xlog.h"
#include "commands/defrem.h"
#include "commands/sequence.h"
#include "commands/sequence_xlog.h"
#include "commands/tablecmds.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "parser/parse_type.h"
#include "storage/bufmgr.h"
#include "storage/lmgr.h"
#include "storage/proc.h"
#include "storage/smgr.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/pg_lsn.h"
#include "utils/resowner.h"
#include "utils/syscache.h"
#include "utils/varlena.h"

Include dependency graph for sequence.c:

Go to the source code of this file.

Data Structures
struct	SeqTableData

Macros
#define	SEQ_LOG_VALS   32
#define	PG_GET_SEQUENCE_DATA_COLS   3

Typedefs
typedef struct SeqTableData	SeqTableData
typedef SeqTableData *	SeqTable

Functions
static void	fill_seq_with_data (Relation rel, HeapTuple tuple)
static void	fill_seq_fork_with_data (Relation rel, HeapTuple tuple, ForkNumber forkNum)
static Relation	lock_and_open_sequence (SeqTable seq)
static void	create_seq_hashtable (void)
static void	init_sequence (Oid relid, SeqTable *p_elm, Relation *p_rel)
static Form_pg_sequence_data	read_seq_tuple (Relation rel, Buffer *buf, HeapTuple seqdatatuple)
static void	init_params (ParseState *pstate, List *options, bool for_identity, bool isInit, Form_pg_sequence seqform, int64 *last_value, bool *reset_state, bool *is_called, bool *need_seq_rewrite, List **owned_by)
static void	process_owned_by (Relation seqrel, List *owned_by, bool for_identity)
ObjectAddress	DefineSequence (ParseState *pstate, CreateSeqStmt *seq)
void	ResetSequence (Oid seq_relid)
ObjectAddress	AlterSequence (ParseState *pstate, AlterSeqStmt *stmt)
void	SequenceChangePersistence (Oid relid, char newrelpersistence)
void	DeleteSequenceTuple (Oid relid)
Datum	nextval (PG_FUNCTION_ARGS)
Datum	nextval_oid (PG_FUNCTION_ARGS)
int64	nextval_internal (Oid relid, bool check_permissions)
Datum	currval_oid (PG_FUNCTION_ARGS)
Datum	lastval (PG_FUNCTION_ARGS)
void	SetSequence (Oid relid, int64 next, bool iscalled)
Datum	setval_oid (PG_FUNCTION_ARGS)
Datum	setval3_oid (PG_FUNCTION_ARGS)
List *	sequence_options (Oid relid)
Datum	pg_sequence_parameters (PG_FUNCTION_ARGS)
Datum	pg_get_sequence_data (PG_FUNCTION_ARGS)
Datum	pg_sequence_last_value (PG_FUNCTION_ARGS)
void	ResetSequenceCaches (void)

Variables
static HTAB *	seqhashtab = NULL
static SeqTableData *	last_used_seq = NULL

Macro Definition Documentation

PG_GET_SEQUENCE_DATA_COLS

#define PG_GET_SEQUENCE_DATA_COLS   3

SEQ_LOG_VALS

#define SEQ_LOG_VALS   32

Definition at line 58 of file sequence.c.

Typedef Documentation

SeqTable

typedef SeqTableData* SeqTable

Definition at line 79 of file sequence.c.

SeqTableData

typedef struct SeqTableData SeqTableData

Function Documentation

AlterSequence()

ObjectAddress AlterSequence	(	ParseState *	pstate,
		AlterSeqStmt *	stmt
	)

Definition at line 429 of file sequence.c.

{
    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;
    bool        reset_state = false;
    bool        is_called;
    int64       last_value;
    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 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);
    last_value = newdataform->last_value;
    is_called = newdataform->is_called;
 
    UnlockReleaseBuffer(buf);
 
    /* Check and set new values */
    init_params(pstate, stmt->options, stmt->for_identity, false,
                seqform, &last_value, &reset_state, &is_called,
                &need_seq_rewrite, &owned_by);
 
    /* 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.
         */
        RelationSetNewRelfilenumber(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.
         */
        newdataform->last_value = last_value;
        newdataform->is_called = is_called;
        if (reset_state)
            newdataform->log_cnt = 0;
        fill_seq_with_data(seqrel, newdatatuple);
    }
 
    /* 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;
 
    /* 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);
    sequence_close(seqrel, NoLock);
 
    return address;
}

References Assert, buf, SeqTableData::cached, CatalogTupleUpdate(), elog, ereport, errmsg(), ERROR, fb(), fill_seq_with_data(), GETSTRUCT(), GetTopTransactionId(), heap_copytuple(), HeapTupleIsValid, init_params(), init_sequence(), InvalidMultiXactId, InvalidObjectAddress, InvalidOid, InvalidTransactionId, InvokeObjectPostAlterHook, SeqTableData::last, NoLock, NOTICE, ObjectAddressSet, ObjectIdGetDatum(), process_owned_by(), RangeVarCallbackOwnsRelation(), RangeVarGetRelidExtended(), read_seq_tuple(), RelationNeedsWAL, RelationSetNewRelfilenumber(), RowExclusiveLock, RVR_MISSING_OK, SearchSysCacheCopy1, sequence_close(), ShareRowExclusiveLock, stmt, table_close(), table_open(), and UnlockReleaseBuffer().

Referenced by ProcessUtilitySlow().

create_seq_hashtable()

static void create_seq_hashtable ( void  )

static

Definition at line 1114 of file sequence.c.

{
    HASHCTL     ctl;
 
    ctl.keysize = sizeof(Oid);
    ctl.entrysize = sizeof(SeqTableData);
 
    seqhashtab = hash_create("Sequence values", 16, &ctl,
                             HASH_ELEM | HASH_BLOBS);
}

References ctl, HASH_BLOBS, hash_create(), HASH_ELEM, HASHCTL::keysize, and seqhashtab.

Referenced by init_sequence().

currval_oid()

Datum currval_oid

(

PG_FUNCTION_ARGS

)

Definition at line 867 of file sequence.c.

{
    Oid         relid = PG_GETARG_OID(0);
    int64       result;
    SeqTable    elm;
    Relation    seqrel;
 
    /* open and lock sequence */
    init_sequence(relid, &elm, &seqrel);
 
    if (pg_class_aclcheck(elm->relid, GetUserId(),
                          ACL_SELECT | ACL_USAGE) != ACLCHECK_OK)
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied for sequence %s",
                        RelationGetRelationName(seqrel))));
 
    if (!elm->last_valid)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("currval of sequence \"%s\" is not yet defined in this session",
                        RelationGetRelationName(seqrel))));
 
    result = elm->last;
 
    sequence_close(seqrel, NoLock);
 
    PG_RETURN_INT64(result);
}

References ACL_SELECT, ACL_USAGE, ACLCHECK_OK, ereport, errcode(), errmsg(), ERROR, fb(), GetUserId(), init_sequence(), SeqTableData::last, SeqTableData::last_valid, NoLock, pg_class_aclcheck(), PG_GETARG_OID, PG_RETURN_INT64, RelationGetRelationName, SeqTableData::relid, and sequence_close().

DefineSequence()

ObjectAddress DefineSequence	(	ParseState *	pstate,
		CreateSeqStmt *	seq
	)

Definition at line 112 of file sequence.c.

{
    FormData_pg_sequence seqform;
    int64       last_value;
    bool        reset_state;
    bool        is_called;
    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;
 
    /*
     * 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))
        {
            /*
             * If we are in an extension script, insist that the pre-existing
             * object be a member of the extension, to avoid security risks.
             */
            ObjectAddressSet(address, RelationRelationId, seqoid);
            checkMembershipInCurrentExtension(&address);
 
            /* OK to skip */
            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, &last_value, &reset_state, &is_called,
                &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 = NULL;
 
        switch (i)
        {
            case SEQ_COL_LASTVAL:
                coldef = makeColumnDef("last_value", INT8OID, -1, InvalidOid);
                value[i - 1] = Int64GetDatumFast(last_value);
                break;
            case SEQ_COL_LOG:
                coldef = makeColumnDef("log_cnt", INT8OID, -1, InvalidOid);
                value[i - 1] = Int64GetDatum((int64) 0);
                break;
            case SEQ_COL_CALLED:
                coldef = makeColumnDef("is_called", BOOLOID, -1, InvalidOid);
                value[i - 1] = BoolGetDatum(false);
                break;
        }
 
        coldef->is_not_null = true;
        null[i - 1] = false;
 
        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 = sequence_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);
 
    sequence_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;
}

References AccessExclusiveLock, Assert, BoolGetDatum(), CatalogTupleInsert(), checkMembershipInCurrentExtension(), DefineRelation(), ereport, errcode(), errmsg(), fb(), fill_seq_with_data(), FormData_pg_sequence, heap_form_tuple(), heap_freetuple(), i, init_params(), Int64GetDatum(), Int64GetDatumFast, InvalidObjectAddress, InvalidOid, lappend(), makeColumnDef(), makeNode, NIL, NoLock, NOTICE, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), OidIsValid, ONCOMMIT_NOOP, process_owned_by(), RangeVarGetAndCheckCreationNamespace(), RelationGetDescr, RowExclusiveLock, SEQ_COL_CALLED, SEQ_COL_FIRSTCOL, SEQ_COL_LASTCOL, SEQ_COL_LASTVAL, SEQ_COL_LOG, sequence_close(), sequence_open(), stmt, table_close(), table_open(), and value.

Referenced by ProcessUtilitySlow().

DeleteSequenceTuple()

void DeleteSequenceTuple

(

Oid

relid

)

Definition at line 571 of file sequence.c.

{
    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);
}

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

Referenced by doDeletion().

fill_seq_fork_with_data()

static void fill_seq_fork_with_data ( Relation  rel, HeapTuple  tuple, ForkNumber  forkNum  )

static

Definition at line 352 of file sequence.c.

{
    Buffer      buf;
    Page        page;
    sequence_magic *sm;
    OffsetNumber offnum;
 
    /* Initialize first page of relation with special magic number */
 
    buf = ExtendBufferedRel(BMR_REL(rel), forkNum, NULL,
                            EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK);
    Assert(BufferGetBlockNumber(buf) == 0);
 
    page = BufferGetPage(buf);
 
    PageInit(page, BufferGetPageSize(buf), sizeof(sequence_magic));
    sm = (sequence_magic *) PageGetSpecialPointer(page);
    sm->magic = SEQ_MAGIC;
 
    /* Now insert sequence tuple */
 
    /*
     * Since VACUUM does not process sequences, we have to force the tuple to
     * have xmin = FrozenTransactionId now.  Otherwise it would become
     * invisible to SELECTs after 2G transactions.  It is okay to do this
     * because if the current transaction aborts, no other xact will ever
     * examine the sequence tuple anyway.
     */
    HeapTupleHeaderSetXmin(tuple->t_data, FrozenTransactionId);
    HeapTupleHeaderSetXminFrozen(tuple->t_data);
    HeapTupleHeaderSetCmin(tuple->t_data, FirstCommandId);
    HeapTupleHeaderSetXmax(tuple->t_data, InvalidTransactionId);
    tuple->t_data->t_infomask |= HEAP_XMAX_INVALID;
    ItemPointerSet(&tuple->t_data->t_ctid, 0, FirstOffsetNumber);
 
    /* check the comment above nextval_internal()'s equivalent call. */
    if (RelationNeedsWAL(rel))
        GetTopTransactionId();
 
    START_CRIT_SECTION();
 
    MarkBufferDirty(buf);
 
    offnum = PageAddItem(page, tuple->t_data, tuple->t_len, InvalidOffsetNumber, false, false);
    if (offnum != FirstOffsetNumber)
        elog(ERROR, "failed to add sequence tuple to page");
 
    /* XLOG stuff */
    if (RelationNeedsWAL(rel) || forkNum == INIT_FORKNUM)
    {
        xl_seq_rec  xlrec;
        XLogRecPtr  recptr;
 
        XLogBeginInsert();
        XLogRegisterBuffer(0, buf, REGBUF_WILL_INIT);
 
        xlrec.locator = rel->rd_locator;
 
        XLogRegisterData(&xlrec, sizeof(xl_seq_rec));
        XLogRegisterData(tuple->t_data, tuple->t_len);
 
        recptr = XLogInsert(RM_SEQ_ID, XLOG_SEQ_LOG);
 
        PageSetLSN(page, recptr);
    }
 
    END_CRIT_SECTION();
 
    UnlockReleaseBuffer(buf);
}

References Assert, BMR_REL, buf, BufferGetBlockNumber(), BufferGetPage(), BufferGetPageSize(), EB_LOCK_FIRST, EB_SKIP_EXTENSION_LOCK, elog, END_CRIT_SECTION, ERROR, ExtendBufferedRel(), fb(), FirstCommandId, FirstOffsetNumber, FrozenTransactionId, GetTopTransactionId(), HEAP_XMAX_INVALID, HeapTupleHeaderSetCmin(), HeapTupleHeaderSetXmax(), HeapTupleHeaderSetXmin(), HeapTupleHeaderSetXminFrozen(), INIT_FORKNUM, InvalidOffsetNumber, InvalidTransactionId, ItemPointerSet(), sequence_magic::magic, MarkBufferDirty(), PageAddItem, PageGetSpecialPointer, PageInit(), PageSetLSN(), RelationData::rd_locator, REGBUF_WILL_INIT, RelationNeedsWAL, SEQ_MAGIC, START_CRIT_SECTION, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleData::t_len, UnlockReleaseBuffer(), XLOG_SEQ_LOG, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by fill_seq_with_data().

fill_seq_with_data()

static void fill_seq_with_data ( Relation  rel, HeapTuple  tuple  )

static

Definition at line 331 of file sequence.c.

{
    fill_seq_fork_with_data(rel, tuple, MAIN_FORKNUM);
 
    if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
    {
        SMgrRelation srel;
 
        srel = smgropen(rel->rd_locator, INVALID_PROC_NUMBER);
        smgrcreate(srel, INIT_FORKNUM, false);
        log_smgrcreate(&rel->rd_locator, INIT_FORKNUM);
        fill_seq_fork_with_data(rel, tuple, INIT_FORKNUM);
        FlushRelationBuffers(rel);
        smgrclose(srel);
    }
}

References fb(), fill_seq_fork_with_data(), FlushRelationBuffers(), INIT_FORKNUM, INVALID_PROC_NUMBER, log_smgrcreate(), MAIN_FORKNUM, RelationData::rd_locator, RelationData::rd_rel, smgrclose(), smgrcreate(), and smgropen().

Referenced by AlterSequence(), DefineSequence(), ResetSequence(), and SequenceChangePersistence().

init_params()

static void init_params ( ParseState *  pstate, List *  options, bool  for_identity, bool  isInit, Form_pg_sequence  seqform, int64 *  last_value, bool *  reset_state, bool *  is_called, bool *  need_seq_rewrite, List **  owned_by  )

static

Definition at line 1260 of file sequence.c.

{
    DefElem    *as_type = NULL;
    DefElem    *start_value = NULL;
    DefElem    *restart_value = NULL;
    DefElem    *increment_by = NULL;
    DefElem    *max_value = NULL;
    DefElem    *min_value = NULL;
    DefElem    *cache_value = NULL;
    DefElem    *is_cycled = NULL;
    ListCell   *option;
    bool        reset_max_value = false;
    bool        reset_min_value = false;
 
    *need_seq_rewrite = false;
    *owned_by = NIL;
 
    foreach(option, options)
    {
        DefElem    *defel = (DefElem *) lfirst(option);
 
        if (strcmp(defel->defname, "as") == 0)
        {
            if (as_type)
                errorConflictingDefElem(defel, pstate);
            as_type = defel;
            *need_seq_rewrite = true;
        }
        else if (strcmp(defel->defname, "increment") == 0)
        {
            if (increment_by)
                errorConflictingDefElem(defel, pstate);
            increment_by = defel;
            *need_seq_rewrite = true;
        }
        else if (strcmp(defel->defname, "start") == 0)
        {
            if (start_value)
                errorConflictingDefElem(defel, pstate);
            start_value = defel;
            *need_seq_rewrite = true;
        }
        else if (strcmp(defel->defname, "restart") == 0)
        {
            if (restart_value)
                errorConflictingDefElem(defel, pstate);
            restart_value = defel;
            *need_seq_rewrite = true;
        }
        else if (strcmp(defel->defname, "maxvalue") == 0)
        {
            if (max_value)
                errorConflictingDefElem(defel, pstate);
            max_value = defel;
            *need_seq_rewrite = true;
        }
        else if (strcmp(defel->defname, "minvalue") == 0)
        {
            if (min_value)
                errorConflictingDefElem(defel, pstate);
            min_value = defel;
            *need_seq_rewrite = true;
        }
        else if (strcmp(defel->defname, "cache") == 0)
        {
            if (cache_value)
                errorConflictingDefElem(defel, pstate);
            cache_value = defel;
            *need_seq_rewrite = true;
        }
        else if (strcmp(defel->defname, "cycle") == 0)
        {
            if (is_cycled)
                errorConflictingDefElem(defel, pstate);
            is_cycled = defel;
            *need_seq_rewrite = true;
        }
        else if (strcmp(defel->defname, "owned_by") == 0)
        {
            if (*owned_by)
                errorConflictingDefElem(defel, pstate);
            *owned_by = defGetQualifiedName(defel);
        }
        else if (strcmp(defel->defname, "sequence_name") == 0)
        {
            /*
             * The parser allows this, but it is only for identity columns, in
             * which case it is filtered out in parse_utilcmd.c.  We only get
             * here if someone puts it into a CREATE SEQUENCE, where it'd be
             * redundant.  (The same is true for the equally-nonstandard
             * LOGGED and UNLOGGED options, but for those, the default error
             * below seems sufficient.)
             */
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("invalid sequence option SEQUENCE NAME"),
                     parser_errposition(pstate, defel->location)));
        }
        else
            elog(ERROR, "option \"%s\" not recognized",
                 defel->defname);
    }
 
    /*
     * We must reset the state of the sequence when isInit or when changing
     * any parameters that would affect future nextval allocations.
     */
    if (isInit)
        *reset_state = true;
 
    /* AS type */
    if (as_type != NULL)
    {
        Oid         newtypid = typenameTypeId(pstate, defGetTypeName(as_type));
 
        if (newtypid != INT2OID &&
            newtypid != INT4OID &&
            newtypid != INT8OID)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     for_identity
                     ? errmsg("identity column type must be smallint, integer, or bigint")
                     : errmsg("sequence type must be smallint, integer, or bigint")));
 
        if (!isInit)
        {
            /*
             * When changing type and the old sequence min/max values were the
             * min/max of the old type, adjust sequence min/max values to
             * min/max of new type.  (Otherwise, the user chose explicit
             * min/max values, which we'll leave alone.)
             */
            if ((seqform->seqtypid == INT2OID && seqform->seqmax == PG_INT16_MAX) ||
                (seqform->seqtypid == INT4OID && seqform->seqmax == PG_INT32_MAX) ||
                (seqform->seqtypid == INT8OID && seqform->seqmax == PG_INT64_MAX))
                reset_max_value = true;
            if ((seqform->seqtypid == INT2OID && seqform->seqmin == PG_INT16_MIN) ||
                (seqform->seqtypid == INT4OID && seqform->seqmin == PG_INT32_MIN) ||
                (seqform->seqtypid == INT8OID && seqform->seqmin == PG_INT64_MIN))
                reset_min_value = true;
        }
 
        seqform->seqtypid = newtypid;
    }
    else if (isInit)
    {
        seqform->seqtypid = INT8OID;
    }
 
    /* INCREMENT BY */
    if (increment_by != NULL)
    {
        seqform->seqincrement = defGetInt64(increment_by);
        if (seqform->seqincrement == 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("INCREMENT must not be zero")));
        *reset_state = true;
    }
    else if (isInit)
    {
        seqform->seqincrement = 1;
    }
 
    /* CYCLE */
    if (is_cycled != NULL)
    {
        seqform->seqcycle = boolVal(is_cycled->arg);
        Assert(BoolIsValid(seqform->seqcycle));
        *reset_state = true;
    }
    else if (isInit)
    {
        seqform->seqcycle = false;
    }
 
    /* MAXVALUE (null arg means NO MAXVALUE) */
    if (max_value != NULL && max_value->arg)
    {
        seqform->seqmax = defGetInt64(max_value);
        *reset_state = true;
    }
    else if (isInit || max_value != NULL || reset_max_value)
    {
        if (seqform->seqincrement > 0 || reset_max_value)
        {
            /* ascending seq */
            if (seqform->seqtypid == INT2OID)
                seqform->seqmax = PG_INT16_MAX;
            else if (seqform->seqtypid == INT4OID)
                seqform->seqmax = PG_INT32_MAX;
            else
                seqform->seqmax = PG_INT64_MAX;
        }
        else
            seqform->seqmax = -1;   /* descending seq */
        *reset_state = true;
    }
 
    /* Validate maximum value.  No need to check INT8 as seqmax is an int64 */
    if ((seqform->seqtypid == INT2OID && (seqform->seqmax < PG_INT16_MIN || seqform->seqmax > PG_INT16_MAX))
        || (seqform->seqtypid == INT4OID && (seqform->seqmax < PG_INT32_MIN || seqform->seqmax > PG_INT32_MAX)))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("MAXVALUE (%" PRId64 ") is out of range for sequence data type %s",
                        seqform->seqmax,
                        format_type_be(seqform->seqtypid))));
 
    /* MINVALUE (null arg means NO MINVALUE) */
    if (min_value != NULL && min_value->arg)
    {
        seqform->seqmin = defGetInt64(min_value);
        *reset_state = true;
    }
    else if (isInit || min_value != NULL || reset_min_value)
    {
        if (seqform->seqincrement < 0 || reset_min_value)
        {
            /* descending seq */
            if (seqform->seqtypid == INT2OID)
                seqform->seqmin = PG_INT16_MIN;
            else if (seqform->seqtypid == INT4OID)
                seqform->seqmin = PG_INT32_MIN;
            else
                seqform->seqmin = PG_INT64_MIN;
        }
        else
            seqform->seqmin = 1;    /* ascending seq */
        *reset_state = true;
    }
 
    /* Validate minimum value.  No need to check INT8 as seqmin is an int64 */
    if ((seqform->seqtypid == INT2OID && (seqform->seqmin < PG_INT16_MIN || seqform->seqmin > PG_INT16_MAX))
        || (seqform->seqtypid == INT4OID && (seqform->seqmin < PG_INT32_MIN || seqform->seqmin > PG_INT32_MAX)))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("MINVALUE (%" PRId64 ") is out of range for sequence data type %s",
                        seqform->seqmin,
                        format_type_be(seqform->seqtypid))));
 
    /* crosscheck min/max */
    if (seqform->seqmin >= seqform->seqmax)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("MINVALUE (%" PRId64 ") must be less than MAXVALUE (%" PRId64 ")",
                        seqform->seqmin,
                        seqform->seqmax)));
 
    /* START WITH */
    if (start_value != NULL)
    {
        seqform->seqstart = defGetInt64(start_value);
    }
    else if (isInit)
    {
        if (seqform->seqincrement > 0)
            seqform->seqstart = seqform->seqmin;    /* ascending seq */
        else
            seqform->seqstart = seqform->seqmax;    /* descending seq */
    }
 
    /* crosscheck START */
    if (seqform->seqstart < seqform->seqmin)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("START value (%" PRId64 ") cannot be less than MINVALUE (%" PRId64 ")",
                        seqform->seqstart,
                        seqform->seqmin)));
    if (seqform->seqstart > seqform->seqmax)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("START value (%" PRId64 ") cannot be greater than MAXVALUE (%" PRId64 ")",
                        seqform->seqstart,
                        seqform->seqmax)));
 
    /* RESTART [WITH] */
    if (restart_value != NULL)
    {
        if (restart_value->arg != NULL)
            *last_value = defGetInt64(restart_value);
        else
            *last_value = seqform->seqstart;
        *is_called = false;
        *reset_state = true;
    }
    else if (isInit)
    {
        *last_value = seqform->seqstart;
        *is_called = false;
    }
 
    /* crosscheck RESTART (or current value, if changing MIN/MAX) */
    if (*last_value < seqform->seqmin)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("RESTART value (%" PRId64 ") cannot be less than MINVALUE (%" PRId64 ")",
                        *last_value,
                        seqform->seqmin)));
    if (*last_value > seqform->seqmax)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("RESTART value (%" PRId64 ") cannot be greater than MAXVALUE (%" PRId64 ")",
                        *last_value,
                        seqform->seqmax)));
 
    /* CACHE */
    if (cache_value != NULL)
    {
        seqform->seqcache = defGetInt64(cache_value);
        if (seqform->seqcache <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("CACHE (%" PRId64 ") must be greater than zero",
                            seqform->seqcache)));
        *reset_state = true;
    }
    else if (isInit)
    {
        seqform->seqcache = 1;
    }
}

References Assert, BoolIsValid, boolVal, defGetInt64(), defGetQualifiedName(), defGetTypeName(), elog, ereport, errcode(), errmsg(), ERROR, errorConflictingDefElem(), fb(), format_type_be(), lfirst, NIL, parser_errposition(), PG_INT16_MAX, PG_INT16_MIN, PG_INT32_MAX, PG_INT32_MIN, PG_INT64_MAX, PG_INT64_MIN, and typenameTypeId().

Referenced by AlterSequence(), and DefineSequence().

init_sequence()

static void init_sequence ( Oid  relid, SeqTable *  p_elm, Relation *  p_rel  )

static

Definition at line 1130 of file sequence.c.

{
    SeqTable    elm;
    Relation    seqrel;
    bool        found;
 
    /* Find or create a hash table entry for this sequence */
    if (seqhashtab == NULL)
        create_seq_hashtable();
 
    elm = (SeqTable) hash_search(seqhashtab, &relid, HASH_ENTER, &found);
 
    /*
     * Initialize the new hash table entry if it did not exist already.
     *
     * NOTE: seqhashtab entries are stored for the life of a backend (unless
     * explicitly discarded with DISCARD). If the sequence itself is deleted
     * then the entry becomes wasted memory, but it's small enough that this
     * should not matter.
     */
    if (!found)
    {
        /* relid already filled in */
        elm->filenumber = InvalidRelFileNumber;
        elm->lxid = InvalidLocalTransactionId;
        elm->last_valid = false;
        elm->last = elm->cached = 0;
    }
 
    /*
     * Open the sequence relation.
     */
    seqrel = lock_and_open_sequence(elm);
 
    /*
     * If the sequence has been transactionally replaced since we last saw it,
     * discard any cached-but-unissued values.  We do not touch the currval()
     * state, however.
     */
    if (seqrel->rd_rel->relfilenode != elm->filenumber)
    {
        elm->filenumber = seqrel->rd_rel->relfilenode;
        elm->cached = elm->last;
    }
 
    /* Return results */
    *p_elm = elm;
    *p_rel = seqrel;
}

References SeqTableData::cached, create_seq_hashtable(), fb(), SeqTableData::filenumber, HASH_ENTER, hash_search(), InvalidLocalTransactionId, InvalidRelFileNumber, SeqTableData::last, SeqTableData::last_valid, lock_and_open_sequence(), SeqTableData::lxid, and seqhashtab.

Referenced by AlterSequence(), currval_oid(), nextval_internal(), pg_sequence_last_value(), ResetSequence(), SequenceChangePersistence(), and SetSequence().

lastval()

Datum lastval

(

PG_FUNCTION_ARGS

)

Definition at line 898 of file sequence.c.

{
    Relation    seqrel;
    int64       result;
 
    if (last_used_seq == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("lastval is not yet defined in this session")));
 
    /* Someone may have dropped the sequence since the last nextval() */
    if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(last_used_seq->relid)))
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("lastval is not yet defined in this session")));
 
    seqrel = lock_and_open_sequence(last_used_seq);
 
    /* nextval() must have already been called for this sequence */
    Assert(last_used_seq->last_valid);
 
    if (pg_class_aclcheck(last_used_seq->relid, GetUserId(),
                          ACL_SELECT | ACL_USAGE) != ACLCHECK_OK)
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied for sequence %s",
                        RelationGetRelationName(seqrel))));
 
    result = last_used_seq->last;
    sequence_close(seqrel, NoLock);
 
    PG_RETURN_INT64(result);
}

References ACL_SELECT, ACL_USAGE, ACLCHECK_OK, Assert, ereport, errcode(), errmsg(), ERROR, fb(), GetUserId(), SeqTableData::last, last_used_seq, SeqTableData::last_valid, lock_and_open_sequence(), NoLock, ObjectIdGetDatum(), pg_class_aclcheck(), PG_RETURN_INT64, RelationGetRelationName, SeqTableData::relid, SearchSysCacheExists1, and sequence_close().

lock_and_open_sequence()

static Relation lock_and_open_sequence ( SeqTable  seq )

static

Definition at line 1086 of file sequence.c.

{
    LocalTransactionId thislxid = MyProc->vxid.lxid;
 
    /* Get the lock if not already held in this xact */
    if (seq->lxid != thislxid)
    {
        ResourceOwner currentOwner;
 
        currentOwner = CurrentResourceOwner;
        CurrentResourceOwner = TopTransactionResourceOwner;
 
        LockRelationOid(seq->relid, RowExclusiveLock);
 
        CurrentResourceOwner = currentOwner;
 
        /* Flag that we have a lock in the current xact */
        seq->lxid = thislxid;
    }
 
    /* We now know we have the lock, and can safely open the rel */
    return sequence_open(seq->relid, NoLock);
}

References CurrentResourceOwner, fb(), LockRelationOid(), PGPROC::lxid, MyProc, NoLock, RowExclusiveLock, sequence_open(), TopTransactionResourceOwner, and PGPROC::vxid.

Referenced by init_sequence(), and lastval().

nextval()

Datum nextval

(

PG_FUNCTION_ARGS

)

Definition at line 594 of file sequence.c.

{
    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));
}

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

Referenced by autoinc().

nextval_internal()

int64 nextval_internal	(	Oid	relid,
		bool	check_permissions
	)

Definition at line 624 of file sequence.c.

{
    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;
        sequence_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);
 
    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)
                    ereport(ERROR,
                            (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
                             errmsg("nextval: reached maximum value of sequence \"%s\" (%" PRId64 ")",
                                    RelationGetRelationName(seqrel),
                                    maxv)));
                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)
                    ereport(ERROR,
                            (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
                             errmsg("nextval: reached minimum value of sequence \"%s\" (%" PRId64 ")",
                                    RelationGetRelationName(seqrel),
                                    minv)));
                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->increment = incby;
    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.locator = seqrel->rd_locator;
 
        XLogRegisterData(&xlrec, sizeof(xl_seq_rec));
        XLogRegisterData(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);
 
    sequence_close(seqrel, NoLock);
 
    return result;
}

References ACL_UPDATE, ACL_USAGE, ACLCHECK_OK, Assert, buf, BufferGetPage(), SeqTableData::cached, elog, END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, fb(), GetRedoRecPtr(), GETSTRUCT(), GetTopTransactionId(), GetUserId(), HeapTupleIsValid, SeqTableData::increment, init_sequence(), SeqTableData::last, last_used_seq, SeqTableData::last_valid, MarkBufferDirty(), next, NoLock, ObjectIdGetDatum(), PageGetLSN(), PageSetLSN(), pg_class_aclcheck(), PreventCommandIfParallelMode(), PreventCommandIfReadOnly(), read_seq_tuple(), REGBUF_WILL_INIT, RelationGetRelationName, RelationNeedsWAL, ReleaseSysCache(), SeqTableData::relid, SearchSysCache1(), SEQ_LOG_VALS, sequence_close(), START_CRIT_SECTION, UnlockReleaseBuffer(), XLOG_SEQ_LOG, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

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

nextval_oid()

Datum nextval_oid

(

PG_FUNCTION_ARGS

)

Definition at line 616 of file sequence.c.

{
    Oid         relid = PG_GETARG_OID(0);
 
    PG_RETURN_INT64(nextval_internal(relid, true));
}

References nextval_internal(), PG_GETARG_OID, and PG_RETURN_INT64.

pg_get_sequence_data()

Datum pg_get_sequence_data

(

PG_FUNCTION_ARGS

)

Definition at line 1793 of file sequence.c.

{
#define PG_GET_SEQUENCE_DATA_COLS   3
    Oid         relid = PG_GETARG_OID(0);
    Relation    seqrel;
    Datum       values[PG_GET_SEQUENCE_DATA_COLS] = {0};
    bool        isnull[PG_GET_SEQUENCE_DATA_COLS] = {0};
    TupleDesc   resultTupleDesc;
    HeapTuple   resultHeapTuple;
    Datum       result;
 
    resultTupleDesc = CreateTemplateTupleDesc(PG_GET_SEQUENCE_DATA_COLS);
    TupleDescInitEntry(resultTupleDesc, (AttrNumber) 1, "last_value",
                       INT8OID, -1, 0);
    TupleDescInitEntry(resultTupleDesc, (AttrNumber) 2, "is_called",
                       BOOLOID, -1, 0);
    TupleDescInitEntry(resultTupleDesc, (AttrNumber) 3, "page_lsn",
                       LSNOID, -1, 0);
    resultTupleDesc = BlessTupleDesc(resultTupleDesc);
 
    seqrel = try_relation_open(relid, AccessShareLock);
 
    /*
     * Return all NULLs for missing sequences, sequences for which we lack
     * privileges, other sessions' temporary sequences, and unlogged sequences
     * on standbys.
     */
    if (seqrel && seqrel->rd_rel->relkind == RELKIND_SEQUENCE &&
        pg_class_aclcheck(relid, GetUserId(), ACL_SELECT) == ACLCHECK_OK &&
        !RELATION_IS_OTHER_TEMP(seqrel) &&
        (RelationIsPermanent(seqrel) || !RecoveryInProgress()))
    {
        Buffer      buf;
        HeapTupleData seqtuple;
        Form_pg_sequence_data seq;
        Page        page;
 
        seq = read_seq_tuple(seqrel, &buf, &seqtuple);
        page = BufferGetPage(buf);
 
        values[0] = Int64GetDatum(seq->last_value);
        values[1] = BoolGetDatum(seq->is_called);
        values[2] = LSNGetDatum(PageGetLSN(page));
 
        UnlockReleaseBuffer(buf);
    }
    else
        memset(isnull, true, sizeof(isnull));
 
    if (seqrel)
        relation_close(seqrel, AccessShareLock);
 
    resultHeapTuple = heap_form_tuple(resultTupleDesc, values, isnull);
    result = HeapTupleGetDatum(resultHeapTuple);
    PG_RETURN_DATUM(result);
#undef PG_GET_SEQUENCE_DATA_COLS
}

References AccessShareLock, ACL_SELECT, ACLCHECK_OK, BlessTupleDesc(), BoolGetDatum(), buf, BufferGetPage(), CreateTemplateTupleDesc(), fb(), GetUserId(), heap_form_tuple(), HeapTupleGetDatum(), Int64GetDatum(), LSNGetDatum(), PageGetLSN(), pg_class_aclcheck(), PG_GET_SEQUENCE_DATA_COLS, PG_GETARG_OID, PG_RETURN_DATUM, read_seq_tuple(), RecoveryInProgress(), relation_close(), RELATION_IS_OTHER_TEMP, RelationIsPermanent, try_relation_open(), TupleDescInitEntry(), UnlockReleaseBuffer(), and values.

pg_sequence_last_value()

Datum pg_sequence_last_value

(

PG_FUNCTION_ARGS

)

Definition at line 1858 of file sequence.c.

{
    Oid         relid = PG_GETARG_OID(0);
    SeqTable    elm;
    Relation    seqrel;
    bool        is_called = false;
    int64       result = 0;
 
    /* open and lock sequence */
    init_sequence(relid, &elm, &seqrel);
 
    /*
     * We return NULL for other sessions' temporary sequences.  The
     * pg_sequences system view already filters those out, but this offers a
     * defense against ERRORs in case someone invokes this function directly.
     *
     * Also, for the benefit of the pg_sequences view, we return NULL for
     * unlogged sequences on standbys and for sequences for which the current
     * user lacks privileges instead of throwing an error.
     */
    if (pg_class_aclcheck(relid, GetUserId(), ACL_SELECT | ACL_USAGE) == ACLCHECK_OK &&
        !RELATION_IS_OTHER_TEMP(seqrel) &&
        (RelationIsPermanent(seqrel) || !RecoveryInProgress()))
    {
        Buffer      buf;
        HeapTupleData seqtuple;
        Form_pg_sequence_data seq;
 
        seq = read_seq_tuple(seqrel, &buf, &seqtuple);
 
        is_called = seq->is_called;
        result = seq->last_value;
 
        UnlockReleaseBuffer(buf);
    }
    sequence_close(seqrel, NoLock);
 
    if (is_called)
        PG_RETURN_INT64(result);
    else
        PG_RETURN_NULL();
}

References ACL_SELECT, ACL_USAGE, ACLCHECK_OK, buf, fb(), GetUserId(), init_sequence(), NoLock, pg_class_aclcheck(), PG_GETARG_OID, PG_RETURN_INT64, PG_RETURN_NULL, read_seq_tuple(), RecoveryInProgress(), RELATION_IS_OTHER_TEMP, RelationIsPermanent, sequence_close(), and UnlockReleaseBuffer().

pg_sequence_parameters()

Datum pg_sequence_parameters

(

PG_FUNCTION_ARGS

)

Definition at line 1746 of file sequence.c.

{
    Oid         relid = PG_GETARG_OID(0);
    TupleDesc   tupdesc;
    Datum       values[7];
    bool        isnull[7];
    HeapTuple   pgstuple;
    Form_pg_sequence pgsform;
 
    if (pg_class_aclcheck(relid, GetUserId(), ACL_SELECT | ACL_UPDATE | ACL_USAGE) != ACLCHECK_OK)
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied for sequence %s",
                        get_rel_name(relid))));
 
    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        elog(ERROR, "return type must be a row type");
 
    memset(isnull, 0, sizeof(isnull));
 
    pgstuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(pgstuple))
        elog(ERROR, "cache lookup failed for sequence %u", relid);
    pgsform = (Form_pg_sequence) GETSTRUCT(pgstuple);
 
    values[0] = Int64GetDatum(pgsform->seqstart);
    values[1] = Int64GetDatum(pgsform->seqmin);
    values[2] = Int64GetDatum(pgsform->seqmax);
    values[3] = Int64GetDatum(pgsform->seqincrement);
    values[4] = BoolGetDatum(pgsform->seqcycle);
    values[5] = Int64GetDatum(pgsform->seqcache);
    values[6] = ObjectIdGetDatum(pgsform->seqtypid);
 
    ReleaseSysCache(pgstuple);
 
    return HeapTupleGetDatum(heap_form_tuple(tupdesc, values, isnull));
}

References ACL_SELECT, ACL_UPDATE, ACL_USAGE, ACLCHECK_OK, BoolGetDatum(), elog, ereport, errcode(), errmsg(), ERROR, fb(), get_call_result_type(), get_rel_name(), GETSTRUCT(), GetUserId(), heap_form_tuple(), HeapTupleGetDatum(), HeapTupleIsValid, Int64GetDatum(), ObjectIdGetDatum(), pg_class_aclcheck(), PG_GETARG_OID, ReleaseSysCache(), SearchSysCache1(), TYPEFUNC_COMPOSITE, and values.

process_owned_by()

static void process_owned_by ( Relation  seqrel, List *  owned_by, bool  for_identity  )

static

Definition at line 1598 of file sequence.c.

{
    DependencyType deptype;
    int         nnames;
    Relation    tablerel;
    AttrNumber  attnum;
 
    deptype = for_identity ? DEPENDENCY_INTERNAL : DEPENDENCY_AUTO;
 
    nnames = list_length(owned_by);
    Assert(nnames > 0);
    if (nnames == 1)
    {
        /* Must be OWNED BY NONE */
        if (strcmp(strVal(linitial(owned_by)), "none") != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("invalid OWNED BY option"),
                     errhint("Specify OWNED BY table.column or OWNED BY NONE.")));
        tablerel = NULL;
        attnum = 0;
    }
    else
    {
        List       *relname;
        char       *attrname;
        RangeVar   *rel;
 
        /* Separate relname and attr name */
        relname = list_copy_head(owned_by, nnames - 1);
        attrname = strVal(llast(owned_by));
 
        /* Open and lock rel to ensure it won't go away meanwhile */
        rel = makeRangeVarFromNameList(relname);
        tablerel = relation_openrv(rel, AccessShareLock);
 
        /* Must be a regular or foreign table */
        if (!(tablerel->rd_rel->relkind == RELKIND_RELATION ||
              tablerel->rd_rel->relkind == RELKIND_FOREIGN_TABLE ||
              tablerel->rd_rel->relkind == RELKIND_VIEW ||
              tablerel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE))
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("sequence cannot be owned by relation \"%s\"",
                            RelationGetRelationName(tablerel)),
                     errdetail_relkind_not_supported(tablerel->rd_rel->relkind)));
 
        /* We insist on same owner and schema */
        if (seqrel->rd_rel->relowner != tablerel->rd_rel->relowner)
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("sequence must have same owner as table it is linked to")));
        if (RelationGetNamespace(seqrel) != RelationGetNamespace(tablerel))
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("sequence must be in same schema as table it is linked to")));
 
        /* Now, fetch the attribute number from the system cache */
        attnum = get_attnum(RelationGetRelid(tablerel), attrname);
        if (attnum == InvalidAttrNumber)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column \"%s\" of relation \"%s\" does not exist",
                            attrname, RelationGetRelationName(tablerel))));
    }
 
    /*
     * Catch user explicitly running OWNED BY on identity sequence.
     */
    if (deptype == DEPENDENCY_AUTO)
    {
        Oid         tableId;
        int32       colId;
 
        if (sequenceIsOwned(RelationGetRelid(seqrel), DEPENDENCY_INTERNAL, &tableId, &colId))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot change ownership of identity sequence"),
                     errdetail("Sequence \"%s\" is linked to table \"%s\".",
                               RelationGetRelationName(seqrel),
                               get_rel_name(tableId))));
    }
 
    /*
     * OK, we are ready to update pg_depend.  First remove any existing
     * dependencies for the sequence, then optionally add a new one.
     */
    deleteDependencyRecordsForClass(RelationRelationId, RelationGetRelid(seqrel),
                                    RelationRelationId, deptype);
 
    if (tablerel)
    {
        ObjectAddress refobject,
                    depobject;
 
        refobject.classId = RelationRelationId;
        refobject.objectId = RelationGetRelid(tablerel);
        refobject.objectSubId = attnum;
        depobject.classId = RelationRelationId;
        depobject.objectId = RelationGetRelid(seqrel);
        depobject.objectSubId = 0;
        recordDependencyOn(&depobject, &refobject, deptype);
    }
 
    /* Done, but hold lock until commit */
    if (tablerel)
        relation_close(tablerel, NoLock);
}

References AccessShareLock, Assert, attnum, ObjectAddress::classId, deleteDependencyRecordsForClass(), DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, ereport, errcode(), errdetail(), errdetail_relkind_not_supported(), errhint(), errmsg(), ERROR, fb(), get_attnum(), get_rel_name(), InvalidAttrNumber, linitial, list_copy_head(), list_length(), llast, makeRangeVarFromNameList(), NoLock, recordDependencyOn(), relation_close(), relation_openrv(), RelationGetNamespace, RelationGetRelationName, RelationGetRelid, relname, sequenceIsOwned(), and strVal.

Referenced by AlterSequence(), and DefineSequence().

read_seq_tuple()

static Form_pg_sequence_data read_seq_tuple ( Relation  rel, Buffer *  buf, HeapTuple  seqdatatuple  )

static

Definition at line 1191 of file sequence.c.

{
    Page        page;
    ItemId      lp;
    sequence_magic *sm;
    Form_pg_sequence_data seq;
 
    *buf = ReadBuffer(rel, 0);
    LockBuffer(*buf, BUFFER_LOCK_EXCLUSIVE);
 
    page = BufferGetPage(*buf);
    sm = (sequence_magic *) PageGetSpecialPointer(page);
 
    if (sm->magic != SEQ_MAGIC)
        elog(ERROR, "bad magic number in sequence \"%s\": %08X",
             RelationGetRelationName(rel), sm->magic);
 
    lp = PageGetItemId(page, FirstOffsetNumber);
    Assert(ItemIdIsNormal(lp));
 
    /* Note we currently only bother to set these two fields of *seqdatatuple */
    seqdatatuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
    seqdatatuple->t_len = ItemIdGetLength(lp);
 
    /*
     * Previous releases of Postgres neglected to prevent SELECT FOR UPDATE on
     * a sequence, which would leave a non-frozen XID in the sequence tuple's
     * xmax, which eventually leads to clog access failures or worse. If we
     * see this has happened, clean up after it.  We treat this like a hint
     * bit update, ie, don't bother to WAL-log it, since we can certainly do
     * this again if the update gets lost.
     */
    Assert(!(seqdatatuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI));
    if (HeapTupleHeaderGetRawXmax(seqdatatuple->t_data) != InvalidTransactionId)
    {
        HeapTupleHeaderSetXmax(seqdatatuple->t_data, InvalidTransactionId);
        seqdatatuple->t_data->t_infomask &= ~HEAP_XMAX_COMMITTED;
        seqdatatuple->t_data->t_infomask |= HEAP_XMAX_INVALID;
        MarkBufferDirtyHint(*buf, true);
    }
 
    seq = (Form_pg_sequence_data) GETSTRUCT(seqdatatuple);
 
    return seq;
}

References Assert, buf, BUFFER_LOCK_EXCLUSIVE, BufferGetPage(), elog, ERROR, fb(), FirstOffsetNumber, GETSTRUCT(), HEAP_XMAX_INVALID, HEAP_XMAX_IS_MULTI, HeapTupleHeaderGetRawXmax(), HeapTupleHeaderSetXmax(), InvalidTransactionId, ItemIdGetLength, ItemIdIsNormal, LockBuffer(), sequence_magic::magic, MarkBufferDirtyHint(), PageGetItem(), PageGetItemId(), PageGetSpecialPointer, ReadBuffer(), RelationGetRelationName, and SEQ_MAGIC.

Referenced by AlterSequence(), nextval_internal(), pg_get_sequence_data(), pg_sequence_last_value(), ResetSequence(), SequenceChangePersistence(), and SetSequence().

ResetSequence()

void ResetSequence

(

Oid

seq_relid

)

Definition at line 255 of file sequence.c.

{
    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.
     */
    RelationSetNewRelfilenumber(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;
 
    sequence_close(seq_rel, NoLock);
}

References Assert, buf, SeqTableData::cached, elog, ERROR, fb(), fill_seq_with_data(), GETSTRUCT(), heap_copytuple(), HeapTupleIsValid, init_sequence(), InvalidMultiXactId, InvalidTransactionId, SeqTableData::last, NoLock, ObjectIdGetDatum(), read_seq_tuple(), RelationSetNewRelfilenumber(), ReleaseSysCache(), SearchSysCache1(), sequence_close(), and UnlockReleaseBuffer().

Referenced by ExecuteTruncateGuts().

ResetSequenceCaches()

void ResetSequenceCaches

(

void

)

Definition at line 1905 of file sequence.c.

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

References fb(), hash_destroy(), last_used_seq, and seqhashtab.

Referenced by DiscardAll(), and DiscardCommand().

sequence_options()

List * sequence_options

(

Oid

relid

)

Definition at line 1712 of file sequence.c.

{
    HeapTuple   pgstuple;
    Form_pg_sequence pgsform;
    List       *options = NIL;
 
    pgstuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(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 *) makeBoolean(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;
}

References elog, ERROR, fb(), GETSTRUCT(), HeapTupleIsValid, INT64_FORMAT, lappend(), makeBoolean(), makeDefElem(), makeFloat(), NIL, ObjectIdGetDatum(), psprintf(), ReleaseSysCache(), and SearchSysCache1().

Referenced by transformTableLikeClause().

SequenceChangePersistence()

void SequenceChangePersistence	(	Oid	relid,
		char	newrelpersistence
	)

Definition at line 542 of file sequence.c.

{
    SeqTable    elm;
    Relation    seqrel;
    Buffer      buf;
    HeapTupleData seqdatatuple;
 
    /*
     * ALTER SEQUENCE acquires this lock earlier.  If we're processing an
     * owned sequence for ALTER TABLE, lock now.  Without the lock, we'd
     * discard increments from nextval() calls (in other sessions) between
     * this function's buffer unlock and this transaction's commit.
     */
    LockRelationOid(relid, AccessExclusiveLock);
    init_sequence(relid, &elm, &seqrel);
 
    /* check the comment above nextval_internal()'s equivalent call. */
    if (RelationNeedsWAL(seqrel))
        GetTopTransactionId();
 
    (void) read_seq_tuple(seqrel, &buf, &seqdatatuple);
    RelationSetNewRelfilenumber(seqrel, newrelpersistence);
    fill_seq_with_data(seqrel, &seqdatatuple);
    UnlockReleaseBuffer(buf);
 
    sequence_close(seqrel, NoLock);
}

References AccessExclusiveLock, buf, fb(), fill_seq_with_data(), GetTopTransactionId(), init_sequence(), LockRelationOid(), NoLock, read_seq_tuple(), RelationNeedsWAL, RelationSetNewRelfilenumber(), sequence_close(), and UnlockReleaseBuffer().

Referenced by ATRewriteTables().

SetSequence()

void SetSequence	(	Oid	relid,
		int64	next,
		bool	iscalled
	)

Definition at line 946 of file sequence.c.

{
    SeqTable    elm;
    Relation    seqrel;
    Buffer      buf;
    HeapTupleData seqdatatuple;
    Form_pg_sequence_data seq;
    HeapTuple   pgstuple;
    Form_pg_sequence pgsform;
    int64       maxv,
                minv;
 
    /* open and lock sequence */
    init_sequence(relid, &elm, &seqrel);
 
    if (pg_class_aclcheck(elm->relid, GetUserId(), ACL_UPDATE) != ACLCHECK_OK)
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied for sequence %s",
                        RelationGetRelationName(seqrel))));
 
    pgstuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(pgstuple))
        elog(ERROR, "cache lookup failed for sequence %u", relid);
    pgsform = (Form_pg_sequence) GETSTRUCT(pgstuple);
    maxv = pgsform->seqmax;
    minv = pgsform->seqmin;
    ReleaseSysCache(pgstuple);
 
    /* read-only transactions may only modify temp sequences */
    if (!seqrel->rd_islocaltemp)
        PreventCommandIfReadOnly("setval()");
 
    /*
     * 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("setval()");
 
    /* lock page buffer and read tuple */
    seq = read_seq_tuple(seqrel, &buf, &seqdatatuple);
 
    if ((next < minv) || (next > maxv))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("setval: value %" PRId64 " is out of bounds for sequence \"%s\" (%" PRId64 "..%" PRId64 ")",
                        next, RelationGetRelationName(seqrel),
                        minv, maxv)));
 
    /* Set the currval() state only if iscalled = true */
    if (iscalled)
    {
        elm->last = next;       /* last returned number */
        elm->last_valid = true;
    }
 
    /* In any case, forget any future cached numbers */
    elm->cached = elm->last;
 
    /* check the comment above nextval_internal()'s equivalent call. */
    if (RelationNeedsWAL(seqrel))
        GetTopTransactionId();
 
    /* ready to change the on-disk (or really, in-buffer) tuple */
    START_CRIT_SECTION();
 
    seq->last_value = next;     /* last fetched number */
    seq->is_called = iscalled;
    seq->log_cnt = 0;
 
    MarkBufferDirty(buf);
 
    /* XLOG stuff */
    if (RelationNeedsWAL(seqrel))
    {
        xl_seq_rec  xlrec;
        XLogRecPtr  recptr;
        Page        page = BufferGetPage(buf);
 
        XLogBeginInsert();
        XLogRegisterBuffer(0, buf, REGBUF_WILL_INIT);
 
        xlrec.locator = seqrel->rd_locator;
        XLogRegisterData(&xlrec, sizeof(xl_seq_rec));
        XLogRegisterData(seqdatatuple.t_data, seqdatatuple.t_len);
 
        recptr = XLogInsert(RM_SEQ_ID, XLOG_SEQ_LOG);
 
        PageSetLSN(page, recptr);
    }
 
    END_CRIT_SECTION();
 
    UnlockReleaseBuffer(buf);
 
    sequence_close(seqrel, NoLock);
}

References ACL_UPDATE, ACLCHECK_OK, buf, BufferGetPage(), SeqTableData::cached, elog, END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, fb(), GETSTRUCT(), GetTopTransactionId(), GetUserId(), HeapTupleIsValid, init_sequence(), SeqTableData::last, SeqTableData::last_valid, MarkBufferDirty(), next, NoLock, ObjectIdGetDatum(), PageSetLSN(), pg_class_aclcheck(), PreventCommandIfParallelMode(), PreventCommandIfReadOnly(), read_seq_tuple(), REGBUF_WILL_INIT, RelationGetRelationName, RelationNeedsWAL, ReleaseSysCache(), SeqTableData::relid, SearchSysCache1(), sequence_close(), START_CRIT_SECTION, UnlockReleaseBuffer(), XLOG_SEQ_LOG, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by copy_sequence(), setval3_oid(), and setval_oid().

setval3_oid()

Datum setval3_oid

(

PG_FUNCTION_ARGS

)

Definition at line 1065 of file sequence.c.

{
    Oid         relid = PG_GETARG_OID(0);
    int64       next = PG_GETARG_INT64(1);
    bool        iscalled = PG_GETARG_BOOL(2);
 
    SetSequence(relid, next, iscalled);
 
    PG_RETURN_INT64(next);
}

References fb(), next, PG_GETARG_BOOL, PG_GETARG_INT64, PG_GETARG_OID, PG_RETURN_INT64, and SetSequence().

setval_oid()

Datum setval_oid

(

PG_FUNCTION_ARGS

)

Definition at line 1050 of file sequence.c.

{
    Oid         relid = PG_GETARG_OID(0);
    int64       next = PG_GETARG_INT64(1);
 
    SetSequence(relid, next, true);
 
    PG_RETURN_INT64(next);
}

References next, PG_GETARG_INT64, PG_GETARG_OID, PG_RETURN_INT64, and SetSequence().

Variable Documentation

last_used_seq

SeqTableData* last_used_seq = NULL

static

Definition at line 87 of file sequence.c.

Referenced by lastval(), nextval_internal(), and ResetSequenceCaches().

seqhashtab

HTAB* seqhashtab = NULL

static

Definition at line 81 of file sequence.c.

Referenced by create_seq_hashtable(), init_sequence(), and ResetSequenceCaches().