PostgreSQL Source Code  git master
sequence.h File Reference
#include "access/xlogreader.h"
#include "catalog/objectaddress.h"
#include "fmgr.h"
#include "lib/stringinfo.h"
#include "nodes/parsenodes.h"
#include "parser/parse_node.h"
#include "storage/relfilelocator.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_dataForm_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)
 
Listsequence_options (Oid relid)
 
ObjectAddress DefineSequence (ParseState *pstate, CreateSeqStmt *seq)
 
ObjectAddress AlterSequence (ParseState *pstate, AlterSeqStmt *stmt)
 
void SequenceChangePersistence (Oid relid, char newrelpersistence)
 
void DeleteSequenceTuple (Oid relid)
 
void ResetSequence (Oid seq_relid)
 
void ResetSequenceCaches (void)
 
void seq_redo (XLogReaderState *record)
 
void seq_desc (StringInfo buf, XLogReaderState *record)
 
const char * seq_identify (uint8 info)
 
void seq_mask (char *page, BlockNumber blkno)
 

Macro Definition Documentation

◆ SEQ_COL_CALLED

#define SEQ_COL_CALLED   3

Definition at line 40 of file sequence.h.

◆ SEQ_COL_FIRSTCOL

#define SEQ_COL_FIRSTCOL   SEQ_COL_LASTVAL

Definition at line 42 of file sequence.h.

◆ SEQ_COL_LASTCOL

#define SEQ_COL_LASTCOL   SEQ_COL_CALLED

Definition at line 43 of file sequence.h.

◆ SEQ_COL_LASTVAL

#define SEQ_COL_LASTVAL   1

Definition at line 38 of file sequence.h.

◆ SEQ_COL_LOG

#define SEQ_COL_LOG   2

Definition at line 39 of file sequence.h.

◆ XLOG_SEQ_LOG

#define XLOG_SEQ_LOG   0x00

Definition at line 46 of file sequence.h.

Typedef Documentation

◆ Form_pg_sequence_data

Definition at line 32 of file sequence.h.

◆ FormData_pg_sequence_data

◆ xl_seq_rec

typedef struct xl_seq_rec xl_seq_rec

Function Documentation

◆ AlterSequence()

ObjectAddress AlterSequence ( ParseState pstate,
AlterSeqStmt stmt 
)

Definition at line 436 of file sequence.c.

437 {
438  Oid relid;
439  SeqTable elm;
440  Relation seqrel;
441  Buffer buf;
442  HeapTupleData datatuple;
443  Form_pg_sequence seqform;
444  Form_pg_sequence_data newdataform;
445  bool need_seq_rewrite;
446  List *owned_by;
447  ObjectAddress address;
448  Relation rel;
449  HeapTuple seqtuple;
450  HeapTuple newdatatuple;
451 
452  /* Open and lock sequence, and check for ownership along the way. */
453  relid = RangeVarGetRelidExtended(stmt->sequence,
455  stmt->missing_ok ? RVR_MISSING_OK : 0,
457  NULL);
458  if (relid == InvalidOid)
459  {
460  ereport(NOTICE,
461  (errmsg("relation \"%s\" does not exist, skipping",
462  stmt->sequence->relname)));
463  return InvalidObjectAddress;
464  }
465 
466  init_sequence(relid, &elm, &seqrel);
467 
468  rel = table_open(SequenceRelationId, RowExclusiveLock);
469  seqtuple = SearchSysCacheCopy1(SEQRELID,
470  ObjectIdGetDatum(relid));
471  if (!HeapTupleIsValid(seqtuple))
472  elog(ERROR, "cache lookup failed for sequence %u",
473  relid);
474 
475  seqform = (Form_pg_sequence) GETSTRUCT(seqtuple);
476 
477  /* lock page buffer and read tuple into new sequence structure */
478  (void) read_seq_tuple(seqrel, &buf, &datatuple);
479 
480  /* copy the existing sequence data tuple, so it can be modified locally */
481  newdatatuple = heap_copytuple(&datatuple);
482  newdataform = (Form_pg_sequence_data) GETSTRUCT(newdatatuple);
483 
485 
486  /* Check and set new values */
487  init_params(pstate, stmt->options, stmt->for_identity, false,
488  seqform, newdataform,
489  &need_seq_rewrite, &owned_by);
490 
491  /* Clear local cache so that we don't think we have cached numbers */
492  /* Note that we do not change the currval() state */
493  elm->cached = elm->last;
494 
495  /* If needed, rewrite the sequence relation itself */
496  if (need_seq_rewrite)
497  {
498  /* check the comment above nextval_internal()'s equivalent call. */
499  if (RelationNeedsWAL(seqrel))
501 
502  /*
503  * Create a new storage file for the sequence, making the state
504  * changes transactional.
505  */
506  RelationSetNewRelfilenumber(seqrel, seqrel->rd_rel->relpersistence);
507 
508  /*
509  * Ensure sequence's relfrozenxid is at 0, since it won't contain any
510  * unfrozen XIDs. Same with relminmxid, since a sequence will never
511  * contain multixacts.
512  */
513  Assert(seqrel->rd_rel->relfrozenxid == InvalidTransactionId);
514  Assert(seqrel->rd_rel->relminmxid == InvalidMultiXactId);
515 
516  /*
517  * Insert the modified tuple into the new storage file.
518  */
519  fill_seq_with_data(seqrel, newdatatuple);
520  }
521 
522  /* process OWNED BY if given */
523  if (owned_by)
524  process_owned_by(seqrel, owned_by, stmt->for_identity);
525 
526  /* update the pg_sequence tuple (we could skip this in some cases...) */
527  CatalogTupleUpdate(rel, &seqtuple->t_self, seqtuple);
528 
529  InvokeObjectPostAlterHook(RelationRelationId, relid, 0);
530 
531  ObjectAddressSet(address, RelationRelationId, relid);
532 
534  relation_close(seqrel, NoLock);
535 
536  return address;
537 }
int Buffer
Definition: buf.h:23
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:4578
int errmsg(const char *fmt,...)
Definition: elog.c:1075
#define ERROR
Definition: elog.h:39
#define NOTICE
Definition: elog.h:35
#define ereport(elevel,...)
Definition: elog.h:149
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:777
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
#define stmt
Definition: indent_codes.h:59
void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
Definition: indexing.c:313
Assert(fmt[strlen(fmt) - 1] !='\n')
#define NoLock
Definition: lockdefs.h:34
#define ShareRowExclusiveLock
Definition: lockdefs.h:41
#define RowExclusiveLock
Definition: lockdefs.h:38
#define InvalidMultiXactId
Definition: multixact.h:24
Oid RangeVarGetRelidExtended(const RangeVar *relation, LOCKMODE lockmode, uint32 flags, RangeVarGetRelidCallback callback, void *callback_arg)
Definition: namespace.c:426
@ RVR_MISSING_OK
Definition: namespace.h:71
#define InvokeObjectPostAlterHook(classId, objectId, subId)
Definition: objectaccess.h:197
const ObjectAddress InvalidObjectAddress
#define ObjectAddressSet(addr, class_id, object_id)
Definition: objectaddress.h:40
FormData_pg_sequence * Form_pg_sequence
Definition: pg_sequence.h:40
static char * buf
Definition: pg_test_fsync.c:73
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
#define RelationNeedsWAL(relation)
Definition: rel.h:627
void RelationSetNewRelfilenumber(Relation relation, char persistence)
Definition: relcache.c:3725
static void fill_seq_with_data(Relation rel, HeapTuple tuple)
Definition: sequence.c:337
static void init_sequence(Oid relid, SeqTable *p_elm, Relation *p_rel)
Definition: sequence.c:1121
static Form_pg_sequence_data read_seq_tuple(Relation rel, Buffer *buf, HeapTuple seqdatatuple)
Definition: sequence.c:1188
static void process_owned_by(Relation seqrel, List *owned_by, bool for_identity)
Definition: sequence.c:1588
static void init_params(ParseState *pstate, List *options, bool for_identity, bool isInit, Form_pg_sequence seqform, Form_pg_sequence_data seqdataform, bool *need_seq_rewrite, List **owned_by)
Definition: sequence.c:1255
FormData_pg_sequence_data * Form_pg_sequence_data
Definition: sequence.h:32
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:206
ItemPointerData t_self
Definition: htup.h:65
Definition: pg_list.h:54
Form_pg_class rd_rel
Definition: rel.h:111
int64 cached
Definition: sequence.c:82
int64 last
Definition: sequence.c:81
#define SearchSysCacheCopy1(cacheId, key1)
Definition: syscache.h:86
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
void RangeVarCallbackOwnsRelation(const RangeVar *relation, Oid relId, Oid oldRelId, void *arg)
Definition: tablecmds.c:18164
#define InvalidTransactionId
Definition: transam.h:31
TransactionId GetTopTransactionId(void)
Definition: xact.c:417

References Assert(), buf, SeqTableData::cached, CatalogTupleUpdate(), elog(), ereport, errmsg(), ERROR, 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(), RelationData::rd_rel, read_seq_tuple(), relation_close(), RelationNeedsWAL, RelationSetNewRelfilenumber(), RowExclusiveLock, RVR_MISSING_OK, SearchSysCacheCopy1, ShareRowExclusiveLock, stmt, HeapTupleData::t_self, table_close(), table_open(), and UnlockReleaseBuffer().

Referenced by ProcessUtilitySlow().

◆ DefineSequence()

ObjectAddress DefineSequence ( ParseState pstate,
CreateSeqStmt seq 
)

Definition at line 120 of file sequence.c.

121 {
122  FormData_pg_sequence seqform;
123  FormData_pg_sequence_data seqdataform;
124  bool need_seq_rewrite;
125  List *owned_by;
127  Oid seqoid;
128  ObjectAddress address;
129  Relation rel;
130  HeapTuple tuple;
131  TupleDesc tupDesc;
133  bool null[SEQ_COL_LASTCOL];
134  Datum pgs_values[Natts_pg_sequence];
135  bool pgs_nulls[Natts_pg_sequence];
136  int i;
137 
138  /*
139  * If if_not_exists was given and a relation with the same name already
140  * exists, bail out. (Note: we needn't check this when not if_not_exists,
141  * because DefineRelation will complain anyway.)
142  */
143  if (seq->if_not_exists)
144  {
146  if (OidIsValid(seqoid))
147  {
148  /*
149  * If we are in an extension script, insist that the pre-existing
150  * object be a member of the extension, to avoid security risks.
151  */
152  ObjectAddressSet(address, RelationRelationId, seqoid);
154 
155  /* OK to skip */
156  ereport(NOTICE,
157  (errcode(ERRCODE_DUPLICATE_TABLE),
158  errmsg("relation \"%s\" already exists, skipping",
159  seq->sequence->relname)));
160  return InvalidObjectAddress;
161  }
162  }
163 
164  /* Check and set all option values */
165  init_params(pstate, seq->options, seq->for_identity, true,
166  &seqform, &seqdataform,
167  &need_seq_rewrite, &owned_by);
168 
169  /*
170  * Create relation (and fill value[] and null[] for the tuple)
171  */
172  stmt->tableElts = NIL;
173  for (i = SEQ_COL_FIRSTCOL; i <= SEQ_COL_LASTCOL; i++)
174  {
175  ColumnDef *coldef = NULL;
176 
177  switch (i)
178  {
179  case SEQ_COL_LASTVAL:
180  coldef = makeColumnDef("last_value", INT8OID, -1, InvalidOid);
181  value[i - 1] = Int64GetDatumFast(seqdataform.last_value);
182  break;
183  case SEQ_COL_LOG:
184  coldef = makeColumnDef("log_cnt", INT8OID, -1, InvalidOid);
185  value[i - 1] = Int64GetDatum((int64) 0);
186  break;
187  case SEQ_COL_CALLED:
188  coldef = makeColumnDef("is_called", BOOLOID, -1, InvalidOid);
189  value[i - 1] = BoolGetDatum(false);
190  break;
191  }
192 
193  coldef->is_not_null = true;
194  null[i - 1] = false;
195 
196  stmt->tableElts = lappend(stmt->tableElts, coldef);
197  }
198 
199  stmt->relation = seq->sequence;
200  stmt->inhRelations = NIL;
201  stmt->constraints = NIL;
202  stmt->options = NIL;
203  stmt->oncommit = ONCOMMIT_NOOP;
204  stmt->tablespacename = NULL;
205  stmt->if_not_exists = seq->if_not_exists;
206 
207  address = DefineRelation(stmt, RELKIND_SEQUENCE, seq->ownerId, NULL, NULL);
208  seqoid = address.objectId;
209  Assert(seqoid != InvalidOid);
210 
211  rel = table_open(seqoid, AccessExclusiveLock);
212  tupDesc = RelationGetDescr(rel);
213 
214  /* now initialize the sequence's data */
215  tuple = heap_form_tuple(tupDesc, value, null);
216  fill_seq_with_data(rel, tuple);
217 
218  /* process OWNED BY if given */
219  if (owned_by)
220  process_owned_by(rel, owned_by, seq->for_identity);
221 
222  table_close(rel, NoLock);
223 
224  /* fill in pg_sequence */
225  rel = table_open(SequenceRelationId, RowExclusiveLock);
226  tupDesc = RelationGetDescr(rel);
227 
228  memset(pgs_nulls, 0, sizeof(pgs_nulls));
229 
230  pgs_values[Anum_pg_sequence_seqrelid - 1] = ObjectIdGetDatum(seqoid);
231  pgs_values[Anum_pg_sequence_seqtypid - 1] = ObjectIdGetDatum(seqform.seqtypid);
232  pgs_values[Anum_pg_sequence_seqstart - 1] = Int64GetDatumFast(seqform.seqstart);
233  pgs_values[Anum_pg_sequence_seqincrement - 1] = Int64GetDatumFast(seqform.seqincrement);
234  pgs_values[Anum_pg_sequence_seqmax - 1] = Int64GetDatumFast(seqform.seqmax);
235  pgs_values[Anum_pg_sequence_seqmin - 1] = Int64GetDatumFast(seqform.seqmin);
236  pgs_values[Anum_pg_sequence_seqcache - 1] = Int64GetDatumFast(seqform.seqcache);
237  pgs_values[Anum_pg_sequence_seqcycle - 1] = BoolGetDatum(seqform.seqcycle);
238 
239  tuple = heap_form_tuple(tupDesc, pgs_values, pgs_nulls);
240  CatalogTupleInsert(rel, tuple);
241 
242  heap_freetuple(tuple);
244 
245  return address;
246 }
#define OidIsValid(objectId)
Definition: c.h:764
int errcode(int sqlerrcode)
Definition: elog.c:860
Datum Int64GetDatum(int64 X)
Definition: fmgr.c:1807
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1117
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1435
void CatalogTupleInsert(Relation heapRel, HeapTuple tup)
Definition: indexing.c:233
static struct @148 value
int i
Definition: isn.c:73
List * lappend(List *list, void *datum)
Definition: list.c:339
#define AccessExclusiveLock
Definition: lockdefs.h:43
ColumnDef * makeColumnDef(const char *colname, Oid typeOid, int32 typmod, Oid collOid)
Definition: makefuncs.c:493
Oid RangeVarGetAndCheckCreationNamespace(RangeVar *relation, LOCKMODE lockmode, Oid *existing_relation_id)
Definition: namespace.c:724
#define makeNode(_type_)
Definition: nodes.h:155
void checkMembershipInCurrentExtension(const ObjectAddress *object)
Definition: pg_depend.c:257
#define NIL
Definition: pg_list.h:68
FormData_pg_sequence
Definition: pg_sequence.h:33
#define Int64GetDatumFast(X)
Definition: postgres.h:554
uintptr_t Datum
Definition: postgres.h:64
static Datum BoolGetDatum(bool X)
Definition: postgres.h:102
@ ONCOMMIT_NOOP
Definition: primnodes.h:57
#define RelationGetDescr(relation)
Definition: rel.h:530
#define SEQ_COL_LASTVAL
Definition: sequence.h:38
#define SEQ_COL_CALLED
Definition: sequence.h:40
#define SEQ_COL_LASTCOL
Definition: sequence.h:43
#define SEQ_COL_LOG
Definition: sequence.h:39
#define SEQ_COL_FIRSTCOL
Definition: sequence.h:42
bool is_not_null
Definition: parsenodes.h:718
bool if_not_exists
Definition: parsenodes.h:2976
List * options
Definition: parsenodes.h:2973
RangeVar * sequence
Definition: parsenodes.h:2972
char * relname
Definition: primnodes.h:82
ObjectAddress DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, ObjectAddress *typaddress, const char *queryString)
Definition: tablecmds.c:686

References AccessExclusiveLock, Assert(), BoolGetDatum(), CatalogTupleInsert(), checkMembershipInCurrentExtension(), DefineRelation(), ereport, errcode(), errmsg(), fill_seq_with_data(), CreateSeqStmt::for_identity, FormData_pg_sequence, heap_form_tuple(), heap_freetuple(), i, CreateSeqStmt::if_not_exists, init_params(), Int64GetDatum(), Int64GetDatumFast, InvalidObjectAddress, InvalidOid, ColumnDef::is_not_null, lappend(), FormData_pg_sequence_data::last_value, makeColumnDef(), makeNode, NIL, NoLock, NOTICE, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), OidIsValid, ONCOMMIT_NOOP, CreateSeqStmt::options, CreateSeqStmt::ownerId, process_owned_by(), RangeVarGetAndCheckCreationNamespace(), RelationGetDescr, RangeVar::relname, RowExclusiveLock, SEQ_COL_CALLED, SEQ_COL_FIRSTCOL, SEQ_COL_LASTCOL, SEQ_COL_LASTVAL, SEQ_COL_LOG, CreateSeqStmt::sequence, stmt, table_close(), table_open(), and value.

Referenced by ProcessUtilitySlow().

◆ DeleteSequenceTuple()

void DeleteSequenceTuple ( Oid  relid)

Definition at line 562 of file sequence.c.

563 {
564  Relation rel;
565  HeapTuple tuple;
566 
567  rel = table_open(SequenceRelationId, RowExclusiveLock);
568 
569  tuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(relid));
570  if (!HeapTupleIsValid(tuple))
571  elog(ERROR, "cache lookup failed for sequence %u", relid);
572 
573  CatalogTupleDelete(rel, &tuple->t_self);
574 
575  ReleaseSysCache(tuple);
577 }
void CatalogTupleDelete(Relation heapRel, ItemPointer tid)
Definition: indexing.c:365
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:267
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:219

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

Referenced by doDeletion().

◆ nextval()

Datum nextval ( PG_FUNCTION_ARGS  )

Definition at line 585 of file sequence.c.

586 {
587  text *seqin = PG_GETARG_TEXT_PP(0);
588  RangeVar *sequence;
589  Oid relid;
590 
592 
593  /*
594  * XXX: This is not safe in the presence of concurrent DDL, but acquiring
595  * a lock here is more expensive than letting nextval_internal do it,
596  * since the latter maintains a cache that keeps us from hitting the lock
597  * manager more than once per transaction. It's not clear whether the
598  * performance penalty is material in practice, but for now, we do it this
599  * way.
600  */
601  relid = RangeVarGetRelid(sequence, NoLock, false);
602 
603  PG_RETURN_INT64(nextval_internal(relid, true));
604 }
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
#define PG_RETURN_INT64(x)
Definition: fmgr.h:368
RangeVar * makeRangeVarFromNameList(const List *names)
Definition: namespace.c:3539
#define RangeVarGetRelid(relation, lockmode, missing_ok)
Definition: namespace.h:79
int64 nextval_internal(Oid relid, bool check_permissions)
Definition: sequence.c:615
Definition: c.h:676
List * textToQualifiedNameList(text *textval)
Definition: varlena.c:3398

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

Referenced by autoinc(), and ttdummy().

◆ nextval_internal()

int64 nextval_internal ( Oid  relid,
bool  check_permissions 
)

Definition at line 615 of file sequence.c.

616 {
617  SeqTable elm;
618  Relation seqrel;
619  Buffer buf;
620  Page page;
621  HeapTuple pgstuple;
622  Form_pg_sequence pgsform;
623  HeapTupleData seqdatatuple;
625  int64 incby,
626  maxv,
627  minv,
628  cache,
629  log,
630  fetch,
631  last;
632  int64 result,
633  next,
634  rescnt = 0;
635  bool cycle;
636  bool logit = false;
637 
638  /* open and lock sequence */
639  init_sequence(relid, &elm, &seqrel);
640 
641  if (check_permissions &&
644  ereport(ERROR,
645  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
646  errmsg("permission denied for sequence %s",
647  RelationGetRelationName(seqrel))));
648 
649  /* read-only transactions may only modify temp sequences */
650  if (!seqrel->rd_islocaltemp)
651  PreventCommandIfReadOnly("nextval()");
652 
653  /*
654  * Forbid this during parallel operation because, to make it work, the
655  * cooperating backends would need to share the backend-local cached
656  * sequence information. Currently, we don't support that.
657  */
658  PreventCommandIfParallelMode("nextval()");
659 
660  if (elm->last != elm->cached) /* some numbers were cached */
661  {
662  Assert(elm->last_valid);
663  Assert(elm->increment != 0);
664  elm->last += elm->increment;
665  relation_close(seqrel, NoLock);
666  last_used_seq = elm;
667  return elm->last;
668  }
669 
670  pgstuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(relid));
671  if (!HeapTupleIsValid(pgstuple))
672  elog(ERROR, "cache lookup failed for sequence %u", relid);
673  pgsform = (Form_pg_sequence) GETSTRUCT(pgstuple);
674  incby = pgsform->seqincrement;
675  maxv = pgsform->seqmax;
676  minv = pgsform->seqmin;
677  cache = pgsform->seqcache;
678  cycle = pgsform->seqcycle;
679  ReleaseSysCache(pgstuple);
680 
681  /* lock page buffer and read tuple */
682  seq = read_seq_tuple(seqrel, &buf, &seqdatatuple);
683  page = BufferGetPage(buf);
684 
685  elm->increment = incby;
686  last = next = result = seq->last_value;
687  fetch = cache;
688  log = seq->log_cnt;
689 
690  if (!seq->is_called)
691  {
692  rescnt++; /* return last_value if not is_called */
693  fetch--;
694  }
695 
696  /*
697  * Decide whether we should emit a WAL log record. If so, force up the
698  * fetch count to grab SEQ_LOG_VALS more values than we actually need to
699  * cache. (These will then be usable without logging.)
700  *
701  * If this is the first nextval after a checkpoint, we must force a new
702  * WAL record to be written anyway, else replay starting from the
703  * checkpoint would fail to advance the sequence past the logged values.
704  * In this case we may as well fetch extra values.
705  */
706  if (log < fetch || !seq->is_called)
707  {
708  /* forced log to satisfy local demand for values */
709  fetch = log = fetch + SEQ_LOG_VALS;
710  logit = true;
711  }
712  else
713  {
714  XLogRecPtr redoptr = GetRedoRecPtr();
715 
716  if (PageGetLSN(page) <= redoptr)
717  {
718  /* last update of seq was before checkpoint */
719  fetch = log = fetch + SEQ_LOG_VALS;
720  logit = true;
721  }
722  }
723 
724  while (fetch) /* try to fetch cache [+ log ] numbers */
725  {
726  /*
727  * Check MAXVALUE for ascending sequences and MINVALUE for descending
728  * sequences
729  */
730  if (incby > 0)
731  {
732  /* ascending sequence */
733  if ((maxv >= 0 && next > maxv - incby) ||
734  (maxv < 0 && next + incby > maxv))
735  {
736  if (rescnt > 0)
737  break; /* stop fetching */
738  if (!cycle)
739  ereport(ERROR,
740  (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
741  errmsg("nextval: reached maximum value of sequence \"%s\" (%lld)",
742  RelationGetRelationName(seqrel),
743  (long long) maxv)));
744  next = minv;
745  }
746  else
747  next += incby;
748  }
749  else
750  {
751  /* descending sequence */
752  if ((minv < 0 && next < minv - incby) ||
753  (minv >= 0 && next + incby < minv))
754  {
755  if (rescnt > 0)
756  break; /* stop fetching */
757  if (!cycle)
758  ereport(ERROR,
759  (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
760  errmsg("nextval: reached minimum value of sequence \"%s\" (%lld)",
761  RelationGetRelationName(seqrel),
762  (long long) minv)));
763  next = maxv;
764  }
765  else
766  next += incby;
767  }
768  fetch--;
769  if (rescnt < cache)
770  {
771  log--;
772  rescnt++;
773  last = next;
774  if (rescnt == 1) /* if it's first result - */
775  result = next; /* it's what to return */
776  }
777  }
778 
779  log -= fetch; /* adjust for any unfetched numbers */
780  Assert(log >= 0);
781 
782  /* save info in local cache */
783  elm->last = result; /* last returned number */
784  elm->cached = last; /* last fetched number */
785  elm->last_valid = true;
786 
787  last_used_seq = elm;
788 
789  /*
790  * If something needs to be WAL logged, acquire an xid, so this
791  * transaction's commit will trigger a WAL flush and wait for syncrep.
792  * It's sufficient to ensure the toplevel transaction has an xid, no need
793  * to assign xids subxacts, that'll already trigger an appropriate wait.
794  * (Have to do that here, so we're outside the critical section)
795  */
796  if (logit && RelationNeedsWAL(seqrel))
798 
799  /* ready to change the on-disk (or really, in-buffer) tuple */
801 
802  /*
803  * We must mark the buffer dirty before doing XLogInsert(); see notes in
804  * SyncOneBuffer(). However, we don't apply the desired changes just yet.
805  * This looks like a violation of the buffer update protocol, but it is in
806  * fact safe because we hold exclusive lock on the buffer. Any other
807  * process, including a checkpoint, that tries to examine the buffer
808  * contents will block until we release the lock, and then will see the
809  * final state that we install below.
810  */
812 
813  /* XLOG stuff */
814  if (logit && RelationNeedsWAL(seqrel))
815  {
816  xl_seq_rec xlrec;
817  XLogRecPtr recptr;
818 
819  /*
820  * We don't log the current state of the tuple, but rather the state
821  * as it would appear after "log" more fetches. This lets us skip
822  * that many future WAL records, at the cost that we lose those
823  * sequence values if we crash.
824  */
825  XLogBeginInsert();
827 
828  /* set values that will be saved in xlog */
829  seq->last_value = next;
830  seq->is_called = true;
831  seq->log_cnt = 0;
832 
833  xlrec.locator = seqrel->rd_locator;
834 
835  XLogRegisterData((char *) &xlrec, sizeof(xl_seq_rec));
836  XLogRegisterData((char *) seqdatatuple.t_data, seqdatatuple.t_len);
837 
838  recptr = XLogInsert(RM_SEQ_ID, XLOG_SEQ_LOG);
839 
840  PageSetLSN(page, recptr);
841  }
842 
843  /* Now update sequence tuple to the intended final state */
844  seq->last_value = last; /* last fetched number */
845  seq->is_called = true;
846  seq->log_cnt = log; /* how much is logged */
847 
849 
851 
852  relation_close(seqrel, NoLock);
853 
854  return result;
855 }
@ ACLCHECK_OK
Definition: acl.h:182
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
Definition: aclchk.c:4081
static int32 next
Definition: blutils.c:221
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:2190
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:350
Pointer Page
Definition: bufpage.h:78
static void PageSetLSN(Page page, XLogRecPtr lsn)
Definition: bufpage.h:388
static XLogRecPtr PageGetLSN(Page page)
Definition: bufpage.h:383
#define START_CRIT_SECTION()
Definition: miscadmin.h:149
#define END_CRIT_SECTION()
Definition: miscadmin.h:151
Oid GetUserId(void)
Definition: miscinit.c:511
#define ACL_USAGE
Definition: parsenodes.h:84
#define ACL_UPDATE
Definition: parsenodes.h:78
#define RelationGetRelationName(relation)
Definition: rel.h:538
static SeqTableData * last_used_seq
Definition: sequence.c:96
#define SEQ_LOG_VALS
Definition: sequence.c:57
#define XLOG_SEQ_LOG
Definition: sequence.h:46
uint32 t_len
Definition: htup.h:64
HeapTupleHeader t_data
Definition: htup.h:68
bool rd_islocaltemp
Definition: rel.h:61
RelFileLocator rd_locator
Definition: rel.h:57
bool last_valid
Definition: sequence.c:80
int64 increment
Definition: sequence.c:84
RelFileLocator locator
Definition: sequence.h:50
void PreventCommandIfReadOnly(const char *cmdname)
Definition: utility.c:411
void PreventCommandIfParallelMode(const char *cmdname)
Definition: utility.c:429
XLogRecPtr GetRedoRecPtr(void)
Definition: xlog.c:6314
uint64 XLogRecPtr
Definition: xlogdefs.h:21
void XLogRegisterData(char *data, uint32 len)
Definition: xloginsert.c:365
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:475
void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
Definition: xloginsert.c:243
void XLogBeginInsert(void)
Definition: xloginsert.c:150
#define REGBUF_WILL_INIT
Definition: xloginsert.h:33

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(), FormData_pg_sequence_data::is_called, SeqTableData::last, last_used_seq, SeqTableData::last_valid, FormData_pg_sequence_data::last_value, xl_seq_rec::locator, FormData_pg_sequence_data::log_cnt, MarkBufferDirty(), next, NoLock, ObjectIdGetDatum(), PageGetLSN(), PageSetLSN(), pg_class_aclcheck(), PreventCommandIfParallelMode(), PreventCommandIfReadOnly(), RelationData::rd_islocaltemp, RelationData::rd_locator, read_seq_tuple(), REGBUF_WILL_INIT, relation_close(), RelationGetRelationName, RelationNeedsWAL, ReleaseSysCache(), SeqTableData::relid, SearchSysCache1(), SEQ_LOG_VALS, 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().

◆ ResetSequence()

void ResetSequence ( Oid  seq_relid)

Definition at line 261 of file sequence.c.

262 {
263  Relation seq_rel;
264  SeqTable elm;
266  Buffer buf;
267  HeapTupleData seqdatatuple;
268  HeapTuple tuple;
269  HeapTuple pgstuple;
270  Form_pg_sequence pgsform;
271  int64 startv;
272 
273  /*
274  * Read the old sequence. This does a bit more work than really
275  * necessary, but it's simple, and we do want to double-check that it's
276  * indeed a sequence.
277  */
278  init_sequence(seq_relid, &elm, &seq_rel);
279  (void) read_seq_tuple(seq_rel, &buf, &seqdatatuple);
280 
281  pgstuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(seq_relid));
282  if (!HeapTupleIsValid(pgstuple))
283  elog(ERROR, "cache lookup failed for sequence %u", seq_relid);
284  pgsform = (Form_pg_sequence) GETSTRUCT(pgstuple);
285  startv = pgsform->seqstart;
286  ReleaseSysCache(pgstuple);
287 
288  /*
289  * Copy the existing sequence tuple.
290  */
291  tuple = heap_copytuple(&seqdatatuple);
292 
293  /* Now we're done with the old page */
295 
296  /*
297  * Modify the copied tuple to execute the restart (compare the RESTART
298  * action in AlterSequence)
299  */
300  seq = (Form_pg_sequence_data) GETSTRUCT(tuple);
301  seq->last_value = startv;
302  seq->is_called = false;
303  seq->log_cnt = 0;
304 
305  /*
306  * Create a new storage file for the sequence.
307  */
308  RelationSetNewRelfilenumber(seq_rel, seq_rel->rd_rel->relpersistence);
309 
310  /*
311  * Ensure sequence's relfrozenxid is at 0, since it won't contain any
312  * unfrozen XIDs. Same with relminmxid, since a sequence will never
313  * contain multixacts.
314  */
315  Assert(seq_rel->rd_rel->relfrozenxid == InvalidTransactionId);
316  Assert(seq_rel->rd_rel->relminmxid == InvalidMultiXactId);
317 
318  /*
319  * Insert the modified tuple into the new storage file.
320  */
321  fill_seq_with_data(seq_rel, tuple);
322 
323  /* Clear local cache so that we don't think we have cached numbers */
324  /* Note that we do not change the currval() state */
325  elm->cached = elm->last;
326 
327  relation_close(seq_rel, NoLock);
328 }

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

Referenced by ExecuteTruncateGuts().

◆ ResetSequenceCaches()

void ResetSequenceCaches ( void  )

Definition at line 1869 of file sequence.c.

1870 {
1871  if (seqhashtab)
1872  {
1874  seqhashtab = NULL;
1875  }
1876 
1877  last_used_seq = NULL;
1878 }
void hash_destroy(HTAB *hashp)
Definition: dynahash.c:863
static HTAB * seqhashtab
Definition: sequence.c:90

References hash_destroy(), last_used_seq, and seqhashtab.

Referenced by DiscardAll(), and DiscardCommand().

◆ seq_desc()

void seq_desc ( StringInfo  buf,
XLogReaderState record 
)

Definition at line 21 of file seqdesc.c.

22 {
23  char *rec = XLogRecGetData(record);
24  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
25  xl_seq_rec *xlrec = (xl_seq_rec *) rec;
26 
27  if (info == XLOG_SEQ_LOG)
28  appendStringInfo(buf, "rel %u/%u/%u",
29  xlrec->locator.spcOid, xlrec->locator.dbOid,
30  xlrec->locator.relNumber);
31 }
unsigned char uint8
Definition: c.h:493
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:97
RelFileNumber relNumber
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:410
#define XLogRecGetData(decoder)
Definition: xlogreader.h:415
#define XLR_INFO_MASK
Definition: xlogrecord.h:62

References appendStringInfo(), buf, RelFileLocator::dbOid, xl_seq_rec::locator, RelFileLocator::relNumber, RelFileLocator::spcOid, XLOG_SEQ_LOG, XLogRecGetData, XLogRecGetInfo, and XLR_INFO_MASK.

◆ seq_identify()

const char* seq_identify ( uint8  info)

Definition at line 34 of file seqdesc.c.

35 {
36  const char *id = NULL;
37 
38  switch (info & ~XLR_INFO_MASK)
39  {
40  case XLOG_SEQ_LOG:
41  id = "LOG";
42  break;
43  }
44 
45  return id;
46 }

References XLOG_SEQ_LOG, and XLR_INFO_MASK.

◆ seq_mask()

void seq_mask ( char *  page,
BlockNumber  blkno 
)

Definition at line 1884 of file sequence.c.

1885 {
1887 
1888  mask_unused_space(page);
1889 }
void mask_page_lsn_and_checksum(Page page)
Definition: bufmask.c:31
void mask_unused_space(Page page)
Definition: bufmask.c:71

References mask_page_lsn_and_checksum(), and mask_unused_space().

◆ seq_redo()

void seq_redo ( XLogReaderState record)

Definition at line 1816 of file sequence.c.

1817 {
1818  XLogRecPtr lsn = record->EndRecPtr;
1819  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
1820  Buffer buffer;
1821  Page page;
1822  Page localpage;
1823  char *item;
1824  Size itemsz;
1825  xl_seq_rec *xlrec = (xl_seq_rec *) XLogRecGetData(record);
1826  sequence_magic *sm;
1827 
1828  if (info != XLOG_SEQ_LOG)
1829  elog(PANIC, "seq_redo: unknown op code %u", info);
1830 
1831  buffer = XLogInitBufferForRedo(record, 0);
1832  page = (Page) BufferGetPage(buffer);
1833 
1834  /*
1835  * We always reinit the page. However, since this WAL record type is also
1836  * used for updating sequences, it's possible that a hot-standby backend
1837  * is examining the page concurrently; so we mustn't transiently trash the
1838  * buffer. The solution is to build the correct new page contents in
1839  * local workspace and then memcpy into the buffer. Then only bytes that
1840  * are supposed to change will change, even transiently. We must palloc
1841  * the local page for alignment reasons.
1842  */
1843  localpage = (Page) palloc(BufferGetPageSize(buffer));
1844 
1845  PageInit(localpage, BufferGetPageSize(buffer), sizeof(sequence_magic));
1846  sm = (sequence_magic *) PageGetSpecialPointer(localpage);
1847  sm->magic = SEQ_MAGIC;
1848 
1849  item = (char *) xlrec + sizeof(xl_seq_rec);
1850  itemsz = XLogRecGetDataLen(record) - sizeof(xl_seq_rec);
1851 
1852  if (PageAddItem(localpage, (Item) item, itemsz,
1853  FirstOffsetNumber, false, false) == InvalidOffsetNumber)
1854  elog(PANIC, "seq_redo: failed to add item to page");
1855 
1856  PageSetLSN(localpage, lsn);
1857 
1858  memcpy(page, localpage, BufferGetPageSize(buffer));
1859  MarkBufferDirty(buffer);
1860  UnlockReleaseBuffer(buffer);
1861 
1862  pfree(localpage);
1863 }
static Size BufferGetPageSize(Buffer buffer)
Definition: bufmgr.h:339
void PageInit(Page page, Size pageSize, Size specialSize)
Definition: bufpage.c:42
static char * PageGetSpecialPointer(Page page)
Definition: bufpage.h:336
#define PageAddItem(page, item, size, offsetNumber, overwrite, is_heap)
Definition: bufpage.h:468
size_t Size
Definition: c.h:594
#define PANIC
Definition: elog.h:42
Pointer Item
Definition: item.h:17
void pfree(void *pointer)
Definition: mcxt.c:1431
void * palloc(Size size)
Definition: mcxt.c:1201
#define InvalidOffsetNumber
Definition: off.h:26
#define FirstOffsetNumber
Definition: off.h:27
#define SEQ_MAGIC
Definition: sequence.c:62
struct xl_seq_rec xl_seq_rec
XLogRecPtr EndRecPtr
Definition: xlogreader.h:207
uint32 magic
Definition: sequence.c:66
#define XLogRecGetDataLen(decoder)
Definition: xlogreader.h:416
Buffer XLogInitBufferForRedo(XLogReaderState *record, uint8 block_id)
Definition: xlogutils.c:329

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

◆ sequence_options()

List* sequence_options ( Oid  relid)

Definition at line 1702 of file sequence.c.

1703 {
1704  HeapTuple pgstuple;
1705  Form_pg_sequence pgsform;
1706  List *options = NIL;
1707 
1708  pgstuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(relid));
1709  if (!HeapTupleIsValid(pgstuple))
1710  elog(ERROR, "cache lookup failed for sequence %u", relid);
1711  pgsform = (Form_pg_sequence) GETSTRUCT(pgstuple);
1712 
1713  /* Use makeFloat() for 64-bit integers, like gram.y does. */
1715  makeDefElem("cache", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqcache)), -1));
1717  makeDefElem("cycle", (Node *) makeBoolean(pgsform->seqcycle), -1));
1719  makeDefElem("increment", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqincrement)), -1));
1721  makeDefElem("maxvalue", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqmax)), -1));
1723  makeDefElem("minvalue", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqmin)), -1));
1725  makeDefElem("start", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqstart)), -1));
1726 
1727  ReleaseSysCache(pgstuple);
1728 
1729  return options;
1730 }
#define INT64_FORMAT
Definition: c.h:537
DefElem * makeDefElem(char *name, Node *arg, int location)
Definition: makefuncs.c:549
static char ** options
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
Definition: nodes.h:129
Boolean * makeBoolean(bool val)
Definition: value.c:49
Float * makeFloat(char *numericStr)
Definition: value.c:37

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

Referenced by transformTableLikeClause().

◆ SequenceChangePersistence()

void SequenceChangePersistence ( Oid  relid,
char  newrelpersistence 
)

Definition at line 540 of file sequence.c.

541 {
542  SeqTable elm;
543  Relation seqrel;
544  Buffer buf;
545  HeapTupleData seqdatatuple;
546 
547  init_sequence(relid, &elm, &seqrel);
548 
549  /* check the comment above nextval_internal()'s equivalent call. */
550  if (RelationNeedsWAL(seqrel))
552 
553  (void) read_seq_tuple(seqrel, &buf, &seqdatatuple);
554  RelationSetNewRelfilenumber(seqrel, newrelpersistence);
555  fill_seq_with_data(seqrel, &seqdatatuple);
557 
558  relation_close(seqrel, NoLock);
559 }

References buf, fill_seq_with_data(), GetTopTransactionId(), init_sequence(), NoLock, read_seq_tuple(), relation_close(), RelationNeedsWAL, RelationSetNewRelfilenumber(), and UnlockReleaseBuffer().

Referenced by ATRewriteTables().