PostgreSQL Source Code git master
Data Structures | Macros | Typedefs | Functions | Variables
sequence.c File Reference
#include "postgres.h"
#include "access/bufmask.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/xlog.h"
#include "access/xloginsert.h"
#include "access/xlogutils.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/tablecmds.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "parser/parse_type.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   sequence_magic
 
struct   SeqTableData
 

Macros

#define  SEQ_LOG_VALS   32
 
#define  SEQ_MAGIC   0x1717
 
#define  PG_GET_SEQUENCE_DATA_COLS   3
 

Typedefs

typedef struct sequence_magic  sequence_magic
 
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  do_setval (Oid relid, int64 next, bool iscalled)
 
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)
 
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  seq_redo (XLogReaderState *record)
 
void  ResetSequenceCaches (void)
 
void  seq_mask (char *page, BlockNumber blkno)
 

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 59 of file sequence.c.

◆ SEQ_MAGIC

#define SEQ_MAGIC   0x1717

Definition at line 64 of file sequence.c.

Typedef Documentation

◆ SeqTable

typedef SeqTableData* SeqTable

Definition at line 90 of file sequence.c.

◆ SeqTableData

typedef struct SeqTableData SeqTableData

◆ sequence_magic

typedef struct sequence_magic sequence_magic

Function Documentation

◆ AlterSequence()

ObjectAddress AlterSequence ( ParseState *  pstate,
AlterSeqStmt *  stmt 
)

Definition at line 442 of file sequence.c.

443{
444 Oid relid;
445 SeqTable elm;
446 Relation seqrel;
447 Buffer buf;
448 HeapTupleData datatuple;
449 Form_pg_sequence seqform;
450 Form_pg_sequence_data newdataform;
451 bool need_seq_rewrite;
452 List *owned_by;
453 ObjectAddress address;
454 Relation rel;
455 HeapTuple seqtuple;
456 bool reset_state = false;
457 bool is_called;
458 int64 last_value;
459 HeapTuple newdatatuple;
460
461 /* Open and lock sequence, and check for ownership along the way. */
462 relid = RangeVarGetRelidExtended(stmt->sequence,
464 stmt->missing_ok ? RVR_MISSING_OK : 0,
466 NULL);
467 if (relid == InvalidOid)
468 {
470 (errmsg("relation \"%s\" does not exist, skipping",
471 stmt->sequence->relname)));
473 }
474
475 init_sequence(relid, &elm, &seqrel);
476
477 rel = table_open(SequenceRelationId, RowExclusiveLock);
478 seqtuple = SearchSysCacheCopy1(SEQRELID,
479 ObjectIdGetDatum(relid));
480 if (!HeapTupleIsValid(seqtuple))
481 elog(ERROR, "cache lookup failed for sequence %u",
482 relid);
483
484 seqform = (Form_pg_sequence) GETSTRUCT(seqtuple);
485
486 /* lock page buffer and read tuple into new sequence structure */
487 (void) read_seq_tuple(seqrel, &buf, &datatuple);
488
489 /* copy the existing sequence data tuple, so it can be modified locally */
490 newdatatuple = heap_copytuple(&datatuple);
491 newdataform = (Form_pg_sequence_data) GETSTRUCT(newdatatuple);
492 last_value = newdataform->last_value;
493 is_called = newdataform->is_called;
494
496
497 /* Check and set new values */
498 init_params(pstate, stmt->options, stmt->for_identity, false,
499 seqform, &last_value, &reset_state, &is_called,
500 &need_seq_rewrite, &owned_by);
501
502 /* If needed, rewrite the sequence relation itself */
503 if (need_seq_rewrite)
504 {
505 /* check the comment above nextval_internal()'s equivalent call. */
506 if (RelationNeedsWAL(seqrel))
508
509 /*
510 * Create a new storage file for the sequence, making the state
511 * changes transactional.
512 */
513 RelationSetNewRelfilenumber(seqrel, seqrel->rd_rel->relpersistence);
514
515 /*
516 * Ensure sequence's relfrozenxid is at 0, since it won't contain any
517 * unfrozen XIDs. Same with relminmxid, since a sequence will never
518 * contain multixacts.
519 */
520 Assert(seqrel->rd_rel->relfrozenxid == InvalidTransactionId);
521 Assert(seqrel->rd_rel->relminmxid == InvalidMultiXactId);
522
523 /*
524 * Insert the modified tuple into the new storage file.
525 */
526 newdataform->last_value = last_value;
527 newdataform->is_called = is_called;
528 if (reset_state)
529 newdataform->log_cnt = 0;
530 fill_seq_with_data(seqrel, newdatatuple);
531 }
532
533 /* Clear local cache so that we don't think we have cached numbers */
534 /* Note that we do not change the currval() state */
535 elm->cached = elm->last;
536
537 /* process OWNED BY if given */
538 if (owned_by)
539 process_owned_by(seqrel, owned_by, stmt->for_identity);
540
541 /* update the pg_sequence tuple (we could skip this in some cases...) */
542 CatalogTupleUpdate(rel, &seqtuple->t_self, seqtuple);
543
544 InvokeObjectPostAlterHook(RelationRelationId, relid, 0);
545
546 ObjectAddressSet(address, RelationRelationId, relid);
547
549 sequence_close(seqrel, NoLock);
550
551 return address;
552}
void sequence_close(Relation relation, LOCKMODE lockmode)
Definition: sequence.c:58
int Buffer
Definition: buf.h:23
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:5355
int64_t int64
Definition: c.h:535
static void fill_seq_with_data(Relation rel, HeapTuple tuple)
Definition: sequence.c:343
static void init_sequence(Oid relid, SeqTable *p_elm, Relation *p_rel)
Definition: sequence.c:1143
static Form_pg_sequence_data read_seq_tuple(Relation rel, Buffer *buf, HeapTuple seqdatatuple)
Definition: sequence.c:1204
static void process_owned_by(Relation seqrel, List *owned_by, bool for_identity)
Definition: sequence.c:1611
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)
Definition: sequence.c:1273
FormData_pg_sequence_data * Form_pg_sequence_data
Definition: sequence.h:32
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
#define NOTICE
Definition: elog.h:35
#define ereport(elevel,...)
Definition: elog.h:150
Assert(PointerIsAligned(start, uint64))
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:778
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
static void * GETSTRUCT(const HeapTupleData *tuple)
Definition: htup_details.h:728
#define stmt
Definition: indent_codes.h:59
void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
Definition: indexing.c:313
#define NoLock
Definition: lockdefs.h:34
#define ShareRowExclusiveLock
Definition: lockdefs.h:41
#define RowExclusiveLock
Definition: lockdefs.h:38
#define InvalidMultiXactId
Definition: multixact.h:25
Oid RangeVarGetRelidExtended(const RangeVar *relation, LOCKMODE lockmode, uint32 flags, RangeVarGetRelidCallback callback, void *callback_arg)
Definition: namespace.c:440
@ RVR_MISSING_OK
Definition: namespace.h:90
#define InvokeObjectPostAlterHook(classId, objectId, subId)
Definition: objectaccess.h:197
const ObjectAddress InvalidObjectAddress
Definition: objectaddress.c:836
#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:72
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:262
#define InvalidOid
Definition: postgres_ext.h:37
unsigned int Oid
Definition: postgres_ext.h:32
#define RelationNeedsWAL(relation)
Definition: rel.h:637
void RelationSetNewRelfilenumber(Relation relation, char persistence)
Definition: relcache.c:3773
Definition: sequence.h:26
bool is_called
Definition: sequence.h:29
int64 last_value
Definition: sequence.h:27
int64 log_cnt
Definition: sequence.h:28
ItemPointerData t_self
Definition: htup.h:65
Definition: pg_list.h:54
Definition: rel.h:56
Form_pg_class rd_rel
Definition: rel.h:111
int64 cached
Definition: sequence.c:84
int64 last
Definition: sequence.c:83
#define SearchSysCacheCopy1(cacheId, key1)
Definition: syscache.h:91
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:19520
#define InvalidTransactionId
Definition: transam.h:31
TransactionId GetTopTransactionId(void)
Definition: xact.c:426

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, FormData_pg_sequence_data::is_called, SeqTableData::last, FormData_pg_sequence_data::last_value, FormData_pg_sequence_data::log_cnt, NoLock, NOTICE, ObjectAddressSet, ObjectIdGetDatum(), process_owned_by(), RangeVarCallbackOwnsRelation(), RangeVarGetRelidExtended(), RelationData::rd_rel, read_seq_tuple(), RelationNeedsWAL, RelationSetNewRelfilenumber(), RowExclusiveLock, RVR_MISSING_OK, SearchSysCacheCopy1, sequence_close(), ShareRowExclusiveLock, stmt, HeapTupleData::t_self, table_close(), table_open(), and UnlockReleaseBuffer().

Referenced by ProcessUtilitySlow().

◆ create_seq_hashtable()

static void create_seq_hashtable ( void  )
static

Definition at line 1127 of file sequence.c.

1128{
1129 HASHCTL ctl;
1130
1131 ctl.keysize = sizeof(Oid);
1132 ctl.entrysize = sizeof(SeqTableData);
1133
1134 seqhashtab = hash_create("Sequence values", 16, &ctl,
1136}
static HTAB * seqhashtab
Definition: sequence.c:92
struct SeqTableData SeqTableData
HTAB * hash_create(const char *tabname, int64 nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:358
#define HASH_ELEM
Definition: hsearch.h:95
#define HASH_BLOBS
Definition: hsearch.h:97
tree ctl
Definition: radixtree.h:1838
Definition: hsearch.h:66

References ctl, HASH_BLOBS, hash_create(), HASH_ELEM, and seqhashtab.

Referenced by init_sequence().

◆ currval_oid()

Datum currval_oid ( PG_FUNCTION_ARGS  )

Definition at line 880 of file sequence.c.

881{
882 Oid relid = PG_GETARG_OID(0);
883 int64 result;
884 SeqTable elm;
885 Relation seqrel;
886
887 /* open and lock sequence */
888 init_sequence(relid, &elm, &seqrel);
889
893 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
894 errmsg("permission denied for sequence %s",
895 RelationGetRelationName(seqrel))));
896
897 if (!elm->last_valid)
899 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
900 errmsg("currval of sequence \"%s\" is not yet defined in this session",
901 RelationGetRelationName(seqrel))));
902
903 result = elm->last;
904
905 sequence_close(seqrel, NoLock);
906
907 PG_RETURN_INT64(result);
908}
@ ACLCHECK_OK
Definition: acl.h:183
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
Definition: aclchk.c:4037
int errcode(int sqlerrcode)
Definition: elog.c:854
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
#define PG_RETURN_INT64(x)
Definition: fmgr.h:368
Oid GetUserId(void)
Definition: miscinit.c:469
#define ACL_USAGE
Definition: parsenodes.h:84
#define ACL_SELECT
Definition: parsenodes.h:77
#define RelationGetRelationName(relation)
Definition: rel.h:548
bool last_valid
Definition: sequence.c:82
Oid relid
Definition: sequence.c:79

References ACL_SELECT, ACL_USAGE, ACLCHECK_OK, ereport, errcode(), errmsg(), ERROR, 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 124 of file sequence.c.

125{
126 FormData_pg_sequence seqform;
127 int64 last_value;
128 bool reset_state;
129 bool is_called;
130 bool need_seq_rewrite;
131 List *owned_by;
133 Oid seqoid;
134 ObjectAddress address;
135 Relation rel;
136 HeapTuple tuple;
137 TupleDesc tupDesc;
139 bool null[SEQ_COL_LASTCOL];
140 Datum pgs_values[Natts_pg_sequence];
141 bool pgs_nulls[Natts_pg_sequence];
142 int i;
143
144 /*
145 * If if_not_exists was given and a relation with the same name already
146 * exists, bail out. (Note: we needn't check this when not if_not_exists,
147 * because DefineRelation will complain anyway.)
148 */
149 if (seq->if_not_exists)
150 {
152 if (OidIsValid(seqoid))
153 {
154 /*
155 * If we are in an extension script, insist that the pre-existing
156 * object be a member of the extension, to avoid security risks.
157 */
158 ObjectAddressSet(address, RelationRelationId, seqoid);
160
161 /* OK to skip */
163 (errcode(ERRCODE_DUPLICATE_TABLE),
164 errmsg("relation \"%s\" already exists, skipping",
165 seq->sequence->relname)));
167 }
168 }
169
170 /* Check and set all option values */
171 init_params(pstate, seq->options, seq->for_identity, true,
172 &seqform, &last_value, &reset_state, &is_called,
173 &need_seq_rewrite, &owned_by);
174
175 /*
176 * Create relation (and fill value[] and null[] for the tuple)
177 */
178 stmt->tableElts = NIL;
179 for (i = SEQ_COL_FIRSTCOL; i <= SEQ_COL_LASTCOL; i++)
180 {
181 ColumnDef *coldef = NULL;
182
183 switch (i)
184 {
185 case SEQ_COL_LASTVAL:
186 coldef = makeColumnDef("last_value", INT8OID, -1, InvalidOid);
187 value[i - 1] = Int64GetDatumFast(last_value);
188 break;
189 case SEQ_COL_LOG:
190 coldef = makeColumnDef("log_cnt", INT8OID, -1, InvalidOid);
191 value[i - 1] = Int64GetDatum((int64) 0);
192 break;
193 case SEQ_COL_CALLED:
194 coldef = makeColumnDef("is_called", BOOLOID, -1, InvalidOid);
195 value[i - 1] = BoolGetDatum(false);
196 break;
197 }
198
199 coldef->is_not_null = true;
200 null[i - 1] = false;
201
202 stmt->tableElts = lappend(stmt->tableElts, coldef);
203 }
204
205 stmt->relation = seq->sequence;
206 stmt->inhRelations = NIL;
207 stmt->constraints = NIL;
208 stmt->options = NIL;
209 stmt->oncommit = ONCOMMIT_NOOP;
210 stmt->tablespacename = NULL;
211 stmt->if_not_exists = seq->if_not_exists;
212
213 address = DefineRelation(stmt, RELKIND_SEQUENCE, seq->ownerId, NULL, NULL);
214 seqoid = address.objectId;
215 Assert(seqoid != InvalidOid);
216
217 rel = sequence_open(seqoid, AccessExclusiveLock);
218 tupDesc = RelationGetDescr(rel);
219
220 /* now initialize the sequence's data */
221 tuple = heap_form_tuple(tupDesc, value, null);
222 fill_seq_with_data(rel, tuple);
223
224 /* process OWNED BY if given */
225 if (owned_by)
226 process_owned_by(rel, owned_by, seq->for_identity);
227
229
230 /* fill in pg_sequence */
231 rel = table_open(SequenceRelationId, RowExclusiveLock);
232 tupDesc = RelationGetDescr(rel);
233
234 memset(pgs_nulls, 0, sizeof(pgs_nulls));
235
236 pgs_values[Anum_pg_sequence_seqrelid - 1] = ObjectIdGetDatum(seqoid);
237 pgs_values[Anum_pg_sequence_seqtypid - 1] = ObjectIdGetDatum(seqform.seqtypid);
238 pgs_values[Anum_pg_sequence_seqstart - 1] = Int64GetDatumFast(seqform.seqstart);
239 pgs_values[Anum_pg_sequence_seqincrement - 1] = Int64GetDatumFast(seqform.seqincrement);
240 pgs_values[Anum_pg_sequence_seqmax - 1] = Int64GetDatumFast(seqform.seqmax);
241 pgs_values[Anum_pg_sequence_seqmin - 1] = Int64GetDatumFast(seqform.seqmin);
242 pgs_values[Anum_pg_sequence_seqcache - 1] = Int64GetDatumFast(seqform.seqcache);
243 pgs_values[Anum_pg_sequence_seqcycle - 1] = BoolGetDatum(seqform.seqcycle);
244
245 tuple = heap_form_tuple(tupDesc, pgs_values, pgs_nulls);
246 CatalogTupleInsert(rel, tuple);
247
248 heap_freetuple(tuple);
250
251 return address;
252}
Relation sequence_open(Oid relationId, LOCKMODE lockmode)
Definition: sequence.c:37
#define OidIsValid(objectId)
Definition: c.h:774
#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
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 @169 value
i
int i
Definition: isn.c:77
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:565
Oid RangeVarGetAndCheckCreationNamespace(RangeVar *relation, LOCKMODE lockmode, Oid *existing_relation_id)
Definition: namespace.c:738
#define makeNode(_type_)
Definition: nodes.h:161
void checkMembershipInCurrentExtension(const ObjectAddress *object)
Definition: pg_depend.c:258
#define NIL
Definition: pg_list.h:68
FormData_pg_sequence
Definition: pg_sequence.h:33
static Datum Int64GetDatum(int64 X)
Definition: postgres.h:403
#define Int64GetDatumFast(X)
Definition: postgres.h:515
static Datum BoolGetDatum(bool X)
Definition: postgres.h:112
uint64_t Datum
Definition: postgres.h:70
@ ONCOMMIT_NOOP
Definition: primnodes.h:58
#define RelationGetDescr(relation)
Definition: rel.h:540
bool is_not_null
Definition: parsenodes.h:759
bool if_not_exists
Definition: parsenodes.h:3229
List * options
Definition: parsenodes.h:3226
bool for_identity
Definition: parsenodes.h:3228
RangeVar * sequence
Definition: parsenodes.h:3225
char * relname
Definition: primnodes.h:83
ObjectAddress DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, ObjectAddress *typaddress, const char *queryString)
Definition: tablecmds.c:765

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(), 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, sequence_close(), sequence_open(), stmt, table_close(), table_open(), and value.

Referenced by ProcessUtilitySlow().

◆ DeleteSequenceTuple()

void DeleteSequenceTuple ( Oid  relid )

Definition at line 584 of file sequence.c.

585{
586 Relation rel;
587 HeapTuple tuple;
588
589 rel = table_open(SequenceRelationId, RowExclusiveLock);
590
591 tuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(relid));
592 if (!HeapTupleIsValid(tuple))
593 elog(ERROR, "cache lookup failed for sequence %u", relid);
594
595 CatalogTupleDelete(rel, &tuple->t_self);
596
597 ReleaseSysCache(tuple);
599}
void CatalogTupleDelete(Relation heapRel, ItemPointer tid)
Definition: indexing.c:365
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:264
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:220

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

Referenced by doDeletion().

◆ do_setval()

static void do_setval ( Oid  relid,
int64  next,
bool  iscalled 
)
static

Definition at line 959 of file sequence.c.

960{
961 SeqTable elm;
962 Relation seqrel;
963 Buffer buf;
964 HeapTupleData seqdatatuple;
966 HeapTuple pgstuple;
967 Form_pg_sequence pgsform;
968 int64 maxv,
969 minv;
970
971 /* open and lock sequence */
972 init_sequence(relid, &elm, &seqrel);
973
976 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
977 errmsg("permission denied for sequence %s",
978 RelationGetRelationName(seqrel))));
979
980 pgstuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(relid));
981 if (!HeapTupleIsValid(pgstuple))
982 elog(ERROR, "cache lookup failed for sequence %u", relid);
983 pgsform = (Form_pg_sequence) GETSTRUCT(pgstuple);
984 maxv = pgsform->seqmax;
985 minv = pgsform->seqmin;
986 ReleaseSysCache(pgstuple);
987
988 /* read-only transactions may only modify temp sequences */
989 if (!seqrel->rd_islocaltemp)
990 PreventCommandIfReadOnly("setval()");
991
992 /*
993 * Forbid this during parallel operation because, to make it work, the
994 * cooperating backends would need to share the backend-local cached
995 * sequence information. Currently, we don't support that.
996 */
998
999 /* lock page buffer and read tuple */
1000 seq = read_seq_tuple(seqrel, &buf, &seqdatatuple);
1001
1002 if ((next < minv) || (next > maxv))
1003 ereport(ERROR,
1004 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1005 errmsg("setval: value %" PRId64 " is out of bounds for sequence \"%s\" (%" PRId64 "..%" PRId64 ")",
1007 minv, maxv)));
1008
1009 /* Set the currval() state only if iscalled = true */
1010 if (iscalled)
1011 {
1012 elm->last = next; /* last returned number */
1013 elm->last_valid = true;
1014 }
1015
1016 /* In any case, forget any future cached numbers */
1017 elm->cached = elm->last;
1018
1019 /* check the comment above nextval_internal()'s equivalent call. */
1020 if (RelationNeedsWAL(seqrel))
1022
1023 /* ready to change the on-disk (or really, in-buffer) tuple */
1025
1026 seq->last_value = next; /* last fetched number */
1027 seq->is_called = iscalled;
1028 seq->log_cnt = 0;
1029
1031
1032 /* XLOG stuff */
1033 if (RelationNeedsWAL(seqrel))
1034 {
1035 xl_seq_rec xlrec;
1036 XLogRecPtr recptr;
1037 Page page = BufferGetPage(buf);
1038
1041
1042 xlrec.locator = seqrel->rd_locator;
1043 XLogRegisterData(&xlrec, sizeof(xl_seq_rec));
1044 XLogRegisterData(seqdatatuple.t_data, seqdatatuple.t_len);
1045
1046 recptr = XLogInsert(RM_SEQ_ID, XLOG_SEQ_LOG);
1047
1048 PageSetLSN(page, recptr);
1049 }
1050
1052
1054
1055 sequence_close(seqrel, NoLock);
1056}
static int32 next
Definition: blutils.c:224
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:2921
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:417
static void PageSetLSN(Page page, XLogRecPtr lsn)
Definition: bufpage.h:391
PageData * Page
Definition: bufpage.h:82
#define XLOG_SEQ_LOG
Definition: sequence.h:46
#define START_CRIT_SECTION()
Definition: miscadmin.h:149
#define END_CRIT_SECTION()
Definition: miscadmin.h:151
#define ACL_UPDATE
Definition: parsenodes.h:78
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
Definition: sequence.h:49
RelFileLocator locator
Definition: sequence.h:50
void PreventCommandIfReadOnly(const char *cmdname)
Definition: utility.c:404
void PreventCommandIfParallelMode(const char *cmdname)
Definition: utility.c:422
uint64 XLogRecPtr
Definition: xlogdefs.h:21
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogRegisterData(const void *data, uint32 len)
Definition: xloginsert.c:364
void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
Definition: xloginsert.c:242
void XLogBeginInsert(void)
Definition: xloginsert.c:149
#define REGBUF_WILL_INIT
Definition: xloginsert.h:34

References ACL_UPDATE, ACLCHECK_OK, buf, BufferGetPage(), SeqTableData::cached, elog, END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, GETSTRUCT(), GetTopTransactionId(), GetUserId(), HeapTupleIsValid, init_sequence(), FormData_pg_sequence_data::is_called, SeqTableData::last, SeqTableData::last_valid, FormData_pg_sequence_data::last_value, xl_seq_rec::locator, FormData_pg_sequence_data::log_cnt, MarkBufferDirty(), next, NoLock, ObjectIdGetDatum(), PageSetLSN(), pg_class_aclcheck(), PreventCommandIfParallelMode(), PreventCommandIfReadOnly(), RelationData::rd_islocaltemp, RelationData::rd_locator, read_seq_tuple(), REGBUF_WILL_INIT, RelationGetRelationName, RelationNeedsWAL, ReleaseSysCache(), SeqTableData::relid, SearchSysCache1(), sequence_close(), START_CRIT_SECTION, HeapTupleData::t_data, HeapTupleData::t_len, UnlockReleaseBuffer(), XLOG_SEQ_LOG, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by setval3_oid(), and setval_oid().

◆ fill_seq_fork_with_data()

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

Definition at line 364 of file sequence.c.

365{
366 Buffer buf;
367 Page page;
368 sequence_magic *sm;
369 OffsetNumber offnum;
370
371 /* Initialize first page of relation with special magic number */
372
373 buf = ExtendBufferedRel(BMR_REL(rel), forkNum, NULL,
376
377 page = BufferGetPage(buf);
378
381 sm->magic = SEQ_MAGIC;
382
383 /* Now insert sequence tuple */
384
385 /*
386 * Since VACUUM does not process sequences, we have to force the tuple to
387 * have xmin = FrozenTransactionId now. Otherwise it would become
388 * invisible to SELECTs after 2G transactions. It is okay to do this
389 * because if the current transaction aborts, no other xact will ever
390 * examine the sequence tuple anyway.
391 */
398
399 /* check the comment above nextval_internal()'s equivalent call. */
400 if (RelationNeedsWAL(rel))
402
404
406
407 offnum = PageAddItem(page, (Item) tuple->t_data, tuple->t_len,
408 InvalidOffsetNumber, false, false);
409 if (offnum != FirstOffsetNumber)
410 elog(ERROR, "failed to add sequence tuple to page");
411
412 /* XLOG stuff */
413 if (RelationNeedsWAL(rel) || forkNum == INIT_FORKNUM)
414 {
415 xl_seq_rec xlrec;
416 XLogRecPtr recptr;
417
420
421 xlrec.locator = rel->rd_locator;
422
423 XLogRegisterData(&xlrec, sizeof(xl_seq_rec));
424 XLogRegisterData(tuple->t_data, tuple->t_len);
425
426 recptr = XLogInsert(RM_SEQ_ID, XLOG_SEQ_LOG);
427
428 PageSetLSN(page, recptr);
429 }
430
432
434}
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:4198
Buffer ExtendBufferedRel(BufferManagerRelation bmr, ForkNumber forkNum, BufferAccessStrategy strategy, uint32 flags)
Definition: bufmgr.c:858
static Size BufferGetPageSize(Buffer buffer)
Definition: bufmgr.h:406
@ EB_SKIP_EXTENSION_LOCK
Definition: bufmgr.h:75
@ EB_LOCK_FIRST
Definition: bufmgr.h:87
#define BMR_REL(p_rel)
Definition: bufmgr.h:111
void PageInit(Page page, Size pageSize, Size specialSize)
Definition: bufpage.c:42
#define PageGetSpecialPointer(page)
Definition: bufpage.h:339
#define PageAddItem(page, item, size, offsetNumber, overwrite, is_heap)
Definition: bufpage.h:472
#define FirstCommandId
Definition: c.h:673
#define SEQ_MAGIC
Definition: sequence.c:64
static void HeapTupleHeaderSetXminFrozen(HeapTupleHeaderData *tup)
Definition: htup_details.h:370
static void HeapTupleHeaderSetCmin(HeapTupleHeaderData *tup, CommandId cid)
Definition: htup_details.h:422
#define HEAP_XMAX_INVALID
Definition: htup_details.h:208
static void HeapTupleHeaderSetXmin(HeapTupleHeaderData *tup, TransactionId xid)
Definition: htup_details.h:331
static void HeapTupleHeaderSetXmax(HeapTupleHeaderData *tup, TransactionId xid)
Definition: htup_details.h:383
Pointer Item
Definition: item.h:17
static void ItemPointerSet(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum)
Definition: itemptr.h:135
#define InvalidOffsetNumber
Definition: off.h:26
uint16 OffsetNumber
Definition: off.h:24
#define FirstOffsetNumber
Definition: off.h:27
@ INIT_FORKNUM
Definition: relpath.h:61
ItemPointerData t_ctid
Definition: htup_details.h:161
Definition: sequence.c:67
uint32 magic
Definition: sequence.c:68
#define FrozenTransactionId
Definition: transam.h:33

References Assert(), BMR_REL, buf, BufferGetBlockNumber(), BufferGetPage(), BufferGetPageSize(), EB_LOCK_FIRST, EB_SKIP_EXTENSION_LOCK, elog, END_CRIT_SECTION, ERROR, ExtendBufferedRel(), FirstCommandId, FirstOffsetNumber, FrozenTransactionId, GetTopTransactionId(), HEAP_XMAX_INVALID, HeapTupleHeaderSetCmin(), HeapTupleHeaderSetXmax(), HeapTupleHeaderSetXmin(), HeapTupleHeaderSetXminFrozen(), INIT_FORKNUM, InvalidOffsetNumber, InvalidTransactionId, ItemPointerSet(), xl_seq_rec::locator, 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 343 of file sequence.c.

344{
346
347 if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
348 {
349 SMgrRelation srel;
350
352 smgrcreate(srel, INIT_FORKNUM, false);
356 smgrclose(srel);
357 }
358}
void FlushRelationBuffers(Relation rel)
Definition: bufmgr.c:4908
static void fill_seq_fork_with_data(Relation rel, HeapTuple tuple, ForkNumber forkNum)
Definition: sequence.c:364
#define INVALID_PROC_NUMBER
Definition: procnumber.h:26
@ MAIN_FORKNUM
Definition: relpath.h:58
SMgrRelation smgropen(RelFileLocator rlocator, ProcNumber backend)
Definition: smgr.c:240
void smgrcreate(SMgrRelation reln, ForkNumber forknum, bool isRedo)
Definition: smgr.c:481
void smgrclose(SMgrRelation reln)
Definition: smgr.c:374
void log_smgrcreate(const RelFileLocator *rlocator, ForkNumber forkNum)
Definition: storage.c:187

References 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 1273 of file sequence.c.

1281{
1282 DefElem *as_type = NULL;
1283 DefElem *start_value = NULL;
1284 DefElem *restart_value = NULL;
1285 DefElem *increment_by = NULL;
1286 DefElem *max_value = NULL;
1287 DefElem *min_value = NULL;
1288 DefElem *cache_value = NULL;
1289 DefElem *is_cycled = NULL;
1291 bool reset_max_value = false;
1292 bool reset_min_value = false;
1293
1294 *need_seq_rewrite = false;
1295 *owned_by = NIL;
1296
1297 foreach(option, options)
1298 {
1299 DefElem *defel = (DefElem *) lfirst(option);
1300
1301 if (strcmp(defel->defname, "as") == 0)
1302 {
1303 if (as_type)
1304 errorConflictingDefElem(defel, pstate);
1305 as_type = defel;
1306 *need_seq_rewrite = true;
1307 }
1308 else if (strcmp(defel->defname, "increment") == 0)
1309 {
1310 if (increment_by)
1311 errorConflictingDefElem(defel, pstate);
1312 increment_by = defel;
1313 *need_seq_rewrite = true;
1314 }
1315 else if (strcmp(defel->defname, "start") == 0)
1316 {
1317 if (start_value)
1318 errorConflictingDefElem(defel, pstate);
1319 start_value = defel;
1320 *need_seq_rewrite = true;
1321 }
1322 else if (strcmp(defel->defname, "restart") == 0)
1323 {
1324 if (restart_value)
1325 errorConflictingDefElem(defel, pstate);
1326 restart_value = defel;
1327 *need_seq_rewrite = true;
1328 }
1329 else if (strcmp(defel->defname, "maxvalue") == 0)
1330 {
1331 if (max_value)
1332 errorConflictingDefElem(defel, pstate);
1333 max_value = defel;
1334 *need_seq_rewrite = true;
1335 }
1336 else if (strcmp(defel->defname, "minvalue") == 0)
1337 {
1338 if (min_value)
1339 errorConflictingDefElem(defel, pstate);
1340 min_value = defel;
1341 *need_seq_rewrite = true;
1342 }
1343 else if (strcmp(defel->defname, "cache") == 0)
1344 {
1345 if (cache_value)
1346 errorConflictingDefElem(defel, pstate);
1347 cache_value = defel;
1348 *need_seq_rewrite = true;
1349 }
1350 else if (strcmp(defel->defname, "cycle") == 0)
1351 {
1352 if (is_cycled)
1353 errorConflictingDefElem(defel, pstate);
1354 is_cycled = defel;
1355 *need_seq_rewrite = true;
1356 }
1357 else if (strcmp(defel->defname, "owned_by") == 0)
1358 {
1359 if (*owned_by)
1360 errorConflictingDefElem(defel, pstate);
1361 *owned_by = defGetQualifiedName(defel);
1362 }
1363 else if (strcmp(defel->defname, "sequence_name") == 0)
1364 {
1365 /*
1366 * The parser allows this, but it is only for identity columns, in
1367 * which case it is filtered out in parse_utilcmd.c. We only get
1368 * here if someone puts it into a CREATE SEQUENCE, where it'd be
1369 * redundant. (The same is true for the equally-nonstandard
1370 * LOGGED and UNLOGGED options, but for those, the default error
1371 * below seems sufficient.)
1372 */
1373 ereport(ERROR,
1374 (errcode(ERRCODE_SYNTAX_ERROR),
1375 errmsg("invalid sequence option SEQUENCE NAME"),
1376 parser_errposition(pstate, defel->location)));
1377 }
1378 else
1379 elog(ERROR, "option \"%s\" not recognized",
1380 defel->defname);
1381 }
1382
1383 /*
1384 * We must reset the state of the sequence when isInit or when changing
1385 * any parameters that would affect future nextval allocations.
1386 */
1387 if (isInit)
1388 *reset_state = true;
1389
1390 /* AS type */
1391 if (as_type != NULL)
1392 {
1393 Oid newtypid = typenameTypeId(pstate, defGetTypeName(as_type));
1394
1395 if (newtypid != INT2OID &&
1396 newtypid != INT4OID &&
1397 newtypid != INT8OID)
1398 ereport(ERROR,
1399 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1400 for_identity
1401 ? errmsg("identity column type must be smallint, integer, or bigint")
1402 : errmsg("sequence type must be smallint, integer, or bigint")));
1403
1404 if (!isInit)
1405 {
1406 /*
1407 * When changing type and the old sequence min/max values were the
1408 * min/max of the old type, adjust sequence min/max values to
1409 * min/max of new type. (Otherwise, the user chose explicit
1410 * min/max values, which we'll leave alone.)
1411 */
1412 if ((seqform->seqtypid == INT2OID && seqform->seqmax == PG_INT16_MAX) ||
1413 (seqform->seqtypid == INT4OID && seqform->seqmax == PG_INT32_MAX) ||
1414 (seqform->seqtypid == INT8OID && seqform->seqmax == PG_INT64_MAX))
1415 reset_max_value = true;
1416 if ((seqform->seqtypid == INT2OID && seqform->seqmin == PG_INT16_MIN) ||
1417 (seqform->seqtypid == INT4OID && seqform->seqmin == PG_INT32_MIN) ||
1418 (seqform->seqtypid == INT8OID && seqform->seqmin == PG_INT64_MIN))
1419 reset_min_value = true;
1420 }
1421
1422 seqform->seqtypid = newtypid;
1423 }
1424 else if (isInit)
1425 {
1426 seqform->seqtypid = INT8OID;
1427 }
1428
1429 /* INCREMENT BY */
1430 if (increment_by != NULL)
1431 {
1432 seqform->seqincrement = defGetInt64(increment_by);
1433 if (seqform->seqincrement == 0)
1434 ereport(ERROR,
1435 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1436 errmsg("INCREMENT must not be zero")));
1437 *reset_state = true;
1438 }
1439 else if (isInit)
1440 {
1441 seqform->seqincrement = 1;
1442 }
1443
1444 /* CYCLE */
1445 if (is_cycled != NULL)
1446 {
1447 seqform->seqcycle = boolVal(is_cycled->arg);
1448 Assert(BoolIsValid(seqform->seqcycle));
1449 *reset_state = true;
1450 }
1451 else if (isInit)
1452 {
1453 seqform->seqcycle = false;
1454 }
1455
1456 /* MAXVALUE (null arg means NO MAXVALUE) */
1457 if (max_value != NULL && max_value->arg)
1458 {
1459 seqform->seqmax = defGetInt64(max_value);
1460 *reset_state = true;
1461 }
1462 else if (isInit || max_value != NULL || reset_max_value)
1463 {
1464 if (seqform->seqincrement > 0 || reset_max_value)
1465 {
1466 /* ascending seq */
1467 if (seqform->seqtypid == INT2OID)
1468 seqform->seqmax = PG_INT16_MAX;
1469 else if (seqform->seqtypid == INT4OID)
1470 seqform->seqmax = PG_INT32_MAX;
1471 else
1472 seqform->seqmax = PG_INT64_MAX;
1473 }
1474 else
1475 seqform->seqmax = -1; /* descending seq */
1476 *reset_state = true;
1477 }
1478
1479 /* Validate maximum value. No need to check INT8 as seqmax is an int64 */
1480 if ((seqform->seqtypid == INT2OID && (seqform->seqmax < PG_INT16_MIN || seqform->seqmax > PG_INT16_MAX))
1481 || (seqform->seqtypid == INT4OID && (seqform->seqmax < PG_INT32_MIN || seqform->seqmax > PG_INT32_MAX)))
1482 ereport(ERROR,
1483 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1484 errmsg("MAXVALUE (%" PRId64 ") is out of range for sequence data type %s",
1485 seqform->seqmax,
1486 format_type_be(seqform->seqtypid))));
1487
1488 /* MINVALUE (null arg means NO MINVALUE) */
1489 if (min_value != NULL && min_value->arg)
1490 {
1491 seqform->seqmin = defGetInt64(min_value);
1492 *reset_state = true;
1493 }
1494 else if (isInit || min_value != NULL || reset_min_value)
1495 {
1496 if (seqform->seqincrement < 0 || reset_min_value)
1497 {
1498 /* descending seq */
1499 if (seqform->seqtypid == INT2OID)
1500 seqform->seqmin = PG_INT16_MIN;
1501 else if (seqform->seqtypid == INT4OID)
1502 seqform->seqmin = PG_INT32_MIN;
1503 else
1504 seqform->seqmin = PG_INT64_MIN;
1505 }
1506 else
1507 seqform->seqmin = 1; /* ascending seq */
1508 *reset_state = true;
1509 }
1510
1511 /* Validate minimum value. No need to check INT8 as seqmin is an int64 */
1512 if ((seqform->seqtypid == INT2OID && (seqform->seqmin < PG_INT16_MIN || seqform->seqmin > PG_INT16_MAX))
1513 || (seqform->seqtypid == INT4OID && (seqform->seqmin < PG_INT32_MIN || seqform->seqmin > PG_INT32_MAX)))
1514 ereport(ERROR,
1515 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1516 errmsg("MINVALUE (%" PRId64 ") is out of range for sequence data type %s",
1517 seqform->seqmin,
1518 format_type_be(seqform->seqtypid))));
1519
1520 /* crosscheck min/max */
1521 if (seqform->seqmin >= seqform->seqmax)
1522 ereport(ERROR,
1523 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1524 errmsg("MINVALUE (%" PRId64 ") must be less than MAXVALUE (%" PRId64 ")",
1525 seqform->seqmin,
1526 seqform->seqmax)));
1527
1528 /* START WITH */
1529 if (start_value != NULL)
1530 {
1531 seqform->seqstart = defGetInt64(start_value);
1532 }
1533 else if (isInit)
1534 {
1535 if (seqform->seqincrement > 0)
1536 seqform->seqstart = seqform->seqmin; /* ascending seq */
1537 else
1538 seqform->seqstart = seqform->seqmax; /* descending seq */
1539 }
1540
1541 /* crosscheck START */
1542 if (seqform->seqstart < seqform->seqmin)
1543 ereport(ERROR,
1544 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1545 errmsg("START value (%" PRId64 ") cannot be less than MINVALUE (%" PRId64 ")",
1546 seqform->seqstart,
1547 seqform->seqmin)));
1548 if (seqform->seqstart > seqform->seqmax)
1549 ereport(ERROR,
1550 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1551 errmsg("START value (%" PRId64 ") cannot be greater than MAXVALUE (%" PRId64 ")",
1552 seqform->seqstart,
1553 seqform->seqmax)));
1554
1555 /* RESTART [WITH] */
1556 if (restart_value != NULL)
1557 {
1558 if (restart_value->arg != NULL)
1559 *last_value = defGetInt64(restart_value);
1560 else
1561 *last_value = seqform->seqstart;
1562 *is_called = false;
1563 *reset_state = true;
1564 }
1565 else if (isInit)
1566 {
1567 *last_value = seqform->seqstart;
1568 *is_called = false;
1569 }
1570
1571 /* crosscheck RESTART (or current value, if changing MIN/MAX) */
1572 if (*last_value < seqform->seqmin)
1573 ereport(ERROR,
1574 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1575 errmsg("RESTART value (%" PRId64 ") cannot be less than MINVALUE (%" PRId64 ")",
1576 *last_value,
1577 seqform->seqmin)));
1578 if (*last_value > seqform->seqmax)
1579 ereport(ERROR,
1580 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1581 errmsg("RESTART value (%" PRId64 ") cannot be greater than MAXVALUE (%" PRId64 ")",
1582 *last_value,
1583 seqform->seqmax)));
1584
1585 /* CACHE */
1586 if (cache_value != NULL)
1587 {
1588 seqform->seqcache = defGetInt64(cache_value);
1589 if (seqform->seqcache <= 0)
1590 ereport(ERROR,
1591 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1592 errmsg("CACHE (%" PRId64 ") must be greater than zero",
1593 seqform->seqcache)));
1594 *reset_state = true;
1595 }
1596 else if (isInit)
1597 {
1598 seqform->seqcache = 1;
1599 }
1600}
#define PG_INT32_MAX
Definition: c.h:594
#define BoolIsValid(boolean)
Definition: c.h:762
#define PG_INT16_MIN
Definition: c.h:590
#define PG_INT64_MAX
Definition: c.h:597
#define PG_INT64_MIN
Definition: c.h:596
#define PG_INT32_MIN
Definition: c.h:593
#define PG_INT16_MAX
Definition: c.h:591
TypeName * defGetTypeName(DefElem *def)
Definition: define.c:271
List * defGetQualifiedName(DefElem *def)
Definition: define.c:239
int64 defGetInt64(DefElem *def)
Definition: define.c:173
void errorConflictingDefElem(DefElem *defel, ParseState *pstate)
Definition: define.c:371
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
Oid typenameTypeId(ParseState *pstate, const TypeName *typeName)
Definition: parse_type.c:291
#define lfirst(lc)
Definition: pg_list.h:172
char * defname
Definition: parsenodes.h:843
ParseLoc location
Definition: parsenodes.h:847
Node * arg
Definition: parsenodes.h:844
Definition: oid2name.c:30
Definition: pg_list.h:46
#define boolVal(v)
Definition: value.h:81

References DefElem::arg, Assert(), BoolIsValid, boolVal, defGetInt64(), defGetQualifiedName(), defGetTypeName(), DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, errorConflictingDefElem(), format_type_be(), lfirst, DefElem::location, 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 1143 of file sequence.c.

1144{
1145 SeqTable elm;
1146 Relation seqrel;
1147 bool found;
1148
1149 /* Find or create a hash table entry for this sequence */
1150 if (seqhashtab == NULL)
1152
1153 elm = (SeqTable) hash_search(seqhashtab, &relid, HASH_ENTER, &found);
1154
1155 /*
1156 * Initialize the new hash table entry if it did not exist already.
1157 *
1158 * NOTE: seqhashtab entries are stored for the life of a backend (unless
1159 * explicitly discarded with DISCARD). If the sequence itself is deleted
1160 * then the entry becomes wasted memory, but it's small enough that this
1161 * should not matter.
1162 */
1163 if (!found)
1164 {
1165 /* relid already filled in */
1168 elm->last_valid = false;
1169 elm->last = elm->cached = 0;
1170 }
1171
1172 /*
1173 * Open the sequence relation.
1174 */
1175 seqrel = lock_and_open_sequence(elm);
1176
1177 /*
1178 * If the sequence has been transactionally replaced since we last saw it,
1179 * discard any cached-but-unissued values. We do not touch the currval()
1180 * state, however.
1181 */
1182 if (seqrel->rd_rel->relfilenode != elm->filenumber)
1183 {
1184 elm->filenumber = seqrel->rd_rel->relfilenode;
1185 elm->cached = elm->last;
1186 }
1187
1188 /* Return results */
1189 *p_elm = elm;
1190 *p_rel = seqrel;
1191}
SeqTableData * SeqTable
Definition: sequence.c:90
static void create_seq_hashtable(void)
Definition: sequence.c:1127
static Relation lock_and_open_sequence(SeqTable seq)
Definition: sequence.c:1099
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:952
@ HASH_ENTER
Definition: hsearch.h:114
#define InvalidLocalTransactionId
Definition: lock.h:67
#define InvalidRelFileNumber
Definition: relpath.h:26
RelFileNumber filenumber
Definition: sequence.c:80
LocalTransactionId lxid
Definition: sequence.c:81

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

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

◆ lastval()

Datum lastval ( PG_FUNCTION_ARGS  )

Definition at line 911 of file sequence.c.

912{
913 Relation seqrel;
914 int64 result;
915
916 if (last_used_seq == NULL)
918 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
919 errmsg("lastval is not yet defined in this session")));
920
921 /* Someone may have dropped the sequence since the last nextval() */
924 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
925 errmsg("lastval is not yet defined in this session")));
926
928
929 /* nextval() must have already been called for this sequence */
931
935 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
936 errmsg("permission denied for sequence %s",
937 RelationGetRelationName(seqrel))));
938
939 result = last_used_seq->last;
940 sequence_close(seqrel, NoLock);
941
942 PG_RETURN_INT64(result);
943}
static SeqTableData * last_used_seq
Definition: sequence.c:98
#define SearchSysCacheExists1(cacheId, key1)
Definition: syscache.h:100

References ACL_SELECT, ACL_USAGE, ACLCHECK_OK, Assert(), ereport, errcode(), errmsg(), ERROR, 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 1099 of file sequence.c.

1100{
1101 LocalTransactionId thislxid = MyProc->vxid.lxid;
1102
1103 /* Get the lock if not already held in this xact */
1104 if (seq->lxid != thislxid)
1105 {
1106 ResourceOwner currentOwner;
1107
1108 currentOwner = CurrentResourceOwner;
1110
1112
1113 CurrentResourceOwner = currentOwner;
1114
1115 /* Flag that we have a lock in the current xact */
1116 seq->lxid = thislxid;
1117 }
1118
1119 /* We now know we have the lock, and can safely open the rel */
1120 return sequence_open(seq->relid, NoLock);
1121}
uint32 LocalTransactionId
Definition: c.h:659
void LockRelationOid(Oid relid, LOCKMODE lockmode)
Definition: lmgr.c:107
ResourceOwner TopTransactionResourceOwner
Definition: resowner.c:175
ResourceOwner CurrentResourceOwner
Definition: resowner.c:173
PGPROC * MyProc
Definition: proc.c:66
LocalTransactionId lxid
Definition: proc.h:217
struct PGPROC::@130 vxid

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

Referenced by init_sequence(), and lastval().

◆ nextval()

Datum nextval ( PG_FUNCTION_ARGS  )

Definition at line 607 of file sequence.c.

608{
609 text *seqin = PG_GETARG_TEXT_PP(0);
610 RangeVar *sequence;
611 Oid relid;
612
614
615 /*
616 * XXX: This is not safe in the presence of concurrent DDL, but acquiring
617 * a lock here is more expensive than letting nextval_internal do it,
618 * since the latter maintains a cache that keeps us from hitting the lock
619 * manager more than once per transaction. It's not clear whether the
620 * performance penalty is material in practice, but for now, we do it this
621 * way.
622 */
623 relid = RangeVarGetRelid(sequence, NoLock, false);
624
625 PG_RETURN_INT64(nextval_internal(relid, true));
626}
int64 nextval_internal(Oid relid, bool check_permissions)
Definition: sequence.c:637
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
RangeVar * makeRangeVarFromNameList(const List *names)
Definition: namespace.c:3624
#define RangeVarGetRelid(relation, lockmode, missing_ok)
Definition: namespace.h:98
Definition: c.h:692
List * textToQualifiedNameList(text *textval)
Definition: varlena.c:2686

References 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 637 of file sequence.c.

638{
639 SeqTable elm;
640 Relation seqrel;
641 Buffer buf;
642 Page page;
643 HeapTuple pgstuple;
644 Form_pg_sequence pgsform;
645 HeapTupleData seqdatatuple;
647 int64 incby,
648 maxv,
649 minv,
650 cache,
651 log,
652 fetch,
653 last;
654 int64 result,
655 next,
656 rescnt = 0;
657 bool cycle;
658 bool logit = false;
659
660 /* open and lock sequence */
661 init_sequence(relid, &elm, &seqrel);
662
663 if (check_permissions &&
667 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
668 errmsg("permission denied for sequence %s",
669 RelationGetRelationName(seqrel))));
670
671 /* read-only transactions may only modify temp sequences */
672 if (!seqrel->rd_islocaltemp)
673 PreventCommandIfReadOnly("nextval()");
674
675 /*
676 * Forbid this during parallel operation because, to make it work, the
677 * cooperating backends would need to share the backend-local cached
678 * sequence information. Currently, we don't support that.
679 */
680 PreventCommandIfParallelMode("nextval()");
681
682 if (elm->last != elm->cached) /* some numbers were cached */
683 {
684 Assert(elm->last_valid);
685 Assert(elm->increment != 0);
686 elm->last += elm->increment;
687 sequence_close(seqrel, NoLock);
688 last_used_seq = elm;
689 return elm->last;
690 }
691
692 pgstuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(relid));
693 if (!HeapTupleIsValid(pgstuple))
694 elog(ERROR, "cache lookup failed for sequence %u", relid);
695 pgsform = (Form_pg_sequence) GETSTRUCT(pgstuple);
696 incby = pgsform->seqincrement;
697 maxv = pgsform->seqmax;
698 minv = pgsform->seqmin;
699 cache = pgsform->seqcache;
700 cycle = pgsform->seqcycle;
701 ReleaseSysCache(pgstuple);
702
703 /* lock page buffer and read tuple */
704 seq = read_seq_tuple(seqrel, &buf, &seqdatatuple);
705 page = BufferGetPage(buf);
706
707 last = next = result = seq->last_value;
708 fetch = cache;
709 log = seq->log_cnt;
710
711 if (!seq->is_called)
712 {
713 rescnt++; /* return last_value if not is_called */
714 fetch--;
715 }
716
717 /*
718 * Decide whether we should emit a WAL log record. If so, force up the
719 * fetch count to grab SEQ_LOG_VALS more values than we actually need to
720 * cache. (These will then be usable without logging.)
721 *
722 * If this is the first nextval after a checkpoint, we must force a new
723 * WAL record to be written anyway, else replay starting from the
724 * checkpoint would fail to advance the sequence past the logged values.
725 * In this case we may as well fetch extra values.
726 */
727 if (log < fetch || !seq->is_called)
728 {
729 /* forced log to satisfy local demand for values */
730 fetch = log = fetch + SEQ_LOG_VALS;
731 logit = true;
732 }
733 else
734 {
735 XLogRecPtr redoptr = GetRedoRecPtr();
736
737 if (PageGetLSN(page) <= redoptr)
738 {
739 /* last update of seq was before checkpoint */
740 fetch = log = fetch + SEQ_LOG_VALS;
741 logit = true;
742 }
743 }
744
745 while (fetch) /* try to fetch cache [+ log ] numbers */
746 {
747 /*
748 * Check MAXVALUE for ascending sequences and MINVALUE for descending
749 * sequences
750 */
751 if (incby > 0)
752 {
753 /* ascending sequence */
754 if ((maxv >= 0 && next > maxv - incby) ||
755 (maxv < 0 && next + incby > maxv))
756 {
757 if (rescnt > 0)
758 break; /* stop fetching */
759 if (!cycle)
761 (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
762 errmsg("nextval: reached maximum value of sequence \"%s\" (%" PRId64 ")",
764 maxv)));
765 next = minv;
766 }
767 else
768 next += incby;
769 }
770 else
771 {
772 /* descending sequence */
773 if ((minv < 0 && next < minv - incby) ||
774 (minv >= 0 && next + incby < minv))
775 {
776 if (rescnt > 0)
777 break; /* stop fetching */
778 if (!cycle)
780 (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
781 errmsg("nextval: reached minimum value of sequence \"%s\" (%" PRId64 ")",
783 minv)));
784 next = maxv;
785 }
786 else
787 next += incby;
788 }
789 fetch--;
790 if (rescnt < cache)
791 {
792 log--;
793 rescnt++;
794 last = next;
795 if (rescnt == 1) /* if it's first result - */
796 result = next; /* it's what to return */
797 }
798 }
799
800 log -= fetch; /* adjust for any unfetched numbers */
801 Assert(log >= 0);
802
803 /* save info in local cache */
804 elm->increment = incby;
805 elm->last = result; /* last returned number */
806 elm->cached = last; /* last fetched number */
807 elm->last_valid = true;
808
809 last_used_seq = elm;
810
811 /*
812 * If something needs to be WAL logged, acquire an xid, so this
813 * transaction's commit will trigger a WAL flush and wait for syncrep.
814 * It's sufficient to ensure the toplevel transaction has an xid, no need
815 * to assign xids subxacts, that'll already trigger an appropriate wait.
816 * (Have to do that here, so we're outside the critical section)
817 */
818 if (logit && RelationNeedsWAL(seqrel))
820
821 /* ready to change the on-disk (or really, in-buffer) tuple */
823
824 /*
825 * We must mark the buffer dirty before doing XLogInsert(); see notes in
826 * SyncOneBuffer(). However, we don't apply the desired changes just yet.
827 * This looks like a violation of the buffer update protocol, but it is in
828 * fact safe because we hold exclusive lock on the buffer. Any other
829 * process, including a checkpoint, that tries to examine the buffer
830 * contents will block until we release the lock, and then will see the
831 * final state that we install below.
832 */
834
835 /* XLOG stuff */
836 if (logit && RelationNeedsWAL(seqrel))
837 {
838 xl_seq_rec xlrec;
839 XLogRecPtr recptr;
840
841 /*
842 * We don't log the current state of the tuple, but rather the state
843 * as it would appear after "log" more fetches. This lets us skip
844 * that many future WAL records, at the cost that we lose those
845 * sequence values if we crash.
846 */
849
850 /* set values that will be saved in xlog */
851 seq->last_value = next;
852 seq->is_called = true;
853 seq->log_cnt = 0;
854
855 xlrec.locator = seqrel->rd_locator;
856
857 XLogRegisterData(&xlrec, sizeof(xl_seq_rec));
858 XLogRegisterData(seqdatatuple.t_data, seqdatatuple.t_len);
859
860 recptr = XLogInsert(RM_SEQ_ID, XLOG_SEQ_LOG);
861
862 PageSetLSN(page, recptr);
863 }
864
865 /* Now update sequence tuple to the intended final state */
866 seq->last_value = last; /* last fetched number */
867 seq->is_called = true;
868 seq->log_cnt = log; /* how much is logged */
869
871
873
874 sequence_close(seqrel, NoLock);
875
876 return result;
877}
static XLogRecPtr PageGetLSN(const PageData *page)
Definition: bufpage.h:386
#define SEQ_LOG_VALS
Definition: sequence.c:59
int64 increment
Definition: sequence.c:86
XLogRecPtr GetRedoRecPtr(void)
Definition: xlog.c:6489

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, RelationGetRelationName, RelationNeedsWAL, ReleaseSysCache(), SeqTableData::relid, SearchSysCache1(), SEQ_LOG_VALS, sequence_close(), 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().

◆ nextval_oid()

Datum nextval_oid ( PG_FUNCTION_ARGS  )

Definition at line 629 of file sequence.c.

630{
631 Oid relid = PG_GETARG_OID(0);
632
633 PG_RETURN_INT64(nextval_internal(relid, true));
634}

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 1805 of file sequence.c.

1806{
1807#define PG_GET_SEQUENCE_DATA_COLS 3
1808 Oid relid = PG_GETARG_OID(0);
1809 SeqTable elm;
1810 Relation seqrel;
1812 bool isnull[PG_GET_SEQUENCE_DATA_COLS] = {0};
1813 TupleDesc resultTupleDesc;
1814 HeapTuple resultHeapTuple;
1815 Datum result;
1816
1818 TupleDescInitEntry(resultTupleDesc, (AttrNumber) 1, "last_value",
1819 INT8OID, -1, 0);
1820 TupleDescInitEntry(resultTupleDesc, (AttrNumber) 2, "is_called",
1821 BOOLOID, -1, 0);
1822 TupleDescInitEntry(resultTupleDesc, (AttrNumber) 3, "page_lsn",
1823 LSNOID, -1, 0);
1824 resultTupleDesc = BlessTupleDesc(resultTupleDesc);
1825
1826 init_sequence(relid, &elm, &seqrel);
1827
1828 /*
1829 * Return all NULLs for sequences for which we lack privileges, other
1830 * sessions' temporary sequences, and unlogged sequences on standbys.
1831 */
1833 !RELATION_IS_OTHER_TEMP(seqrel) &&
1835 {
1836 Buffer buf;
1837 HeapTupleData seqtuple;
1839 Page page;
1840
1841 seq = read_seq_tuple(seqrel, &buf, &seqtuple);
1842 page = BufferGetPage(buf);
1843
1844 values[0] = Int64GetDatum(seq->last_value);
1845 values[1] = BoolGetDatum(seq->is_called);
1846 values[2] = LSNGetDatum(PageGetLSN(page));
1847
1849 }
1850 else
1851 memset(isnull, true, sizeof(isnull));
1852
1853 sequence_close(seqrel, NoLock);
1854
1855 resultHeapTuple = heap_form_tuple(resultTupleDesc, values, isnull);
1856 result = HeapTupleGetDatum(resultHeapTuple);
1857 PG_RETURN_DATUM(result);
1858#undef PG_GET_SEQUENCE_DATA_COLS
1859}
int16 AttrNumber
Definition: attnum.h:21
static Datum values[MAXATTR]
Definition: bootstrap.c:153
#define PG_GET_SEQUENCE_DATA_COLS
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
Definition: execTuples.c:2260
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:353
static Datum HeapTupleGetDatum(const HeapTupleData *tuple)
Definition: funcapi.h:230
static Datum LSNGetDatum(XLogRecPtr X)
Definition: pg_lsn.h:31
#define RELATION_IS_OTHER_TEMP(relation)
Definition: rel.h:667
#define RelationIsPermanent(relation)
Definition: rel.h:626
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:182
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:842
bool RecoveryInProgress(void)
Definition: xlog.c:6386

References ACL_SELECT, ACLCHECK_OK, BlessTupleDesc(), BoolGetDatum(), buf, BufferGetPage(), CreateTemplateTupleDesc(), GetUserId(), heap_form_tuple(), HeapTupleGetDatum(), init_sequence(), Int64GetDatum(), FormData_pg_sequence_data::is_called, FormData_pg_sequence_data::last_value, LSNGetDatum(), NoLock, PageGetLSN(), pg_class_aclcheck(), PG_GET_SEQUENCE_DATA_COLS, PG_GETARG_OID, PG_RETURN_DATUM, read_seq_tuple(), RecoveryInProgress(), RELATION_IS_OTHER_TEMP, RelationIsPermanent, sequence_close(), TupleDescInitEntry(), UnlockReleaseBuffer(), and values.

◆ pg_sequence_last_value()

Datum pg_sequence_last_value ( PG_FUNCTION_ARGS  )

Definition at line 1868 of file sequence.c.

1869{
1870 Oid relid = PG_GETARG_OID(0);
1871 SeqTable elm;
1872 Relation seqrel;
1873 bool is_called = false;
1874 int64 result = 0;
1875
1876 /* open and lock sequence */
1877 init_sequence(relid, &elm, &seqrel);
1878
1879 /*
1880 * We return NULL for other sessions' temporary sequences. The
1881 * pg_sequences system view already filters those out, but this offers a
1882 * defense against ERRORs in case someone invokes this function directly.
1883 *
1884 * Also, for the benefit of the pg_sequences view, we return NULL for
1885 * unlogged sequences on standbys and for sequences for which the current
1886 * user lacks privileges instead of throwing an error.
1887 */
1889 !RELATION_IS_OTHER_TEMP(seqrel) &&
1891 {
1892 Buffer buf;
1893 HeapTupleData seqtuple;
1895
1896 seq = read_seq_tuple(seqrel, &buf, &seqtuple);
1897
1898 is_called = seq->is_called;
1899 result = seq->last_value;
1900
1902 }
1903 sequence_close(seqrel, NoLock);
1904
1905 if (is_called)
1906 PG_RETURN_INT64(result);
1907 else
1909}
#define PG_RETURN_NULL()
Definition: fmgr.h:345

References ACL_SELECT, ACL_USAGE, ACLCHECK_OK, buf, GetUserId(), init_sequence(), FormData_pg_sequence_data::is_called, FormData_pg_sequence_data::last_value, 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 1759 of file sequence.c.

1760{
1761 Oid relid = PG_GETARG_OID(0);
1762 TupleDesc tupdesc;
1763 Datum values[7];
1764 bool isnull[7];
1765 HeapTuple pgstuple;
1766 Form_pg_sequence pgsform;
1767
1769 ereport(ERROR,
1770 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
1771 errmsg("permission denied for sequence %s",
1772 get_rel_name(relid))));
1773
1774 if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
1775 elog(ERROR, "return type must be a row type");
1776
1777 memset(isnull, 0, sizeof(isnull));
1778
1779 pgstuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(relid));
1780 if (!HeapTupleIsValid(pgstuple))
1781 elog(ERROR, "cache lookup failed for sequence %u", relid);
1782 pgsform = (Form_pg_sequence) GETSTRUCT(pgstuple);
1783
1784 values[0] = Int64GetDatum(pgsform->seqstart);
1785 values[1] = Int64GetDatum(pgsform->seqmin);
1786 values[2] = Int64GetDatum(pgsform->seqmax);
1787 values[3] = Int64GetDatum(pgsform->seqincrement);
1788 values[4] = BoolGetDatum(pgsform->seqcycle);
1789 values[5] = Int64GetDatum(pgsform->seqcache);
1790 values[6] = ObjectIdGetDatum(pgsform->seqtypid);
1791
1792 ReleaseSysCache(pgstuple);
1793
1794 return HeapTupleGetDatum(heap_form_tuple(tupdesc, values, isnull));
1795}
TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo, Oid *resultTypeId, TupleDesc *resultTupleDesc)
Definition: funcapi.c:276
@ TYPEFUNC_COMPOSITE
Definition: funcapi.h:149
char * get_rel_name(Oid relid)
Definition: lsyscache.c:2095

References ACL_SELECT, ACL_UPDATE, ACL_USAGE, ACLCHECK_OK, BoolGetDatum(), elog, ereport, errcode(), errmsg(), ERROR, 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 1611 of file sequence.c.

1612{
1613 DependencyType deptype;
1614 int nnames;
1615 Relation tablerel;
1617
1618 deptype = for_identity ? DEPENDENCY_INTERNAL : DEPENDENCY_AUTO;
1619
1620 nnames = list_length(owned_by);
1621 Assert(nnames > 0);
1622 if (nnames == 1)
1623 {
1624 /* Must be OWNED BY NONE */
1625 if (strcmp(strVal(linitial(owned_by)), "none") != 0)
1626 ereport(ERROR,
1627 (errcode(ERRCODE_SYNTAX_ERROR),
1628 errmsg("invalid OWNED BY option"),
1629 errhint("Specify OWNED BY table.column or OWNED BY NONE.")));
1630 tablerel = NULL;
1631 attnum = 0;
1632 }
1633 else
1634 {
1635 List *relname;
1636 char *attrname;
1637 RangeVar *rel;
1638
1639 /* Separate relname and attr name */
1640 relname = list_copy_head(owned_by, nnames - 1);
1641 attrname = strVal(llast(owned_by));
1642
1643 /* Open and lock rel to ensure it won't go away meanwhile */
1645 tablerel = relation_openrv(rel, AccessShareLock);
1646
1647 /* Must be a regular or foreign table */
1648 if (!(tablerel->rd_rel->relkind == RELKIND_RELATION ||
1649 tablerel->rd_rel->relkind == RELKIND_FOREIGN_TABLE ||
1650 tablerel->rd_rel->relkind == RELKIND_VIEW ||
1651 tablerel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE))
1652 ereport(ERROR,
1653 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1654 errmsg("sequence cannot be owned by relation \"%s\"",
1655 RelationGetRelationName(tablerel)),
1656 errdetail_relkind_not_supported(tablerel->rd_rel->relkind)));
1657
1658 /* We insist on same owner and schema */
1659 if (seqrel->rd_rel->relowner != tablerel->rd_rel->relowner)
1660 ereport(ERROR,
1661 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1662 errmsg("sequence must have same owner as table it is linked to")));
1663 if (RelationGetNamespace(seqrel) != RelationGetNamespace(tablerel))
1664 ereport(ERROR,
1665 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1666 errmsg("sequence must be in same schema as table it is linked to")));
1667
1668 /* Now, fetch the attribute number from the system cache */
1669 attnum = get_attnum(RelationGetRelid(tablerel), attrname);
1671 ereport(ERROR,
1672 (errcode(ERRCODE_UNDEFINED_COLUMN),
1673 errmsg("column \"%s\" of relation \"%s\" does not exist",
1674 attrname, RelationGetRelationName(tablerel))));
1675 }
1676
1677 /*
1678 * Catch user explicitly running OWNED BY on identity sequence.
1679 */
1680 if (deptype == DEPENDENCY_AUTO)
1681 {
1682 Oid tableId;
1683 int32 colId;
1684
1685 if (sequenceIsOwned(RelationGetRelid(seqrel), DEPENDENCY_INTERNAL, &tableId, &colId))
1686 ereport(ERROR,
1687 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1688 errmsg("cannot change ownership of identity sequence"),
1689 errdetail("Sequence \"%s\" is linked to table \"%s\".",
1691 get_rel_name(tableId))));
1692 }
1693
1694 /*
1695 * OK, we are ready to update pg_depend. First remove any existing
1696 * dependencies for the sequence, then optionally add a new one.
1697 */
1698 deleteDependencyRecordsForClass(RelationRelationId, RelationGetRelid(seqrel),
1699 RelationRelationId, deptype);
1700
1701 if (tablerel)
1702 {
1703 ObjectAddress refobject,
1704 depobject;
1705
1706 refobject.classId = RelationRelationId;
1707 refobject.objectId = RelationGetRelid(tablerel);
1708 refobject.objectSubId = attnum;
1709 depobject.classId = RelationRelationId;
1710 depobject.objectId = RelationGetRelid(seqrel);
1711 depobject.objectSubId = 0;
1712 recordDependencyOn(&depobject, &refobject, deptype);
1713 }
1714
1715 /* Done, but hold lock until commit */
1716 if (tablerel)
1717 relation_close(tablerel, NoLock);
1718}
#define InvalidAttrNumber
Definition: attnum.h:23
int32_t int32
Definition: c.h:534
DependencyType
Definition: dependency.h:32
@ DEPENDENCY_AUTO
Definition: dependency.h:34
@ DEPENDENCY_INTERNAL
Definition: dependency.h:35
int errdetail(const char *fmt,...)
Definition: elog.c:1207
int errhint(const char *fmt,...)
Definition: elog.c:1321
List * list_copy_head(const List *oldlist, int len)
Definition: list.c:1593
#define AccessShareLock
Definition: lockdefs.h:36
AttrNumber get_attnum(Oid relid, const char *attname)
Definition: lsyscache.c:951
int16 attnum
Definition: pg_attribute.h:74
int errdetail_relkind_not_supported(char relkind)
Definition: pg_class.c:24
NameData relname
Definition: pg_class.h:38
void recordDependencyOn(const ObjectAddress *depender, const ObjectAddress *referenced, DependencyType behavior)
Definition: pg_depend.c:45
long deleteDependencyRecordsForClass(Oid classId, Oid objectId, Oid refclassId, char deptype)
Definition: pg_depend.c:351
bool sequenceIsOwned(Oid seqId, char deptype, Oid *tableId, int32 *colId)
Definition: pg_depend.c:828
#define llast(l)
Definition: pg_list.h:198
static int list_length(const List *l)
Definition: pg_list.h:152
#define linitial(l)
Definition: pg_list.h:178
#define RelationGetRelid(relation)
Definition: rel.h:514
#define RelationGetNamespace(relation)
Definition: rel.h:555
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:205
Relation relation_openrv(const RangeVar *relation, LOCKMODE lockmode)
Definition: relation.c:137
int32 objectSubId
Definition: objectaddress.h:28
#define strVal(v)
Definition: value.h:82

References AccessShareLock, Assert(), attnum, ObjectAddress::classId, deleteDependencyRecordsForClass(), DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, ereport, errcode(), errdetail(), errdetail_relkind_not_supported(), errhint(), errmsg(), ERROR, get_attnum(), get_rel_name(), InvalidAttrNumber, linitial, list_copy_head(), list_length(), llast, makeRangeVarFromNameList(), NoLock, ObjectAddress::objectId, ObjectAddress::objectSubId, RelationData::rd_rel, 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 1204 of file sequence.c.

1205{
1206 Page page;
1207 ItemId lp;
1208 sequence_magic *sm;
1210
1211 *buf = ReadBuffer(rel, 0);
1213
1214 page = BufferGetPage(*buf);
1216
1217 if (sm->magic != SEQ_MAGIC)
1218 elog(ERROR, "bad magic number in sequence \"%s\": %08X",
1219 RelationGetRelationName(rel), sm->magic);
1220
1221 lp = PageGetItemId(page, FirstOffsetNumber);
1223
1224 /* Note we currently only bother to set these two fields of *seqdatatuple */
1225 seqdatatuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
1226 seqdatatuple->t_len = ItemIdGetLength(lp);
1227
1228 /*
1229 * Previous releases of Postgres neglected to prevent SELECT FOR UPDATE on
1230 * a sequence, which would leave a non-frozen XID in the sequence tuple's
1231 * xmax, which eventually leads to clog access failures or worse. If we
1232 * see this has happened, clean up after it. We treat this like a hint
1233 * bit update, ie, don't bother to WAL-log it, since we can certainly do
1234 * this again if the update gets lost.
1235 */
1236 Assert(!(seqdatatuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI));
1238 {
1240 seqdatatuple->t_data->t_infomask &= ~HEAP_XMAX_COMMITTED;
1241 seqdatatuple->t_data->t_infomask |= HEAP_XMAX_INVALID;
1242 MarkBufferDirtyHint(*buf, true);
1243 }
1244
1245 seq = (Form_pg_sequence_data) GETSTRUCT(seqdatatuple);
1246
1247 return seq;
1248}
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:5572
void MarkBufferDirtyHint(Buffer buffer, bool buffer_std)
Definition: bufmgr.c:5402
Buffer ReadBuffer(Relation reln, BlockNumber blockNum)
Definition: bufmgr.c:758
#define BUFFER_LOCK_EXCLUSIVE
Definition: bufmgr.h:198
static Item PageGetItem(const PageData *page, const ItemIdData *itemId)
Definition: bufpage.h:354
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:244
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
static TransactionId HeapTupleHeaderGetRawXmax(const HeapTupleHeaderData *tup)
Definition: htup_details.h:377
#define HEAP_XMAX_IS_MULTI
Definition: htup_details.h:209
#define ItemIdGetLength(itemId)
Definition: itemid.h:59
#define ItemIdIsNormal(itemId)
Definition: itemid.h:99
Definition: itemid.h:26

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

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

◆ ResetSequence()

void ResetSequence ( Oid  seq_relid )

Definition at line 267 of file sequence.c.

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

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(), RelationSetNewRelfilenumber(), ReleaseSysCache(), SearchSysCache1(), sequence_close(), and UnlockReleaseBuffer().

Referenced by ExecuteTruncateGuts().

◆ ResetSequenceCaches()

void ResetSequenceCaches ( void  )

Definition at line 1966 of file sequence.c.

1967{
1968 if (seqhashtab)
1969 {
1971 seqhashtab = NULL;
1972 }
1973
1974 last_used_seq = NULL;
1975}
void hash_destroy(HTAB *hashp)
Definition: dynahash.c:865

References hash_destroy(), last_used_seq, and seqhashtab.

Referenced by DiscardAll(), and DiscardCommand().

◆ seq_mask()

void seq_mask ( char *  page,
BlockNumber  blkno 
)

Definition at line 1981 of file sequence.c.

1982{
1984
1985 mask_unused_space(page);
1986}
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 1913 of file sequence.c.

1914{
1915 XLogRecPtr lsn = record->EndRecPtr;
1916 uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
1917 Buffer buffer;
1918 Page page;
1919 Page localpage;
1920 char *item;
1921 Size itemsz;
1922 xl_seq_rec *xlrec = (xl_seq_rec *) XLogRecGetData(record);
1923 sequence_magic *sm;
1924
1925 if (info != XLOG_SEQ_LOG)
1926 elog(PANIC, "seq_redo: unknown op code %u", info);
1927
1928 buffer = XLogInitBufferForRedo(record, 0);
1929 page = BufferGetPage(buffer);
1930
1931 /*
1932 * We always reinit the page. However, since this WAL record type is also
1933 * used for updating sequences, it's possible that a hot-standby backend
1934 * is examining the page concurrently; so we mustn't transiently trash the
1935 * buffer. The solution is to build the correct new page contents in
1936 * local workspace and then memcpy into the buffer. Then only bytes that
1937 * are supposed to change will change, even transiently. We must palloc
1938 * the local page for alignment reasons.
1939 */
1940 localpage = (Page) palloc(BufferGetPageSize(buffer));
1941
1942 PageInit(localpage, BufferGetPageSize(buffer), sizeof(sequence_magic));
1943 sm = (sequence_magic *) PageGetSpecialPointer(localpage);
1944 sm->magic = SEQ_MAGIC;
1945
1946 item = (char *) xlrec + sizeof(xl_seq_rec);
1947 itemsz = XLogRecGetDataLen(record) - sizeof(xl_seq_rec);
1948
1949 if (PageAddItem(localpage, (Item) item, itemsz,
1950 FirstOffsetNumber, false, false) == InvalidOffsetNumber)
1951 elog(PANIC, "seq_redo: failed to add item to page");
1952
1953 PageSetLSN(localpage, lsn);
1954
1955 memcpy(page, localpage, BufferGetPageSize(buffer));
1956 MarkBufferDirty(buffer);
1957 UnlockReleaseBuffer(buffer);
1958
1959 pfree(localpage);
1960}
uint8_t uint8
Definition: c.h:536
size_t Size
Definition: c.h:610
struct xl_seq_rec xl_seq_rec
#define PANIC
Definition: elog.h:42
void pfree(void *pointer)
Definition: mcxt.c:1594
void * palloc(Size size)
Definition: mcxt.c:1365
XLogRecPtr EndRecPtr
Definition: xlogreader.h:207
#define XLogRecGetDataLen(decoder)
Definition: xlogreader.h:416
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:410
#define XLogRecGetData(decoder)
Definition: xlogreader.h:415
Buffer XLogInitBufferForRedo(XLogReaderState *record, uint8 block_id)
Definition: xlogutils.c:315

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, and XLogRecGetInfo.

◆ sequence_options()

List * sequence_options ( Oid  relid )

Definition at line 1725 of file sequence.c.

1726{
1727 HeapTuple pgstuple;
1728 Form_pg_sequence pgsform;
1729 List *options = NIL;
1730
1731 pgstuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(relid));
1732 if (!HeapTupleIsValid(pgstuple))
1733 elog(ERROR, "cache lookup failed for sequence %u", relid);
1734 pgsform = (Form_pg_sequence) GETSTRUCT(pgstuple);
1735
1736 /* Use makeFloat() for 64-bit integers, like gram.y does. */
1738 makeDefElem("cache", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqcache)), -1));
1740 makeDefElem("cycle", (Node *) makeBoolean(pgsform->seqcycle), -1));
1742 makeDefElem("increment", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqincrement)), -1));
1744 makeDefElem("maxvalue", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqmax)), -1));
1746 makeDefElem("minvalue", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqmin)), -1));
1748 makeDefElem("start", (Node *) makeFloat(psprintf(INT64_FORMAT, pgsform->seqstart)), -1));
1749
1750 ReleaseSysCache(pgstuple);
1751
1752 return options;
1753}
#define INT64_FORMAT
Definition: c.h:556
DefElem * makeDefElem(char *name, Node *arg, int location)
Definition: makefuncs.c:637
static char ** options
Definition: pg_recvlogical.c:59
char * psprintf(const char *fmt,...)
Definition: psprintf.c:43
Definition: nodes.h:135
Float * makeFloat(char *numericStr)
Definition: value.c:37
Boolean * makeBoolean(bool val)
Definition: value.c:49

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 555 of file sequence.c.

556{
557 SeqTable elm;
558 Relation seqrel;
559 Buffer buf;
560 HeapTupleData seqdatatuple;
561
562 /*
563 * ALTER SEQUENCE acquires this lock earlier. If we're processing an
564 * owned sequence for ALTER TABLE, lock now. Without the lock, we'd
565 * discard increments from nextval() calls (in other sessions) between
566 * this function's buffer unlock and this transaction's commit.
567 */
569 init_sequence(relid, &elm, &seqrel);
570
571 /* check the comment above nextval_internal()'s equivalent call. */
572 if (RelationNeedsWAL(seqrel))
574
575 (void) read_seq_tuple(seqrel, &buf, &seqdatatuple);
576 RelationSetNewRelfilenumber(seqrel, newrelpersistence);
577 fill_seq_with_data(seqrel, &seqdatatuple);
579
580 sequence_close(seqrel, NoLock);
581}

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

Referenced by ATRewriteTables().

◆ setval3_oid()

Datum setval3_oid ( PG_FUNCTION_ARGS  )

Definition at line 1078 of file sequence.c.

1079{
1080 Oid relid = PG_GETARG_OID(0);
1082 bool iscalled = PG_GETARG_BOOL(2);
1083
1084 do_setval(relid, next, iscalled);
1085
1087}
static void do_setval(Oid relid, int64 next, bool iscalled)
Definition: sequence.c:959
#define PG_GETARG_INT64(n)
Definition: fmgr.h:283
#define PG_GETARG_BOOL(n)
Definition: fmgr.h:274

References do_setval(), next, PG_GETARG_BOOL, PG_GETARG_INT64, PG_GETARG_OID, and PG_RETURN_INT64.

◆ setval_oid()

Datum setval_oid ( PG_FUNCTION_ARGS  )

Definition at line 1063 of file sequence.c.

1064{
1065 Oid relid = PG_GETARG_OID(0);
1067
1068 do_setval(relid, next, true);
1069
1071}

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

Variable Documentation

◆ last_used_seq

SeqTableData* last_used_seq = NULL
static

Definition at line 98 of file sequence.c.

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

◆ seqhashtab

HTAB* seqhashtab = NULL
static

Definition at line 92 of file sequence.c.

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

AltStyle によって変換されたページ (->オリジナル) /