#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

#define SEQ_COL_CALLED 3

Definition at line 40 of file sequence.h.

Referenced by DefineSequence().

#define SEQ_COL_FIRSTCOL SEQ_COL_LASTVAL

Definition at line 42 of file sequence.h.

Referenced by DefineSequence().

#define SEQ_COL_LASTCOL SEQ_COL_CALLED

Definition at line 43 of file sequence.h.

Referenced by DefineSequence().

#define SEQ_COL_LASTVAL 1

Definition at line 38 of file sequence.h.

Referenced by DefineSequence().

#define SEQ_COL_LOG 2

Definition at line 39 of file sequence.h.

Referenced by DefineSequence().

#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

typedef FormData_pg_sequence_data* Form_pg_sequence_data

Definition at line 32 of file sequence.h.

typedef struct FormData_pg_sequence_data FormData_pg_sequence_data

typedef struct xl_seq_rec xl_seq_rec

Function Documentation

ObjectAddress AlterSequence	(	ParseState *	pstate,
		AlterSeqStmt *	stmt
	)

Definition at line 416 of file sequence.c.

References buf, SeqTableData::cached, CatalogTupleUpdate(), elog, ereport, errmsg(), ERROR, fill_seq_with_data(), AlterSeqStmt::for_identity, GETSTRUCT, GetTopTransactionId(), heap_close, heap_copytuple(), heap_open(), 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, RelationRelationId, RelationSetNewRelfilenode(), RangeVar::relname, RowExclusiveLock, SearchSysCacheCopy1, SEQRELID, AlterSeqStmt::sequence, SequenceRelationId, ShareRowExclusiveLock, HeapTupleData::t_self, 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,
                                      false,
                                      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 = heap_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.  We want to keep the sequence's relfrozenxid
          * at 0, since it won't contain any unfrozen XIDs.  Same with
          * relminmxid, since a sequence will never contain multixacts.
          */
         RelationSetNewRelfilenode(seqrel, seqrel->rd_rel->relpersistence,
                                   InvalidTransactionId, 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);
 
     heap_close(rel, RowExclusiveLock);
     relation_close(seqrel, NoLock);
 
     return address;
 }

ObjectAddress DefineSequence	(	ParseState *	pstate,
		CreateSeqStmt *	stmt
	)

Definition at line 116 of file sequence.c.

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->is_from_parent = 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 = heap_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);
 
     heap_close(rel, NoLock);
 
     /* fill in pg_sequence */
     rel = heap_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);
     heap_close(rel, RowExclusiveLock);
 
     return address;
 }

void DeleteSequenceTuple ( Oid relid )

Definition at line 516 of file sequence.c.

References CatalogTupleDelete(), elog, ERROR, heap_close, heap_open(), HeapTupleIsValid, ObjectIdGetDatum, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), SEQRELID, SequenceRelationId, and HeapTupleData::t_self.

Referenced by doDeletion().

 {
     Relation    rel;
     HeapTuple   tuple;
 
     rel = heap_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);
     heap_close(rel, RowExclusiveLock);
 }

Datum nextval ( PG_FUNCTION_ARGS )

Definition at line 539 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));
 }

int64 nextval_internal	(	Oid	relid,
		bool	check_permissions
	)

Definition at line 569 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;
 }

void ResetSequence ( Oid seq_relid )

Definition at line 269 of file sequence.c.

References 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 ExecuteTruncate().

 {
     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.  We want to keep the
      * sequence's relfrozenxid at 0, since it won't contain any unfrozen XIDs.
      * Same with relminmxid, since a sequence will never contain multixacts.
      */
     RelationSetNewRelfilenode(seq_rel, seq_rel->rd_rel->relpersistence,
                               InvalidTransactionId, 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);
 }

void ResetSequenceCaches ( void )

Definition at line 1919 of file sequence.c.

References hash_destroy().

Referenced by DiscardAll(), and DiscardCommand().

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

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

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

void seq_mask	(	char *	pagedata,
		BlockNumber	blkno
	)

Definition at line 1934 of file sequence.c.

References mask_page_lsn_and_checksum(), and mask_unused_space().

 {
     mask_page_lsn_and_checksum(page);
 
     mask_unused_space(page);
 }

void seq_redo ( XLogReaderState * rptr )

Definition at line 1866 of file sequence.c.

References buffer, 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);
 }

List* sequence_options ( Oid relid )

Definition at line 1744 of file sequence.c.

References elog, ERROR, GETSTRUCT, HeapTupleIsValid, lappend(), makeDefElem(), makeInteger(), NIL, options, 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);
 
     options = lappend(options, makeDefElem("cache", (Node *) makeInteger(pgsform->seqcache), -1));
     options = lappend(options, makeDefElem("cycle", (Node *) makeInteger(pgsform->seqcycle), -1));
     options = lappend(options, makeDefElem("increment", (Node *) makeInteger(pgsform->seqincrement), -1));
     options = lappend(options, makeDefElem("maxvalue", (Node *) makeInteger(pgsform->seqmax), -1));
     options = lappend(options, makeDefElem("minvalue", (Node *) makeInteger(pgsform->seqmin), -1));
     options = lappend(options, makeDefElem("start", (Node *) makeInteger(pgsform->seqstart), -1));
 
     ReleaseSysCache(pgstuple);
 
     return options;
 }

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation