Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1s0Ey9-002HUq-MV for pgsql-hackers@arkaria.postgresql.org; Fri, 26 Apr 2024 06:22:02 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.94.2) (envelope-from ) id 1s0Ey7-007DjM-2L for pgsql-hackers@arkaria.postgresql.org; Fri, 26 Apr 2024 06:21:59 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1s0Ey5-007Dj9-4J for pgsql-hackers@lists.postgresql.org; Fri, 26 Apr 2024 06:21:59 +0000 Received: from fhigh7-smtp.messagingengine.com ([103.168.172.158]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1s0Exv-00084H-LC for pgsql-hackers@lists.postgresql.org; Fri, 26 Apr 2024 06:21:57 +0000 Received: from compute2.internal (compute2.nyi.internal [10.202.2.46]) by mailfhigh.nyi.internal (Postfix) with ESMTP id A71ED1140106; Fri, 26 Apr 2024 02:21:44 -0400 (EDT) Received: from mailfrontend2 ([10.202.2.163]) by compute2.internal (MEProxy); Fri, 26 Apr 2024 02:21:44 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=paquier.xyz; h= cc:cc:content-type:content-type:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:subject :subject:to:to; s=fm3; t=1714112504; x=1714198904; bh=FBBmimH8yo nZvArchWYLsu3r++LNZ4PnzFakPjBT4PA=; b=Mv1VEzZocTlg8CWiVQ+kBx4CLg uNfd03wd0NtSLgWkMm6n27Qxrwpik616D/Iy7aOIRrTPgo+ekKzH2j/Z12j2xVLW 64k2s2sGJWDM8ZWDzKlUZtqjXQBo2BbrSQB1gjpnAke/8OgTJxaws9Bi4pNx4NkU FxO/jjMi50VEtvthuePwb/8OmJgxNZ25VVUj5nrB4WSmEnOkmBjn1ZWUCU0J4sVG vLpUWhk7ko4SAGQbKLrcxFzVx493vP31WEE3qvj/rAfZGOqM3V2ePOrEkBLhTsNz Bc3eaBEAp0AatjcBmVIVHumxindvNiJvTS+DZjLGL/Pm7Hnnf6Fl6j14yG4Q== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-type:content-type:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:subject:subject:to :to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s= fm3; t=1714112504; x=1714198904; bh=FBBmimH8yonZvArchWYLsu3r++LN Z4PnzFakPjBT4PA=; b=jDClavWmUJAyNAxN+HdOcVWyYL8M0PXA0ZmnQiwqJ5sD +XtyKfMS3cxQ0FTYr7UH7AIyznNWmT098LEr+wSJni28PCnJ/mL9GtlPvm7v7osF MYfdD2SoB7sOHSgNRlYDp74BebXBH4CfAuPWGDUSIHVk3LqG27Q1QeQtJ9vfqBx6 ubqdj5BBtNHrUs5ZeXggcscLWo4RgvkLl/tbWWS197rzatSDKKsuABsbbysKwCM+ fUkiSZMN7VvJV+7oGlny2Hns/Z9Pq7xjUQSEeic/Lnx+sGCpNfXHhCT2nr9p/eSD fVg7JlkyDyXD0czjdAWd34SH3DcfanXxZtO+Z9qjDw== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvledrudelkedgleekucetufdoteggodetrfdotf fvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfqfgfvpdfurfetoffkrfgpnffqhgen uceurghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmne gfrhhlucfvnfffucdlfeehmdenucfjughrpeffhffvvefukfhfgggtuggjsehgtderredt tddvnecuhfhrohhmpefoihgthhgrvghlucfrrghquhhivghruceomhhitghhrggvlhesph grqhhuihgvrhdrgiihiieqnecuggftrfgrthhtvghrnhepjeejtdelleeggeelffduhfej tdeuvdekkeethffhuedvvdeuudeugeefudevtdeinecuffhomhgrihhnpehgihhthhhusg drtghomhenucevlhhushhtvghrufhiiigvpedtnecurfgrrhgrmhepmhgrihhlfhhrohhm pehmihgthhgrvghlsehprghquhhivghrrdighiii X-ME-Proxy: Feedback-ID: i0fe9450f:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Fri, 26 Apr 2024 02:21:41 -0400 (EDT) Date: Fri, 26 Apr 2024 15:21:29 +0900 From: Michael Paquier To: Peter Eisentraut Cc: Tomas Vondra , Peter Smith , Postgres hackers Subject: Re: Sequence Access Methods, round two Message-ID: References: MIME-Version: 1.0 Content-Type: multipart/signed; micalg=pgp-sha512; protocol="application/pgp-signature"; boundary="kkepPBWX+YAe7BPK" Content-Disposition: inline In-Reply-To: List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --kkepPBWX+YAe7BPK Content-Type: multipart/mixed; boundary="Hb9lJVq6MVTkbU7F" Content-Disposition: inline --Hb9lJVq6MVTkbU7F Content-Type: text/plain; charset=us-ascii Content-Disposition: inline On Fri, Apr 19, 2024 at 04:00:28PM +0900, Michael Paquier wrote: > I have plans to rework this patch set for the next commit fest, > and this includes some investigation about custom data types that > could be plugged into these AMs. So, I have worked more on this patch set, and finished by reorganizing it more, with more things: - The in-core sequence access method is split into more files: -- One for its callbacks, called seqlocalam.c. -- The WAL replay routines are moved into their own file. - As asked, Implementation of a contrib module that introduces a sequence access method for snowflake IDs, to demonstrate what can be done using the APIs of the patch. The data of such sequences is stored in an unlogged table, based on the assumption that the timestamps and the machine IDs ensure the unicity of the IDs for the sequences. The advantage of what's presented here is that support for lastval(), nextval() and currval() is straight-forward. Identity columns are able to feed on that. cache is handled by sequence.c, not the AM. WAL-logging is needed for the init fork, it goes through the generic WAL APIs like bloom to log full pages. Some docs are included. This is still a rough WIP, though, and the buffer handling is not optimal, and could be made transactional this time (assuming autovacuum is able to process them at some point, or perhaps the sequence AMs should offer a way for autovacuum to know if such sequences should be cleaned up or not). After having done that, I've also found about a module developed by pgEdge, that copies a bunch of the code from sequence.c, though it is not able to handle the sequence cache: https://github.com/pgEdge/snowflake The approach this module uses is quite similar to what I have here, but it is smarter regarding clock ticking, where the internal sequence counter is bumped only when we fetch the same timestamp as a previous attempt. The module presented could be switched to do something similar by storing into the heap table used by the sequence a bit more data than just the sequence counter. Well, the point I want to make at this stage is what can be done with sequence AMs, so let's discuss about that later. Finally, custom types, where I have come up with a list of open questions: - Catalog representation. pg_sequence and pg_sequences switch to something else than int64. - The existing functions are also interesting to consider here. nextval() & co would not be usable as they are for sequence AMs that use more than int64. Note that the current design taken in the patch has a strong dependency on int64 (see sequenceam.h). So the types would need to reflect. With identity columns, the change would not be that hard as the executor has NextValueExpr. Perhaps each sequence AM should just have callback equivalents for currval(), nextval() and lastval(). This hits with the fact that this makes sequence AMs less transparent to applications because custom data types means different functions than the native ones. - Option representation. - I have polled Twitter and Fosstodon with four choices: -- No need for that, 64b representation is enough. -- Possibility to have integer-like types (MSSQL does something like that). -- Support for 128b or larger (UUIDs, etc, with text-like representation or varlenas). -- Support for binary representation, which comes down to the possibility of having sequence values even larger than 128b. Based on the first estimations, 50%-ish of people mentioned than 64b is more than enough, while Jelte mentioned that Citus has tackled this problem with an equivalent of 128b (64b for the sequence values, some more for machine states). Then there's a trend of 25%-ish in favor of 128b and 25%-ish for more than that. The results are far from being final, but that's something. My own take after pondering about it is that 64b is still more than enough for the clustering cases I've seen in the past 15 years or so, while offering room for implementations even if it comes to thousands of nodes. So there's some margin depending on the number of bits reserved for the "machine" part of the sequence IDs when used in clusters. The next plan is to hopefully be able to trigger a discussion at the next pgconf.dev at the end of May, but let's see how it goes. Thanks, -- Michael --Hb9lJVq6MVTkbU7F Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v5-0001-Switch-pg_sequence_last_value-to-report-a-tuple-a.patch" Content-Transfer-Encoding: quoted-printable =46rom 573886ba8f50ffa59024b3f1a1c31ca4a7d1e006 Mon Sep 17 00:00:00 2001 =46rom: Michael Paquier Date: Tue, 27 Feb 2024 09:02:57 +0900 Subject: [PATCH v5 1/8] Switch pg_sequence_last_value() to report a tuple a= nd use it in pg_dump This commit switches pg_sequence_last_value() to report a tuple made of (last_value,is_called) that can be directly be used for the arguments of setval() in a sequence. Going forward with PostgreSQL 17, pg_dump and pg_sequences make use of it instead of scanning the heap table assumed to always exist for a sequence. Note: this requires a catversion bump. --- src/include/catalog/pg_proc.dat | 6 ++++-- src/backend/catalog/system_views.sql | 6 +++++- src/backend/commands/sequence.c | 19 +++++++++++++------ src/bin/pg_dump/pg_dump.c | 16 +++++++++++++--- src/test/regress/expected/rules.out | 7 ++++++- 5 files changed, 41 insertions(+), 13 deletions(-) diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.= dat index 134e3b22fd..1a8c8ebba5 100644 --- a/src/include/catalog/pg_proc.dat +++ b/src/include/catalog/pg_proc.dat @@ -3325,9 +3325,11 @@ proargmodes =3D> '{i,o,o,o,o,o,o,o}', proargnames =3D> '{sequence_oid,start_value,minimum_value,maximum_value,= increment,cycle_option,cache_size,data_type}', prosrc =3D> 'pg_sequence_parameters' }, -{ oid =3D> '4032', descr =3D> 'sequence last value', +{ oid =3D> '4032', descr =3D> 'sequence last value data', proname =3D> 'pg_sequence_last_value', provolatile =3D> 'v', proparallel= =3D> 'u', - prorettype =3D> 'int8', proargtypes =3D> 'regclass', + prorettype =3D> 'record', proargtypes =3D> 'regclass', + proallargtypes =3D> '{regclass,bool,int8}', proargmodes =3D> '{i,o,o}', + proargnames =3D> '{seqid,is_called,last_value}', prosrc =3D> 'pg_sequence_last_value' }, =20 { oid =3D> '275', descr =3D> 'return the next oid for a system table', diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/sys= tem_views.sql index 2e61f6d74e..0dfb6346ea 100644 --- a/src/backend/catalog/system_views.sql +++ b/src/backend/catalog/system_views.sql @@ -178,7 +178,11 @@ CREATE VIEW pg_sequences AS S.seqcache AS cache_size, CASE WHEN has_sequence_privilege(C.oid, 'SELECT,USAGE'::text) - THEN pg_sequence_last_value(C.oid) + THEN (SELECT + CASE WHEN sl.is_called + THEN sl.last_value ELSE NULL + END + FROM pg_sequence_last_value(C.oid) sl) ELSE NULL END AS last_value FROM pg_sequence S JOIN pg_class C ON (C.oid =3D S.seqrelid) diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequenc= e.c index 46103561c3..9646c72228 100644 --- a/src/backend/commands/sequence.c +++ b/src/backend/commands/sequence.c @@ -1774,14 +1774,22 @@ pg_sequence_parameters(PG_FUNCTION_ARGS) Datum pg_sequence_last_value(PG_FUNCTION_ARGS) { +#define PG_SEQUENCE_LAST_VALUE_COLS 2 Oid relid =3D PG_GETARG_OID(0); + Datum values[PG_SEQUENCE_LAST_VALUE_COLS] =3D {0}; + bool nulls[PG_SEQUENCE_LAST_VALUE_COLS] =3D {0}; SeqTable elm; Relation seqrel; + TupleDesc tupdesc; Buffer buf; HeapTupleData seqtuple; Form_pg_sequence_data seq; bool is_called; - int64 result; + int64 last_value; + + /* Build a tuple descriptor for our result type */ + if (get_call_result_type(fcinfo, NULL, &tupdesc) !=3D TYPEFUNC_COMPOSITE) + elog(ERROR, "return type must be a row type"); =20 /* open and lock sequence */ init_sequence(relid, &elm, &seqrel); @@ -1795,15 +1803,14 @@ pg_sequence_last_value(PG_FUNCTION_ARGS) seq =3D read_seq_tuple(seqrel, &buf, &seqtuple); =20 is_called =3D seq->is_called; - result =3D seq->last_value; + last_value =3D seq->last_value; =20 UnlockReleaseBuffer(buf); sequence_close(seqrel, NoLock); =20 - if (is_called) - PG_RETURN_INT64(result); - else - PG_RETURN_NULL(); + values[0] =3D BoolGetDatum(is_called); + values[1] =3D Int64GetDatum(last_value); + PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)= )); } =20 =20 diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c index 242ebe807f..54c4f75861 100644 --- a/src/bin/pg_dump/pg_dump.c +++ b/src/bin/pg_dump/pg_dump.c @@ -17824,9 +17824,19 @@ dumpSequenceData(Archive *fout, const TableDataInf= o *tdinfo) bool called; PQExpBuffer query =3D createPQExpBuffer(); =20 - appendPQExpBuffer(query, - "SELECT last_value, is_called FROM %s", - fmtQualifiedDumpable(tbinfo)); + /* + * In versions 17 and up, pg_sequence_last_value() has been switched to + * return a tuple with last_value and is_called. + */ + if (fout->remoteVersion >=3D 170000) + appendPQExpBuffer(query, + "SELECT last_value, is_called " + "FROM pg_sequence_last_value('%s')", + fmtQualifiedDumpable(tbinfo)); + else + appendPQExpBuffer(query, + "SELECT last_value, is_called FROM %s", + fmtQualifiedDumpable(tbinfo)); =20 res =3D ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK); =20 diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expecte= d/rules.out index f4a0f36377..096ac5110b 100644 --- a/src/test/regress/expected/rules.out +++ b/src/test/regress/expected/rules.out @@ -1700,7 +1700,12 @@ pg_sequences| SELECT n.nspname AS schemaname, s.seqcycle AS cycle, s.seqcache AS cache_size, CASE - WHEN has_sequence_privilege(c.oid, 'SELECT,USAGE'::text) THEN = pg_sequence_last_value((c.oid)::regclass) + WHEN has_sequence_privilege(c.oid, 'SELECT,USAGE'::text) THEN = ( SELECT + CASE + WHEN sl.is_called THEN sl.last_value + ELSE NULL::bigint + END AS "case" + FROM pg_sequence_last_value((c.oid)::regclass) sl(is_called= , last_value)) ELSE NULL::bigint END AS last_value FROM ((pg_sequence s --=20 2.43.0 --Hb9lJVq6MVTkbU7F Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v5-0002-Remove-FormData_pg_sequence_data-from-init_params.patch" Content-Transfer-Encoding: quoted-printable =46rom 6ba98cb686a66d38cec4e5dbe42969d469c180fd Mon Sep 17 00:00:00 2001 =46rom: Michael Paquier Date: Fri, 1 Dec 2023 12:00:45 +0900 Subject: [PATCH v5 2/8] Remove FormData_pg_sequence_data from init_params()/sequence.c init_params() sets up "last_value" and "is_called" for a sequence, based on the sequence properties in pg_sequences. This simplifies the logic around log_cnt, which is reset to 0 when the metadata of a sequence is expected to start from afresh when its properties are updated. --- src/backend/commands/sequence.c | 81 ++++++++++++++++++++------------- 1 file changed, 49 insertions(+), 32 deletions(-) diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequenc= e.c index 9646c72228..98a28dfb45 100644 --- a/src/backend/commands/sequence.c +++ b/src/backend/commands/sequence.c @@ -106,7 +106,9 @@ static Form_pg_sequence_data read_seq_tuple(Relation re= l, static void init_params(ParseState *pstate, List *options, bool for_identi= ty, bool isInit, Form_pg_sequence seqform, - Form_pg_sequence_data seqdataform, + 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); @@ -121,7 +123,9 @@ ObjectAddress DefineSequence(ParseState *pstate, CreateSeqStmt *seq) { FormData_pg_sequence seqform; - FormData_pg_sequence_data seqdataform; + int64 last_value; + bool reset_state; + bool is_called; bool need_seq_rewrite; List *owned_by; CreateStmt *stmt =3D makeNode(CreateStmt); @@ -164,7 +168,7 @@ DefineSequence(ParseState *pstate, CreateSeqStmt *seq) =20 /* Check and set all option values */ init_params(pstate, seq->options, seq->for_identity, true, - &seqform, &seqdataform, + &seqform, &last_value, &reset_state, &is_called, &need_seq_rewrite, &owned_by); =20 /* @@ -179,7 +183,7 @@ DefineSequence(ParseState *pstate, CreateSeqStmt *seq) { case SEQ_COL_LASTVAL: coldef =3D makeColumnDef("last_value", INT8OID, -1, InvalidOid); - value[i - 1] =3D Int64GetDatumFast(seqdataform.last_value); + value[i - 1] =3D Int64GetDatumFast(last_value); break; case SEQ_COL_LOG: coldef =3D makeColumnDef("log_cnt", INT8OID, -1, InvalidOid); @@ -448,6 +452,9 @@ AlterSequence(ParseState *pstate, AlterSeqStmt *stmt) ObjectAddress address; Relation rel; HeapTuple seqtuple; + bool reset_state =3D false; + bool is_called; + int64 last_value; HeapTuple newdatatuple; =20 /* Open and lock sequence, and check for ownership along the way. */ @@ -481,12 +488,14 @@ AlterSequence(ParseState *pstate, AlterSeqStmt *stmt) /* copy the existing sequence data tuple, so it can be modified locally */ newdatatuple =3D heap_copytuple(&datatuple); newdataform =3D (Form_pg_sequence_data) GETSTRUCT(newdatatuple); + last_value =3D newdataform->last_value; + is_called =3D newdataform->is_called; =20 UnlockReleaseBuffer(buf); =20 /* Check and set new values */ init_params(pstate, stmt->options, stmt->for_identity, false, - seqform, newdataform, + seqform, &last_value, &reset_state, &is_called, &need_seq_rewrite, &owned_by); =20 /* If needed, rewrite the sequence relation itself */ @@ -513,6 +522,10 @@ AlterSequence(ParseState *pstate, AlterSeqStmt *stmt) /* * Insert the modified tuple into the new storage file. */ + newdataform->last_value =3D last_value; + newdataform->is_called =3D is_called; + if (reset_state) + newdataform->log_cnt =3D 0; fill_seq_with_data(seqrel, newdatatuple); } =20 @@ -1229,17 +1242,19 @@ read_seq_tuple(Relation rel, Buffer *buf, HeapTuple= seqdatatuple) /* * init_params: process the options list of CREATE or ALTER SEQUENCE, and * store the values into appropriate fields of seqform, for changes that go - * into the pg_sequence catalog, and fields of seqdataform for changes to = the - * sequence relation itself. Set *need_seq_rewrite to true if we changed = any - * parameters that require rewriting the sequence's relation (interesting = for - * ALTER SEQUENCE). Also set *owned_by to any OWNED BY option, or to NIL = if - * there is none. + * into the pg_sequence catalog, and fields for changes to the sequence + * relation itself (is_called, last_value or any state it may hold). Set + * *need_seq_rewrite to true if we changed any parameters that require + * rewriting the sequence's relation (interesting for ALTER SEQUENCE). Al= so + * set *owned_by to any OWNED BY option, or to NIL if there is none. Set + * *reset_state if the internal state of the sequence needs to change on a + * follow-up nextval(). * * If isInit is true, fill any unspecified options with default values; * otherwise, do not change existing options that aren't explicitly overri= dden. * * Note: we force a sequence rewrite whenever we change parameters that af= fect - * generation of future sequence values, even if the seqdataform per se is= not + * generation of future sequence values, even if the metadata per se is not * changed. This allows ALTER SEQUENCE to behave transactionally. Curren= tly, * the only option that doesn't cause that is OWNED BY. It's *necessary* = for * ALTER SEQUENCE OWNED BY to not rewrite the sequence, because that would @@ -1250,7 +1265,9 @@ static void init_params(ParseState *pstate, List *options, bool for_identity, bool isInit, Form_pg_sequence seqform, - Form_pg_sequence_data seqdataform, + int64 *last_value, + bool *reset_state, + bool *is_called, bool *need_seq_rewrite, List **owned_by) { @@ -1353,11 +1370,11 @@ init_params(ParseState *pstate, List *options, bool= for_identity, } =20 /* - * We must reset log_cnt when isInit or when changing any parameters that - * would affect future nextval allocations. + * We must reset the state when isInit or when changing any parameters + * that would affect future nextval allocations. */ if (isInit) - seqdataform->log_cnt =3D 0; + *reset_state =3D true; =20 /* AS type */ if (as_type !=3D NULL) @@ -1406,7 +1423,7 @@ init_params(ParseState *pstate, List *options, bool f= or_identity, ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("INCREMENT must not be zero"))); - seqdataform->log_cnt =3D 0; + *reset_state =3D true; } else if (isInit) { @@ -1418,7 +1435,7 @@ init_params(ParseState *pstate, List *options, bool f= or_identity, { seqform->seqcycle =3D boolVal(is_cycled->arg); Assert(BoolIsValid(seqform->seqcycle)); - seqdataform->log_cnt =3D 0; + *reset_state =3D true; } else if (isInit) { @@ -1429,7 +1446,7 @@ init_params(ParseState *pstate, List *options, bool f= or_identity, if (max_value !=3D NULL && max_value->arg) { seqform->seqmax =3D defGetInt64(max_value); - seqdataform->log_cnt =3D 0; + *reset_state =3D true; } else if (isInit || max_value !=3D NULL || reset_max_value) { @@ -1445,7 +1462,7 @@ init_params(ParseState *pstate, List *options, bool f= or_identity, } else seqform->seqmax =3D -1; /* descending seq */ - seqdataform->log_cnt =3D 0; + *reset_state =3D true; } =20 /* Validate maximum value. No need to check INT8 as seqmax is an int64 */ @@ -1461,7 +1478,7 @@ init_params(ParseState *pstate, List *options, bool f= or_identity, if (min_value !=3D NULL && min_value->arg) { seqform->seqmin =3D defGetInt64(min_value); - seqdataform->log_cnt =3D 0; + *reset_state =3D true; } else if (isInit || min_value !=3D NULL || reset_min_value) { @@ -1477,7 +1494,7 @@ init_params(ParseState *pstate, List *options, bool f= or_identity, } else seqform->seqmin =3D 1; /* ascending seq */ - seqdataform->log_cnt =3D 0; + *reset_state =3D true; } =20 /* Validate minimum value. No need to check INT8 as seqmin is an int64 */ @@ -1528,30 +1545,30 @@ init_params(ParseState *pstate, List *options, bool= for_identity, if (restart_value !=3D NULL) { if (restart_value->arg !=3D NULL) - seqdataform->last_value =3D defGetInt64(restart_value); + *last_value =3D defGetInt64(restart_value); else - seqdataform->last_value =3D seqform->seqstart; - seqdataform->is_called =3D false; - seqdataform->log_cnt =3D 0; + *last_value =3D seqform->seqstart; + *is_called =3D false; + *reset_state =3D true; } else if (isInit) { - seqdataform->last_value =3D seqform->seqstart; - seqdataform->is_called =3D false; + *last_value =3D seqform->seqstart; + *is_called =3D false; } =20 /* crosscheck RESTART (or current value, if changing MIN/MAX) */ - if (seqdataform->last_value < seqform->seqmin) + if (*last_value < seqform->seqmin) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("RESTART value (%lld) cannot be less than MINVALUE (%lld)", - (long long) seqdataform->last_value, + (long long) *last_value, (long long) seqform->seqmin))); - if (seqdataform->last_value > seqform->seqmax) + if (*last_value > seqform->seqmax) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("RESTART value (%lld) cannot be greater than MAXVALUE (%lld)", - (long long) seqdataform->last_value, + (long long) *last_value, (long long) seqform->seqmax))); =20 /* CACHE */ @@ -1563,7 +1580,7 @@ init_params(ParseState *pstate, List *options, bool f= or_identity, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("CACHE (%lld) must be greater than zero", (long long) seqform->seqcache))); - seqdataform->log_cnt =3D 0; + *reset_state =3D true; } else if (isInit) { --=20 2.43.0 --Hb9lJVq6MVTkbU7F Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v5-0003-Integrate-addition-of-attributes-for-sequences-wi.patch" Content-Transfer-Encoding: quoted-printable =46rom cf4a668d7da0906eedc634ec9882a6061795f2ef Mon Sep 17 00:00:00 2001 =46rom: Michael Paquier Date: Fri, 19 Jan 2024 15:00:14 +0900 Subject: [PATCH v5 3/8] Integrate addition of attributes for sequences with ALTER TABLE This is a process similar to CREATE OR REPLACE VIEW, where attributes are added to a sequence after the initial creation of its Relation. This gives more flexibility to sequence AMs, as these may want to force their own set of attributes to use when coupled with their computation methods and/or underlying table AM. --- src/include/nodes/parsenodes.h | 1 + src/backend/commands/sequence.c | 29 +++++++++++++++++-- src/backend/commands/tablecmds.c | 10 +++++++ src/backend/tcop/utility.c | 4 +++ .../test_ddl_deparse/expected/alter_table.out | 10 +++++-- .../expected/create_sequence_1.out | 5 +++- .../expected/create_table.out | 15 ++++++++-- .../test_ddl_deparse/test_ddl_deparse.c | 3 ++ 8 files changed, 69 insertions(+), 8 deletions(-) diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h index af80a5d38e..fdcebc268e 100644 --- a/src/include/nodes/parsenodes.h +++ b/src/include/nodes/parsenodes.h @@ -2353,6 +2353,7 @@ typedef struct AlterTableStmt typedef enum AlterTableType { AT_AddColumn, /* add column */ + AT_AddColumnToSequence, /* implicitly via CREATE SEQUENCE */ AT_AddColumnToView, /* implicitly via CREATE OR REPLACE VIEW */ AT_ColumnDefault, /* alter column default */ AT_CookedColumnDefault, /* add a pre-cooked column default */ diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequenc= e.c index 98a28dfb45..d6f2fc3ce0 100644 --- a/src/backend/commands/sequence.c +++ b/src/backend/commands/sequence.c @@ -136,6 +136,9 @@ DefineSequence(ParseState *pstate, CreateSeqStmt *seq) TupleDesc tupDesc; Datum value[SEQ_COL_LASTCOL]; bool null[SEQ_COL_LASTCOL]; + List *elts =3D NIL; + List *atcmds =3D NIL; + ListCell *lc; Datum pgs_values[Natts_pg_sequence]; bool pgs_nulls[Natts_pg_sequence]; int i; @@ -174,7 +177,6 @@ DefineSequence(ParseState *pstate, CreateSeqStmt *seq) /* * Create relation (and fill value[] and null[] for the tuple) */ - stmt->tableElts =3D NIL; for (i =3D SEQ_COL_FIRSTCOL; i <=3D SEQ_COL_LASTCOL; i++) { ColumnDef *coldef =3D NULL; @@ -198,7 +200,7 @@ DefineSequence(ParseState *pstate, CreateSeqStmt *seq) coldef->is_not_null =3D true; null[i - 1] =3D false; =20 - stmt->tableElts =3D lappend(stmt->tableElts, coldef); + elts =3D lappend(elts, coldef); } =20 stmt->relation =3D seq->sequence; @@ -208,12 +210,35 @@ DefineSequence(ParseState *pstate, CreateSeqStmt *seq) stmt->oncommit =3D ONCOMMIT_NOOP; stmt->tablespacename =3D NULL; stmt->if_not_exists =3D seq->if_not_exists; + /* + * Initial relation has no attributes, these are added later. + */ + stmt->tableElts =3D NIL; =20 address =3D DefineRelation(stmt, RELKIND_SEQUENCE, seq->ownerId, NULL, NU= LL); seqoid =3D address.objectId; Assert(seqoid !=3D InvalidOid); =20 rel =3D sequence_open(seqoid, AccessExclusiveLock); + + /* Add all the attributes to the sequence */ + foreach(lc, elts) + { + AlterTableCmd *atcmd; + + atcmd =3D makeNode(AlterTableCmd); + atcmd->subtype =3D AT_AddColumnToSequence; + atcmd->def =3D (Node *) lfirst(lc); + atcmds =3D lappend(atcmds, atcmd); + } + + /* + * No recursion needed. Note that EventTriggerAlterTableStart() should + * have been called. + */ + AlterTableInternal(RelationGetRelid(rel), atcmds, false); + CommandCounterIncrement(); + tupDesc =3D RelationGetDescr(rel); =20 /* now initialize the sequence's data */ diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablec= mds.c index 3556240c8e..ad24777bb8 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -4555,6 +4555,7 @@ AlterTableGetLockLevel(List *cmds) * Subcommands that may be visible to concurrent SELECTs */ case AT_DropColumn: /* change visible to SELECT */ + case AT_AddColumnToSequence: /* CREATE SEQUENCE */ case AT_AddColumnToView: /* CREATE VIEW */ case AT_DropOids: /* used to equiv to DropColumn */ case AT_EnableAlwaysRule: /* may change SELECT rules */ @@ -4858,6 +4859,13 @@ ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd= *cmd, /* Recursion occurs during execution phase */ pass =3D AT_PASS_ADD_COL; break; + case AT_AddColumnToSequence: /* add column via CREATE SEQUENCE */ + ATSimplePermissions(cmd->subtype, rel, ATT_SEQUENCE); + ATPrepAddColumn(wqueue, rel, recurse, recursing, false, cmd, + lockmode, context); + /* Recursion occurs during execution phase */ + pass =3D AT_PASS_ADD_COL; + break; case AT_AddColumnToView: /* add column via CREATE OR REPLACE VIEW */ ATSimplePermissions(cmd->subtype, rel, ATT_VIEW); ATPrepAddColumn(wqueue, rel, recurse, recursing, true, cmd, @@ -5285,6 +5293,7 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, switch (cmd->subtype) { case AT_AddColumn: /* ADD COLUMN */ + case AT_AddColumnToSequence: /* add column via CREATE SEQUENCE */ case AT_AddColumnToView: /* add column via CREATE OR REPLACE VIEW */ address =3D ATExecAddColumn(wqueue, tab, rel, &cmd, cmd->recurse, false, @@ -6465,6 +6474,7 @@ alter_table_type_to_string(AlterTableType cmdtype) switch (cmdtype) { case AT_AddColumn: + case AT_AddColumnToSequence: case AT_AddColumnToView: return "ADD COLUMN"; case AT_ColumnDefault: diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c index fa66b8017e..b64acfb23f 100644 --- a/src/backend/tcop/utility.c +++ b/src/backend/tcop/utility.c @@ -1664,7 +1664,11 @@ ProcessUtilitySlow(ParseState *pstate, break; =20 case T_CreateSeqStmt: + EventTriggerAlterTableStart(parsetree); address =3D DefineSequence(pstate, (CreateSeqStmt *) parsetree); + /* stashed internally */ + commandCollected =3D true; + EventTriggerAlterTableEnd(); break; =20 case T_AlterSeqStmt: diff --git a/src/test/modules/test_ddl_deparse/expected/alter_table.out b/s= rc/test/modules/test_ddl_deparse/expected/alter_table.out index b5e71af9aa..7ebd85200f 100644 --- a/src/test/modules/test_ddl_deparse/expected/alter_table.out +++ b/src/test/modules/test_ddl_deparse/expected/alter_table.out @@ -25,7 +25,10 @@ NOTICE: DDL test: type simple, tag CREATE TABLE CREATE TABLE grandchild () INHERITS (child); NOTICE: DDL test: type simple, tag CREATE TABLE ALTER TABLE parent ADD COLUMN b serial; -NOTICE: DDL test: type simple, tag CREATE SEQUENCE +NOTICE: DDL test: type alter table, tag CREATE SEQUENCE +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column last_value = of sequence parent_b_seq +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column log_cnt of = sequence parent_b_seq +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column is_called o= f sequence parent_b_seq NOTICE: DDL test: type alter table, tag ALTER TABLE NOTICE: subcommand: type ADD COLUMN (and recurse) desc column b of tabl= e parent NOTICE: subcommand: type ADD CONSTRAINT (and recurse) desc constraint p= arent_b_not_null on table parent @@ -71,7 +74,10 @@ ALTER TABLE parent ALTER COLUMN a SET NOT NULL; NOTICE: DDL test: type alter table, tag ALTER TABLE NOTICE: subcommand: type SET NOT NULL (and recurse) desc constraint par= ent_a_not_null on table parent ALTER TABLE parent ALTER COLUMN a ADD GENERATED ALWAYS AS IDENTITY; -NOTICE: DDL test: type simple, tag CREATE SEQUENCE +NOTICE: DDL test: type alter table, tag CREATE SEQUENCE +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column last_value = of sequence parent_a_seq +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column log_cnt of = sequence parent_a_seq +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column is_called o= f sequence parent_a_seq NOTICE: DDL test: type simple, tag ALTER SEQUENCE NOTICE: DDL test: type alter table, tag ALTER TABLE NOTICE: subcommand: type ADD IDENTITY (and recurse) desc column a of ta= ble parent diff --git a/src/test/modules/test_ddl_deparse/expected/create_sequence_1.o= ut b/src/test/modules/test_ddl_deparse/expected/create_sequence_1.out index 5837ea484e..310ce5a6ba 100644 --- a/src/test/modules/test_ddl_deparse/expected/create_sequence_1.out +++ b/src/test/modules/test_ddl_deparse/expected/create_sequence_1.out @@ -8,4 +8,7 @@ CREATE SEQUENCE fkey_table_seq START 10 CACHE 10 CYCLE; -NOTICE: DDL test: type simple, tag CREATE SEQUENCE +NOTICE: DDL test: type alter table, tag CREATE SEQUENCE +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column last_value = of sequence fkey_table_seq +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column log_cnt of = sequence fkey_table_seq +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column is_called o= f sequence fkey_table_seq diff --git a/src/test/modules/test_ddl_deparse/expected/create_table.out b/= src/test/modules/test_ddl_deparse/expected/create_table.out index 75b62aff4d..69e54358ee 100644 --- a/src/test/modules/test_ddl_deparse/expected/create_table.out +++ b/src/test/modules/test_ddl_deparse/expected/create_table.out @@ -50,9 +50,18 @@ CREATE TABLE datatype_table ( PRIMARY KEY (id), UNIQUE (id_big) ); -NOTICE: DDL test: type simple, tag CREATE SEQUENCE -NOTICE: DDL test: type simple, tag CREATE SEQUENCE -NOTICE: DDL test: type simple, tag CREATE SEQUENCE +NOTICE: DDL test: type alter table, tag CREATE SEQUENCE +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column last_value = of sequence datatype_table_id_seq +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column log_cnt of = sequence datatype_table_id_seq +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column is_called o= f sequence datatype_table_id_seq +NOTICE: DDL test: type alter table, tag CREATE SEQUENCE +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column last_value = of sequence datatype_table_id_big_seq +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column log_cnt of = sequence datatype_table_id_big_seq +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column is_called o= f sequence datatype_table_id_big_seq +NOTICE: DDL test: type alter table, tag CREATE SEQUENCE +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column last_value = of sequence datatype_table_is_small_seq +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column log_cnt of = sequence datatype_table_is_small_seq +NOTICE: subcommand: type ADD COLUMN TO SEQUENCE desc column is_called o= f sequence datatype_table_is_small_seq NOTICE: DDL test: type simple, tag CREATE TABLE NOTICE: DDL test: type alter table, tag ALTER TABLE NOTICE: subcommand: type SET ATTNOTNULL desc diff --git a/src/test/modules/test_ddl_deparse/test_ddl_deparse.c b/src/tes= t/modules/test_ddl_deparse/test_ddl_deparse.c index 265ef2a547..4be07bcbc8 100644 --- a/src/test/modules/test_ddl_deparse/test_ddl_deparse.c +++ b/src/test/modules/test_ddl_deparse/test_ddl_deparse.c @@ -114,6 +114,9 @@ get_altertable_subcmdinfo(PG_FUNCTION_ARGS) case AT_AddColumn: strtype =3D "ADD COLUMN"; break; + case AT_AddColumnToSequence: + strtype =3D "ADD COLUMN TO SEQUENCE"; + break; case AT_AddColumnToView: strtype =3D "ADD COLUMN TO VIEW"; break; --=20 2.43.0 --Hb9lJVq6MVTkbU7F Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v5-0004-Refactor-code-for-in-core-local-sequences.patch" Content-Transfer-Encoding: quoted-printable =46rom 060ec6d4fa0e8165c72fea39ca5c7b63cc8e4d91 Mon Sep 17 00:00:00 2001 =46rom: Michael Paquier Date: Thu, 25 Apr 2024 16:49:47 +0900 Subject: [PATCH v5 4/8] Refactor code for in-core "local" sequences This commit restructures the code of in-core sequences into a new set of files: - seqdesc.c is renamed to seqlocaldesc.c. - seqlocalxlog.c to the code in the WAL replay logic. - seqlocalam.c to store a set of routines called from sequence.c, finishing the separation between the main sequence logic and the in-core sequences. - seqlocalam.h to store the AM-specific structures and routine related to the in-core sequences. WAL records are renamed to "SequenceLocal" with structures, variables and file structures mapping to that. --- src/include/access/rmgrlist.h | 2 +- src/include/access/seqlocalam.h | 58 ++ src/backend/access/rmgrdesc/Makefile | 2 +- src/backend/access/rmgrdesc/meson.build | 2 +- .../rmgrdesc/{seqdesc.c =3D> seqlocaldesc.c} | 20 +- src/backend/access/sequence/Makefile | 2 +- src/backend/access/sequence/meson.build | 2 + src/backend/access/sequence/seqlocalam.c | 634 ++++++++++++++++++ src/backend/access/sequence/seqlocalxlog.c | 82 +++ src/backend/access/transam/rmgr.c | 1 + src/backend/commands/sequence.c | 619 +---------------- src/bin/pg_waldump/.gitignore | 2 +- src/bin/pg_waldump/rmgrdesc.c | 1 + src/bin/pg_waldump/t/001_basic.pl | 2 +- 14 files changed, 816 insertions(+), 613 deletions(-) create mode 100644 src/include/access/seqlocalam.h rename src/backend/access/rmgrdesc/{seqdesc.c =3D> seqlocaldesc.c} (64%) create mode 100644 src/backend/access/sequence/seqlocalam.c create mode 100644 src/backend/access/sequence/seqlocalxlog.c diff --git a/src/include/access/rmgrlist.h b/src/include/access/rmgrlist.h index 78e6b908c6..fa94beb6ed 100644 --- a/src/include/access/rmgrlist.h +++ b/src/include/access/rmgrlist.h @@ -40,7 +40,7 @@ PG_RMGR(RM_BTREE_ID, "Btree", btree_redo, btree_desc, btr= ee_identify, btree_xlog PG_RMGR(RM_HASH_ID, "Hash", hash_redo, hash_desc, hash_identify, NULL, NUL= L, hash_mask, NULL) PG_RMGR(RM_GIN_ID, "Gin", gin_redo, gin_desc, gin_identify, gin_xlog_start= up, gin_xlog_cleanup, gin_mask, NULL) PG_RMGR(RM_GIST_ID, "Gist", gist_redo, gist_desc, gist_identify, gist_xlog= _startup, gist_xlog_cleanup, gist_mask, NULL) -PG_RMGR(RM_SEQ_ID, "Sequence", seq_redo, seq_desc, seq_identify, NULL, NUL= L, seq_mask, NULL) +PG_RMGR(RM_SEQ_LOCAL_ID, "SequenceLocal", seq_local_redo, seq_local_desc, = seq_local_identify, NULL, NULL, seq_local_mask, NULL) PG_RMGR(RM_SPGIST_ID, "SPGist", spg_redo, spg_desc, spg_identify, spg_xlog= _startup, spg_xlog_cleanup, spg_mask, NULL) PG_RMGR(RM_BRIN_ID, "BRIN", brin_redo, brin_desc, brin_identify, NULL, NUL= L, brin_mask, NULL) PG_RMGR(RM_COMMIT_TS_ID, "CommitTs", commit_ts_redo, commit_ts_desc, commi= t_ts_identify, NULL, NULL, NULL, NULL) diff --git a/src/include/access/seqlocalam.h b/src/include/access/seqlocala= m.h new file mode 100644 index 0000000000..225fb9a2cb --- /dev/null +++ b/src/include/access/seqlocalam.h @@ -0,0 +1,58 @@ +/*------------------------------------------------------------------------- + * + * seqlocalam.h + * Local sequence access method. + * + * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/access/seqlocalam.h + * + *------------------------------------------------------------------------- + */ +#ifndef SEQLOCALAM_H +#define SEQLOCALAM_H + +#include "access/xlogreader.h" +#include "storage/relfilelocator.h" +#include "utils/rel.h" + +/* XLOG stuff */ +#define XLOG_SEQ_LOCAL_LOG 0x00 + +typedef struct xl_seq_local_rec +{ + RelFileLocator locator; + /* SEQUENCE TUPLE DATA FOLLOWS AT THE END */ +} xl_seq_local_rec; + +/* + * The "special area" of a local sequence's buffer page looks like this. + */ +#define SEQ_LOCAL_MAGIC 0x1717 + +typedef struct seq_local_magic +{ + uint32 magic; +} seq_local_magic; + +extern void seq_local_redo(XLogReaderState *record); +extern void seq_local_desc(StringInfo buf, XLogReaderState *record); +extern const char *seq_local_identify(uint8 info); +extern void seq_local_mask(char *page, BlockNumber blkno); + +/* access routines */ +extern int64 seq_local_nextval(Relation rel, int64 incby, int64 maxv, + int64 minv, int64 cache, bool cycle, + int64 *last); +extern const char *seq_local_get_table_am(void); +extern void seq_local_init(Relation rel, int64 last_value, bool is_called); +extern void seq_local_setval(Relation rel, int64 next, bool iscalled); +extern void seq_local_reset(Relation rel, int64 startv, bool is_called, + bool reset_state); +extern void seq_local_get_state(Relation rel, int64 *last_value, + bool *is_called); +extern void seq_local_change_persistence(Relation rel, + char newrelpersistence); + +#endif /* SEQLOCALAM_H */ diff --git a/src/backend/access/rmgrdesc/Makefile b/src/backend/access/rmgr= desc/Makefile index cd95eec37f..e5900ed77a 100644 --- a/src/backend/access/rmgrdesc/Makefile +++ b/src/backend/access/rmgrdesc/Makefile @@ -24,7 +24,7 @@ OBJS =3D \ relmapdesc.o \ replorigindesc.o \ rmgrdesc_utils.o \ - seqdesc.o \ + seqlocaldesc.o \ smgrdesc.o \ spgdesc.o \ standbydesc.o \ diff --git a/src/backend/access/rmgrdesc/meson.build b/src/backend/access/r= mgrdesc/meson.build index e8b7a65fc7..e390d385bf 100644 --- a/src/backend/access/rmgrdesc/meson.build +++ b/src/backend/access/rmgrdesc/meson.build @@ -17,7 +17,7 @@ rmgr_desc_sources =3D files( 'relmapdesc.c', 'replorigindesc.c', 'rmgrdesc_utils.c', - 'seqdesc.c', + 'seqlocaldesc.c', 'smgrdesc.c', 'spgdesc.c', 'standbydesc.c', diff --git a/src/backend/access/rmgrdesc/seqdesc.c b/src/backend/access/rmg= rdesc/seqlocaldesc.c similarity index 64% rename from src/backend/access/rmgrdesc/seqdesc.c rename to src/backend/access/rmgrdesc/seqlocaldesc.c index cf0e02ded5..409c67335e 100644 --- a/src/backend/access/rmgrdesc/seqdesc.c +++ b/src/backend/access/rmgrdesc/seqlocaldesc.c @@ -1,44 +1,44 @@ /*------------------------------------------------------------------------- * - * seqdesc.c - * rmgr descriptor routines for commands/sequence.c + * seqlocaldesc.c + * rmgr descriptor routines for sequence/seqlocal.c * * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION - * src/backend/access/rmgrdesc/seqdesc.c + * src/backend/access/rmgrdesc/seqlocaldesc.c * *------------------------------------------------------------------------- */ #include "postgres.h" =20 -#include "commands/sequence.h" +#include "access/seqlocalam.h" =20 =20 void -seq_desc(StringInfo buf, XLogReaderState *record) +seq_local_desc(StringInfo buf, XLogReaderState *record) { char *rec =3D XLogRecGetData(record); uint8 info =3D XLogRecGetInfo(record) & ~XLR_INFO_MASK; - xl_seq_rec *xlrec =3D (xl_seq_rec *) rec; + xl_seq_local_rec *xlrec =3D (xl_seq_local_rec *) rec; =20 - if (info =3D=3D XLOG_SEQ_LOG) + if (info =3D=3D XLOG_SEQ_LOCAL_LOG) appendStringInfo(buf, "rel %u/%u/%u", xlrec->locator.spcOid, xlrec->locator.dbOid, xlrec->locator.relNumber); } =20 const char * -seq_identify(uint8 info) +seq_local_identify(uint8 info) { const char *id =3D NULL; =20 switch (info & ~XLR_INFO_MASK) { - case XLOG_SEQ_LOG: - id =3D "LOG"; + case XLOG_SEQ_LOCAL_LOG: + id =3D "SEQ_LOCAL_LOG"; break; } =20 diff --git a/src/backend/access/sequence/Makefile b/src/backend/access/sequ= ence/Makefile index 9f9d31f542..a15ceec1c0 100644 --- a/src/backend/access/sequence/Makefile +++ b/src/backend/access/sequence/Makefile @@ -12,6 +12,6 @@ subdir =3D src/backend/access/sequence top_builddir =3D ../../../.. include $(top_builddir)/src/Makefile.global =20 -OBJS =3D sequence.o +OBJS =3D seqlocalam.o seqlocalxlog.o sequence.o =20 include $(top_srcdir)/src/backend/common.mk diff --git a/src/backend/access/sequence/meson.build b/src/backend/access/s= equence/meson.build index 1843aed38d..4d24f900b6 100644 --- a/src/backend/access/sequence/meson.build +++ b/src/backend/access/sequence/meson.build @@ -1,5 +1,7 @@ # Copyright (c) 2022-2024, PostgreSQL Global Development Group =20 backend_sources +=3D files( + 'seqlocalam.c', + 'seqlocalxlog.c', 'sequence.c', ) diff --git a/src/backend/access/sequence/seqlocalam.c b/src/backend/access/= sequence/seqlocalam.c new file mode 100644 index 0000000000..b0a0d72966 --- /dev/null +++ b/src/backend/access/sequence/seqlocalam.c @@ -0,0 +1,634 @@ +/*------------------------------------------------------------------------- + * + * seqlocalam.c + * Local sequence access manager + * + * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * src/backend/access/sequence/seqlocalam.c + * + *------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include "access/multixact.h" +#include "access/seqlocalam.h" +#include "access/xact.h" +#include "access/xloginsert.h" +#include "access/xlogutils.h" +#include "catalog/storage_xlog.h" +#include "commands/tablecmds.h" +#include "miscadmin.h" +#include "nodes/makefuncs.h" + + +/* + * We don't want to log each fetching of a value from a sequence, + * so we pre-log a few fetches in advance. In the event of + * crash we can lose (skip over) as many values as we pre-logged. + */ +#define SEQ_LOCAL_LOG_VALS 32 + +/* Format of tuples stored in heap table associated to local sequences */ +typedef struct FormData_pg_seq_local_data +{ + int64 last_value; + int64 log_cnt; + bool is_called; +} FormData_pg_seq_local_data; + +typedef FormData_pg_seq_local_data *Form_pg_seq_local_data; + +/* + * Columns of a local sequence relation + */ +#define SEQ_LOCAL_COL_LASTVAL 1 +#define SEQ_LOCAL_COL_LOG 2 +#define SEQ_LOCAL_COL_CALLED 3 + +#define SEQ_LOCAL_COL_FIRSTCOL SEQ_LOCAL_COL_LASTVAL +#define SEQ_LOCAL_COL_LASTCOL SEQ_LOCAL_COL_CALLED + + +/* + * We don't want to log each fetching of a value from a sequence, + * so we pre-log a few fetches in advance. In the event of + * crash we can lose (skip over) as many values as we pre-logged. + */ +#define SEQ_LOCAL_LOG_VALS 32 + +static Form_pg_seq_local_data read_seq_tuple(Relation rel, + Buffer *buf, + HeapTuple seqdatatuple); +static void fill_seq_with_data(Relation rel, HeapTuple tuple); +static void fill_seq_fork_with_data(Relation rel, HeapTuple tuple, + ForkNumber forkNum); + +/* + * Given an opened sequence relation, lock the page buffer and find the tu= ple + * + * *buf receives the reference to the pinned-and-ex-locked buffer + * *seqdatatuple receives the reference to the sequence tuple proper + * (this arg should point to a local variable of type HeapTupleData) + * + * Function's return value points to the data payload of the tuple + */ +static Form_pg_seq_local_data +read_seq_tuple(Relation rel, Buffer *buf, HeapTuple seqdatatuple) +{ + Page page; + ItemId lp; + seq_local_magic *sm; + Form_pg_seq_local_data seq; + + *buf =3D ReadBuffer(rel, 0); + LockBuffer(*buf, BUFFER_LOCK_EXCLUSIVE); + + page =3D BufferGetPage(*buf); + sm =3D (seq_local_magic *) PageGetSpecialPointer(page); + + if (sm->magic !=3D SEQ_LOCAL_MAGIC) + elog(ERROR, "bad magic number in sequence \"%s\": %08X", + RelationGetRelationName(rel), sm->magic); + + lp =3D PageGetItemId(page, FirstOffsetNumber); + Assert(ItemIdIsNormal(lp)); + + /* Note we currently only bother to set these two fields of *seqdatatuple= */ + seqdatatuple->t_data =3D (HeapTupleHeader) PageGetItem(page, lp); + seqdatatuple->t_len =3D ItemIdGetLength(lp); + + /* + * Previous releases of Postgres neglected to prevent SELECT FOR UPDATE on + * a sequence, which would leave a non-frozen XID in the sequence tuple's + * xmax, which eventually leads to clog access failures or worse. If we + * see this has happened, clean up after it. We treat this like a hint + * bit update, ie, don't bother to WAL-log it, since we can certainly do + * this again if the update gets lost. + */ + Assert(!(seqdatatuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI)); + if (HeapTupleHeaderGetRawXmax(seqdatatuple->t_data) !=3D InvalidTransacti= onId) + { + HeapTupleHeaderSetXmax(seqdatatuple->t_data, InvalidTransactionId); + seqdatatuple->t_data->t_infomask &=3D ~HEAP_XMAX_COMMITTED; + seqdatatuple->t_data->t_infomask |=3D HEAP_XMAX_INVALID; + MarkBufferDirtyHint(*buf, true); + } + + seq =3D (Form_pg_seq_local_data) GETSTRUCT(seqdatatuple); + + return seq; +} + +/* + * Initialize a sequence's relation with the specified tuple as content + * + * This handles unlogged sequences by writing to both the main and the init + * fork as necessary. + */ +static void +fill_seq_with_data(Relation rel, HeapTuple tuple) +{ + fill_seq_fork_with_data(rel, tuple, MAIN_FORKNUM); + + if (rel->rd_rel->relpersistence =3D=3D RELPERSISTENCE_UNLOGGED) + { + SMgrRelation srel; + + srel =3D smgropen(rel->rd_locator, INVALID_PROC_NUMBER); + smgrcreate(srel, INIT_FORKNUM, false); + log_smgrcreate(&rel->rd_locator, INIT_FORKNUM); + fill_seq_fork_with_data(rel, tuple, INIT_FORKNUM); + FlushRelationBuffers(rel); + smgrclose(srel); + } +} + +/* + * Initialize a sequence's relation fork with the specified tuple as conte= nt + */ +static void +fill_seq_fork_with_data(Relation rel, HeapTuple tuple, ForkNumber forkNum) +{ + Buffer buf; + Page page; + seq_local_magic *sm; + OffsetNumber offnum; + + /* Initialize first page of relation with special magic number */ + + buf =3D ExtendBufferedRel(BMR_REL(rel), forkNum, NULL, + EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK); + Assert(BufferGetBlockNumber(buf) =3D=3D 0); + + page =3D BufferGetPage(buf); + + PageInit(page, BufferGetPageSize(buf), sizeof(seq_local_magic)); + sm =3D (seq_local_magic *) PageGetSpecialPointer(page); + sm->magic =3D SEQ_LOCAL_MAGIC; + + /* Now insert sequence tuple */ + + /* + * Since VACUUM does not process sequences, we have to force the tuple to + * have xmin =3D FrozenTransactionId now. Otherwise it would become + * invisible to SELECTs after 2G transactions. It is okay to do this + * because if the current transaction aborts, no other xact will ever + * examine the sequence tuple anyway. + */ + HeapTupleHeaderSetXmin(tuple->t_data, FrozenTransactionId); + HeapTupleHeaderSetXminFrozen(tuple->t_data); + HeapTupleHeaderSetCmin(tuple->t_data, FirstCommandId); + HeapTupleHeaderSetXmax(tuple->t_data, InvalidTransactionId); + tuple->t_data->t_infomask |=3D HEAP_XMAX_INVALID; + ItemPointerSet(&tuple->t_data->t_ctid, 0, FirstOffsetNumber); + + /* check the comment above nextval_internal()'s equivalent call. */ + if (RelationNeedsWAL(rel)) + GetTopTransactionId(); + + START_CRIT_SECTION(); + + MarkBufferDirty(buf); + + offnum =3D PageAddItem(page, (Item) tuple->t_data, tuple->t_len, + InvalidOffsetNumber, false, false); + if (offnum !=3D FirstOffsetNumber) + elog(ERROR, "failed to add sequence tuple to page"); + + /* XLOG stuff */ + if (RelationNeedsWAL(rel) || forkNum =3D=3D INIT_FORKNUM) + { + xl_seq_local_rec xlrec; + XLogRecPtr recptr; + + XLogBeginInsert(); + XLogRegisterBuffer(0, buf, REGBUF_WILL_INIT); + + xlrec.locator =3D rel->rd_locator; + + XLogRegisterData((char *) &xlrec, sizeof(xl_seq_local_rec)); + XLogRegisterData((char *) tuple->t_data, tuple->t_len); + + recptr =3D XLogInsert(RM_SEQ_LOCAL_ID, XLOG_SEQ_LOCAL_LOG); + + PageSetLSN(page, recptr); + } + + END_CRIT_SECTION(); + + UnlockReleaseBuffer(buf); +} + +/* + * seq_local_nextval() + * + * Allocate a new value for a local sequence, based on the sequence + * configuration. + */ +int64 +seq_local_nextval(Relation rel, int64 incby, int64 maxv, + int64 minv, int64 cache, bool cycle, + int64 *last) +{ + int64 result; + int64 fetch; + int64 next; + int64 rescnt =3D 0; + int64 log; + Buffer buf; + HeapTupleData seqdatatuple; + Form_pg_seq_local_data seq; + Page page; + bool logit =3D false; + + /* lock page buffer and read tuple */ + seq =3D read_seq_tuple(rel, &buf, &seqdatatuple); + page =3D BufferGetPage(buf); + + *last =3D next =3D result =3D seq->last_value; + fetch =3D cache; + log =3D seq->log_cnt; + + if (!seq->is_called) + { + rescnt++; /* return last_value if not is_called */ + fetch--; + } + + /* + * Decide whether we should emit a WAL log record. If so, force up the + * fetch count to grab SEQ_LOCAL_LOG_VALS more values than we actually + * need to cache. (These will then be usable without logging.) + * + * If this is the first nextval after a checkpoint, we must force a new + * WAL record to be written anyway, else replay starting from the + * checkpoint would fail to advance the sequence past the logged values. + * In this case we may as well fetch extra values. + */ + if (log < fetch || !seq->is_called) + { + /* forced log to satisfy local demand for values */ + fetch =3D log =3D fetch + SEQ_LOCAL_LOG_VALS; + logit =3D true; + } + else + { + XLogRecPtr redoptr =3D GetRedoRecPtr(); + + if (PageGetLSN(page) <=3D redoptr) + { + /* last update of seq was before checkpoint */ + fetch =3D log =3D fetch + SEQ_LOCAL_LOG_VALS; + logit =3D true; + } + } + + while (fetch) /* try to fetch cache [+ log ] numbers */ + { + /* + * Check MAXVALUE for ascending sequences and MINVALUE for descending + * sequences + */ + if (incby > 0) + { + /* ascending sequence */ + if ((maxv >=3D 0 && next > maxv - incby) || + (maxv < 0 && next + incby > maxv)) + { + if (rescnt > 0) + break; /* stop fetching */ + if (!cycle) + ereport(ERROR, + (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED), + errmsg("nextval: reached maximum value of sequence \"%s\" (%lld)", + RelationGetRelationName(rel), + (long long) maxv))); + next =3D minv; + } + else + next +=3D incby; + } + else + { + /* descending sequence */ + if ((minv < 0 && next < minv - incby) || + (minv >=3D 0 && next + incby < minv)) + { + if (rescnt > 0) + break; /* stop fetching */ + if (!cycle) + ereport(ERROR, + (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED), + errmsg("nextval: reached minimum value of sequence \"%s\" (%lld)", + RelationGetRelationName(rel), + (long long) minv))); + next =3D maxv; + } + else + next +=3D incby; + } + fetch--; + if (rescnt < cache) + { + log--; + rescnt++; + *last =3D next; + if (rescnt =3D=3D 1) /* if it's first result - */ + result =3D next; /* it's what to return */ + } + } + + log -=3D fetch; /* adjust for any unfetched numbers */ + Assert(log >=3D 0); + + /* + * If something needs to be WAL logged, acquire an xid, so this + * transaction's commit will trigger a WAL flush and wait for syncrep. + * It's sufficient to ensure the toplevel transaction has an xid, no need + * to assign xids subxacts, that'll already trigger an appropriate wait. + * (Have to do that here, so we're outside the critical section) + */ + if (logit && RelationNeedsWAL(rel)) + GetTopTransactionId(); + + /* ready to change the on-disk (or really, in-buffer) tuple */ + START_CRIT_SECTION(); + + /* + * We must mark the buffer dirty before doing XLogInsert(); see notes in + * SyncOneBuffer(). However, we don't apply the desired changes just yet. + * This looks like a violation of the buffer update protocol, but it is in + * fact safe because we hold exclusive lock on the buffer. Any other + * process, including a checkpoint, that tries to examine the buffer + * contents will block until we release the lock, and then will see the + * final state that we install below. + */ + MarkBufferDirty(buf); + + /* XLOG stuff */ + if (logit && RelationNeedsWAL(rel)) + { + xl_seq_local_rec xlrec; + XLogRecPtr recptr; + + /* + * We don't log the current state of the tuple, but rather the state + * as it would appear after "log" more fetches. This lets us skip + * that many future WAL records, at the cost that we lose those + * sequence values if we crash. + */ + XLogBeginInsert(); + XLogRegisterBuffer(0, buf, REGBUF_WILL_INIT); + + /* set values that will be saved in xlog */ + seq->last_value =3D next; + seq->is_called =3D true; + seq->log_cnt =3D 0; + + xlrec.locator =3D rel->rd_locator; + + XLogRegisterData((char *) &xlrec, sizeof(xl_seq_local_rec)); + XLogRegisterData((char *) seqdatatuple.t_data, seqdatatuple.t_len); + + recptr =3D XLogInsert(RM_SEQ_LOCAL_ID, XLOG_SEQ_LOCAL_LOG); + + PageSetLSN(page, recptr); + } + + /* Now update sequence tuple to the intended final state */ + seq->last_value =3D *last; /* last fetched number */ + seq->is_called =3D true; + seq->log_cnt =3D log; /* how much is logged */ + + END_CRIT_SECTION(); + + UnlockReleaseBuffer(buf); + + return result; +} + +/* + * seq_local_get_table_am() + * + * Return the table access method used by this sequence. + */ +const char * +seq_local_get_table_am(void) +{ + return "heap"; +} + +/* + * seq_local_init() + * + * Add the sequence attributes to the relation created for this sequence + * AM and insert a tuple of metadata into the sequence relation, based on + * the information guessed from pg_sequences. This is the first tuple + * inserted after the relation has been created, filling in its heap + * table. + */ +void +seq_local_init(Relation rel, int64 last_value, bool is_called) +{ + Datum value[SEQ_LOCAL_COL_LASTCOL]; + bool null[SEQ_LOCAL_COL_LASTCOL]; + List *elts =3D NIL; + List *atcmds =3D NIL; + ListCell *lc; + TupleDesc tupdesc; + HeapTuple tuple; + + /* + * Create relation (and fill value[] and null[] for the initial tuple). + */ + for (int i =3D SEQ_LOCAL_COL_FIRSTCOL; i <=3D SEQ_LOCAL_COL_LASTCOL; i++) + { + ColumnDef *coldef =3D NULL; + + switch (i) + { + case SEQ_LOCAL_COL_LASTVAL: + coldef =3D makeColumnDef("last_value", INT8OID, -1, InvalidOid); + value[i - 1] =3D Int64GetDatumFast(last_value); + break; + case SEQ_LOCAL_COL_LOG: + coldef =3D makeColumnDef("log_cnt", INT8OID, -1, InvalidOid); + value[i - 1] =3D Int64GetDatum(0); + break; + case SEQ_LOCAL_COL_CALLED: + coldef =3D makeColumnDef("is_called", BOOLOID, -1, InvalidOid); + value[i - 1] =3D BoolGetDatum(is_called); + break; + } + + coldef->is_not_null =3D true; + null[i - 1] =3D false; + elts =3D lappend(elts, coldef); + } + + /* Add all the attributes to the sequence */ + foreach(lc, elts) + { + AlterTableCmd *atcmd; + + atcmd =3D makeNode(AlterTableCmd); + atcmd->subtype =3D AT_AddColumnToSequence; + atcmd->def =3D (Node *) lfirst(lc); + atcmds =3D lappend(atcmds, atcmd); + } + + /* + * No recursion needed. Note that EventTriggerAlterTableStart() should + * have been called. + */ + AlterTableInternal(RelationGetRelid(rel), atcmds, false); + CommandCounterIncrement(); + + tupdesc =3D RelationGetDescr(rel); + tuple =3D heap_form_tuple(tupdesc, value, null); + fill_seq_with_data(rel, tuple); +} + +/* + * seq_local_setval() + * + * Callback for setval(). + */ +void +seq_local_setval(Relation rel, int64 next, bool iscalled) +{ + Buffer buf; + HeapTupleData seqdatatuple; + Form_pg_seq_local_data seq; + + /* lock page buffer and read tuple */ + seq =3D read_seq_tuple(rel, &buf, &seqdatatuple); + + /* ready to change the on-disk (or really, in-buffer) tuple */ + START_CRIT_SECTION(); + seq->last_value =3D next; /* last fetched number */ + seq->is_called =3D iscalled; + seq->log_cnt =3D 0; + + MarkBufferDirty(buf); + + /* XLOG stuff */ + if (RelationNeedsWAL(rel)) + { + xl_seq_local_rec xlrec; + XLogRecPtr recptr; + Page page =3D BufferGetPage(buf); + + XLogBeginInsert(); + XLogRegisterBuffer(0, buf, REGBUF_WILL_INIT); + + xlrec.locator =3D rel->rd_locator; + XLogRegisterData((char *) &xlrec, sizeof(xl_seq_local_rec)); + XLogRegisterData((char *) seqdatatuple.t_data, seqdatatuple.t_len); + + recptr =3D XLogInsert(RM_SEQ_LOCAL_ID, XLOG_SEQ_LOCAL_LOG); + + PageSetLSN(page, recptr); + } + + END_CRIT_SECTION(); + + UnlockReleaseBuffer(buf); +} + +/* + * seq_local_reset() + * + * Perform a hard reset on the local sequence, rewriting its heap data + * entirely. + */ +void +seq_local_reset(Relation rel, int64 startv, bool is_called, bool reset_sta= te) +{ + Form_pg_seq_local_data seq; + Buffer buf; + HeapTupleData seqdatatuple; + HeapTuple tuple; + + /* lock buffer page and read tuple */ + (void) read_seq_tuple(rel, &buf, &seqdatatuple); + + /* + * Copy the existing sequence tuple. + */ + tuple =3D heap_copytuple(&seqdatatuple); + + /* Now we're done with the old page */ + UnlockReleaseBuffer(buf); + + /* + * Modify the copied tuple to execute the restart (compare the RESTART + * action in AlterSequence) + */ + seq =3D (Form_pg_seq_local_data) GETSTRUCT(tuple); + seq->last_value =3D startv; + seq->is_called =3D is_called; + if (reset_state) + seq->log_cnt =3D 0; + + /* + * Create a new storage file for the sequence. + */ + RelationSetNewRelfilenumber(rel, rel->rd_rel->relpersistence); + + /* + * Ensure sequence's relfrozenxid is at 0, since it won't contain any + * unfrozen XIDs. Same with relminmxid, since a sequence will never + * contain multixacts. + */ + Assert(rel->rd_rel->relfrozenxid =3D=3D InvalidTransactionId); + Assert(rel->rd_rel->relminmxid =3D=3D InvalidMultiXactId); + + /* + * Insert the modified tuple into the new storage file. + */ + fill_seq_with_data(rel, tuple); +} + +/* + * seq_local_get_state() + * + * Retrieve the state of a local sequence. + */ +void +seq_local_get_state(Relation rel, int64 *last_value, bool *is_called) +{ + Buffer buf; + HeapTupleData seqdatatuple; + Form_pg_seq_local_data seq; + + /* lock page buffer and read tuple */ + seq =3D read_seq_tuple(rel, &buf, &seqdatatuple); + + *last_value =3D seq->last_value; + *is_called =3D seq->is_called; + + UnlockReleaseBuffer(buf); +} + +/* + * seq_local_change_persistence() + * + * Persistence change for the local sequence Relation. + */ +void +seq_local_change_persistence(Relation rel, char newrelpersistence) +{ + Buffer buf; + HeapTupleData seqdatatuple; + + (void) read_seq_tuple(rel, &buf, &seqdatatuple); + RelationSetNewRelfilenumber(rel, newrelpersistence); + fill_seq_with_data(rel, &seqdatatuple); + UnlockReleaseBuffer(buf); +} diff --git a/src/backend/access/sequence/seqlocalxlog.c b/src/backend/acces= s/sequence/seqlocalxlog.c new file mode 100644 index 0000000000..db0ad969db --- /dev/null +++ b/src/backend/access/sequence/seqlocalxlog.c @@ -0,0 +1,82 @@ +/*------------------------------------------------------------------------- + * + * seqlocalxlog.c + * WAL replay logic for local sequence access manager + * + * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * src/backend/access/sequence/seqlocalxlog.c + * + *------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include "access/bufmask.h" +#include "access/seqlocalam.h" +#include "access/xlogutils.h" +#include "storage/block.h" + +/* + * Mask a Sequence page before performing consistency checks on it. + */ +void +seq_local_mask(char *page, BlockNumber blkno) +{ + mask_page_lsn_and_checksum(page); + + mask_unused_space(page); +} + +void +seq_local_redo(XLogReaderState *record) +{ + XLogRecPtr lsn =3D record->EndRecPtr; + uint8 info =3D XLogRecGetInfo(record) & ~XLR_INFO_MASK; + Buffer buffer; + Page page; + Page localpage; + char *item; + Size itemsz; + xl_seq_local_rec *xlrec =3D (xl_seq_local_rec *) XLogRecGetData(record); + seq_local_magic *sm; + + if (info !=3D XLOG_SEQ_LOCAL_LOG) + elog(PANIC, "seq_redo: unknown op code %u", info); + + buffer =3D XLogInitBufferForRedo(record, 0); + page =3D (Page) BufferGetPage(buffer); + + /* + * We always reinit the page. However, since this WAL record type is also + * used for updating sequences, it's possible that a hot-standby backend + * is examining the page concurrently; so we mustn't transiently trash the + * buffer. The solution is to build the correct new page contents in + * local workspace and then memcpy into the buffer. Then only bytes that + * are supposed to change will change, even transiently. We must palloc + * the local page for alignment reasons. + */ + localpage =3D (Page) palloc(BufferGetPageSize(buffer)); + + PageInit(localpage, BufferGetPageSize(buffer), sizeof(seq_local_magic)); + sm =3D (seq_local_magic *) PageGetSpecialPointer(localpage); + sm->magic =3D SEQ_LOCAL_MAGIC; + + item =3D (char *) xlrec + sizeof(xl_seq_local_rec); + itemsz =3D XLogRecGetDataLen(record) - sizeof(xl_seq_local_rec); + + if (PageAddItem(localpage, (Item) item, itemsz, + FirstOffsetNumber, false, false) =3D=3D InvalidOffsetNumber) + elog(PANIC, "seq_local_redo: failed to add item to page"); + + PageSetLSN(localpage, lsn); + + memcpy(page, localpage, BufferGetPageSize(buffer)); + MarkBufferDirty(buffer); + UnlockReleaseBuffer(buffer); + + pfree(localpage); +} diff --git a/src/backend/access/transam/rmgr.c b/src/backend/access/transam= /rmgr.c index 3e2f1d4a23..9c22ef315f 100644 --- a/src/backend/access/transam/rmgr.c +++ b/src/backend/access/transam/rmgr.c @@ -27,6 +27,7 @@ #include "access/gistxlog.h" #include "access/hash_xlog.h" #include "access/heapam_xlog.h" +#include "access/seqlocalam.h" #include "access/multixact.h" #include "access/nbtxlog.h" #include "access/spgxlog.h" diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequenc= e.c index d6f2fc3ce0..6d712e76e2 100644 --- a/src/backend/commands/sequence.c +++ b/src/backend/commands/sequence.c @@ -16,6 +16,7 @@ =20 #include "access/bufmask.h" #include "access/htup_details.h" +#include "access/seqlocalam.h" #include "access/multixact.h" #include "access/relation.h" #include "access/sequence.h" @@ -50,23 +51,6 @@ #include "utils/varlena.h" =20 =20 -/* - * We don't want to log each fetching of a value from a sequence, - * so we pre-log a few fetches in advance. In the event of - * crash we can lose (skip over) as many values as we pre-logged. - */ -#define SEQ_LOG_VALS 32 - -/* - * The "special area" of a sequence's buffer page looks like this. - */ -#define SEQ_MAGIC 0x1717 - -typedef struct sequence_magic -{ - uint32 magic; -} sequence_magic; - /* * We store a SeqTable item for every sequence we have touched in the curr= ent * session. This is needed to hold onto nextval/currval state. (We can't @@ -96,13 +80,9 @@ static HTAB *seqhashtab =3D NULL; /* hash table for SeqT= able items */ */ static SeqTableData *last_used_seq =3D NULL; =20 -static void fill_seq_with_data(Relation rel, HeapTuple tuple); -static void fill_seq_fork_with_data(Relation rel, HeapTuple tuple, ForkNum= ber 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_identi= ty, bool isInit, Form_pg_sequence seqform, @@ -134,14 +114,8 @@ DefineSequence(ParseState *pstate, CreateSeqStmt *seq) Relation rel; HeapTuple tuple; TupleDesc tupDesc; - Datum value[SEQ_COL_LASTCOL]; - bool null[SEQ_COL_LASTCOL]; - List *elts =3D NIL; - List *atcmds =3D NIL; - ListCell *lc; Datum pgs_values[Natts_pg_sequence]; bool pgs_nulls[Natts_pg_sequence]; - int i; =20 /* * If if_not_exists was given and a relation with the same name already @@ -174,35 +148,6 @@ DefineSequence(ParseState *pstate, CreateSeqStmt *seq) &seqform, &last_value, &reset_state, &is_called, &need_seq_rewrite, &owned_by); =20 - /* - * Create relation (and fill value[] and null[] for the tuple) - */ - for (i =3D SEQ_COL_FIRSTCOL; i <=3D SEQ_COL_LASTCOL; i++) - { - ColumnDef *coldef =3D NULL; - - switch (i) - { - case SEQ_COL_LASTVAL: - coldef =3D makeColumnDef("last_value", INT8OID, -1, InvalidOid); - value[i - 1] =3D Int64GetDatumFast(last_value); - break; - case SEQ_COL_LOG: - coldef =3D makeColumnDef("log_cnt", INT8OID, -1, InvalidOid); - value[i - 1] =3D Int64GetDatum((int64) 0); - break; - case SEQ_COL_CALLED: - coldef =3D makeColumnDef("is_called", BOOLOID, -1, InvalidOid); - value[i - 1] =3D BoolGetDatum(false); - break; - } - - coldef->is_not_null =3D true; - null[i - 1] =3D false; - - elts =3D lappend(elts, coldef); - } - stmt->relation =3D seq->sequence; stmt->inhRelations =3D NIL; stmt->constraints =3D NIL; @@ -215,35 +160,20 @@ DefineSequence(ParseState *pstate, CreateSeqStmt *seq) */ stmt->tableElts =3D NIL; =20 + /* + * Initial relation has no attributes, these can be added later via the + * "init" AM callback. + */ + stmt->tableElts =3D NIL; + address =3D DefineRelation(stmt, RELKIND_SEQUENCE, seq->ownerId, NULL, NU= LL); seqoid =3D address.objectId; Assert(seqoid !=3D InvalidOid); =20 rel =3D sequence_open(seqoid, AccessExclusiveLock); =20 - /* Add all the attributes to the sequence */ - foreach(lc, elts) - { - AlterTableCmd *atcmd; - - atcmd =3D makeNode(AlterTableCmd); - atcmd->subtype =3D AT_AddColumnToSequence; - atcmd->def =3D (Node *) lfirst(lc); - atcmds =3D lappend(atcmds, atcmd); - } - - /* - * No recursion needed. Note that EventTriggerAlterTableStart() should - * have been called. - */ - AlterTableInternal(RelationGetRelid(rel), atcmds, false); - CommandCounterIncrement(); - - tupDesc =3D RelationGetDescr(rel); - - /* now initialize the sequence's data */ - tuple =3D heap_form_tuple(tupDesc, value, null); - fill_seq_with_data(rel, tuple); + /* now initialize the sequence table structure and its data */ + seq_local_init(rel, last_value, is_called); =20 /* process OWNED BY if given */ if (owned_by) @@ -292,10 +222,6 @@ ResetSequence(Oid seq_relid) { Relation seq_rel; SeqTable elm; - Form_pg_sequence_data seq; - Buffer buf; - HeapTupleData seqdatatuple; - HeapTuple tuple; HeapTuple pgstuple; Form_pg_sequence pgsform; int64 startv; @@ -306,7 +232,6 @@ ResetSequence(Oid seq_relid) * indeed a sequence. */ init_sequence(seq_relid, &elm, &seq_rel); - (void) read_seq_tuple(seq_rel, &buf, &seqdatatuple); =20 pgstuple =3D SearchSysCache1(SEQRELID, ObjectIdGetDatum(seq_relid)); if (!HeapTupleIsValid(pgstuple)) @@ -315,40 +240,8 @@ ResetSequence(Oid seq_relid) startv =3D pgsform->seqstart; ReleaseSysCache(pgstuple); =20 - /* - * Copy the existing sequence tuple. - */ - tuple =3D heap_copytuple(&seqdatatuple); - - /* Now we're done with the old page */ - UnlockReleaseBuffer(buf); - - /* - * Modify the copied tuple to execute the restart (compare the RESTART - * action in AlterSequence) - */ - seq =3D (Form_pg_sequence_data) GETSTRUCT(tuple); - seq->last_value =3D startv; - seq->is_called =3D false; - seq->log_cnt =3D 0; - - /* - * Create a new storage file for the sequence. - */ - RelationSetNewRelfilenumber(seq_rel, seq_rel->rd_rel->relpersistence); - - /* - * Ensure sequence's relfrozenxid is at 0, since it won't contain any - * unfrozen XIDs. Same with relminmxid, since a sequence will never - * contain multixacts. - */ - Assert(seq_rel->rd_rel->relfrozenxid =3D=3D InvalidTransactionId); - Assert(seq_rel->rd_rel->relminmxid =3D=3D InvalidMultiXactId); - - /* - * Insert the modified tuple into the new storage file. - */ - fill_seq_with_data(seq_rel, tuple); + /* Sequence state is forcibly reset here. */ + seq_local_reset(seq_rel, startv, false, true); =20 /* Clear local cache so that we don't think we have cached numbers */ /* Note that we do not change the currval() state */ @@ -357,106 +250,6 @@ ResetSequence(Oid seq_relid) sequence_close(seq_rel, NoLock); } =20 -/* - * Initialize a sequence's relation with the specified tuple as content - * - * This handles unlogged sequences by writing to both the main and the init - * fork as necessary. - */ -static void -fill_seq_with_data(Relation rel, HeapTuple tuple) -{ - fill_seq_fork_with_data(rel, tuple, MAIN_FORKNUM); - - if (rel->rd_rel->relpersistence =3D=3D RELPERSISTENCE_UNLOGGED) - { - SMgrRelation srel; - - srel =3D smgropen(rel->rd_locator, INVALID_PROC_NUMBER); - smgrcreate(srel, INIT_FORKNUM, false); - log_smgrcreate(&rel->rd_locator, INIT_FORKNUM); - fill_seq_fork_with_data(rel, tuple, INIT_FORKNUM); - FlushRelationBuffers(rel); - smgrclose(srel); - } -} - -/* - * Initialize a sequence's relation fork with the specified tuple as conte= nt - */ -static void -fill_seq_fork_with_data(Relation rel, HeapTuple tuple, ForkNumber forkNum) -{ - Buffer buf; - Page page; - sequence_magic *sm; - OffsetNumber offnum; - - /* Initialize first page of relation with special magic number */ - - buf =3D ExtendBufferedRel(BMR_REL(rel), forkNum, NULL, - EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK); - Assert(BufferGetBlockNumber(buf) =3D=3D 0); - - page =3D BufferGetPage(buf); - - PageInit(page, BufferGetPageSize(buf), sizeof(sequence_magic)); - sm =3D (sequence_magic *) PageGetSpecialPointer(page); - sm->magic =3D SEQ_MAGIC; - - /* Now insert sequence tuple */ - - /* - * Since VACUUM does not process sequences, we have to force the tuple to - * have xmin =3D FrozenTransactionId now. Otherwise it would become - * invisible to SELECTs after 2G transactions. It is okay to do this - * because if the current transaction aborts, no other xact will ever - * examine the sequence tuple anyway. - */ - HeapTupleHeaderSetXmin(tuple->t_data, FrozenTransactionId); - HeapTupleHeaderSetXminFrozen(tuple->t_data); - HeapTupleHeaderSetCmin(tuple->t_data, FirstCommandId); - HeapTupleHeaderSetXmax(tuple->t_data, InvalidTransactionId); - tuple->t_data->t_infomask |=3D HEAP_XMAX_INVALID; - ItemPointerSet(&tuple->t_data->t_ctid, 0, FirstOffsetNumber); - - /* check the comment above nextval_internal()'s equivalent call. */ - if (RelationNeedsWAL(rel)) - GetTopTransactionId(); - - START_CRIT_SECTION(); - - MarkBufferDirty(buf); - - offnum =3D PageAddItem(page, (Item) tuple->t_data, tuple->t_len, - InvalidOffsetNumber, false, false); - if (offnum !=3D FirstOffsetNumber) - elog(ERROR, "failed to add sequence tuple to page"); - - /* XLOG stuff */ - if (RelationNeedsWAL(rel) || forkNum =3D=3D INIT_FORKNUM) - { - xl_seq_rec xlrec; - XLogRecPtr recptr; - - XLogBeginInsert(); - XLogRegisterBuffer(0, buf, REGBUF_WILL_INIT); - - xlrec.locator =3D rel->rd_locator; - - XLogRegisterData((char *) &xlrec, sizeof(xl_seq_rec)); - XLogRegisterData((char *) tuple->t_data, tuple->t_len); - - recptr =3D XLogInsert(RM_SEQ_ID, XLOG_SEQ_LOG); - - PageSetLSN(page, recptr); - } - - END_CRIT_SECTION(); - - UnlockReleaseBuffer(buf); -} - /* * AlterSequence * @@ -468,10 +261,7 @@ AlterSequence(ParseState *pstate, AlterSeqStmt *stmt) Oid relid; SeqTable elm; Relation seqrel; - Buffer buf; - HeapTupleData datatuple; Form_pg_sequence seqform; - Form_pg_sequence_data newdataform; bool need_seq_rewrite; List *owned_by; ObjectAddress address; @@ -480,7 +270,6 @@ AlterSequence(ParseState *pstate, AlterSeqStmt *stmt) bool reset_state =3D false; bool is_called; int64 last_value; - HeapTuple newdatatuple; =20 /* Open and lock sequence, and check for ownership along the way. */ relid =3D RangeVarGetRelidExtended(stmt->sequence, @@ -507,16 +296,8 @@ AlterSequence(ParseState *pstate, AlterSeqStmt *stmt) =20 seqform =3D (Form_pg_sequence) GETSTRUCT(seqtuple); =20 - /* lock page buffer and read tuple into new sequence structure */ - (void) read_seq_tuple(seqrel, &buf, &datatuple); - - /* copy the existing sequence data tuple, so it can be modified locally */ - newdatatuple =3D heap_copytuple(&datatuple); - newdataform =3D (Form_pg_sequence_data) GETSTRUCT(newdatatuple); - last_value =3D newdataform->last_value; - is_called =3D newdataform->is_called; - - UnlockReleaseBuffer(buf); + /* Read sequence data */ + seq_local_get_state(seqrel, &last_value, &is_called); =20 /* Check and set new values */ init_params(pstate, stmt->options, stmt->for_identity, false, @@ -526,32 +307,10 @@ AlterSequence(ParseState *pstate, AlterSeqStmt *stmt) /* If needed, rewrite the sequence relation itself */ if (need_seq_rewrite) { - /* check the comment above nextval_internal()'s equivalent call. */ if (RelationNeedsWAL(seqrel)) GetTopTransactionId(); =20 - /* - * Create a new storage file for the sequence, making the state - * changes transactional. - */ - RelationSetNewRelfilenumber(seqrel, seqrel->rd_rel->relpersistence); - - /* - * Ensure sequence's relfrozenxid is at 0, since it won't contain any - * unfrozen XIDs. Same with relminmxid, since a sequence will never - * contain multixacts. - */ - Assert(seqrel->rd_rel->relfrozenxid =3D=3D InvalidTransactionId); - Assert(seqrel->rd_rel->relminmxid =3D=3D InvalidMultiXactId); - - /* - * Insert the modified tuple into the new storage file. - */ - newdataform->last_value =3D last_value; - newdataform->is_called =3D is_called; - if (reset_state) - newdataform->log_cnt =3D 0; - fill_seq_with_data(seqrel, newdatatuple); + seq_local_reset(seqrel, last_value, is_called, reset_state); } =20 /* Clear local cache so that we don't think we have cached numbers */ @@ -580,8 +339,6 @@ SequenceChangePersistence(Oid relid, char newrelpersist= ence) { SeqTable elm; Relation seqrel; - Buffer buf; - HeapTupleData seqdatatuple; =20 init_sequence(relid, &elm, &seqrel); =20 @@ -589,10 +346,7 @@ SequenceChangePersistence(Oid relid, char newrelpersis= tence) if (RelationNeedsWAL(seqrel)) GetTopTransactionId(); =20 - (void) read_seq_tuple(seqrel, &buf, &seqdatatuple); - RelationSetNewRelfilenumber(seqrel, newrelpersistence); - fill_seq_with_data(seqrel, &seqdatatuple); - UnlockReleaseBuffer(buf); + seq_local_change_persistence(seqrel, newrelpersistence); =20 sequence_close(seqrel, NoLock); } @@ -655,24 +409,15 @@ nextval_internal(Oid relid, bool check_permissions) { SeqTable elm; Relation seqrel; - Buffer buf; - Page page; HeapTuple pgstuple; Form_pg_sequence pgsform; - HeapTupleData seqdatatuple; - Form_pg_sequence_data seq; int64 incby, maxv, minv, cache, - log, - fetch, last; - int64 result, - next, - rescnt =3D 0; + int64 result; bool cycle; - bool logit =3D false; =20 /* open and lock sequence */ init_sequence(relid, &elm, &seqrel); @@ -717,105 +462,9 @@ nextval_internal(Oid relid, bool check_permissions) cycle =3D pgsform->seqcycle; ReleaseSysCache(pgstuple); =20 - /* lock page buffer and read tuple */ - seq =3D read_seq_tuple(seqrel, &buf, &seqdatatuple); - page =3D BufferGetPage(buf); - - last =3D next =3D result =3D seq->last_value; - fetch =3D cache; - log =3D seq->log_cnt; - - if (!seq->is_called) - { - rescnt++; /* return last_value if not is_called */ - fetch--; - } - - /* - * Decide whether we should emit a WAL log record. If so, force up the - * fetch count to grab SEQ_LOG_VALS more values than we actually need to - * cache. (These will then be usable without logging.) - * - * If this is the first nextval after a checkpoint, we must force a new - * WAL record to be written anyway, else replay starting from the - * checkpoint would fail to advance the sequence past the logged values. - * In this case we may as well fetch extra values. - */ - if (log < fetch || !seq->is_called) - { - /* forced log to satisfy local demand for values */ - fetch =3D log =3D fetch + SEQ_LOG_VALS; - logit =3D true; - } - else - { - XLogRecPtr redoptr =3D GetRedoRecPtr(); - - if (PageGetLSN(page) <=3D redoptr) - { - /* last update of seq was before checkpoint */ - fetch =3D log =3D fetch + SEQ_LOG_VALS; - logit =3D true; - } - } - - while (fetch) /* try to fetch cache [+ log ] numbers */ - { - /* - * Check MAXVALUE for ascending sequences and MINVALUE for descending - * sequences - */ - if (incby > 0) - { - /* ascending sequence */ - if ((maxv >=3D 0 && next > maxv - incby) || - (maxv < 0 && next + incby > maxv)) - { - if (rescnt > 0) - break; /* stop fetching */ - if (!cycle) - ereport(ERROR, - (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED), - errmsg("nextval: reached maximum value of sequence \"%s\" (%lld)", - RelationGetRelationName(seqrel), - (long long) maxv))); - next =3D minv; - } - else - next +=3D incby; - } - else - { - /* descending sequence */ - if ((minv < 0 && next < minv - incby) || - (minv >=3D 0 && next + incby < minv)) - { - if (rescnt > 0) - break; /* stop fetching */ - if (!cycle) - ereport(ERROR, - (errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED), - errmsg("nextval: reached minimum value of sequence \"%s\" (%lld)", - RelationGetRelationName(seqrel), - (long long) minv))); - next =3D maxv; - } - else - next +=3D incby; - } - fetch--; - if (rescnt < cache) - { - log--; - rescnt++; - last =3D next; - if (rescnt =3D=3D 1) /* if it's first result - */ - result =3D next; /* it's what to return */ - } - } - - log -=3D fetch; /* adjust for any unfetched numbers */ - Assert(log >=3D 0); + /* retrieve next value from the access method */ + result =3D seq_local_nextval(seqrel, incby, maxv, minv, cache, cycle, + &last); =20 /* save info in local cache */ elm->increment =3D incby; @@ -825,69 +474,6 @@ nextval_internal(Oid relid, bool check_permissions) =20 last_used_seq =3D elm; =20 - /* - * If something needs to be WAL logged, acquire an xid, so this - * transaction's commit will trigger a WAL flush and wait for syncrep. - * It's sufficient to ensure the toplevel transaction has an xid, no need - * to assign xids subxacts, that'll already trigger an appropriate wait. - * (Have to do that here, so we're outside the critical section) - */ - if (logit && RelationNeedsWAL(seqrel)) - GetTopTransactionId(); - - /* ready to change the on-disk (or really, in-buffer) tuple */ - START_CRIT_SECTION(); - - /* - * We must mark the buffer dirty before doing XLogInsert(); see notes in - * SyncOneBuffer(). However, we don't apply the desired changes just yet. - * This looks like a violation of the buffer update protocol, but it is in - * fact safe because we hold exclusive lock on the buffer. Any other - * process, including a checkpoint, that tries to examine the buffer - * contents will block until we release the lock, and then will see the - * final state that we install below. - */ - MarkBufferDirty(buf); - - /* XLOG stuff */ - if (logit && RelationNeedsWAL(seqrel)) - { - xl_seq_rec xlrec; - XLogRecPtr recptr; - - /* - * We don't log the current state of the tuple, but rather the state - * as it would appear after "log" more fetches. This lets us skip - * that many future WAL records, at the cost that we lose those - * sequence values if we crash. - */ - XLogBeginInsert(); - XLogRegisterBuffer(0, buf, REGBUF_WILL_INIT); - - /* set values that will be saved in xlog */ - seq->last_value =3D next; - seq->is_called =3D true; - seq->log_cnt =3D 0; - - xlrec.locator =3D seqrel->rd_locator; - - XLogRegisterData((char *) &xlrec, sizeof(xl_seq_rec)); - XLogRegisterData((char *) seqdatatuple.t_data, seqdatatuple.t_len); - - recptr =3D XLogInsert(RM_SEQ_ID, XLOG_SEQ_LOG); - - PageSetLSN(page, recptr); - } - - /* Now update sequence tuple to the intended final state */ - seq->last_value =3D last; /* last fetched number */ - seq->is_called =3D true; - seq->log_cnt =3D log; /* how much is logged */ - - END_CRIT_SECTION(); - - UnlockReleaseBuffer(buf); - sequence_close(seqrel, NoLock); =20 return result; @@ -977,9 +563,6 @@ do_setval(Oid relid, int64 next, bool iscalled) { SeqTable elm; Relation seqrel; - Buffer buf; - HeapTupleData seqdatatuple; - Form_pg_sequence_data seq; HeapTuple pgstuple; Form_pg_sequence pgsform; int64 maxv, @@ -1013,9 +596,6 @@ do_setval(Oid relid, int64 next, bool iscalled) */ PreventCommandIfParallelMode("setval()"); =20 - /* lock page buffer and read tuple */ - seq =3D read_seq_tuple(seqrel, &buf, &seqdatatuple); - if ((next < minv) || (next > maxv)) ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), @@ -1037,37 +617,8 @@ do_setval(Oid relid, int64 next, bool iscalled) if (RelationNeedsWAL(seqrel)) GetTopTransactionId(); =20 - /* ready to change the on-disk (or really, in-buffer) tuple */ - START_CRIT_SECTION(); - - seq->last_value =3D next; /* last fetched number */ - seq->is_called =3D iscalled; - seq->log_cnt =3D 0; - - MarkBufferDirty(buf); - - /* XLOG stuff */ - if (RelationNeedsWAL(seqrel)) - { - xl_seq_rec xlrec; - XLogRecPtr recptr; - Page page =3D BufferGetPage(buf); - - XLogBeginInsert(); - XLogRegisterBuffer(0, buf, REGBUF_WILL_INIT); - - xlrec.locator =3D seqrel->rd_locator; - XLogRegisterData((char *) &xlrec, sizeof(xl_seq_rec)); - XLogRegisterData((char *) seqdatatuple.t_data, seqdatatuple.t_len); - - recptr =3D XLogInsert(RM_SEQ_ID, XLOG_SEQ_LOG); - - PageSetLSN(page, recptr); - } - - END_CRIT_SECTION(); - - UnlockReleaseBuffer(buf); + /* Call the access method callback */ + seq_local_setval(seqrel, next, iscalled); =20 sequence_close(seqrel, NoLock); } @@ -1208,62 +759,6 @@ init_sequence(Oid relid, SeqTable *p_elm, Relation *p= _rel) } =20 =20 -/* - * Given an opened sequence relation, lock the page buffer and find the tu= ple - * - * *buf receives the reference to the pinned-and-ex-locked buffer - * *seqdatatuple receives the reference to the sequence tuple proper - * (this arg should point to a local variable of type HeapTupleData) - * - * Function's return value points to the data payload of the tuple - */ -static Form_pg_sequence_data -read_seq_tuple(Relation rel, Buffer *buf, HeapTuple seqdatatuple) -{ - Page page; - ItemId lp; - sequence_magic *sm; - Form_pg_sequence_data seq; - - *buf =3D ReadBuffer(rel, 0); - LockBuffer(*buf, BUFFER_LOCK_EXCLUSIVE); - - page =3D BufferGetPage(*buf); - sm =3D (sequence_magic *) PageGetSpecialPointer(page); - - if (sm->magic !=3D SEQ_MAGIC) - elog(ERROR, "bad magic number in sequence \"%s\": %08X", - RelationGetRelationName(rel), sm->magic); - - lp =3D PageGetItemId(page, FirstOffsetNumber); - Assert(ItemIdIsNormal(lp)); - - /* Note we currently only bother to set these two fields of *seqdatatuple= */ - seqdatatuple->t_data =3D (HeapTupleHeader) PageGetItem(page, lp); - seqdatatuple->t_len =3D ItemIdGetLength(lp); - - /* - * Previous releases of Postgres neglected to prevent SELECT FOR UPDATE on - * a sequence, which would leave a non-frozen XID in the sequence tuple's - * xmax, which eventually leads to clog access failures or worse. If we - * see this has happened, clean up after it. We treat this like a hint - * bit update, ie, don't bother to WAL-log it, since we can certainly do - * this again if the update gets lost. - */ - Assert(!(seqdatatuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI)); - if (HeapTupleHeaderGetRawXmax(seqdatatuple->t_data) !=3D InvalidTransacti= onId) - { - HeapTupleHeaderSetXmax(seqdatatuple->t_data, InvalidTransactionId); - seqdatatuple->t_data->t_infomask &=3D ~HEAP_XMAX_COMMITTED; - seqdatatuple->t_data->t_infomask |=3D HEAP_XMAX_INVALID; - MarkBufferDirtyHint(*buf, true); - } - - seq =3D (Form_pg_sequence_data) GETSTRUCT(seqdatatuple); - - return seq; -} - /* * init_params: process the options list of CREATE or ALTER SEQUENCE, and * store the values into appropriate fields of seqform, for changes that go @@ -1823,9 +1318,6 @@ pg_sequence_last_value(PG_FUNCTION_ARGS) SeqTable elm; Relation seqrel; TupleDesc tupdesc; - Buffer buf; - HeapTupleData seqtuple; - Form_pg_sequence_data seq; bool is_called; int64 last_value; =20 @@ -1842,12 +1334,7 @@ pg_sequence_last_value(PG_FUNCTION_ARGS) errmsg("permission denied for sequence %s", RelationGetRelationName(seqrel)))); =20 - seq =3D read_seq_tuple(seqrel, &buf, &seqtuple); - - is_called =3D seq->is_called; - last_value =3D seq->last_value; - - UnlockReleaseBuffer(buf); + seq_local_get_state(seqrel, &last_value, &is_called); sequence_close(seqrel, NoLock); =20 values[0] =3D BoolGetDatum(is_called); @@ -1855,57 +1342,6 @@ pg_sequence_last_value(PG_FUNCTION_ARGS) PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)= )); } =20 - -void -seq_redo(XLogReaderState *record) -{ - XLogRecPtr lsn =3D record->EndRecPtr; - uint8 info =3D XLogRecGetInfo(record) & ~XLR_INFO_MASK; - Buffer buffer; - Page page; - Page localpage; - char *item; - Size itemsz; - xl_seq_rec *xlrec =3D (xl_seq_rec *) XLogRecGetData(record); - sequence_magic *sm; - - if (info !=3D XLOG_SEQ_LOG) - elog(PANIC, "seq_redo: unknown op code %u", info); - - buffer =3D XLogInitBufferForRedo(record, 0); - page =3D (Page) BufferGetPage(buffer); - - /* - * We always reinit the page. However, since this WAL record type is also - * used for updating sequences, it's possible that a hot-standby backend - * is examining the page concurrently; so we mustn't transiently trash the - * buffer. The solution is to build the correct new page contents in - * local workspace and then memcpy into the buffer. Then only bytes that - * are supposed to change will change, even transiently. We must palloc - * the local page for alignment reasons. - */ - localpage =3D (Page) palloc(BufferGetPageSize(buffer)); - - PageInit(localpage, BufferGetPageSize(buffer), sizeof(sequence_magic)); - sm =3D (sequence_magic *) PageGetSpecialPointer(localpage); - sm->magic =3D SEQ_MAGIC; - - item =3D (char *) xlrec + sizeof(xl_seq_rec); - itemsz =3D XLogRecGetDataLen(record) - sizeof(xl_seq_rec); - - if (PageAddItem(localpage, (Item) item, itemsz, - FirstOffsetNumber, false, false) =3D=3D InvalidOffsetNumber) - elog(PANIC, "seq_redo: failed to add item to page"); - - PageSetLSN(localpage, lsn); - - memcpy(page, localpage, BufferGetPageSize(buffer)); - MarkBufferDirty(buffer); - UnlockReleaseBuffer(buffer); - - pfree(localpage); -} - /* * Flush cached sequence information. */ @@ -1920,14 +1356,3 @@ ResetSequenceCaches(void) =20 last_used_seq =3D NULL; } - -/* - * Mask a Sequence page before performing consistency checks on it. - */ -void -seq_mask(char *page, BlockNumber blkno) -{ - mask_page_lsn_and_checksum(page); - - mask_unused_space(page); -} diff --git a/src/bin/pg_waldump/.gitignore b/src/bin/pg_waldump/.gitignore index ec51f41c76..8d1195de26 100644 --- a/src/bin/pg_waldump/.gitignore +++ b/src/bin/pg_waldump/.gitignore @@ -10,13 +10,13 @@ /gistdesc.c /hashdesc.c /heapdesc.c +/seqlocaldesc.c /logicalmsgdesc.c /mxactdesc.c /nbtdesc.c /relmapdesc.c /replorigindesc.c /rmgrdesc_utils.c -/seqdesc.c /smgrdesc.c /spgdesc.c /standbydesc.c diff --git a/src/bin/pg_waldump/rmgrdesc.c b/src/bin/pg_waldump/rmgrdesc.c index 6b8c17bb4c..2fccc7a4e2 100644 --- a/src/bin/pg_waldump/rmgrdesc.c +++ b/src/bin/pg_waldump/rmgrdesc.c @@ -16,6 +16,7 @@ #include "access/gistxlog.h" #include "access/hash_xlog.h" #include "access/heapam_xlog.h" +#include "access/seqlocalam.h" #include "access/multixact.h" #include "access/nbtxlog.h" #include "access/rmgr.h" diff --git a/src/bin/pg_waldump/t/001_basic.pl b/src/bin/pg_waldump/t/001_b= asic.pl index 082cb8a589..8a36f49947 100644 --- a/src/bin/pg_waldump/t/001_basic.pl +++ b/src/bin/pg_waldump/t/001_basic.pl @@ -41,7 +41,7 @@ Btree Hash Gin Gist -Sequence +SequenceLocal SPGist BRIN CommitTs --=20 2.43.0 --Hb9lJVq6MVTkbU7F Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v5-0005-Sequence-access-methods-backend-support.patch" Content-Transfer-Encoding: quoted-printable =46rom 2448144361ef88729a7d56619f90348aca28e7a7 Mon Sep 17 00:00:00 2001 =46rom: Michael Paquier Date: Thu, 25 Apr 2024 17:15:20 +0900 Subject: [PATCH v5 5/8] Sequence access methods - backend support The "seqlocal" sequence AM is now plugged in as a handler in the relcache, and a set of callbacks in sequenceam.h. --- src/include/access/seqlocalam.h | 15 -- src/include/access/sequenceam.h | 181 ++++++++++++++++++ src/include/catalog/pg_am.dat | 3 + src/include/catalog/pg_am.h | 1 + src/include/catalog/pg_class.h | 6 + src/include/catalog/pg_proc.dat | 13 ++ src/include/catalog/pg_type.dat | 6 + src/include/commands/defrem.h | 1 + src/include/commands/sequence.h | 34 ---- src/include/nodes/meson.build | 1 + src/include/nodes/parsenodes.h | 1 + src/include/utils/guc_hooks.h | 2 + src/include/utils/rel.h | 5 + src/backend/access/sequence/Makefile | 2 +- src/backend/access/sequence/meson.build | 1 + src/backend/access/sequence/seqlocalam.c | 41 +++- src/backend/access/sequence/sequence.c | 3 +- src/backend/access/sequence/sequenceamapi.c | 145 ++++++++++++++ src/backend/catalog/heap.c | 6 +- src/backend/commands/amcmds.c | 16 ++ src/backend/commands/sequence.c | 21 +- src/backend/commands/tablecmds.c | 17 +- src/backend/nodes/Makefile | 1 + src/backend/nodes/gen_node_support.pl | 2 + src/backend/parser/gram.y | 12 +- src/backend/parser/parse_utilcmd.c | 2 + src/backend/utils/adt/pseudotypes.c | 1 + src/backend/utils/cache/relcache.c | 91 +++++++-- src/backend/utils/misc/guc_tables.c | 12 ++ src/backend/utils/misc/postgresql.conf.sample | 1 + src/bin/psql/describe.c | 2 + src/bin/psql/tab-complete.c | 4 +- src/test/regress/expected/create_am.out | 55 ++++-- src/test/regress/expected/opr_sanity.out | 12 ++ src/test/regress/expected/psql.out | 96 +++++----- src/test/regress/sql/create_am.sql | 24 ++- src/test/regress/sql/opr_sanity.sql | 10 + src/tools/pgindent/typedefs.list | 5 +- 38 files changed, 682 insertions(+), 169 deletions(-) create mode 100644 src/include/access/sequenceam.h create mode 100644 src/backend/access/sequence/sequenceamapi.c diff --git a/src/include/access/seqlocalam.h b/src/include/access/seqlocala= m.h index 225fb9a2cb..21936511ac 100644 --- a/src/include/access/seqlocalam.h +++ b/src/include/access/seqlocalam.h @@ -15,7 +15,6 @@ =20 #include "access/xlogreader.h" #include "storage/relfilelocator.h" -#include "utils/rel.h" =20 /* XLOG stuff */ #define XLOG_SEQ_LOCAL_LOG 0x00 @@ -41,18 +40,4 @@ extern void seq_local_desc(StringInfo buf, XLogReaderSta= te *record); extern const char *seq_local_identify(uint8 info); extern void seq_local_mask(char *page, BlockNumber blkno); =20 -/* access routines */ -extern int64 seq_local_nextval(Relation rel, int64 incby, int64 maxv, - int64 minv, int64 cache, bool cycle, - int64 *last); -extern const char *seq_local_get_table_am(void); -extern void seq_local_init(Relation rel, int64 last_value, bool is_called); -extern void seq_local_setval(Relation rel, int64 next, bool iscalled); -extern void seq_local_reset(Relation rel, int64 startv, bool is_called, - bool reset_state); -extern void seq_local_get_state(Relation rel, int64 *last_value, - bool *is_called); -extern void seq_local_change_persistence(Relation rel, - char newrelpersistence); - #endif /* SEQLOCALAM_H */ diff --git a/src/include/access/sequenceam.h b/src/include/access/sequencea= m.h new file mode 100644 index 0000000000..ac48c8b468 --- /dev/null +++ b/src/include/access/sequenceam.h @@ -0,0 +1,181 @@ +/*------------------------------------------------------------------------- + * + * sequenceam.h + * POSTGRES sequence access method definitions. + * + * + * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/access/sequenceam.h + * + * NOTES + * See sequenceam.sgml for higher level documentation. + * + *------------------------------------------------------------------------- + */ +#ifndef SEQUENCEAM_H +#define SEQUENCEAM_H + +#include "utils/rel.h" + +#define DEFAULT_SEQUENCE_ACCESS_METHOD "seqlocal" + +/* GUCs */ +extern PGDLLIMPORT char *default_sequence_access_method; + +/* + * API struct for a sequence AM. Note this must be allocated in a + * server-lifetime manner, typically as a static const struct, which then = gets + * returned by FormData_pg_am.amhandler. + * + * In most cases it's not appropriate to call the callbacks directly, use = the + * sequence_* wrapper functions instead. + * + * GetSequenceAmRoutine() asserts that required callbacks are filled in, + * remember to update when adding a callback. + */ +typedef struct SequenceAmRoutine +{ + /* this must be set to T_SequenceAmRoutine */ + NodeTag type; + + /* + * Retrieve table access method used by a sequence to store its metadata. + */ + const char *(*get_table_am) (void); + + /* + * Initialize sequence after creating a sequence Relation in pg_class, + * setting up the sequence for use. "last_value" and "is_called" are + * guessed from the options set for the sequence in CREATE SEQUENCE, based + * on the configuration of pg_sequence. + */ + void (*init) (Relation rel, int64 last_value, bool is_called); + + /* + * Retrieve a result for nextval(), based on the options retrieved from + * the sequence's options in pg_sequence. "last" is the last value + * calculated stored in the session's local cache, for lastval(). + */ + int64 (*nextval) (Relation rel, int64 incby, int64 maxv, + int64 minv, int64 cache, bool cycle, + int64 *last); + + /* + * Callback to set the state of a sequence, based on the input arguments + * from setval(). + */ + void (*setval) (Relation rel, int64 next, bool iscalled); + + /* + * Reset a sequence to its initial value. "reset_state", if set to true, + * means that the sequence parameters have changed, hence its internal + * state may need to be reset as well. "startv" and "is_called" are + * values guessed from the configuration of the sequence, based on the + * contents of pg_sequence. + */ + void (*reset) (Relation rel, int64 startv, bool is_called, + bool reset_state); + + /* + * Returns the current state of a sequence, returning data for + * pg_sequence_last_value() and related DDLs like ALTER SEQUENCE. + * "last_value" and "is_called" should be assigned to the values retrieved + * from the sequence Relation. + */ + void (*get_state) (Relation rel, int64 *last_value, bool *is_called); + + /* + * Callback used when switching persistence of a sequence Relation, to + * reset the sequence based on its new persistence "newrelpersistence". + */ + void (*change_persistence) (Relation rel, char newrelpersistence); + +} SequenceAmRoutine; + + +/* -----------------------------------------------------------------------= ---- + * Wrapper functions for each callback. + * -----------------------------------------------------------------------= ---- + */ + +/* + * Returns the name of the table access method used by this sequence. + */ +static inline const char * +sequence_get_table_am(Relation rel) +{ + return rel->rd_sequenceam->get_table_am(); +} + +/* + * Insert tuple data based on the information guessed from the contents + * of pg_sequence. + */ +static inline void +sequence_init(Relation rel, int64 last_value, bool is_called) +{ + rel->rd_sequenceam->init(rel, last_value, is_called); +} + +/* + * Allocate a set of values for the given sequence. "last" is the last va= lue + * allocated. The result returned is the next value of the sequence compu= ted. + */ +static inline int64 +sequence_nextval(Relation rel, int64 incby, int64 maxv, + int64 minv, int64 cache, bool cycle, + int64 *last) +{ + return rel->rd_sequenceam->nextval(rel, incby, maxv, minv, cache, + cycle, last); +} + +/* + * Callback to set the state of a sequence, based on the input arguments + * from setval(). + */ +static inline void +sequence_setval(Relation rel, int64 next, bool iscalled) +{ + rel->rd_sequenceam->setval(rel, next, iscalled); +} + +/* + * Reset a sequence to its initial state. + */ +static inline void +sequence_reset(Relation rel, int64 startv, bool is_called, + bool reset_state) +{ + rel->rd_sequenceam->reset(rel, startv, is_called, reset_state); +} + +/* + * Retrieve sequence metadata. + */ +static inline void +sequence_get_state(Relation rel, int64 *last_value, bool *is_called) +{ + rel->rd_sequenceam->get_state(rel, last_value, is_called); +} + +/* + * Callback to change the persistence of a sequence Relation. + */ +static inline void +sequence_change_persistence(Relation rel, char newrelpersistence) +{ + rel->rd_sequenceam->change_persistence(rel, newrelpersistence); +} + +/* -----------------------------------------------------------------------= ----- + * Functions in sequenceamapi.c + * -----------------------------------------------------------------------= ----- + */ + +extern const SequenceAmRoutine *GetSequenceAmRoutine(Oid amhandler); +extern Oid GetSequenceAmRoutineId(Oid amoid); + +#endif /* SEQUENCEAM_H */ diff --git a/src/include/catalog/pg_am.dat b/src/include/catalog/pg_am.dat index db87490282..d991a77604 100644 --- a/src/include/catalog/pg_am.dat +++ b/src/include/catalog/pg_am.dat @@ -15,6 +15,9 @@ { oid =3D> '2', oid_symbol =3D> 'HEAP_TABLE_AM_OID', descr =3D> 'heap table access method', amname =3D> 'heap', amhandler =3D> 'heap_tableam_handler', amtype =3D> '= t' }, +{ oid =3D> '8048', oid_symbol =3D> 'LOCAL_SEQUENCE_AM_OID', + descr =3D> 'local sequence access method', + amname =3D> 'seqlocal', amhandler =3D> 'seq_local_sequenceam_handler', a= mtype =3D> 's' }, { oid =3D> '403', oid_symbol =3D> 'BTREE_AM_OID', descr =3D> 'b-tree index access method', amname =3D> 'btree', amhandler =3D> 'bthandler', amtype =3D> 'i' }, diff --git a/src/include/catalog/pg_am.h b/src/include/catalog/pg_am.h index 475593fad4..3a94e8c636 100644 --- a/src/include/catalog/pg_am.h +++ b/src/include/catalog/pg_am.h @@ -59,6 +59,7 @@ MAKE_SYSCACHE(AMOID, pg_am_oid_index, 4); * Allowed values for amtype */ #define AMTYPE_INDEX 'i' /* index access method */ +#define AMTYPE_SEQUENCE 's' /* sequence access method */ #define AMTYPE_TABLE 't' /* table access method */ =20 #endif /* EXPOSE_TO_CLIENT_CODE */ diff --git a/src/include/catalog/pg_class.h b/src/include/catalog/pg_class.h index 0fc2c093b0..21623f34fa 100644 --- a/src/include/catalog/pg_class.h +++ b/src/include/catalog/pg_class.h @@ -228,6 +228,12 @@ MAKE_SYSCACHE(RELNAMENSP, pg_class_relname_nsp_index, = 128); (relkind) =3D=3D RELKIND_TOASTVALUE || \ (relkind) =3D=3D RELKIND_MATVIEW) =20 +/* + * Relation kinds with a sequence access method (rd_sequenceam). + */ +#define RELKIND_HAS_SEQUENCE_AM(relkind) \ + ((relkind) =3D=3D RELKIND_SEQUENCE) + extern int errdetail_relkind_not_supported(char relkind); =20 #endif /* EXPOSE_TO_CLIENT_CODE */ diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.= dat index 1a8c8ebba5..f012afbbde 100644 --- a/src/include/catalog/pg_proc.dat +++ b/src/include/catalog/pg_proc.dat @@ -913,6 +913,12 @@ prorettype =3D> 'table_am_handler', proargtypes =3D> 'internal', prosrc =3D> 'heap_tableam_handler' }, =20 +# Sequence access method handlers +{ oid =3D> '8209', descr =3D> 'local sequence access method handler', + proname =3D> 'seq_local_sequenceam_handler', provolatile =3D> 'v', + prorettype =3D> 'sequence_am_handler', proargtypes =3D> 'internal', + prosrc =3D> 'seq_local_sequenceam_handler' }, + # Index access method handlers { oid =3D> '330', descr =3D> 'btree index access method handler', proname =3D> 'bthandler', provolatile =3D> 'v', prorettype =3D> 'index_a= m_handler', @@ -7627,6 +7633,13 @@ { oid =3D> '327', descr =3D> 'I/O', proname =3D> 'index_am_handler_out', prorettype =3D> 'cstring', proargtypes =3D> 'index_am_handler', prosrc =3D> 'index_am_handler_out' = }, +{ oid =3D> '8207', descr =3D> 'I/O', + proname =3D> 'sequence_am_handler_in', proisstrict =3D> 'f', + prorettype =3D> 'sequence_am_handler', proargtypes =3D> 'cstring', + prosrc =3D> 'sequence_am_handler_in' }, +{ oid =3D> '8208', descr =3D> 'I/O', + proname =3D> 'sequence_am_handler_out', prorettype =3D> 'cstring', + proargtypes =3D> 'sequence_am_handler', prosrc =3D> 'sequence_am_handler= _out' }, { oid =3D> '3311', descr =3D> 'I/O', proname =3D> 'tsm_handler_in', proisstrict =3D> 'f', prorettype =3D> 'ts= m_handler', proargtypes =3D> 'cstring', prosrc =3D> 'tsm_handler_in' }, diff --git a/src/include/catalog/pg_type.dat b/src/include/catalog/pg_type.= dat index d29194da31..8f00b322ec 100644 --- a/src/include/catalog/pg_type.dat +++ b/src/include/catalog/pg_type.dat @@ -626,6 +626,12 @@ typcategory =3D> 'P', typinput =3D> 'index_am_handler_in', typoutput =3D> 'index_am_handler_out', typreceive =3D> '-', typsend =3D>= '-', typalign =3D> 'i' }, +{ oid =3D> '8210', + descr =3D> 'pseudo-type for the result of a sequence AM handler function= ', + typname =3D> 'sequence_am_handler', typlen =3D> '4', typbyval =3D> 't', + typtype =3D> 'p', typcategory =3D> 'P', typinput =3D> 'sequence_am_handl= er_in', + typoutput =3D> 'sequence_am_handler_out', typreceive =3D> '-', typsend = =3D> '-', + typalign =3D> 'i' }, { oid =3D> '3310', descr =3D> 'pseudo-type for the result of a tablesample method function', typname =3D> 'tsm_handler', typlen =3D> '4', typbyval =3D> 't', typtype = =3D> 'p', diff --git a/src/include/commands/defrem.h b/src/include/commands/defrem.h index 5fd095ea17..a43a6cbf85 100644 --- a/src/include/commands/defrem.h +++ b/src/include/commands/defrem.h @@ -145,6 +145,7 @@ extern Datum transformGenericOptions(Oid catalogId, extern ObjectAddress CreateAccessMethod(CreateAmStmt *stmt); extern Oid get_index_am_oid(const char *amname, bool missing_ok); extern Oid get_table_am_oid(const char *amname, bool missing_ok); +extern Oid get_sequence_am_oid(const char *amname, bool missing_ok); extern Oid get_am_oid(const char *amname, bool missing_ok); extern char *get_am_name(Oid amOid); =20 diff --git a/src/include/commands/sequence.h b/src/include/commands/sequenc= e.h index e88cbee3b5..9b22b2f248 100644 --- a/src/include/commands/sequence.h +++ b/src/include/commands/sequence.h @@ -22,35 +22,6 @@ #include "storage/relfilelocator.h" =20 =20 -typedef struct FormData_pg_sequence_data -{ - int64 last_value; - int64 log_cnt; - bool is_called; -} FormData_pg_sequence_data; - -typedef FormData_pg_sequence_data *Form_pg_sequence_data; - -/* - * Columns of a sequence relation - */ - -#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 - -/* XLOG stuff */ -#define XLOG_SEQ_LOG 0x00 - -typedef struct xl_seq_rec -{ - RelFileLocator locator; - /* SEQUENCE TUPLE DATA FOLLOWS AT THE END */ -} xl_seq_rec; - extern int64 nextval_internal(Oid relid, bool check_permissions); extern Datum nextval(PG_FUNCTION_ARGS); extern List *sequence_options(Oid relid); @@ -62,9 +33,4 @@ extern void DeleteSequenceTuple(Oid relid); extern void ResetSequence(Oid seq_relid); extern void ResetSequenceCaches(void); =20 -extern void seq_redo(XLogReaderState *record); -extern void seq_desc(StringInfo buf, XLogReaderState *record); -extern const char *seq_identify(uint8 info); -extern void seq_mask(char *page, BlockNumber blkno); - #endif /* SEQUENCE_H */ diff --git a/src/include/nodes/meson.build b/src/include/nodes/meson.build index b665e55b65..774ae2652c 100644 --- a/src/include/nodes/meson.build +++ b/src/include/nodes/meson.build @@ -9,6 +9,7 @@ node_support_input_i =3D [ 'nodes/execnodes.h', 'access/amapi.h', 'access/sdir.h', + 'access/sequenceam.h', 'access/tableam.h', 'access/tsmapi.h', 'commands/event_trigger.h', diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h index fdcebc268e..5910768cf7 100644 --- a/src/include/nodes/parsenodes.h +++ b/src/include/nodes/parsenodes.h @@ -3133,6 +3133,7 @@ typedef struct CreateSeqStmt List *options; Oid ownerId; /* ID of owner, or InvalidOid for default */ bool for_identity; + char *accessMethod; /* USING name of access method (eg. local) */ bool if_not_exists; /* just do nothing if it already exists? */ } CreateSeqStmt; =20 diff --git a/src/include/utils/guc_hooks.h b/src/include/utils/guc_hooks.h index d64dc5fcdb..539ca97003 100644 --- a/src/include/utils/guc_hooks.h +++ b/src/include/utils/guc_hooks.h @@ -55,6 +55,8 @@ extern bool check_debug_io_direct(char **newval, void **e= xtra, GucSource source) extern void assign_debug_io_direct(const char *newval, void *extra); extern bool check_default_table_access_method(char **newval, void **extra, GucSource source); +extern bool check_default_sequence_access_method(char **newval, void **ext= ra, + GucSource source); extern bool check_default_tablespace(char **newval, void **extra, GucSource source); extern bool check_default_text_search_config(char **newval, void **extra, = GucSource source); diff --git a/src/include/utils/rel.h b/src/include/utils/rel.h index 8700204953..2a4b7bed2b 100644 --- a/src/include/utils/rel.h +++ b/src/include/utils/rel.h @@ -188,6 +188,11 @@ typedef struct RelationData */ const struct TableAmRoutine *rd_tableam; =20 + /* + * Sequence access method. + */ + const struct SequenceAmRoutine *rd_sequenceam; + /* These are non-NULL only for an index relation: */ Form_pg_index rd_index; /* pg_index tuple describing this index */ /* use "struct" here to avoid needing to include htup.h: */ diff --git a/src/backend/access/sequence/Makefile b/src/backend/access/sequ= ence/Makefile index a15ceec1c0..62006165a1 100644 --- a/src/backend/access/sequence/Makefile +++ b/src/backend/access/sequence/Makefile @@ -12,6 +12,6 @@ subdir =3D src/backend/access/sequence top_builddir =3D ../../../.. include $(top_builddir)/src/Makefile.global =20 -OBJS =3D seqlocalam.o seqlocalxlog.o sequence.o +OBJS =3D seqlocalam.o seqlocalxlog.o sequence.o sequenceamapi.o =20 include $(top_srcdir)/src/backend/common.mk diff --git a/src/backend/access/sequence/meson.build b/src/backend/access/s= equence/meson.build index 4d24f900b6..ea91990552 100644 --- a/src/backend/access/sequence/meson.build +++ b/src/backend/access/sequence/meson.build @@ -4,4 +4,5 @@ backend_sources +=3D files( 'seqlocalam.c', 'seqlocalxlog.c', 'sequence.c', + 'sequenceamapi.c', ) diff --git a/src/backend/access/sequence/seqlocalam.c b/src/backend/access/= sequence/seqlocalam.c index b0a0d72966..2e524c9e99 100644 --- a/src/backend/access/sequence/seqlocalam.c +++ b/src/backend/access/sequence/seqlocalam.c @@ -17,6 +17,7 @@ =20 #include "access/multixact.h" #include "access/seqlocalam.h" +#include "access/sequenceam.h" #include "access/xact.h" #include "access/xloginsert.h" #include "access/xlogutils.h" @@ -24,6 +25,7 @@ #include "commands/tablecmds.h" #include "miscadmin.h" #include "nodes/makefuncs.h" +#include "utils/builtins.h" =20 =20 /* @@ -230,10 +232,10 @@ fill_seq_fork_with_data(Relation rel, HeapTuple tuple= , ForkNumber forkNum) * Allocate a new value for a local sequence, based on the sequence * configuration. */ -int64 +static int64 seq_local_nextval(Relation rel, int64 incby, int64 maxv, - int64 minv, int64 cache, bool cycle, - int64 *last) + int64 minv, int64 cache, bool cycle, + int64 *last) { int64 result; int64 fetch; @@ -417,7 +419,7 @@ seq_local_nextval(Relation rel, int64 incby, int64 maxv, * * Return the table access method used by this sequence. */ -const char * +static const char * seq_local_get_table_am(void) { return "heap"; @@ -432,7 +434,7 @@ seq_local_get_table_am(void) * inserted after the relation has been created, filling in its heap * table. */ -void +static void seq_local_init(Relation rel, int64 last_value, bool is_called) { Datum value[SEQ_LOCAL_COL_LASTCOL]; @@ -499,7 +501,7 @@ seq_local_init(Relation rel, int64 last_value, bool is_= called) * * Callback for setval(). */ -void +static void seq_local_setval(Relation rel, int64 next, bool iscalled) { Buffer buf; @@ -547,7 +549,7 @@ seq_local_setval(Relation rel, int64 next, bool iscalle= d) * Perform a hard reset on the local sequence, rewriting its heap data * entirely. */ -void +static void seq_local_reset(Relation rel, int64 startv, bool is_called, bool reset_sta= te) { Form_pg_seq_local_data seq; @@ -600,7 +602,7 @@ seq_local_reset(Relation rel, int64 startv, bool is_cal= led, bool reset_state) * * Retrieve the state of a local sequence. */ -void +static void seq_local_get_state(Relation rel, int64 *last_value, bool *is_called) { Buffer buf; @@ -621,7 +623,7 @@ seq_local_get_state(Relation rel, int64 *last_value, bo= ol *is_called) * * Persistence change for the local sequence Relation. */ -void +static void seq_local_change_persistence(Relation rel, char newrelpersistence) { Buffer buf; @@ -632,3 +634,24 @@ seq_local_change_persistence(Relation rel, char newrel= persistence) fill_seq_with_data(rel, &seqdatatuple); UnlockReleaseBuffer(buf); } + +/* ------------------------------------------------------------------------ + * Definition of the local sequence access method. + * ------------------------------------------------------------------------ + */ +static const SequenceAmRoutine seq_local_methods =3D { + .type =3D T_SequenceAmRoutine, + .get_table_am =3D seq_local_get_table_am, + .init =3D seq_local_init, + .nextval =3D seq_local_nextval, + .setval =3D seq_local_setval, + .reset =3D seq_local_reset, + .get_state =3D seq_local_get_state, + .change_persistence =3D seq_local_change_persistence +}; + +Datum +seq_local_sequenceam_handler(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(&seq_local_methods); +} diff --git a/src/backend/access/sequence/sequence.c b/src/backend/access/se= quence/sequence.c index 8d6b7bb5dc..5e7d76d3b0 100644 --- a/src/backend/access/sequence/sequence.c +++ b/src/backend/access/sequence/sequence.c @@ -13,7 +13,8 @@ * * NOTES * This file contains sequence_ routines that implement access to sequen= ces - * (in contrast to other relation types like indexes). + * (in contrast to other relation types like indexes) that are independe= nt + * of individual sequence access methods. * *------------------------------------------------------------------------- */ diff --git a/src/backend/access/sequence/sequenceamapi.c b/src/backend/acce= ss/sequence/sequenceamapi.c new file mode 100644 index 0000000000..dd1a60d827 --- /dev/null +++ b/src/backend/access/sequence/sequenceamapi.c @@ -0,0 +1,145 @@ +/*------------------------------------------------------------------------- + * + * sequenceamapi.c + * general sequence access method routines + * + * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * src/backend/access/sequence/sequenceamapi.c + * + * + * Sequence access method allows the SQL Standard Sequence objects to be + * managed according to either the default access method or a pluggable + * replacement. Each sequence can only use one access method at a time, + * though different sequence access methods can be in use by different + * sequences at the same time. + * + * -----------------------------------------------------------------------= -- + */ + +#include "postgres.h" + +#include "access/xact.h" +#include "access/sequenceam.h" +#include "catalog/pg_am.h" +#include "commands/defrem.h" +#include "miscadmin.h" +#include "utils/guc_hooks.h" +#include "utils/syscache.h" + + +/* GUC */ +char *default_sequence_access_method =3D DEFAULT_SEQUENCE_ACCESS_METHOD; + +/* + * GetSequenceAmRoutine + * Call the specified access method handler routine to get its + * SequenceAmRoutine struct, which will be palloc'd in the caller's + * memory context. + */ +const SequenceAmRoutine * +GetSequenceAmRoutine(Oid amhandler) +{ + Datum datum; + SequenceAmRoutine *routine; + + datum =3D OidFunctionCall0(amhandler); + routine =3D (SequenceAmRoutine *) DatumGetPointer(datum); + + if (routine =3D=3D NULL || !IsA(routine, SequenceAmRoutine)) + elog(ERROR, "sequence access method handler %u did not return a Sequence= AmRoutine struct", + amhandler); + + /* + * Assert that all required callbacks are present. That makes it a bit + * easier to keep AMs up to date, e.g. when forward porting them to a new + * major version. + */ + Assert(routine->get_table_am !=3D NULL); + Assert(routine->init !=3D NULL); + Assert(routine->nextval !=3D NULL); + Assert(routine->setval !=3D NULL); + Assert(routine->reset !=3D NULL); + Assert(routine->get_state !=3D NULL); + Assert(routine->change_persistence !=3D NULL); + + return routine; +} + +/* + * GetSequenceAmRoutineId + * Call pg_am and retrieve the OID of the access method handler. + */ +Oid +GetSequenceAmRoutineId(Oid amoid) +{ + Oid amhandleroid; + HeapTuple tuple; + Form_pg_am aform; + + tuple =3D SearchSysCache1(AMOID, + ObjectIdGetDatum(amoid)); + if (!HeapTupleIsValid(tuple)) + elog(ERROR, "cache lookup failed for access method %u", amoid); + aform =3D (Form_pg_am) GETSTRUCT(tuple); + Assert(aform->amtype =3D=3D AMTYPE_SEQUENCE); + amhandleroid =3D aform->amhandler; + ReleaseSysCache(tuple); + + return amhandleroid; +} + +/* check_hook: validate new default_sequence_access_method */ +bool +check_default_sequence_access_method(char **newval, void **extra, + GucSource source) +{ + if (**newval =3D=3D '\0') + { + GUC_check_errdetail("%s cannot be empty.", + "default_sequence_access_method"); + return false; + } + + if (strlen(*newval) >=3D NAMEDATALEN) + { + GUC_check_errdetail("%s is too long (maximum %d characters).", + "default_sequence_access_method", NAMEDATALEN - 1); + return false; + } + + /* + * If we aren't inside a transaction, or not connected to a database, we + * cannot do the catalog access necessary to verify the method. Must + * accept the value on faith. + */ + if (IsTransactionState() && MyDatabaseId !=3D InvalidOid) + { + if (!OidIsValid(get_sequence_am_oid(*newval, true))) + { + /* + * When source =3D=3D PGC_S_TEST, don't throw a hard error for a + * nonexistent sequence access method, only a NOTICE. See comments + * in guc.h. + */ + if (source =3D=3D PGC_S_TEST) + { + ereport(NOTICE, + (errcode(ERRCODE_UNDEFINED_OBJECT), + errmsg("sequence access method \"%s\" does not exist", + *newval))); + } + else + { + GUC_check_errdetail("sequence access method \"%s\" does not exist.", + *newval); + return false; + } + } + } + + return true; +} diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c index f0278b9c01..bca2259e4b 100644 --- a/src/backend/catalog/heap.c +++ b/src/backend/catalog/heap.c @@ -1464,8 +1464,12 @@ heap_create_with_catalog(const char *relname, * * No need to add an explicit dependency for the toast table, as the * main table depends on it. + * + * Sequences and tables are created with their access method ID + * given by the caller of this function. */ - if (RELKIND_HAS_TABLE_AM(relkind) && relkind !=3D RELKIND_TOASTVALUE) + if ((RELKIND_HAS_TABLE_AM(relkind) && relkind !=3D RELKIND_TOASTVALUE) || + RELKIND_HAS_SEQUENCE_AM(relkind)) { ObjectAddressSet(referenced, AccessMethodRelationId, accessmtd); add_exact_object_address(&referenced, addrs); diff --git a/src/backend/commands/amcmds.c b/src/backend/commands/amcmds.c index aaa0f9a1dc..1a27f191a3 100644 --- a/src/backend/commands/amcmds.c +++ b/src/backend/commands/amcmds.c @@ -15,6 +15,7 @@ =20 #include "access/htup_details.h" #include "access/table.h" +#include "access/sequenceam.h" #include "catalog/catalog.h" #include "catalog/dependency.h" #include "catalog/indexing.h" @@ -175,6 +176,16 @@ get_table_am_oid(const char *amname, bool missing_ok) return get_am_type_oid(amname, AMTYPE_TABLE, missing_ok); } =20 +/* + * get_sequence_am_oid - given an access method name, look up its OID + * and verify it corresponds to an sequence AM. + */ +Oid +get_sequence_am_oid(const char *amname, bool missing_ok) +{ + return get_am_type_oid(amname, AMTYPE_SEQUENCE, missing_ok); +} + /* * get_am_oid - given an access method name, look up its OID. * The type is not checked. @@ -215,6 +226,8 @@ get_am_type_string(char amtype) { case AMTYPE_INDEX: return "INDEX"; + case AMTYPE_SEQUENCE: + return "SEQUENCE"; case AMTYPE_TABLE: return "TABLE"; default: @@ -251,6 +264,9 @@ lookup_am_handler_func(List *handler_name, char amtype) case AMTYPE_INDEX: expectedType =3D INDEX_AM_HANDLEROID; break; + case AMTYPE_SEQUENCE: + expectedType =3D SEQUENCE_AM_HANDLEROID; + break; case AMTYPE_TABLE: expectedType =3D TABLE_AM_HANDLEROID; break; diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequenc= e.c index 6d712e76e2..57db43501e 100644 --- a/src/backend/commands/sequence.c +++ b/src/backend/commands/sequence.c @@ -16,10 +16,10 @@ =20 #include "access/bufmask.h" #include "access/htup_details.h" -#include "access/seqlocalam.h" #include "access/multixact.h" #include "access/relation.h" #include "access/sequence.h" +#include "access/sequenceam.h" #include "access/table.h" #include "access/transam.h" #include "access/xact.h" @@ -152,6 +152,7 @@ DefineSequence(ParseState *pstate, CreateSeqStmt *seq) stmt->inhRelations =3D NIL; stmt->constraints =3D NIL; stmt->options =3D NIL; + stmt->accessMethod =3D seq->accessMethod ? pstrdup(seq->accessMethod) : N= ULL; stmt->oncommit =3D ONCOMMIT_NOOP; stmt->tablespacename =3D NULL; stmt->if_not_exists =3D seq->if_not_exists; @@ -173,7 +174,7 @@ DefineSequence(ParseState *pstate, CreateSeqStmt *seq) rel =3D sequence_open(seqoid, AccessExclusiveLock); =20 /* now initialize the sequence table structure and its data */ - seq_local_init(rel, last_value, is_called); + sequence_init(rel, last_value, is_called); =20 /* process OWNED BY if given */ if (owned_by) @@ -241,7 +242,7 @@ ResetSequence(Oid seq_relid) ReleaseSysCache(pgstuple); =20 /* Sequence state is forcibly reset here. */ - seq_local_reset(seq_rel, startv, false, true); + sequence_reset(seq_rel, startv, false, true); =20 /* Clear local cache so that we don't think we have cached numbers */ /* Note that we do not change the currval() state */ @@ -297,7 +298,7 @@ AlterSequence(ParseState *pstate, AlterSeqStmt *stmt) seqform =3D (Form_pg_sequence) GETSTRUCT(seqtuple); =20 /* Read sequence data */ - seq_local_get_state(seqrel, &last_value, &is_called); + sequence_get_state(seqrel, &last_value, &is_called); =20 /* Check and set new values */ init_params(pstate, stmt->options, stmt->for_identity, false, @@ -310,7 +311,7 @@ AlterSequence(ParseState *pstate, AlterSeqStmt *stmt) if (RelationNeedsWAL(seqrel)) GetTopTransactionId(); =20 - seq_local_reset(seqrel, last_value, is_called, reset_state); + sequence_reset(seqrel, last_value, is_called, reset_state); } =20 /* Clear local cache so that we don't think we have cached numbers */ @@ -346,7 +347,7 @@ SequenceChangePersistence(Oid relid, char newrelpersist= ence) if (RelationNeedsWAL(seqrel)) GetTopTransactionId(); =20 - seq_local_change_persistence(seqrel, newrelpersistence); + sequence_change_persistence(seqrel, newrelpersistence); =20 sequence_close(seqrel, NoLock); } @@ -463,8 +464,8 @@ nextval_internal(Oid relid, bool check_permissions) ReleaseSysCache(pgstuple); =20 /* retrieve next value from the access method */ - result =3D seq_local_nextval(seqrel, incby, maxv, minv, cache, cycle, - &last); + result =3D sequence_nextval(seqrel, incby, maxv, minv, cache, cycle, + &last); =20 /* save info in local cache */ elm->increment =3D incby; @@ -618,7 +619,7 @@ do_setval(Oid relid, int64 next, bool iscalled) GetTopTransactionId(); =20 /* Call the access method callback */ - seq_local_setval(seqrel, next, iscalled); + sequence_setval(seqrel, next, iscalled); =20 sequence_close(seqrel, NoLock); } @@ -1334,7 +1335,7 @@ pg_sequence_last_value(PG_FUNCTION_ARGS) errmsg("permission denied for sequence %s", RelationGetRelationName(seqrel)))); =20 - seq_local_get_state(seqrel, &last_value, &is_called); + sequence_get_state(seqrel, &last_value, &is_called); sequence_close(seqrel, NoLock); =20 values[0] =3D BoolGetDatum(is_called); diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablec= mds.c index ad24777bb8..f8a771d1ff 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -23,6 +23,7 @@ #include "access/reloptions.h" #include "access/relscan.h" #include "access/sysattr.h" +#include "access/sequenceam.h" #include "access/tableam.h" #include "access/toast_compression.h" #include "access/xact.h" @@ -964,14 +965,18 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ow= nerId, } =20 /* - * For relations with table AM and partitioned tables, select access - * method to use: an explicitly indicated one, or (in the case of a + * For relations with table AM, partitioned tables or sequences, select + * access method to use: an explicitly indicated one, or (in the case of a * partitioned table) the parent's, if it has one. */ if (stmt->accessMethod !=3D NULL) { - Assert(RELKIND_HAS_TABLE_AM(relkind) || relkind =3D=3D RELKIND_PARTITION= ED_TABLE); - accessMethodId =3D get_table_am_oid(stmt->accessMethod, false); + Assert(RELKIND_HAS_TABLE_AM(relkind) || relkind =3D=3D RELKIND_PARTITION= ED_TABLE || + RELKIND_HAS_SEQUENCE_AM(relkind)); + if (RELKIND_HAS_SEQUENCE_AM(relkind)) + accessMethodId =3D get_sequence_am_oid(stmt->accessMethod, false); + else + accessMethodId =3D get_table_am_oid(stmt->accessMethod, false); } else if (RELKIND_HAS_TABLE_AM(relkind) || relkind =3D=3D RELKIND_PARTITIO= NED_TABLE) { @@ -984,6 +989,10 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid own= erId, if (RELKIND_HAS_TABLE_AM(relkind) && !OidIsValid(accessMethodId)) accessMethodId =3D get_table_am_oid(default_table_access_method, false); } + else if (RELKIND_HAS_SEQUENCE_AM(relkind)) + { + accessMethodId =3D get_sequence_am_oid(default_sequence_access_method, f= alse); + } =20 /* * Create the relation. Inherited defaults and constraints are passed in diff --git a/src/backend/nodes/Makefile b/src/backend/nodes/Makefile index 66bbad8e6e..86b1773c0b 100644 --- a/src/backend/nodes/Makefile +++ b/src/backend/nodes/Makefile @@ -47,6 +47,7 @@ node_headers =3D \ nodes/execnodes.h \ access/amapi.h \ access/sdir.h \ + access/sequenceam.h \ access/tableam.h \ access/tsmapi.h \ commands/event_trigger.h \ diff --git a/src/backend/nodes/gen_node_support.pl b/src/backend/nodes/gen_= node_support.pl index 81df3bdf95..d2450e559d 100644 --- a/src/backend/nodes/gen_node_support.pl +++ b/src/backend/nodes/gen_node_support.pl @@ -59,6 +59,7 @@ my @all_input_files =3D qw( nodes/execnodes.h access/amapi.h access/sdir.h + access/sequenceam.h access/tableam.h access/tsmapi.h commands/event_trigger.h @@ -83,6 +84,7 @@ my @nodetag_only_files =3D qw( nodes/execnodes.h access/amapi.h access/sdir.h + access/sequenceam.h access/tableam.h access/tsmapi.h commands/event_trigger.h diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y index e8b619926e..2e33fb4578 100644 --- a/src/backend/parser/gram.y +++ b/src/backend/parser/gram.y @@ -391,6 +391,7 @@ static Node *makeRecursiveViewSelect(char *relname, Lis= t *aliases, Node *query); %type copy_file_name access_method_clause attr_name table_access_method_clause name cursor_name file_name + sequence_access_method_clause cluster_index_specification =20 %type func_name handler_name qual_Op qual_all_Op subquery_Op @@ -4929,23 +4930,26 @@ RefreshMatViewStmt: =20 CreateSeqStmt: CREATE OptTemp SEQUENCE qualified_name OptSeqOptList + sequence_access_method_clause { CreateSeqStmt *n =3D makeNode(CreateSeqStmt); - $4->relpersistence =3D $2; n->sequence =3D $4; n->options =3D $5; + n->accessMethod =3D $6; n->ownerId =3D InvalidOid; n->if_not_exists =3D false; $$ =3D (Node *) n; } | CREATE OptTemp SEQUENCE IF_P NOT EXISTS qualified_name OptSeqOptList + sequence_access_method_clause { CreateSeqStmt *n =3D makeNode(CreateSeqStmt); =20 $7->relpersistence =3D $2; n->sequence =3D $7; n->options =3D $8; + n->accessMethod =3D $9; n->ownerId =3D InvalidOid; n->if_not_exists =3D true; $$ =3D (Node *) n; @@ -4982,6 +4986,11 @@ OptParenthesizedSeqOptList: '(' SeqOptList ')' { $$= =3D $2; } | /*EMPTY*/ { $$ =3D NIL; } ; =20 +sequence_access_method_clause: + USING name { $$ =3D $2; } + | /*EMPTY*/ { $$ =3D NULL; } + ; + SeqOptList: SeqOptElem { $$ =3D list_make1($1); } | SeqOptList SeqOptElem { $$ =3D lappend($1, $2); } ; @@ -5978,6 +5987,7 @@ CreateAmStmt: CREATE ACCESS METHOD name TYPE_P am_typ= e HANDLER handler_name =20 am_type: INDEX { $$ =3D AMTYPE_INDEX; } + | SEQUENCE { $$ =3D AMTYPE_SEQUENCE; } | TABLE { $$ =3D AMTYPE_TABLE; } ; =20 diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_= utilcmd.c index fef084f5d5..ae63168634 100644 --- a/src/backend/parser/parse_utilcmd.c +++ b/src/backend/parser/parse_utilcmd.c @@ -26,6 +26,7 @@ #include "access/htup_details.h" #include "access/relation.h" #include "access/reloptions.h" +#include "access/sequenceam.h" #include "access/table.h" #include "access/toast_compression.h" #include "catalog/dependency.h" @@ -473,6 +474,7 @@ generateSerialExtraStmts(CreateStmtContext *cxt, Column= Def *column, seqstmt->sequence->relpersistence =3D cxt->rel ? cxt->rel->rd_rel->relper= sistence : cxt->relation->relpersistence; =20 seqstmt->options =3D seqoptions; + seqstmt->accessMethod =3D NULL; =20 /* * If a sequence data type was specified, add it to the options. Prepend diff --git a/src/backend/utils/adt/pseudotypes.c b/src/backend/utils/adt/ps= eudotypes.c index e189e9b79d..e31dbb0ebb 100644 --- a/src/backend/utils/adt/pseudotypes.c +++ b/src/backend/utils/adt/pseudotypes.c @@ -369,6 +369,7 @@ PSEUDOTYPE_DUMMY_IO_FUNCS(language_handler); PSEUDOTYPE_DUMMY_IO_FUNCS(fdw_handler); PSEUDOTYPE_DUMMY_IO_FUNCS(table_am_handler); PSEUDOTYPE_DUMMY_IO_FUNCS(index_am_handler); +PSEUDOTYPE_DUMMY_IO_FUNCS(sequence_am_handler); PSEUDOTYPE_DUMMY_IO_FUNCS(tsm_handler); PSEUDOTYPE_DUMMY_IO_FUNCS(internal); PSEUDOTYPE_DUMMY_IO_FUNCS(anyelement); diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/r= elcache.c index 262c9878dd..d9e40c5979 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -34,6 +34,7 @@ #include "access/multixact.h" #include "access/parallel.h" #include "access/reloptions.h" +#include "access/sequenceam.h" #include "access/sysattr.h" #include "access/table.h" #include "access/tableam.h" @@ -64,6 +65,7 @@ #include "catalog/pg_type.h" #include "catalog/schemapg.h" #include "catalog/storage.h" +#include "commands/defrem.h" #include "commands/policy.h" #include "commands/publicationcmds.h" #include "commands/trigger.h" @@ -300,6 +302,7 @@ static void RelationParseRelOptions(Relation relation, = HeapTuple tuple); static void RelationBuildTupleDesc(Relation relation); static Relation RelationBuildDesc(Oid targetRelId, bool insertIt); static void RelationInitPhysicalAddr(Relation relation); +static void RelationInitSequenceAccessMethod(Relation relation); static void load_critical_index(Oid indexoid, Oid heapoid); static TupleDesc GetPgClassDescriptor(void); static TupleDesc GetPgIndexDescriptor(void); @@ -1205,8 +1208,7 @@ retry: if (relation->rd_rel->relkind =3D=3D RELKIND_INDEX || relation->rd_rel->relkind =3D=3D RELKIND_PARTITIONED_INDEX) RelationInitIndexAccessInfo(relation); - else if (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind) || - relation->rd_rel->relkind =3D=3D RELKIND_SEQUENCE) + else if (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind)) RelationInitTableAccessMethod(relation); else if (relation->rd_rel->relkind =3D=3D RELKIND_PARTITIONED_TABLE) { @@ -1215,6 +1217,8 @@ retry: * inherit. */ } + else if (RELKIND_HAS_SEQUENCE_AM(relation->rd_rel->relkind)) + RelationInitSequenceAccessMethod(relation); else Assert(relation->rd_rel->relam =3D=3D InvalidOid); =20 @@ -1811,17 +1815,9 @@ RelationInitTableAccessMethod(Relation relation) HeapTuple tuple; Form_pg_am aform; =20 - if (relation->rd_rel->relkind =3D=3D RELKIND_SEQUENCE) - { - /* - * Sequences are currently accessed like heap tables, but it doesn't - * seem prudent to show that in the catalog. So just overwrite it - * here. - */ - Assert(relation->rd_rel->relam =3D=3D InvalidOid); - relation->rd_amhandler =3D F_HEAP_TABLEAM_HANDLER; - } - else if (IsCatalogRelation(relation)) + Assert(RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind)); + + if (IsCatalogRelation(relation)) { /* * Avoid doing a syscache lookup for catalog tables. @@ -1852,6 +1848,49 @@ RelationInitTableAccessMethod(Relation relation) InitTableAmRoutine(relation); } =20 +/* + * Initialize sequence-access-method support data for a sequence relation + */ +static void +RelationInitSequenceAccessMethod(Relation relation) +{ + HeapTuple tuple; + Form_pg_am aform; + const char *tableam_name; + Oid tableam_oid; + Oid tableam_handler; + + Assert(RELKIND_HAS_SEQUENCE_AM(relation->rd_rel->relkind)); + + /* + * Look up the sequence access method, save the OID of its handler + * function. + */ + Assert(relation->rd_rel->relam !=3D InvalidOid); + relation->rd_amhandler =3D GetSequenceAmRoutineId(relation->rd_rel->relam= ); + + /* + * Now we can fetch the sequence AM's API struct. + */ + relation->rd_sequenceam =3D GetSequenceAmRoutine(relation->rd_amhandler); + + /* + * From the sequence AM, set its expected table access method. + */ + tableam_name =3D sequence_get_table_am(relation); + tableam_oid =3D get_table_am_oid(tableam_name, false); + + tuple =3D SearchSysCache1(AMOID, ObjectIdGetDatum(tableam_oid)); + if (!HeapTupleIsValid(tuple)) + elog(ERROR, "cache lookup failed for access method %u", + tableam_oid); + aform =3D (Form_pg_am) GETSTRUCT(tuple); + tableam_handler =3D aform->amhandler; + ReleaseSysCache(tuple); + + relation->rd_tableam =3D GetTableAmRoutine(tableam_handler); +} + /* * formrdesc * @@ -3670,14 +3709,17 @@ RelationBuildLocalRelation(const char *relname, rel->rd_rel->relam =3D accessmtd; =20 /* - * RelationInitTableAccessMethod will do syscache lookups, so we mustn't - * run it in CacheMemoryContext. Fortunately, the remaining steps don't - * require a long-lived current context. + * RelationInitTableAccessMethod() and RelationInitSequenceAccessMethod() + * will do syscache lookups, so we mustn't run them in CacheMemoryContext. + * Fortunately, the remaining steps don't require a long-lived current + * context. */ MemoryContextSwitchTo(oldcxt); =20 - if (RELKIND_HAS_TABLE_AM(relkind) || relkind =3D=3D RELKIND_SEQUENCE) + if (RELKIND_HAS_TABLE_AM(relkind)) RelationInitTableAccessMethod(rel); + else if (relkind =3D=3D RELKIND_SEQUENCE) + RelationInitSequenceAccessMethod(rel); =20 /* * Okay to insert into the relcache hash table. @@ -4292,13 +4334,21 @@ RelationCacheInitializePhase3(void) =20 /* Reload tableam data if needed */ if (relation->rd_tableam =3D=3D NULL && - (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind) || relation->rd_rel->r= elkind =3D=3D RELKIND_SEQUENCE)) + (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind))) { RelationInitTableAccessMethod(relation); Assert(relation->rd_tableam !=3D NULL); =20 restart =3D true; } + else if (relation->rd_sequenceam =3D=3D NULL && + relation->rd_rel->relkind =3D=3D RELKIND_SEQUENCE) + { + RelationInitSequenceAccessMethod(relation); + Assert(relation->rd_sequenceam !=3D NULL); + + restart =3D true; + } =20 /* Release hold on the relation */ RelationDecrementReferenceCount(relation); @@ -6319,8 +6369,10 @@ load_relcache_init_file(bool shared) nailed_rels++; =20 /* Load table AM data */ - if (RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind) || rel->rd_rel->relkind = =3D=3D RELKIND_SEQUENCE) + if (RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind)) RelationInitTableAccessMethod(rel); + else if (rel->rd_rel->relkind =3D=3D RELKIND_SEQUENCE) + RelationInitSequenceAccessMethod(rel); =20 Assert(rel->rd_index =3D=3D NULL); Assert(rel->rd_indextuple =3D=3D NULL); @@ -6332,6 +6384,7 @@ load_relcache_init_file(bool shared) Assert(rel->rd_supportinfo =3D=3D NULL); Assert(rel->rd_indoption =3D=3D NULL); Assert(rel->rd_indcollation =3D=3D NULL); + Assert(rel->rd_sequenceam =3D=3D NULL); Assert(rel->rd_opcoptions =3D=3D NULL); } =20 diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/g= uc_tables.c index c68fdc008b..c384bc00ba 100644 --- a/src/backend/utils/misc/guc_tables.c +++ b/src/backend/utils/misc/guc_tables.c @@ -30,6 +30,7 @@ #include "access/gin.h" #include "access/slru.h" #include "access/toast_compression.h" +#include "access/sequenceam.h" #include "access/twophase.h" #include "access/xlog_internal.h" #include "access/xlogprefetcher.h" @@ -4139,6 +4140,17 @@ struct config_string ConfigureNamesString[] =3D check_default_table_access_method, NULL, NULL }, =20 + { + {"default_sequence_access_method", PGC_USERSET, CLIENT_CONN_STATEMENT, + gettext_noop("Sets the default sequence access method for new sequences= =2E"), + NULL, + GUC_IS_NAME + }, + &default_sequence_access_method, + DEFAULT_SEQUENCE_ACCESS_METHOD, + check_default_sequence_access_method, NULL, NULL + }, + { {"default_tablespace", PGC_USERSET, CLIENT_CONN_STATEMENT, gettext_noop("Sets the default tablespace to create tables and indexes = in."), diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/ut= ils/misc/postgresql.conf.sample index 2166ea4a87..6ee5b5bfca 100644 --- a/src/backend/utils/misc/postgresql.conf.sample +++ b/src/backend/utils/misc/postgresql.conf.sample @@ -703,6 +703,7 @@ # error #search_path =3D '"$user", public' # schema names #row_security =3D on +#default_sequence_access_method =3D 'seqlocal' #default_table_access_method =3D 'heap' #default_tablespace =3D '' # a tablespace name, '' uses the default #default_toast_compression =3D 'pglz' # 'pglz' or 'lz4' diff --git a/src/bin/psql/describe.c b/src/bin/psql/describe.c index 4a9ee4a54d..bad66978bb 100644 --- a/src/bin/psql/describe.c +++ b/src/bin/psql/describe.c @@ -161,10 +161,12 @@ describeAccessMethods(const char *pattern, bool verbo= se) "SELECT amname AS \"%s\",\n" " CASE amtype" " WHEN 'i' THEN '%s'" + " WHEN 's' THEN '%s'" " WHEN 't' THEN '%s'" " END AS \"%s\"", gettext_noop("Name"), gettext_noop("Index"), + gettext_noop("Sequence"), gettext_noop("Table"), gettext_noop("Type")); =20 diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c index 6fee3160f0..229dc203e3 100644 --- a/src/bin/psql/tab-complete.c +++ b/src/bin/psql/tab-complete.c @@ -2200,7 +2200,7 @@ psql_completion(const char *text, int start, int end) else if (Matches("ALTER", "SEQUENCE", MatchAny)) COMPLETE_WITH("AS", "INCREMENT", "MINVALUE", "MAXVALUE", "RESTART", "START", "NO", "CACHE", "CYCLE", "SET", "OWNED BY", - "OWNER TO", "RENAME TO"); + "OWNER TO", "RENAME TO", "USING"); /* ALTER SEQUENCE AS */ else if (TailMatches("ALTER", "SEQUENCE", MatchAny, "AS")) COMPLETE_WITH_CS("smallint", "integer", "bigint"); @@ -3226,7 +3226,7 @@ psql_completion(const char *text, int start, int end) else if (TailMatches("CREATE", "SEQUENCE", MatchAny) || TailMatches("CREATE", "TEMP|TEMPORARY", "SEQUENCE", MatchAny)) COMPLETE_WITH("AS", "INCREMENT BY", "MINVALUE", "MAXVALUE", "NO", - "CACHE", "CYCLE", "OWNED BY", "START WITH"); + "CACHE", "CYCLE", "OWNED BY", "START WITH", "USING"); else if (TailMatches("CREATE", "SEQUENCE", MatchAny, "AS") || TailMatches("CREATE", "TEMP|TEMPORARY", "SEQUENCE", MatchAny, "AS")) COMPLETE_WITH_CS("smallint", "integer", "bigint"); diff --git a/src/test/regress/expected/create_am.out b/src/test/regress/exp= ected/create_am.out index 9762c332ce..b6566e27d5 100644 --- a/src/test/regress/expected/create_am.out +++ b/src/test/regress/expected/create_am.out @@ -163,11 +163,6 @@ CREATE VIEW tableam_view_heap2 USING heap2 AS SELECT *= FROM tableam_tbl_heap2; ERROR: syntax error at or near "USING" LINE 1: CREATE VIEW tableam_view_heap2 USING heap2 AS SELECT * FROM ... ^ --- CREATE SEQUENCE doesn't support USING -CREATE SEQUENCE tableam_seq_heap2 USING heap2; -ERROR: syntax error at or near "USING" -LINE 1: CREATE SEQUENCE tableam_seq_heap2 USING heap2; - ^ -- CREATE MATERIALIZED VIEW does support USING CREATE MATERIALIZED VIEW tableam_tblmv_heap2 USING heap2 AS SELECT * FROM = tableam_tbl_heap2; SELECT f1 FROM tableam_tblmv_heap2 ORDER BY f1; @@ -500,9 +495,12 @@ CREATE TABLE tableam_parted_heapx (a text, b int) PART= ITION BY list (a); CREATE TABLE tableam_parted_1_heapx PARTITION OF tableam_parted_heapx FOR = VALUES IN ('a', 'b'); -- but an explicitly set AM overrides it CREATE TABLE tableam_parted_2_heapx PARTITION OF tableam_parted_heapx FOR = VALUES IN ('c', 'd') USING heap; --- sequences, views and foreign servers shouldn't have an AM -CREATE VIEW tableam_view_heapx AS SELECT * FROM tableam_tbl_heapx; +-- sequences have an AM +SET LOCAL default_sequence_access_method =3D 'seqlocal'; CREATE SEQUENCE tableam_seq_heapx; +RESET default_sequence_access_method; +-- views and foreign servers shouldn't have an AM +CREATE VIEW tableam_view_heapx AS SELECT * FROM tableam_tbl_heapx; CREATE FOREIGN DATA WRAPPER fdw_heap2 VALIDATOR postgresql_fdw_validator; CREATE SERVER fs_heap2 FOREIGN DATA WRAPPER fdw_heap2 ; CREATE FOREIGN table tableam_fdw_heapx () SERVER fs_heap2; @@ -519,18 +517,18 @@ FROM pg_class AS pc LEFT JOIN pg_am AS pa ON (pa.oid =3D pc.relam) WHERE pc.relname LIKE 'tableam_%_heapx' ORDER BY 3, 1, 2; - relkind | amname | relname =20 ----------+--------+----------------------------- - f | | tableam_fdw_heapx - r | heap2 | tableam_parted_1_heapx - r | heap | tableam_parted_2_heapx - p | | tableam_parted_heapx - S | | tableam_seq_heapx - r | heap2 | tableam_tbl_heapx - r | heap2 | tableam_tblas_heapx - m | heap2 | tableam_tblmv_heapx - r | heap2 | tableam_tblselectinto_heapx - v | | tableam_view_heapx + relkind | amname | relname =20 +---------+----------+----------------------------- + f | | tableam_fdw_heapx + r | heap2 | tableam_parted_1_heapx + r | heap | tableam_parted_2_heapx + p | | tableam_parted_heapx + S | seqlocal | tableam_seq_heapx + r | heap2 | tableam_tbl_heapx + r | heap2 | tableam_tblas_heapx + m | heap2 | tableam_tblmv_heapx + r | heap2 | tableam_tblselectinto_heapx + v | | tableam_view_heapx (10 rows) =20 -- don't want to keep those tables, nor the default @@ -560,3 +558,22 @@ table tableam_parted_b_heap2 depends on access method = heap2 table tableam_parted_d_heap2 depends on access method heap2 HINT: Use DROP ... CASCADE to drop the dependent objects too. -- we intentionally leave the objects created above alive, to verify pg_du= mp support +-- Checks for sequence access methods +-- Create new sequence access method which uses standard local handler +CREATE ACCESS METHOD local2 TYPE SEQUENCE HANDLER seq_local_sequenceam_han= dler; +-- Create and use sequence +CREATE SEQUENCE test_seqam USING local2; +SELECT nextval('test_seqam'::regclass); + nextval=20 +--------- + 1 +(1 row) + +-- Try to drop and fail on dependency +DROP ACCESS METHOD local2; +ERROR: cannot drop access method local2 because other objects depend on it +DETAIL: sequence test_seqam depends on access method local2 +HINT: Use DROP ... CASCADE to drop the dependent objects too. +-- And cleanup +DROP SEQUENCE test_seqam; +DROP ACCESS METHOD local2; diff --git a/src/test/regress/expected/opr_sanity.out b/src/test/regress/ex= pected/opr_sanity.out index 9d047b21b8..ffb4c66853 100644 --- a/src/test/regress/expected/opr_sanity.out +++ b/src/test/regress/expected/opr_sanity.out @@ -1931,6 +1931,18 @@ WHERE p1.oid =3D a1.amhandler AND a1.amtype =3D 't' = AND -----+--------+-----+--------- (0 rows) =20 +-- check for sequence amhandler functions with the wrong signature +SELECT a1.oid, a1.amname, p1.oid, p1.proname +FROM pg_am AS a1, pg_proc AS p1 +WHERE p1.oid =3D a1.amhandler AND a1.amtype =3D 's' AND + (p1.prorettype !=3D 'sequence_am_handler'::regtype + OR p1.proretset + OR p1.pronargs !=3D 1 + OR p1.proargtypes[0] !=3D 'internal'::regtype); + oid | amname | oid | proname=20 +-----+--------+-----+--------- +(0 rows) + -- **************** pg_amop **************** -- Look for illegal values in pg_amop fields SELECT a1.amopfamily, a1.amopstrategy diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected= /psql.out index 3bbe4c5f97..e64e50bbb9 100644 --- a/src/test/regress/expected/psql.out +++ b/src/test/regress/expected/psql.out @@ -4962,31 +4962,33 @@ Indexes: -- check printing info about access methods \dA List of access methods - Name | Type =20 ---------+------- - brin | Index - btree | Index - gin | Index - gist | Index - hash | Index - heap | Table - heap2 | Table - spgist | Index -(8 rows) + Name | Type =20 +----------+---------- + brin | Index + btree | Index + gin | Index + gist | Index + hash | Index + heap | Table + heap2 | Table + seqlocal | Sequence + spgist | Index +(9 rows) =20 \dA * List of access methods - Name | Type =20 ---------+------- - brin | Index - btree | Index - gin | Index - gist | Index - hash | Index - heap | Table - heap2 | Table - spgist | Index -(8 rows) + Name | Type =20 +----------+---------- + brin | Index + btree | Index + gin | Index + gist | Index + hash | Index + heap | Table + heap2 | Table + seqlocal | Sequence + spgist | Index +(9 rows) =20 \dA h* List of access methods @@ -5011,32 +5013,34 @@ List of access methods =20 \dA: extra argument "bar" ignored \dA+ - List of access methods - Name | Type | Handler | Description = =20 ---------+-------+----------------------+----------------------------------= ------ - brin | Index | brinhandler | block range index (BRIN) access m= ethod - btree | Index | bthandler | b-tree index access method - gin | Index | ginhandler | GIN index access method - gist | Index | gisthandler | GiST index access method - hash | Index | hashhandler | hash index access method - heap | Table | heap_tableam_handler | heap table access method - heap2 | Table | heap_tableam_handler |=20 - spgist | Index | spghandler | SP-GiST index access method -(8 rows) + List of access methods + Name | Type | Handler | Descrip= tion =20 +----------+----------+------------------------------+---------------------= ------------------- + brin | Index | brinhandler | block range index (B= RIN) access method + btree | Index | bthandler | b-tree index access = method + gin | Index | ginhandler | GIN index access met= hod + gist | Index | gisthandler | GiST index access me= thod + hash | Index | hashhandler | hash index access me= thod + heap | Table | heap_tableam_handler | heap table access me= thod + heap2 | Table | heap_tableam_handler |=20 + seqlocal | Sequence | seq_local_sequenceam_handler | local sequence acces= s method + spgist | Index | spghandler | SP-GiST index access= method +(9 rows) =20 \dA+ * - List of access methods - Name | Type | Handler | Description = =20 ---------+-------+----------------------+----------------------------------= ------ - brin | Index | brinhandler | block range index (BRIN) access m= ethod - btree | Index | bthandler | b-tree index access method - gin | Index | ginhandler | GIN index access method - gist | Index | gisthandler | GiST index access method - hash | Index | hashhandler | hash index access method - heap | Table | heap_tableam_handler | heap table access method - heap2 | Table | heap_tableam_handler |=20 - spgist | Index | spghandler | SP-GiST index access method -(8 rows) + List of access methods + Name | Type | Handler | Descrip= tion =20 +----------+----------+------------------------------+---------------------= ------------------- + brin | Index | brinhandler | block range index (B= RIN) access method + btree | Index | bthandler | b-tree index access = method + gin | Index | ginhandler | GIN index access met= hod + gist | Index | gisthandler | GiST index access me= thod + hash | Index | hashhandler | hash index access me= thod + heap | Table | heap_tableam_handler | heap table access me= thod + heap2 | Table | heap_tableam_handler |=20 + seqlocal | Sequence | seq_local_sequenceam_handler | local sequence acces= s method + spgist | Index | spghandler | SP-GiST index access= method +(9 rows) =20 \dA+ h* List of access methods diff --git a/src/test/regress/sql/create_am.sql b/src/test/regress/sql/crea= te_am.sql index 825aed325e..472289994e 100644 --- a/src/test/regress/sql/create_am.sql +++ b/src/test/regress/sql/create_am.sql @@ -117,9 +117,6 @@ SELECT INTO tableam_tblselectinto_heap2 USING heap2 FRO= M tableam_tbl_heap2; -- CREATE VIEW doesn't support USING CREATE VIEW tableam_view_heap2 USING heap2 AS SELECT * FROM tableam_tbl_he= ap2; =20 --- CREATE SEQUENCE doesn't support USING -CREATE SEQUENCE tableam_seq_heap2 USING heap2; - -- CREATE MATERIALIZED VIEW does support USING CREATE MATERIALIZED VIEW tableam_tblmv_heap2 USING heap2 AS SELECT * FROM = tableam_tbl_heap2; SELECT f1 FROM tableam_tblmv_heap2 ORDER BY f1; @@ -317,9 +314,13 @@ CREATE TABLE tableam_parted_1_heapx PARTITION OF table= am_parted_heapx FOR VALUES -- but an explicitly set AM overrides it CREATE TABLE tableam_parted_2_heapx PARTITION OF tableam_parted_heapx FOR = VALUES IN ('c', 'd') USING heap; =20 --- sequences, views and foreign servers shouldn't have an AM -CREATE VIEW tableam_view_heapx AS SELECT * FROM tableam_tbl_heapx; +-- sequences have an AM +SET LOCAL default_sequence_access_method =3D 'seqlocal'; CREATE SEQUENCE tableam_seq_heapx; +RESET default_sequence_access_method; + +-- views and foreign servers shouldn't have an AM +CREATE VIEW tableam_view_heapx AS SELECT * FROM tableam_tbl_heapx; CREATE FOREIGN DATA WRAPPER fdw_heap2 VALIDATOR postgresql_fdw_validator; CREATE SERVER fs_heap2 FOREIGN DATA WRAPPER fdw_heap2 ; CREATE FOREIGN table tableam_fdw_heapx () SERVER fs_heap2; @@ -355,3 +356,16 @@ CREATE FOREIGN TABLE fp PARTITION OF tableam_parted_a_= heap2 DEFAULT SERVER x; DROP ACCESS METHOD heap2; =20 -- we intentionally leave the objects created above alive, to verify pg_du= mp support + +-- Checks for sequence access methods + +-- Create new sequence access method which uses standard local handler +CREATE ACCESS METHOD local2 TYPE SEQUENCE HANDLER seq_local_sequenceam_han= dler; +-- Create and use sequence +CREATE SEQUENCE test_seqam USING local2; +SELECT nextval('test_seqam'::regclass); +-- Try to drop and fail on dependency +DROP ACCESS METHOD local2; +-- And cleanup +DROP SEQUENCE test_seqam; +DROP ACCESS METHOD local2; diff --git a/src/test/regress/sql/opr_sanity.sql b/src/test/regress/sql/opr= _sanity.sql index 2fe7b6dcc4..1409622374 100644 --- a/src/test/regress/sql/opr_sanity.sql +++ b/src/test/regress/sql/opr_sanity.sql @@ -1229,6 +1229,16 @@ WHERE p1.oid =3D a1.amhandler AND a1.amtype =3D 't' = AND OR p1.pronargs !=3D 1 OR p1.proargtypes[0] !=3D 'internal'::regtype); =20 +-- check for sequence amhandler functions with the wrong signature + +SELECT a1.oid, a1.amname, p1.oid, p1.proname +FROM pg_am AS a1, pg_proc AS p1 +WHERE p1.oid =3D a1.amhandler AND a1.amtype =3D 's' AND + (p1.prorettype !=3D 'sequence_am_handler'::regtype + OR p1.proretset + OR p1.pronargs !=3D 1 + OR p1.proargtypes[0] !=3D 'internal'::regtype); + -- **************** pg_amop **************** =20 -- Look for illegal values in pg_amop fields diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs= =2Elist index 90a7c389b2..fedf2a77d7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2557,6 +2557,7 @@ SeqScan SeqScanState SeqTable SeqTableData +SequenceAmRoutine SerCommitSeqNo SerialControl SerialIOData @@ -3541,6 +3542,7 @@ lineno_t list_sort_comparator local_relopt local_relopts +local_sequence_magic local_source locale_t locate_agg_of_level_context @@ -3805,7 +3807,6 @@ save_buffer scram_state scram_state_enum sem_t -sequence_magic set_join_pathlist_hook_type set_rel_pathlist_hook_type shm_mq @@ -4020,6 +4021,7 @@ xl_heap_visible xl_invalid_page xl_invalid_page_key xl_invalidations +xl_local_seq_rec xl_logical_message xl_multi_insert_tuple xl_multixact_create @@ -4031,7 +4033,6 @@ xl_replorigin_drop xl_replorigin_set xl_restore_point xl_running_xacts -xl_seq_rec xl_smgr_create xl_smgr_truncate xl_standby_lock --=20 2.43.0 --Hb9lJVq6MVTkbU7F Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v5-0006-Sequence-access-methods-dump-restore-support.patch" Content-Transfer-Encoding: quoted-printable =46rom 0043f858105559de904fd6b4f1efcabcc832c5de Mon Sep 17 00:00:00 2001 =46rom: Michael Paquier Date: Thu, 25 Apr 2024 17:28:27 +0900 Subject: [PATCH v5 6/8] Sequence access methods - dump/restore support --- src/bin/pg_dump/pg_backup.h | 2 + src/bin/pg_dump/pg_backup_archiver.c | 66 ++++++++++++++++++++++++++++ src/bin/pg_dump/pg_backup_archiver.h | 6 ++- src/bin/pg_dump/pg_dump.c | 39 ++++++++++++++-- src/bin/pg_dump/pg_dumpall.c | 5 +++ src/bin/pg_dump/pg_restore.c | 4 ++ src/bin/pg_dump/t/002_pg_dump.pl | 63 ++++++++++++++++++++++---- doc/src/sgml/ref/pg_dump.sgml | 17 +++++++ doc/src/sgml/ref/pg_dumpall.sgml | 11 +++++ doc/src/sgml/ref/pg_restore.sgml | 11 +++++ 10 files changed, 210 insertions(+), 14 deletions(-) diff --git a/src/bin/pg_dump/pg_backup.h b/src/bin/pg_dump/pg_backup.h index fbf5f1c515..4eae73c16e 100644 --- a/src/bin/pg_dump/pg_backup.h +++ b/src/bin/pg_dump/pg_backup.h @@ -95,6 +95,7 @@ typedef struct _restoreOptions { int createDB; /* Issue commands to create the database */ int noOwner; /* Don't try to match original object owner */ + int noSequenceAm; /* Don't issue sequence-AM-related commands */ int noTableAm; /* Don't issue table-AM-related commands */ int noTablespace; /* Don't issue tablespace-related commands */ int disable_triggers; /* disable triggers during data-only @@ -185,6 +186,7 @@ typedef struct _dumpOptions int no_unlogged_table_data; int serializable_deferrable; int disable_triggers; + int outputNoSequenceAm; int outputNoTableAm; int outputNoTablespaces; int use_setsessauth; diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_back= up_archiver.c index c6c101c118..f5d2b2fa4f 100644 --- a/src/bin/pg_dump/pg_backup_archiver.c +++ b/src/bin/pg_dump/pg_backup_archiver.c @@ -174,6 +174,7 @@ dumpOptionsFromRestoreOptions(RestoreOptions *ropt) dopt->outputSuperuser =3D ropt->superuser; dopt->outputCreateDB =3D ropt->createDB; dopt->outputNoOwner =3D ropt->noOwner; + dopt->outputNoSequenceAm =3D ropt->noSequenceAm; dopt->outputNoTableAm =3D ropt->noTableAm; dopt->outputNoTablespaces =3D ropt->noTablespace; dopt->disable_triggers =3D ropt->disable_triggers; @@ -1224,6 +1225,7 @@ ArchiveEntry(Archive *AHX, CatalogId catalogId, DumpI= d dumpId, newToc->tag =3D pg_strdup(opts->tag); newToc->namespace =3D opts->namespace ? pg_strdup(opts->namespace) : NULL; newToc->tablespace =3D opts->tablespace ? pg_strdup(opts->tablespace) : N= ULL; + newToc->sequenceam =3D opts->sequenceam ? pg_strdup(opts->sequenceam) : N= ULL; newToc->tableam =3D opts->tableam ? pg_strdup(opts->tableam) : NULL; newToc->relkind =3D opts->relkind; newToc->owner =3D opts->owner ? pg_strdup(opts->owner) : NULL; @@ -2376,6 +2378,7 @@ _allocAH(const char *FileSpec, const ArchiveFormat fm= t, =20 AH->currUser =3D NULL; /* unknown */ AH->currSchema =3D NULL; /* ditto */ + AH->currSequenceAm =3D NULL; /* ditto */ AH->currTablespace =3D NULL; /* ditto */ AH->currTableAm =3D NULL; /* ditto */ =20 @@ -2605,6 +2608,7 @@ WriteToc(ArchiveHandle *AH) WriteStr(AH, te->copyStmt); WriteStr(AH, te->namespace); WriteStr(AH, te->tablespace); + WriteStr(AH, te->sequenceam); WriteStr(AH, te->tableam); WriteInt(AH, te->relkind); WriteStr(AH, te->owner); @@ -2709,6 +2713,9 @@ ReadToc(ArchiveHandle *AH) if (AH->version >=3D K_VERS_1_10) te->tablespace =3D ReadStr(AH); =20 + if (AH->version >=3D K_VERS_1_17) + te->sequenceam =3D ReadStr(AH); + if (AH->version >=3D K_VERS_1_14) te->tableam =3D ReadStr(AH); =20 @@ -3364,6 +3371,9 @@ _reconnectToDB(ArchiveHandle *AH, const char *dbname) free(AH->currSchema); AH->currSchema =3D NULL; =20 + free(AH->currSequenceAm); + AH->currSequenceAm =3D NULL; + free(AH->currTableAm); AH->currTableAm =3D NULL; =20 @@ -3526,6 +3536,57 @@ _selectTablespace(ArchiveHandle *AH, const char *tab= lespace) destroyPQExpBuffer(qry); } =20 +/* + * Set the proper default_sequence_access_method value for the sequence. + */ +static void +_selectSequenceAccessMethod(ArchiveHandle *AH, const char *sequenceam) +{ + RestoreOptions *ropt =3D AH->public.ropt; + PQExpBuffer cmd; + const char *want, + *have; + + /* do nothing in --no-sequence-access-method mode */ + if (ropt->noSequenceAm) + return; + + have =3D AH->currSequenceAm; + want =3D sequenceam; + + if (!want) + return; + + if (have && strcmp(want, have) =3D=3D 0) + return; + + cmd =3D createPQExpBuffer(); + appendPQExpBuffer(cmd, + "SET default_sequence_access_method =3D %s;", + fmtId(want)); + + if (RestoringToDB(AH)) + { + PGresult *res; + + res =3D PQexec(AH->connection, cmd->data); + + if (!res || PQresultStatus(res) !=3D PGRES_COMMAND_OK) + warn_or_exit_horribly(AH, + "could not set default_sequence_access_method: %s", + PQerrorMessage(AH->connection)); + + PQclear(res); + } + else + ahprintf(AH, "%s\n\n", cmd->data); + + destroyPQExpBuffer(cmd); + + free(AH->currSequenceAm); + AH->currSequenceAm =3D pg_strdup(want); +} + /* * Set the proper default_table_access_method value for the table. */ @@ -3735,6 +3796,7 @@ _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool = isData) _becomeOwner(AH, te); _selectOutputSchema(AH, te->namespace); _selectTablespace(AH, te->tablespace); + _selectSequenceAccessMethod(AH, te->sequenceam); if (te->relkind !=3D RELKIND_PARTITIONED_TABLE) _selectTableAccessMethod(AH, te->tableam); =20 @@ -4237,6 +4299,8 @@ restore_toc_entries_prefork(ArchiveHandle *AH, TocEnt= ry *pending_list) AH->currUser =3D NULL; free(AH->currSchema); AH->currSchema =3D NULL; + free(AH->currSequenceAm); + AH->currSequenceAm =3D NULL; free(AH->currTablespace); AH->currTablespace =3D NULL; free(AH->currTableAm); @@ -4976,6 +5040,7 @@ CloneArchive(ArchiveHandle *AH) clone->connCancel =3D NULL; clone->currUser =3D NULL; clone->currSchema =3D NULL; + clone->currSequenceAm =3D NULL; clone->currTableAm =3D NULL; clone->currTablespace =3D NULL; =20 @@ -5035,6 +5100,7 @@ DeCloneArchive(ArchiveHandle *AH) /* Clear any connection-local state */ free(AH->currUser); free(AH->currSchema); + free(AH->currSequenceAm); free(AH->currTablespace); free(AH->currTableAm); free(AH->savedPassword); diff --git a/src/bin/pg_dump/pg_backup_archiver.h b/src/bin/pg_dump/pg_back= up_archiver.h index ce5ed1dd39..cdfebcd340 100644 --- a/src/bin/pg_dump/pg_backup_archiver.h +++ b/src/bin/pg_dump/pg_backup_archiver.h @@ -71,10 +71,11 @@ #define K_VERS_1_16 MAKE_ARCHIVE_VERSION(1, 16, 0) /* BLOB METADATA entries * and multiple BLOBS, * relkind */ +#define K_VERS_1_17 MAKE_ARCHIVE_VERSION(1, 17, 0) /* add sequenceam */ =20 /* Current archive version number (the format we can output) */ #define K_VERS_MAJOR 1 -#define K_VERS_MINOR 16 +#define K_VERS_MINOR 17 #define K_VERS_REV 0 #define K_VERS_SELF MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, K_VER= S_REV) =20 @@ -322,6 +323,7 @@ struct _archiveHandle /* these vars track state to avoid sending redundant SET commands */ char *currUser; /* current username, or NULL if unknown */ char *currSchema; /* current schema, or NULL */ + char *currSequenceAm; /* current sequence access method, or NULL */ char *currTablespace; /* current tablespace, or NULL */ char *currTableAm; /* current table access method, or NULL */ =20 @@ -353,6 +355,7 @@ struct _tocEntry char *namespace; /* null or empty string if not in a schema */ char *tablespace; /* null if not in a tablespace; empty string * means use database default */ + char *sequenceam; /* table access method, only for SEQUENCE tags */ char *tableam; /* table access method, only for TABLE tags */ char relkind; /* relation kind, only for TABLE tags */ char *owner; @@ -394,6 +397,7 @@ typedef struct _archiveOpts const char *tag; const char *namespace; const char *tablespace; + const char *sequenceam; const char *tableam; char relkind; const char *owner; diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c index 54c4f75861..c1c7e40e20 100644 --- a/src/bin/pg_dump/pg_dump.c +++ b/src/bin/pg_dump/pg_dump.c @@ -422,6 +422,7 @@ main(int argc, char **argv) {"if-exists", no_argument, &dopt.if_exists, 1}, {"inserts", no_argument, NULL, 9}, {"lock-wait-timeout", required_argument, NULL, 2}, + {"no-sequence-access-method", no_argument, &dopt.outputNoSequenceAm, 1}, {"no-table-access-method", no_argument, &dopt.outputNoTableAm, 1}, {"no-tablespaces", no_argument, &dopt.outputNoTablespaces, 1}, {"quote-all-identifiers", no_argument, "e_all_identifiers, 1}, @@ -1036,6 +1037,7 @@ main(int argc, char **argv) ropt->superuser =3D dopt.outputSuperuser; ropt->createDB =3D dopt.outputCreateDB; ropt->noOwner =3D dopt.outputNoOwner; + ropt->noSequenceAm =3D dopt.outputNoSequenceAm; ropt->noTableAm =3D dopt.outputNoTableAm; ropt->noTablespace =3D dopt.outputNoTablespaces; ropt->disable_triggers =3D dopt.disable_triggers; @@ -1152,6 +1154,7 @@ help(const char *progname) printf(_(" --no-publications do not dump publications\n")); printf(_(" --no-security-labels do not dump security label assig= nments\n")); printf(_(" --no-subscriptions do not dump subscriptions\n")); + printf(_(" --no-sequence-access-method do not sequence table access met= hods\n")); printf(_(" --no-table-access-method do not dump table access methods= \n")); printf(_(" --no-tablespaces do not dump tablespace assignmen= ts\n")); printf(_(" --no-toast-compression do not dump TOAST compression me= thods\n")); @@ -13317,6 +13320,9 @@ dumpAccessMethod(Archive *fout, const AccessMethodI= nfo *aminfo) case AMTYPE_INDEX: appendPQExpBufferStr(q, "TYPE INDEX "); break; + case AMTYPE_SEQUENCE: + appendPQExpBufferStr(q, "TYPE SEQUENCE "); + break; case AMTYPE_TABLE: appendPQExpBufferStr(q, "TYPE TABLE "); break; @@ -17559,7 +17565,8 @@ dumpSequence(Archive *fout, const TableInfo *tbinfo) *maxv, *minv, *cache, - *seqtype; + *seqtype, + *seqam; bool cycled; bool is_ascending; int64 default_minv, @@ -17573,13 +17580,35 @@ dumpSequence(Archive *fout, const TableInfo *tbin= fo) =20 qseqname =3D pg_strdup(fmtId(tbinfo->dobj.name)); =20 - if (fout->remoteVersion >=3D 100000) + if (fout->remoteVersion >=3D 170000) { + /* + * PostgreSQL 17 has added support for sequence access methods. + */ + appendPQExpBuffer(query, + "SELECT format_type(s.seqtypid, NULL), " + "s.seqstart, s.seqincrement, " + "s.seqmax, s.seqmin, " + "s.seqcache, s.seqcycle, " + "a.amname AS seqam " + "FROM pg_catalog.pg_sequence s " + "JOIN pg_class c ON (c.oid =3D s.seqrelid) " + "JOIN pg_am a ON (a.oid =3D c.relam) " + "WHERE s.seqrelid =3D '%u'::oid", + tbinfo->dobj.catId.oid); + } + else if (fout->remoteVersion >=3D 100000) + { + /* + * PostgreSQL 10 has moved sequence metadata to the catalog + * pg_sequence. + */ appendPQExpBuffer(query, "SELECT format_type(seqtypid, NULL), " "seqstart, seqincrement, " "seqmax, seqmin, " - "seqcache, seqcycle " + "seqcache, seqcycle, " + "'seqlocal' AS seqam " "FROM pg_catalog.pg_sequence " "WHERE seqrelid =3D '%u'::oid", tbinfo->dobj.catId.oid); @@ -17595,7 +17624,7 @@ dumpSequence(Archive *fout, const TableInfo *tbinfo) appendPQExpBuffer(query, "SELECT 'bigint' AS sequence_type, " "start_value, increment_by, max_value, min_value, " - "cache_value, is_cycled FROM %s", + "cache_value, is_cycled, 'seqlocal' as seqam FROM %s", fmtQualifiedDumpable(tbinfo)); } =20 @@ -17614,6 +17643,7 @@ dumpSequence(Archive *fout, const TableInfo *tbinfo) minv =3D PQgetvalue(res, 0, 4); cache =3D PQgetvalue(res, 0, 5); cycled =3D (strcmp(PQgetvalue(res, 0, 6), "t") =3D=3D 0); + seqam =3D PQgetvalue(res, 0, 7); =20 /* Calculate default limits for a sequence of this type */ is_ascending =3D (incby[0] !=3D '-'); @@ -17745,6 +17775,7 @@ dumpSequence(Archive *fout, const TableInfo *tbinfo) ARCHIVE_OPTS(.tag =3D tbinfo->dobj.name, .namespace =3D tbinfo->dobj.namespace->dobj.name, .owner =3D tbinfo->rolname, + .sequenceam =3D seqam, .description =3D "SEQUENCE", .section =3D SECTION_PRE_DATA, .createStmt =3D query->data, diff --git a/src/bin/pg_dump/pg_dumpall.c b/src/bin/pg_dump/pg_dumpall.c index 73337f3392..756a63c24d 100644 --- a/src/bin/pg_dump/pg_dumpall.c +++ b/src/bin/pg_dump/pg_dumpall.c @@ -97,6 +97,7 @@ static int disable_dollar_quoting =3D 0; static int disable_triggers =3D 0; static int if_exists =3D 0; static int inserts =3D 0; +static int no_sequence_access_method =3D 0; static int no_table_access_method =3D 0; static int no_tablespaces =3D 0; static int use_setsessauth =3D 0; @@ -161,6 +162,7 @@ main(int argc, char *argv[]) {"if-exists", no_argument, &if_exists, 1}, {"inserts", no_argument, &inserts, 1}, {"lock-wait-timeout", required_argument, NULL, 2}, + {"no-sequence-access-method", no_argument, &no_sequence_access_method, 1= }, {"no-table-access-method", no_argument, &no_table_access_method, 1}, {"no-tablespaces", no_argument, &no_tablespaces, 1}, {"quote-all-identifiers", no_argument, "e_all_identifiers, 1}, @@ -435,6 +437,8 @@ main(int argc, char *argv[]) appendPQExpBufferStr(pgdumpopts, " --disable-triggers"); if (inserts) appendPQExpBufferStr(pgdumpopts, " --inserts"); + if (no_sequence_access_method) + appendPQExpBufferStr(pgdumpopts, " --no-sequence-access-method"); if (no_table_access_method) appendPQExpBufferStr(pgdumpopts, " --no-table-access-method"); if (no_tablespaces) @@ -668,6 +672,7 @@ help(void) printf(_(" --no-security-labels do not dump security label assig= nments\n")); printf(_(" --no-subscriptions do not dump subscriptions\n")); printf(_(" --no-sync do not wait for changes to be wr= itten safely to disk\n")); + printf(_(" --no-sequence-access-method do not dump sequence access meth= ods\n")); printf(_(" --no-table-access-method do not dump table access methods= \n")); printf(_(" --no-tablespaces do not dump tablespace assignmen= ts\n")); printf(_(" --no-toast-compression do not dump TOAST compression me= thods\n")); diff --git a/src/bin/pg_dump/pg_restore.c b/src/bin/pg_dump/pg_restore.c index 5ea78cf7cc..077489f4b1 100644 --- a/src/bin/pg_dump/pg_restore.c +++ b/src/bin/pg_dump/pg_restore.c @@ -68,6 +68,7 @@ main(int argc, char **argv) static int enable_row_security =3D 0; static int if_exists =3D 0; static int no_data_for_failed_tables =3D 0; + static int outputNoSequenceAm =3D 0; static int outputNoTableAm =3D 0; static int outputNoTablespaces =3D 0; static int use_setsessauth =3D 0; @@ -115,6 +116,7 @@ main(int argc, char **argv) {"enable-row-security", no_argument, &enable_row_security, 1}, {"if-exists", no_argument, &if_exists, 1}, {"no-data-for-failed-tables", no_argument, &no_data_for_failed_tables, 1= }, + {"no-sequence-access-method", no_argument, &outputNoSequenceAm, 1}, {"no-table-access-method", no_argument, &outputNoTableAm, 1}, {"no-tablespaces", no_argument, &outputNoTablespaces, 1}, {"role", required_argument, NULL, 2}, @@ -363,6 +365,7 @@ main(int argc, char **argv) opts->disable_triggers =3D disable_triggers; opts->enable_row_security =3D enable_row_security; opts->noDataForFailedTables =3D no_data_for_failed_tables; + opts->noSequenceAm =3D outputNoSequenceAm; opts->noTableAm =3D outputNoTableAm; opts->noTablespace =3D outputNoTablespaces; opts->use_setsessauth =3D use_setsessauth; @@ -491,6 +494,7 @@ usage(const char *progname) printf(_(" --no-publications do not restore publications\n")); printf(_(" --no-security-labels do not restore security labels\n= ")); printf(_(" --no-subscriptions do not restore subscriptions\n")= ); + printf(_(" --no-sequence-access-method do not restore sequence acces= s methods\n")); printf(_(" --no-table-access-method do not restore table access meth= ods\n")); printf(_(" --no-tablespaces do not restore tablespace assign= ments\n")); printf(_(" --section=3DSECTION restore named section (pre-dat= a, data, or post-data)\n")); diff --git a/src/bin/pg_dump/t/002_pg_dump.pl b/src/bin/pg_dump/t/002_pg_du= mp.pl index 7085053a2d..0f5bc6f812 100644 --- a/src/bin/pg_dump/t/002_pg_dump.pl +++ b/src/bin/pg_dump/t/002_pg_dump.pl @@ -537,6 +537,13 @@ my %pgdump_runs =3D ( 'postgres', ], }, + no_sequence_access_method =3D> { + dump_cmd =3D> [ + 'pg_dump', '--no-sync', + "--file=3D$tempdir/no_sequence_access_method.sql", + '--no-sequence-access-method', 'postgres', + ], + }, no_table_access_method =3D> { dump_cmd =3D> [ 'pg_dump', '--no-sync', @@ -711,6 +718,7 @@ my %full_runs =3D ( no_large_objects =3D> 1, no_owner =3D> 1, no_privs =3D> 1, + no_sequence_access_method =3D> 1, no_table_access_method =3D> 1, pg_dumpall_dbprivs =3D> 1, pg_dumpall_exclude =3D> 1, @@ -3855,9 +3863,7 @@ my %tests =3D ( \QCREATE INDEX measurement_city_id_logdate_idx ON ONLY dump_test.measure= ment USING\E /xm, like =3D> { - %full_runs, - %dump_test_schema_runs, - section_post_data =3D> 1, + %full_runs, %dump_test_schema_runs, section_post_data =3D> 1, }, unlike =3D> { exclude_dump_test_schema =3D> 1, @@ -4526,6 +4532,18 @@ my %tests =3D ( }, }, =20 + 'CREATE ACCESS METHOD regress_test_sequence_am' =3D> { + create_order =3D> 11, + create_sql =3D> + 'CREATE ACCESS METHOD regress_sequence_am TYPE SEQUENCE HANDLER seq_lo= cal_sequenceam_handler;', + regexp =3D> qr/^ + \QCREATE ACCESS METHOD regress_sequence_am TYPE SEQUENCE HANDLER seq_lo= cal_sequenceam_handler;\E + \n/xm, + like =3D> { + %full_runs, section_pre_data =3D> 1, + }, + }, + # It's a bit tricky to ensure that the proper SET of default table # AM occurs. To achieve that we create a table with the standard # AM, test AM, standard AM. That guarantees that there needs to be @@ -4554,6 +4572,35 @@ my %tests =3D ( }, }, =20 + + # This uses the same trick as for materialized views and tables, + # but this time with a sequence access method, checking that a + # correct set of SET queries are created. + 'CREATE SEQUENCE regress_pg_dump_seq_am' =3D> { + create_order =3D> 12, + create_sql =3D> ' + CREATE SEQUENCE dump_test.regress_pg_dump_seq_am_0 USING seqlocal; + CREATE SEQUENCE dump_test.regress_pg_dump_seq_am_1 USING regress_sequen= ce_am; + CREATE SEQUENCE dump_test.regress_pg_dump_seq_am_2 USING seqlocal;', + regexp =3D> qr/^ + \QSET default_sequence_access_method =3D regress_sequence_am;\E + (\n(?!SET[^;]+;)[^\n]*)* + \n\QCREATE SEQUENCE dump_test.regress_pg_dump_seq_am_1\E + \n\s+\QSTART WITH 1\E + \n\s+\QINCREMENT BY 1\E + \n\s+\QNO MINVALUE\E + \n\s+\QNO MAXVALUE\E + \n\s+\QCACHE 1;\E\n/xm, + like =3D> { + %full_runs, %dump_test_schema_runs, section_pre_data =3D> 1, + }, + unlike =3D> { + exclude_dump_test_schema =3D> 1, + no_sequence_access_method =3D> 1, + only_dump_measurement =3D> 1, + }, + }, + 'CREATE MATERIALIZED VIEW regress_pg_dump_matview_am' =3D> { create_order =3D> 13, create_sql =3D> ' @@ -4783,10 +4830,8 @@ $node->command_fails_like( ############################################################## # Test dumping pg_catalog (for research -- cannot be reloaded) =20 -$node->command_ok( - [ 'pg_dump', '-p', "$port", '-n', 'pg_catalog' ], - 'pg_dump: option -n pg_catalog' -); +$node->command_ok([ 'pg_dump', '-p', "$port", '-n', 'pg_catalog' ], + 'pg_dump: option -n pg_catalog'); =20 ######################################### # Test valid database exclusion patterns @@ -4953,8 +4998,8 @@ foreach my $run (sort keys %pgdump_runs) } # Check for useless entries in "unlike" list. Runs that are # not listed in "like" don't need to be excluded in "unlike". - if ($tests{$test}->{unlike}->{$test_key} && - !defined($tests{$test}->{like}->{$test_key})) + if ($tests{$test}->{unlike}->{$test_key} + && !defined($tests{$test}->{like}->{$test_key})) { die "useless \"unlike\" entry \"$test_key\" in test \"$test\""; } diff --git a/doc/src/sgml/ref/pg_dump.sgml b/doc/src/sgml/ref/pg_dump.sgml index 08d775379f..0261a0fcbf 100644 --- a/doc/src/sgml/ref/pg_dump.sgml +++ b/doc/src/sgml/ref/pg_dump.sgml @@ -1104,6 +1104,23 @@ PostgreSQL documentation =20 + + + + + Do not output commands to select sequence access methods. + With this option, all objects will be created with whichever + sequence access method is the default during restore. + + + + This option is ignored when emitting an archive (non-text) output + file. For the archive formats, you can specify the option when you + call pg_restore. + + + + diff --git a/doc/src/sgml/ref/pg_dumpall.sgml b/doc/src/sgml/ref/pg_dumpall= =2Esgml index 4d7c046468..34643175fb 100644 --- a/doc/src/sgml/ref/pg_dumpall.sgml +++ b/doc/src/sgml/ref/pg_dumpall.sgml @@ -479,6 +479,17 @@ exclude database PATT= ERN =20 + + + + + Do not output commands to select sequence access methods. + With this option, all objects will be created with whichever + sequence access method is the default during restore. + + + + diff --git a/doc/src/sgml/ref/pg_restore.sgml b/doc/src/sgml/ref/pg_restore= =2Esgml index 2e3ba80258..c552a1e746 100644 --- a/doc/src/sgml/ref/pg_restore.sgml +++ b/doc/src/sgml/ref/pg_restore.sgml @@ -733,6 +733,17 @@ PostgreSQL documentation =20 + + + + + Do not output commands to select sequence access methods. + With this option, all objects will be created with whichever + sequence access method is the default during restore. + + + + --=20 2.43.0 --Hb9lJVq6MVTkbU7F Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v5-0007-Sequence-access-methods-core-documentation.patch" Content-Transfer-Encoding: quoted-printable =46rom 19d13ccc50a165f22b41a3fe381ec67744660c41 Mon Sep 17 00:00:00 2001 =46rom: Michael Paquier Date: Fri, 1 Dec 2023 12:55:56 +0900 Subject: [PATCH v5 7/8] Sequence access methods - core documentation --- doc/src/sgml/config.sgml | 16 +++++ doc/src/sgml/filelist.sgml | 1 + doc/src/sgml/postgres.sgml | 1 + doc/src/sgml/ref/create_access_method.sgml | 15 ++-- doc/src/sgml/ref/create_sequence.sgml | 12 ++++ doc/src/sgml/sequenceam.sgml | 80 ++++++++++++++++++++++ 6 files changed, 119 insertions(+), 6 deletions(-) create mode 100644 doc/src/sgml/sequenceam.sgml diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml index d8e1282e12..3d595711c3 100644 --- a/doc/src/sgml/config.sgml +++ b/doc/src/sgml/config.sgml @@ -8971,6 +8971,22 @@ COPY postgres_log FROM '/full/path/to/logfile.csv' W= ITH csv; =20 + + default_sequence_access_method (strin= g) + + default_sequence_access_method configur= ation parameter + + + + + This parameter specifies the default sequence access method to use= when + creating sequences if the CREATE SEQUENCE + command does not explicitly specify an access method. The default = is + local. + + + + default_tablespace (string) diff --git a/doc/src/sgml/filelist.sgml b/doc/src/sgml/filelist.sgml index 38ec362d8f..4e1218aa89 100644 --- a/doc/src/sgml/filelist.sgml +++ b/doc/src/sgml/filelist.sgml @@ -95,6 +95,7 @@ + diff --git a/doc/src/sgml/postgres.sgml b/doc/src/sgml/postgres.sgml index ec9f90e283..6b82f4c7fc 100644 --- a/doc/src/sgml/postgres.sgml +++ b/doc/src/sgml/postgres.sgml @@ -256,6 +256,7 @@ break is not needed in a wider output rendering. &geqo; &tableam; &indexam; + &sequenceam; &wal-for-extensions; &indextypes; &storage; diff --git a/doc/src/sgml/ref/create_access_method.sgml b/doc/src/sgml/ref/= create_access_method.sgml index dae43dbaed..3067dc4d4d 100644 --- a/doc/src/sgml/ref/create_access_method.sgml +++ b/doc/src/sgml/ref/create_access_method.sgml @@ -61,8 +61,8 @@ CREATE ACCESS METHOD nam= e This clause specifies the type of access method to define. - Only TABLE and INDEX - are supported at present. + Only TABLE, SEQUENCE and + INDEX are supported at present. @@ -77,12 +77,15 @@ CREATE ACCESS METHOD n= ame declared to take a single argument of type internal, and its return type depends on the type of access method; for TABLE access methods, it must - be table_am_handler and for INDEX - access methods, it must be index_am_handler. + be table_am_handler; for INDEX + access methods, it must be index_am_handler; + for SEQUENCE, it must be + sequence_am_handler; The C-level API that the handler function must implement varies depending on the type of access method. The table access method API - is described in and the index access met= hod - API is described in . + is described in , the index access method + API is described in and the sequence acc= ess + method is described in . diff --git a/doc/src/sgml/ref/create_sequence.sgml b/doc/src/sgml/ref/creat= e_sequence.sgml index 34e9084b5c..d00bdabde0 100644 --- a/doc/src/sgml/ref/create_sequence.sgml +++ b/doc/src/sgml/ref/create_sequence.sgml @@ -27,6 +27,7 @@ CREATE [ { TEMPORARY | TEMP } | UNLOGGED ] SEQUENCE [ IF = NOT EXISTS ] minvalue | N= O MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ] [ START [ WITH ] start = ] [ CACHE cache ] [ [ NO ] C= YCLE ] [ OWNED BY { table_name= =2Ecolumn_name | NONE } ] + [ USING access_method ] =20 @@ -261,6 +262,17 @@ SELECT * FROM name; + + + USING access= _method + + + The USING option specifies which sequence access + method will be used when generating the sequence numbers. The default + is local. + + + =20 diff --git a/doc/src/sgml/sequenceam.sgml b/doc/src/sgml/sequenceam.sgml new file mode 100644 index 0000000000..a96170bfac --- /dev/null +++ b/doc/src/sgml/sequenceam.sgml @@ -0,0 +1,80 @@ + + + + Sequence Access Method Interface Definition + + + Sequence Access Method + + + sequenceam + Sequence Access Method + + + + This chapter explains the interface between the core + PostgreSQL system and sequence acc= ess + methods, which manage the operations around sequences . The = core + system knows little about these access methods beyond what is specified = here, + so it is possible to develop entirely new access method types by writing + add-on code. + + + + Each sequence access method is described by a row in the + pg_am sy= stem + catalog. The pg_am entry specifies a name and a + handler function for the sequence access method. = These + entries can be created and deleted using the + and + SQL commands. + + + + A sequence access method handler function must be declared to accept a s= ingle + argument of type internal and to return the pseudo-type + sequence_am_handler. The argument is a dummy value that si= mply + serves to prevent handler functions from being called directly from SQL = commands. + + The result of the function must be a pointer to a struct of type + SequenceAmRoutine, which contains everything th= at the + core code needs to know to make use of the sequence access method. The r= eturn + value needs to be of server lifetime, which is typically achieved by + defining it as a static const variable in global + scope. The SequenceAmRoutine struct, also calle= d the + access method's API struct, defines the behavior = of + the access method using callbacks. These callbacks are pointers to plain= C + functions and are not visible or callable at the SQL level. All the + callbacks and their behavior is defined in the + SequenceAmRoutine structure (with comments insi= de + the struct defining the requirements for callbacks). Most callbacks have + wrapper functions, which are documented from the point of view of a user + (rather than an implementor) of the sequence access method. For details, + please refer to the + src/include/access/sequenceam.h file. + + + + Currently, the way a sequence access method stores data is fairly + unconstrained, and it is possible to use a predefined + Table Access Method to store sequence + data. + + + + For crash safety, a sequence access method can use + WAL, or a custom + implementation. + If WAL is chosen, either + Generic WAL Records can be used, or= a + Custom WAL Resource Manager can be + implemented. + + + + Any developer of a new sequence access method can ref= er to + the existing local implementation present in + src/backend/access/sequence/local.c for details of + its implementation. + + --=20 2.43.0 --Hb9lJVq6MVTkbU7F Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v5-0008-snowflake-Add-sequence-AM-based-on-it.patch" Content-Transfer-Encoding: quoted-printable =46rom 07b626d6641e7bb871caf7f4e35262097bc988d0 Mon Sep 17 00:00:00 2001 =46rom: Michael Paquier Date: Fri, 26 Apr 2024 15:09:00 +0900 Subject: [PATCH v5 8/8] snowflake: Add sequence AM based on it This includes documentation and a basic implementation, though this is in a very early stage. --- doc/src/sgml/contrib.sgml | 1 + doc/src/sgml/filelist.sgml | 1 + doc/src/sgml/snowflake.sgml | 100 ++++ contrib/Makefile | 1 + contrib/meson.build | 1 + contrib/snowflake/.gitignore | 3 + contrib/snowflake/Makefile | 19 + contrib/snowflake/expected/snowflake.out | 73 +++ contrib/snowflake/meson.build | 34 ++ contrib/snowflake/snowflake--1.0.sql | 21 + contrib/snowflake/snowflake.c | 570 +++++++++++++++++++++++ contrib/snowflake/snowflake.control | 5 + contrib/snowflake/sql/snowflake.sql | 29 ++ 13 files changed, 858 insertions(+) create mode 100644 doc/src/sgml/snowflake.sgml create mode 100644 contrib/snowflake/.gitignore create mode 100644 contrib/snowflake/Makefile create mode 100644 contrib/snowflake/expected/snowflake.out create mode 100644 contrib/snowflake/meson.build create mode 100644 contrib/snowflake/snowflake--1.0.sql create mode 100644 contrib/snowflake/snowflake.c create mode 100644 contrib/snowflake/snowflake.control create mode 100644 contrib/snowflake/sql/snowflake.sql diff --git a/doc/src/sgml/contrib.sgml b/doc/src/sgml/contrib.sgml index 44639a8dca..e7b8871e8a 100644 --- a/doc/src/sgml/contrib.sgml +++ b/doc/src/sgml/contrib.sgml @@ -166,6 +166,7 @@ CREATE EXTENSION extension_name; &seg; &sepgsql; &contrib-spi; + &snowflake; &sslinfo; &tablefunc; &tcn; diff --git a/doc/src/sgml/filelist.sgml b/doc/src/sgml/filelist.sgml index 4e1218aa89..3b9e38e320 100644 --- a/doc/src/sgml/filelist.sgml +++ b/doc/src/sgml/filelist.sgml @@ -156,6 +156,7 @@ + diff --git a/doc/src/sgml/snowflake.sgml b/doc/src/sgml/snowflake.sgml new file mode 100644 index 0000000000..060699e7ec --- /dev/null +++ b/doc/src/sgml/snowflake.sgml @@ -0,0 +1,100 @@ + + + + snowflake — sequence access method + + + snowflake + + + + snowflake provides a sequence access method based on + Snowflake IDs<= /ulink>. + + + + A Snowflake ID (or snowflake) is a unique 64-bit identifier made of three + components: + + 41 bits for a timestamp, epoch-adjusted in milli-second= s + 10 bits for machine ID + 12 bits for a sequence number + + + + + Functions + + + + + snowflake_get(raw int8) returns record + + snowflake_get + function + + + + + + Returns a record made of the timestamp in milli-seconds, the machine= ID + and the sequence number for a single snowflake ID. + + + + + + + + Configuration Parameters + + + + + snowflake.machine_id + + snowflake.machine_id configuration param= eter + + + + + Machine ID assigned to the snowflake IDs used in the sequence. The + default value is 1. + + + + + + + + Examples + + + This is an example of creating a snowflake sequence: + + + +CREATE SEQUENCE snowflake_seq USING snowflake; + + + + Similarly to the default sequence access method, snowflake sequences + can be queried as a table: + + + + =3D# SELECT * FROM snowflake_seq; + count | is_called +-------+----------- + 1 | f +(1 row) +=3D# SELECT to_timestamp(time_ms / 1000), machine, counter + FROM snowflake_get(nextval('snowflake_seq')); + to_timestamp | machine | counter +------------------------+---------+--------- + 2024-04-26 14:28:26+09 | 1 | 3 +(1 row) + + + + diff --git a/contrib/Makefile b/contrib/Makefile index abd780f277..f5d1b568b2 100644 --- a/contrib/Makefile +++ b/contrib/Makefile @@ -42,6 +42,7 @@ SUBDIRS =3D \ pg_walinspect \ postgres_fdw \ seg \ + snowflake \ spi \ tablefunc \ tcn \ diff --git a/contrib/meson.build b/contrib/meson.build index 14a8906865..4f2603e7e9 100644 --- a/contrib/meson.build +++ b/contrib/meson.build @@ -57,6 +57,7 @@ subdir('pg_walinspect') subdir('postgres_fdw') subdir('seg') subdir('sepgsql') +subdir('snowflake') subdir('spi') subdir('sslinfo') # start-scripts doesn't contain build products diff --git a/contrib/snowflake/.gitignore b/contrib/snowflake/.gitignore new file mode 100644 index 0000000000..44d119cfcc --- /dev/null +++ b/contrib/snowflake/.gitignore @@ -0,0 +1,3 @@ +# Generated subdirectories +/log/ +/results/ diff --git a/contrib/snowflake/Makefile b/contrib/snowflake/Makefile new file mode 100644 index 0000000000..fa5b48d565 --- /dev/null +++ b/contrib/snowflake/Makefile @@ -0,0 +1,19 @@ +# contrib/snowflake/Makefile + +MODULES =3D snowflake + +EXTENSION =3D snowflake +DATA =3D snowflake--1.0.sql + +REGRESS =3D snowflake + +ifdef USE_PGXS +PG_CONFIG =3D pg_config +PGXS :=3D $(shell $(PG_CONFIG) --pgxs) +include $(PGXS) +else +subdir =3D contrib/snowflake +top_builddir =3D ../.. +include $(top_builddir)/src/Makefile.global +include $(top_srcdir)/contrib/contrib-global.mk +endif diff --git a/contrib/snowflake/expected/snowflake.out b/contrib/snowflake/e= xpected/snowflake.out new file mode 100644 index 0000000000..b7e469bf73 --- /dev/null +++ b/contrib/snowflake/expected/snowflake.out @@ -0,0 +1,73 @@ +CREATE EXTENSION snowflake; +CREATE SEQUENCE snowflake_seq USING snowflake; +SET snowflake.machine_id =3D 2000; -- error +ERROR: 2000 is outside the valid range for parameter "snowflake.machine_i= d" (0 .. 1023) +SET snowflake.machine_id =3D 4; -- ok +SELECT machine, counter FROM snowflake_get(nextval('snowflake_seq')); + machine | counter=20 +---------+--------- + 4 | 2 +(1 row) + +SELECT machine, counter FROM snowflake_get(lastval()); + machine | counter=20 +---------+--------- + 4 | 2 +(1 row) + +SELECT machine, counter FROM snowflake_get(nextval('snowflake_seq')); + machine | counter=20 +---------+--------- + 4 | 3 +(1 row) + +SELECT machine, counter FROM snowflake_get(currval('snowflake_seq')); + machine | counter=20 +---------+--------- + 4 | 3 +(1 row) + +-- Sequence relation exists, is unlogged and remains unlogged. +SELECT * FROM snowflake_seq; + count | is_called=20 +-------+----------- + 3 | t +(1 row) + +ALTER SEQUENCE snowflake_seq SET LOGGED; +SELECT relpersistence FROM pg_class where relname =3D 'snowflake_seq'; + relpersistence=20 +---------------- + u +(1 row) + +ALTER SEQUENCE snowflake_seq RESTART; +SELECT * FROM snowflake_seq; + count | is_called=20 +-------+----------- + 1 | f +(1 row) + +-- Identity column, where cache affects value. +SET default_sequence_access_method =3D 'snowflake'; +CREATE TABLE snowflake_tab (a int GENERATED ALWAYS AS IDENTITY, b int); +INSERT INTO snowflake_tab VALUES (DEFAULT, generate_series(1, 10)); +SELECT data.machine, data.counter + FROM snowflake_tab, LATERAL snowflake_get(a) AS data; + machine | counter=20 +---------+--------- + 4 | 2 + 4 | 3 + 4 | 4 + 4 | 5 + 4 | 6 + 4 | 7 + 4 | 8 + 4 | 9 + 4 | 10 + 4 | 11 +(10 rows) + +DROP TABLE snowflake_tab; +DROP SEQUENCE snowflake_seq; +DROP EXTENSION snowflake; diff --git a/contrib/snowflake/meson.build b/contrib/snowflake/meson.build new file mode 100644 index 0000000000..567669eea7 --- /dev/null +++ b/contrib/snowflake/meson.build @@ -0,0 +1,34 @@ +# Copyright (c) 2024, PostgreSQL Global Development Group + +snowflake_sources =3D files( + 'snowflake.c', +) + +if host_system =3D=3D 'windows' + snowflake_sources +=3D rc_lib_gen.process(win32ver_rc, extra_args: [ + '--NAME', 'snowflake', + '--FILEDESC', 'snowflake - sequence access method',]) +endif + +snowflake =3D shared_module('snowflake', + snowflake_sources, + kwargs: contrib_mod_args, +) +contrib_targets +=3D bloom + +install_data( + 'snowflake.control', + 'snowflake--1.0.sql', + kwargs: contrib_data_args, +) + +tests +=3D { + 'name': 'snowflake', + 'sd': meson.current_source_dir(), + 'bd': meson.current_build_dir(), + 'regress': { + 'sql': [ + 'snowflake', + ], + }, +} diff --git a/contrib/snowflake/snowflake--1.0.sql b/contrib/snowflake/snowf= lake--1.0.sql new file mode 100644 index 0000000000..bcb9d754f1 --- /dev/null +++ b/contrib/snowflake/snowflake--1.0.sql @@ -0,0 +1,21 @@ +/* contrib/snowflake/snowflake--1.0.sql */ + +-- complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "CREATE EXTENSION snowflake" to load this file. \quit + +CREATE FUNCTION snowflake_sequenceam_handler(internal) + RETURNS sequence_am_handler + AS 'MODULE_PATHNAME' + LANGUAGE C; + +CREATE ACCESS METHOD snowflake + TYPE SEQUENCE HANDLER snowflake_sequenceam_handler; +COMMENT ON ACCESS METHOD snowflake IS 'snowflake sequence access method'; + +CREATE FUNCTION snowflake_get(IN raw int8, + OUT time_ms int8, + OUT machine int4, + OUT counter int4) + RETURNS record + AS 'MODULE_PATHNAME' + LANGUAGE C STRICT diff --git a/contrib/snowflake/snowflake.c b/contrib/snowflake/snowflake.c new file mode 100644 index 0000000000..be4c4039ec --- /dev/null +++ b/contrib/snowflake/snowflake.c @@ -0,0 +1,570 @@ +/*------------------------------------------------------------------------- + * + * snowflake.c + * + * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * contrib/snowflake/snowflake.c + * + *------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include + +#include "access/generic_xlog.h" +#include "access/sequenceam.h" +#include "access/xact.h" +#include "catalog/storage_xlog.h" +#include "commands/tablecmds.h" +#include "fmgr.h" +#include "funcapi.h" +#include "miscadmin.h" +#include "nodes/makefuncs.h" +#include "storage/bufmgr.h" +#include "utils/guc.h" +#include "utils/numeric.h" + +PG_MODULE_MAGIC; + +/* "special area" of a snowflake's buffer page. */ +#define SNOWFLAKE_MAGIC 0x01 + +typedef struct snowflake_magic +{ + uint32 magic; +} snowflake_magic; + +/* ----------------------------------------------------------------------- + * Snowflake ID are 64-bit based, with the following structure: + * - 41 bits for an epoch-based timestamp, in milli-seconds. + * - 10 bits for a machine ID. + * - 12 bits for a sequence counter. + * + * The timestamp can be cut to an offset. The machine ID is controlled + * by a superuser GUC. Sequence properties apply to the sequence counter, + * as the other two are environment-dependent. + * ----------------------------------------------------------------------- + */ + +/* + * Helper routines to convert a snowflake ID from/to an int64. + */ +#define SNOWFLAKE_COUNTER_MASK 0x0000000000000FFF /* 12 bits */ +#define SNOWFLAKE_COUNTER_SHIFT 0 +#define SNOWFLAKE_MACHINE_ID_MASK 0x00000000000003FF /* 10 bits */ +#define SNOWFLAKE_MACHINE_ID_SHIFT 12 /* counter */ +#define SNOWFLAKE_TIMESTAMP_MASK 0x000001FFFFFFFFFF /* 41 bits */ +#define SNOWFLAKE_TIMESTAMP_SHIFT 22 /* machine ID + counter sizes */ + +typedef struct snowflake_id +{ + uint32 count; + uint32 machine; + uint64 time_ms; +} snowflake_id; + +#define snowflake_id_to_int64(id, raw) { \ + raw =3D (((id).count) & SNOWFLAKE_COUNTER_MASK) << SNOWFLAKE_COUNTER_SHIF= T | \ + (((id).machine) & SNOWFLAKE_MACHINE_ID_MASK) << SNOWFLAKE_MACHINE_ID_SHI= FT | \ + (((id).time_ms) & SNOWFLAKE_TIMESTAMP_MASK) << SNOWFLAKE_TIMESTAMP_SHIFT= ; \ +} + +#define int64_to_snowflake_id(raw, id) { \ + (id).count =3D ((raw) >> SNOWFLAKE_COUNTER_SHIFT) & SNOWFLAKE_COUNTER_MAS= K; \ + (id).machine =3D ((raw) >> SNOWFLAKE_MACHINE_ID_SHIFT) & SNOWFLAKE_MACHIN= E_ID_MASK; \ + (id).time_ms =3D ((raw) >> SNOWFLAKE_TIMESTAMP_SHIFT) & SNOWFLAKE_TIMESTA= MP_MASK; \ +} + +/* + * Format of tuples stored in heap table associated to snowflake sequence. + */ +typedef struct FormData_snowflake_data +{ + /* enough to cover 12 bits of the internal counter */ + int16 count; + bool is_called; +} FormData_snowflake_data; + +typedef FormData_snowflake_data *Form_snowflake_data; + +/* + * Columns of a snowflake sequence relation. + */ +#define SNOWFLAKE_COL_COUNT 1 +#define SNOWFLAKE_COL_CALLED 2 + +#define SNOWFLAKE_COLS 2 + +/* GUC parameter */ +static int snowflake_machine_id =3D 1; + +PG_FUNCTION_INFO_V1(snowflake_sequenceam_handler); + +/* ----------------------------------------------------------------------- + * Interfaces for relation manipulation. + * ----------------------------------------------------------------------- + */ + +/* + * Initialize snowflake relation's fork with some data. + */ +static void +fill_snowflake_fork(Relation rel, HeapTuple tuple, ForkNumber forkNum) +{ + Buffer buf; + Page page; + snowflake_magic *sm; + OffsetNumber offnum; + GenericXLogState *state =3D NULL; + + /* Initialize first page of relation with special magic number */ + + buf =3D ExtendBufferedRel(BMR_REL(rel), forkNum, NULL, + EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK); + Assert(BufferGetBlockNumber(buf) =3D=3D 0); + + page =3D BufferGetPage(buf); + + PageInit(page, BufferGetPageSize(buf), sizeof(snowflake_magic)); + sm =3D (snowflake_magic *) PageGetSpecialPointer(page); + sm->magic =3D SNOWFLAKE_MAGIC; + + /* Now insert sequence tuple */ + + /* + * Since VACUUM does not process sequences, we have to force the tuple to + * have xmin =3D FrozenTransactionId now. Otherwise it would become + * invisible to SELECTs after 2G transactions. It is okay to do this + * because if the current transaction aborts, no other xact will ever + * examine the sequence tuple anyway. + */ + HeapTupleHeaderSetXmin(tuple->t_data, FrozenTransactionId); + HeapTupleHeaderSetXminFrozen(tuple->t_data); + HeapTupleHeaderSetCmin(tuple->t_data, FirstCommandId); + HeapTupleHeaderSetXmax(tuple->t_data, InvalidTransactionId); + tuple->t_data->t_infomask |=3D HEAP_XMAX_INVALID; + ItemPointerSet(&tuple->t_data->t_ctid, 0, FirstOffsetNumber); + + /* + * Initialize before entering in the critical section, as this does + * allocations. + */ + if (forkNum =3D=3D INIT_FORKNUM) + state =3D GenericXLogStart(rel); + + START_CRIT_SECTION(); + + MarkBufferDirty(buf); + + offnum =3D PageAddItem(page, (Item) tuple->t_data, tuple->t_len, + InvalidOffsetNumber, false, false); + if (offnum !=3D FirstOffsetNumber) + elog(ERROR, "failed to add sequence tuple to page"); + + /* + * Init forks have to be logged. These go through generic WAL records + * for simplicity's sake to save from the need of a custom RMGR. + */ + if (forkNum =3D=3D INIT_FORKNUM) + { + (void) GenericXLogRegisterBuffer(state, buf, GENERIC_XLOG_FULL_IMAGE); + GenericXLogFinish(state); + } + + END_CRIT_SECTION(); + + UnlockReleaseBuffer(buf); +} + +/* + * Initialize snowflake relation. + * + * This needs to handle both the initial and main forks. + */ +static void +fill_snowflake(Relation rel, HeapTuple tuple) +{ + SMgrRelation srel; + + Assert(rel->rd_rel->relpersistence =3D=3D RELPERSISTENCE_UNLOGGED); + + fill_snowflake_fork(rel, tuple, MAIN_FORKNUM); + + /* init fork */ + srel =3D smgropen(rel->rd_locator, INVALID_PROC_NUMBER); + smgrcreate(srel, INIT_FORKNUM, false); + log_smgrcreate(&rel->rd_locator, INIT_FORKNUM); + fill_snowflake_fork(rel, tuple, INIT_FORKNUM); + FlushRelationBuffers(rel); + smgrclose(srel); +} + +/* + * Read the current state of a snowflake sequence + * + * Given an opened sequence relation, lock the page buffer and find the tu= ple. + * + * *buf receives the reference to the pinned-and-ex-locked buffer. + * *seqdatatuple receives the reference to the sequence tuple proper. + * + * Returns value points to the data payload of the tuple. + */ +static Form_snowflake_data +read_snowflake(Relation rel, Buffer *buf, HeapTuple seqdatatuple) +{ + Page page; + ItemId lp; + snowflake_magic *sm; + Form_snowflake_data seq; + + *buf =3D ReadBuffer(rel, 0); + LockBuffer(*buf, BUFFER_LOCK_EXCLUSIVE); + + page =3D BufferGetPage(*buf); + sm =3D (snowflake_magic *) PageGetSpecialPointer(page); + + if (sm->magic !=3D SNOWFLAKE_MAGIC) + elog(ERROR, "bad magic number in sequence \"%s\": %08X", + RelationGetRelationName(rel), sm->magic); + + lp =3D PageGetItemId(page, FirstOffsetNumber); + Assert(ItemIdIsNormal(lp)); + + /* Note we currently only bother to set these two fields of *seqdatatuple= */ + seqdatatuple->t_data =3D (HeapTupleHeader) PageGetItem(page, lp); + seqdatatuple->t_len =3D ItemIdGetLength(lp); + + /* + * Previous releases of Postgres neglected to prevent SELECT FOR UPDATE on + * a sequence, which would leave a non-frozen XID in the sequence tuple's + * xmax, which eventually leads to clog access failures or worse. If we + * see this has happened, clean up after it. We treat this like a hint + * bit update, ie, don't bother to WAL-log it, since we can certainly do + * this again if the update gets lost. + */ + Assert(!(seqdatatuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI)); + if (HeapTupleHeaderGetRawXmax(seqdatatuple->t_data) !=3D InvalidTransacti= onId) + { + HeapTupleHeaderSetXmax(seqdatatuple->t_data, InvalidTransactionId); + seqdatatuple->t_data->t_infomask &=3D ~HEAP_XMAX_COMMITTED; + seqdatatuple->t_data->t_infomask |=3D HEAP_XMAX_INVALID; + MarkBufferDirtyHint(*buf, true); + } + + seq =3D (Form_snowflake_data) GETSTRUCT(seqdatatuple); + + return seq; +} + + +/* ------------------------------------------------------------------------ + * Callbacks for the snowflake sequence access method. + * ------------------------------------------------------------------------ + */ + +/* + * Return the table access method used by this sequence. + * + * This is just an on-memory sequence, so anything is fine. + */ +static const char * +snowflake_sequenceam_get_table_am(void) +{ + return "heap"; +} + +/* + * snowflake_sequenceam_init + * + * Initialize relation of a snowflake sequence. This stores the sequence + * counter in an unlogged relation as timestamps ensure value unicity. + */ +static void +snowflake_sequenceam_init(Relation rel, int64 last_value, bool is_called) +{ + Datum values[SNOWFLAKE_COLS]; + bool nulls[SNOWFLAKE_COLS]; + int16 counter; + TupleDesc tupdesc; + HeapTuple tuple; + List *elts =3D NIL; + ListCell *lc; + ColumnDef *coldef =3D NULL; + AlterTableCmd *atcmd; + List *atcmds =3D NIL; + + /* Adjust last_value, depending on the defaults given */ + counter =3D ((int16) last_value) & SNOWFLAKE_COUNTER_MASK; + + /* + * Create unlogged relation with its attributes. + */ + coldef =3D makeColumnDef("count", INT2OID, -1, InvalidOid); + coldef->is_not_null =3D true; + elts =3D lappend(elts, coldef); + coldef =3D makeColumnDef("is_called", BOOLOID, -1, InvalidOid); + coldef->is_not_null =3D true; + elts =3D lappend(elts, coldef); + + foreach(lc, elts) + { + atcmd =3D makeNode(AlterTableCmd); + atcmd->subtype =3D AT_AddColumnToSequence; + atcmd->def =3D (Node *) lfirst(lc); + atcmds =3D lappend(atcmds, atcmd); + } + + /* + * No recursion needed. Note that EventTriggerAlterTableStart() should + * have been called. + */ + AlterTableInternal(RelationGetRelid(rel), atcmds, false); + CommandCounterIncrement(); + + /* + * Switch the relation to be unlogged. This forces a rewrite, but + * the relation is empty so that's OK. + */ + RelationSetNewRelfilenumber(rel, RELPERSISTENCE_UNLOGGED); + + /* And insert its first tuple */ + values[0] =3D Int16GetDatum(counter); + nulls[0] =3D false; + values[1] =3D BoolGetDatum(is_called); + nulls[1] =3D false; + + tupdesc =3D RelationGetDescr(rel); + tuple =3D heap_form_tuple(tupdesc, values, nulls); + fill_snowflake(rel, tuple); +} + +/* + * snowflake_sequenceam_nextval + * + * Return the next value for a snowflake sequence. + */ +static int64 +snowflake_sequenceam_nextval(Relation rel, int64 incby, int64 maxv, + int64 minv, int64 cache, bool cycle, + int64 *last) +{ + Buffer buf; + Form_snowflake_data seq; + HeapTupleData seqdatatuple; + int64 result =3D 0; + snowflake_id id =3D {0}; + struct timeval tp; + + /* lock page buffer and read tuple */ + seq =3D read_snowflake(rel, &buf, &seqdatatuple); + + /* + * The logic here is quite simple, increment the counter until its + * threshold is reached and get back to the start. If the threshold + * is reached, wait 1ms to ensure a unique timestamp. There is no + * need to do a retry as the buffer is already locked. + */ + id.count =3D seq->count; + id.count++; + + if (id.count > (PG_INT16_MAX & SNOWFLAKE_COUNTER_MASK)) + { + /* + * Threshold reached, so wait a bit for force clock to a new + * timestamp. + */ + id.count =3D 1; + pg_usleep(1000L); /* 1ms */ + } + + /* Compute timestamp, with buffer locked */ + gettimeofday(&tp, NULL); + id.time_ms =3D (uint64) tp.tv_sec * 1000 + + tp.tv_usec / 1000; + + /* Machine ID */ + id.machine =3D snowflake_machine_id; + + /* ready to change the on-disk (or really, in-buffer) tuple */ + START_CRIT_SECTION(); + seq->count =3D id.count; + seq->is_called =3D true; + END_CRIT_SECTION(); + + UnlockReleaseBuffer(buf); + + /* Store the last value computed for lastval() */ + snowflake_id_to_int64(id, result); + *last =3D result; + return result; +} + +/* + * snowflake_sequenceam_setval + * + * Set the sequence value, manipulating only the sequence counter. + */ +static void +snowflake_sequenceam_setval(Relation rel, int64 next, bool iscalled) +{ + Buffer buf; + HeapTupleData seqdatatuple; + Form_snowflake_data seq; + + /* lock page buffer and read tuple */ + seq =3D read_snowflake(rel, &buf, &seqdatatuple); + + /* Change the in-buffer tuple */ + START_CRIT_SECTION(); + seq->count =3D (next & SNOWFLAKE_COUNTER_MASK); + seq->is_called =3D iscalled; + MarkBufferDirty(buf); + END_CRIT_SECTION(); + + UnlockReleaseBuffer(buf); +} + +/* + * snowflake_sequenceam_get_state + * + * Return the last sequence counter value. + */ +static void +snowflake_sequenceam_get_state(Relation rel, int64 *last_value, bool *is_c= alled) +{ + Buffer buf; + HeapTupleData seqdatatuple; + Form_snowflake_data seq; + + seq =3D read_snowflake(rel, &buf, &seqdatatuple); + *last_value =3D seq->count; + *is_called =3D seq->is_called; + UnlockReleaseBuffer(buf); +} + +/* + * snowflake_sequenceam_reset + * + * Reset the sequence, coming down to resetting its counter. + */ +static void +snowflake_sequenceam_reset(Relation rel, int64 startv, bool is_called, + bool reset_state) +{ + HeapTupleData seqdatatuple; + HeapTuple tuple; + Form_snowflake_data seq; + Buffer buf; + + /* lock buffer page and read tuple */ + (void) read_snowflake(rel, &buf, &seqdatatuple); + + /* copy the existing tuple */ + tuple =3D heap_copytuple(&seqdatatuple); + + /* Now we're done with the old page */ + UnlockReleaseBuffer(buf); + + /* + * Modify the copied tuple to execute the restart (compare the RESTART + * action in AlterSequence) + */ + seq =3D (Form_snowflake_data) GETSTRUCT(tuple); + seq->count =3D (startv & SNOWFLAKE_COUNTER_MASK); + seq->is_called =3D is_called; + + /* create new storage */ + RelationSetNewRelfilenumber(rel, rel->rd_rel->relpersistence); + + /* insert the modified tuple into the page */ + fill_snowflake(rel, tuple); +} + +/* + * snowflake_sequenceam_change_persistence + * + * There is nothing to do here, the underneath relation has to remain + * unlogged and is set as such when creating the sequence. + */ +static void +snowflake_sequenceam_change_persistence(Relation rel, char newrelpersisten= ce) +{ + /* Nothing to do here */ +} + +/* ------------------------------------------------------------------------ + * Definition of the snowflake sequence access method. + * ------------------------------------------------------------------------ + */ + +static const SequenceAmRoutine snowflake_sequenceam_methods =3D { + .type =3D T_SequenceAmRoutine, + .get_table_am =3D snowflake_sequenceam_get_table_am, + .init =3D snowflake_sequenceam_init, + .nextval =3D snowflake_sequenceam_nextval, + .setval =3D snowflake_sequenceam_setval, + .get_state =3D snowflake_sequenceam_get_state, + .reset =3D snowflake_sequenceam_reset, + .change_persistence =3D snowflake_sequenceam_change_persistence +}; + +Datum +snowflake_sequenceam_handler(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(&snowflake_sequenceam_methods); +} + +/* Utility functions */ + +/* + * snowflake_get + * + * Return a tuple worth of snowflake ID data, in a readable shape. + */ +PG_FUNCTION_INFO_V1(snowflake_get); +Datum +snowflake_get(PG_FUNCTION_ARGS) +{ +#define SNOWFLAKE_GET_COLS 3 + int64 raw =3D PG_GETARG_INT64(0); + Datum *values; + bool *nulls; + TupleDesc tupdesc; + snowflake_id id; + + /* determine result type */ + if (get_call_result_type(fcinfo, NULL, &tupdesc) !=3D TYPEFUNC_COMPOSITE) + elog(ERROR, "return type must be a row type"); + + int64_to_snowflake_id(raw, id); + + nulls =3D palloc0(sizeof(bool) * tupdesc->natts); + values =3D palloc0(sizeof(Datum) * tupdesc->natts); + + values[0] =3D Int64GetDatum(id.time_ms); + values[1] =3D Int32GetDatum(id.machine); + values[2] =3D Int32GetDatum(id.count); + + /* Returns the record as Datum */ + PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)= )); +} + +/* + * Entry point when loading extension. + */ +void +_PG_init(void) +{ + DefineCustomIntVariable("snowflake.machine_id", + "Machine ID to use with snowflake sequence.", + "Default value is 1.", + &snowflake_machine_id, + 1, 0, 1023, /* 10 bits as max */ + PGC_SUSET, + 0, NULL, NULL, NULL); +} diff --git a/contrib/snowflake/snowflake.control b/contrib/snowflake/snowfl= ake.control new file mode 100644 index 0000000000..7b8c6089c2 --- /dev/null +++ b/contrib/snowflake/snowflake.control @@ -0,0 +1,5 @@ +# snowflake extension +comment =3D 'snowflake - sequence access method' +default_version =3D '1.0' +module_pathname =3D '$libdir/snowflake' +relocatable =3D true diff --git a/contrib/snowflake/sql/snowflake.sql b/contrib/snowflake/sql/sn= owflake.sql new file mode 100644 index 0000000000..395d166ba4 --- /dev/null +++ b/contrib/snowflake/sql/snowflake.sql @@ -0,0 +1,29 @@ +CREATE EXTENSION snowflake; + +CREATE SEQUENCE snowflake_seq USING snowflake; + +SET snowflake.machine_id =3D 2000; -- error +SET snowflake.machine_id =3D 4; -- ok +SELECT machine, counter FROM snowflake_get(nextval('snowflake_seq')); +SELECT machine, counter FROM snowflake_get(lastval()); +SELECT machine, counter FROM snowflake_get(nextval('snowflake_seq')); +SELECT machine, counter FROM snowflake_get(currval('snowflake_seq')); + +-- Sequence relation exists, is unlogged and remains unlogged. +SELECT * FROM snowflake_seq; +ALTER SEQUENCE snowflake_seq SET LOGGED; +SELECT relpersistence FROM pg_class where relname =3D 'snowflake_seq'; + +ALTER SEQUENCE snowflake_seq RESTART; +SELECT * FROM snowflake_seq; + +-- Identity column, where cache affects value. +SET default_sequence_access_method =3D 'snowflake'; +CREATE TABLE snowflake_tab (a int GENERATED ALWAYS AS IDENTITY, b int); +INSERT INTO snowflake_tab VALUES (DEFAULT, generate_series(1, 10)); +SELECT data.machine, data.counter + FROM snowflake_tab, LATERAL snowflake_get(a) AS data; +DROP TABLE snowflake_tab; + +DROP SEQUENCE snowflake_seq; +DROP EXTENSION snowflake; --=20 2.43.0 --Hb9lJVq6MVTkbU7F-- --kkepPBWX+YAe7BPK Content-Type: application/pgp-signature; name="signature.asc" -----BEGIN PGP SIGNATURE----- iQIzBAABCgAdFiEEG72nH6vTowiyblFKnvQgOdbyQH0FAmYrR+gACgkQnvQgOdby QH38XQ/+Lj5s2Rtg2Cd3456XYy7LWydj2noEDIJ0r4p0zEXitbzB5jaqxjK9vMwR mPIU+2tQTHxftNJg8rGMg+MFq5XLXqF3TlCpuBPw2a5Y+R6KXNx5laTRA4RsoeRI UnfuZQik+HCWhCcVCvth1HPkqAPCDTnyrj+qZ++wRQ0OGunvw2Vwf09ZQqS6jrjj Grmq6EOr7C7epuvkkbrmuKCNUmuteWIMdcM2oGrlJjcmrNqT/4uCiraaqZZsNGuk QHnRHS01be+DQscSnl7l2+QS9UXRfl0hA6wsE8M3QtKFVg1DNLc2zVeMkFE+xxFa XEkXsHZV5F4hcK6/r7sw+d7PqgUIt1ESPTlamDs80Ml34vkZa86byEkOVKZ5Zu5t Lal0OXFjQzYV59YzFJFgvn3s/JwkLsXE428Myd/B0zCHgK5Tb4LtxdEzXU/4JnW4 o0CJ8YtuU9LxgF1BHFvEksENgHnJSSU5p2yJrYLYgx4nfmCek3wJtraVKsqrG9QX h3W39E+B+YcFPg4fQ2CpHEAzT6uZ6xEb+eZUSbC+Zz/mRTqkNMm3328JSbqfChR7 7rdbeu4jN8BO7WHJswbdSJRgt0vgShEDo+a5slRjGrG1rK4OFEm/oER/6/ZsruH8 3RkxyNZXulXXTmgCnOaHPS/IA9QIr6Pr1ZM4+ZiJ/pBmQt2/JIo= =rIjK -----END PGP SIGNATURE----- --kkepPBWX+YAe7BPK--