From 121048ebe85349f273a6f20da043596dad1f7287 Mon Sep 17 00:00:00 2001 From: Andrew Dunstan Date: Fri, 13 Mar 2026 10:22:37 -0400 Subject: [PATCH 01/12] Global temporary tables: catalog and DDL support Add a new relpersistence value RELPERSISTENCE_GLOBAL_TEMP ('g') for global temporary tables. Per the SQL standard, global temporary tables have a persistent, shared catalog definition visible to all sessions, but per-session private data (the per-session data isolation is not yet implemented and will come in a subsequent commit). The grammar now produces RELPERSISTENCE_GLOBAL_TEMP for CREATE GLOBAL TEMPORARY TABLE, replacing the previous deprecation warning. ON COMMIT PRESERVE ROWS and DELETE ROWS are accepted; ON COMMIT DROP is rejected since the table definition is persistent. All relpersistence switch statements across the backend are updated to handle the new value: catalog.c, storage.c, relcache.c, bufmgr.c, dbsize.c, and tablecmds.c. The new persistence type uses shared buffers and no WAL, similar to unlogged tables; a subsequent commit redirects it to local buffers. Sequences implicitly created for SERIAL or IDENTITY columns of a GTT inherit the GTT persistence, so each session gets its own counter. parse_utilcmd propagates RELPERSISTENCE_GLOBAL_TEMP to the generated CreateSeqStmt, and relation_open seeds the per-session sequence page on first open from pg_sequence's initial state, so even a direct scan of the sequence relation (SELECT last_value FROM seq, as psql's \d emits) sees the one mandatory row in any session. Standalone CREATE GLOBAL TEMPORARY SEQUENCE is also supported. GetNewRelFileNumber probes the backend's temp-relation namespace for RELPERSISTENCE_GLOBAL_TEMP, since that is where a GTT's per-session files actually live; the shared path never holds a file for a GTT. psql \dt+ shows "global temporary" in the Persistence column. pg_dump emits CREATE GLOBAL TEMPORARY TABLE. Restrictions enforced: - FK constraints between GTTs and non-GTTs are rejected - ALTER TABLE SET LOGGED/UNLOGGED is rejected for GTTs - ALTER TABLE SET TABLESPACE is rejected for GTTs (would rotate the shared-catalog relfilenode that every session uses as the stem of its own per-session file name) - Mixing GTTs and local temp tables in inheritance is rejected, both at CREATE TABLE time (MergeAttributes) and at ALTER TABLE INHERIT / ATTACH PARTITION time - GTTs cannot be created in temporary schemas - CREATE GLOBAL TEMPORARY VIEW and CREATE GLOBAL TEMPORARY PROPERTY GRAPH are rejected: such relations have no storage for the GTT machinery to manage - CREATE MATERIALIZED VIEW over a GTT is rejected: the matview's heap is permanent and shared, so populating it would capture one session's private rows. Direct references are caught at creation time via query_uses_temp_object (which gains a global_temp_matters flag, false for the view-downgrade and function-lifetime callers); references through a view are caught at population time, where the planner has flattened the view into the range table -- covering both CREATE ... WITH DATA and REFRESH. Plain views over GTTs remain allowed and stay permanent: they re-evaluate per session. --- src/backend/access/common/relation.c | 24 +++++ src/backend/catalog/catalog.c | 13 +++ src/backend/catalog/dependency.c | 28 +++++- src/backend/catalog/namespace.c | 15 +++ src/backend/catalog/pg_proc.c | 3 +- src/backend/catalog/storage.c | 1 + src/backend/commands/matview.c | 21 ++++ src/backend/commands/propgraphcmds.c | 6 ++ src/backend/commands/sequence.c | 56 ++++++++++- src/backend/commands/tablecmds.c | 142 +++++++++++++++++++++++++-- src/backend/commands/view.c | 12 ++- src/backend/parser/analyze.c | 27 +++-- src/backend/parser/gram.y | 36 ++----- src/backend/storage/buffer/bufmgr.c | 3 +- src/backend/utils/adt/dbsize.c | 1 + src/backend/utils/cache/relcache.c | 2 + src/bin/pg_dump/pg_dump.c | 2 + src/bin/psql/describe.c | 2 + src/include/catalog/dependency.h | 4 +- src/include/catalog/pg_class.h | 1 + src/include/commands/sequence.h | 2 + src/include/utils/rel.h | 11 +++ 22 files changed, 361 insertions(+), 51 deletions(-) diff --git a/src/backend/access/common/relation.c b/src/backend/access/common/relation.c index 38b356b8239..57eca0ee635 100644 --- a/src/backend/access/common/relation.c +++ b/src/backend/access/common/relation.c @@ -23,12 +23,30 @@ #include "access/relation.h" #include "access/xact.h" #include "catalog/namespace.h" +#include "commands/sequence.h" #include "pgstat.h" #include "storage/lmgr.h" #include "storage/lock.h" #include "utils/inval.h" #include "utils/syscache.h" +static void relation_open_gtt_prepare(Relation r); + +/* + * relation_open_gtt_prepare + * Lazily materialize the session-local pieces of a global temporary + * relation that need more than bare storage: sequences must be seeded + * with their initial tuple. Doing this here, at the single chokepoint + * every open funnels through, covers direct relation_open callers + * (executor scans of a sequence) as well as the sequence functions. + */ +static void +relation_open_gtt_prepare(Relation r) +{ + if (r->rd_rel->relkind == RELKIND_SEQUENCE) + GttEnsureSequenceInitialized(r); +} + /* ---------------- * relation_open - open any relation by relation OID @@ -73,6 +91,9 @@ relation_open(Oid relationId, LOCKMODE lockmode) if (RelationUsesLocalBuffers(r)) MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPNAMESPACE; + if (RelationIsGlobalTemp(r)) + relation_open_gtt_prepare(r); + pgstat_init_relation(r); return r; @@ -123,6 +144,9 @@ try_relation_open(Oid relationId, LOCKMODE lockmode) if (RelationUsesLocalBuffers(r)) MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPNAMESPACE; + if (RelationIsGlobalTemp(r)) + relation_open_gtt_prepare(r); + pgstat_init_relation(r); return r; diff --git a/src/backend/catalog/catalog.c b/src/backend/catalog/catalog.c index 7be49032934..48fb623b2e8 100644 --- a/src/backend/catalog/catalog.c +++ b/src/backend/catalog/catalog.c @@ -573,6 +573,19 @@ GetNewRelFileNumber(Oid reltablespace, Relation pg_class, char relpersistence) case RELPERSISTENCE_TEMP: procNumber = ProcNumberForTempRelations(); break; + + /* + * A global temporary table never has a file at the shared path; + * its per-session files live in each backend's temp-relation + * namespace, using this relfilenumber. Probe our own temp + * namespace, the same one the file will be created in for this + * session; other backends' namespaces cannot be checked here, + * which is the same (wraparound-only) exposure regular temp + * tables have. + */ + case RELPERSISTENCE_GLOBAL_TEMP: + procNumber = ProcNumberForTempRelations(); + break; case RELPERSISTENCE_UNLOGGED: case RELPERSISTENCE_PERMANENT: procNumber = INVALID_PROC_NUMBER; diff --git a/src/backend/catalog/dependency.c b/src/backend/catalog/dependency.c index c54774b3275..fd4cc08c724 100644 --- a/src/backend/catalog/dependency.c +++ b/src/backend/catalog/dependency.c @@ -29,6 +29,7 @@ #include "catalog/pg_amproc.h" #include "catalog/pg_attrdef.h" #include "catalog/pg_authid.h" +#include "catalog/pg_class.h" #include "catalog/pg_auth_members.h" #include "catalog/pg_cast.h" #include "catalog/pg_collation.h" @@ -2533,6 +2534,14 @@ process_function_rte_ref(RangeTblEntry *rte, AttrNumber attnum, * local_temp_okay is true. If one is found, return true after storing its * address in *foundobj. * + * If include_gtt is true, relations that are global temporary + * tables also count as temporary objects. GTTs live in ordinary schemas, + * so the namespace test never catches them; but their *data* is + * session-private, which is what callers like the materialized-view check + * care about. Callers that only care about object lifetime (e.g. the + * temporary-view downgrade, where the GTT definition's persistence is what + * matters) pass false. + * * Current callers only use this to deliver helpful notices, so reporting * one such object seems sufficient. We return the first one, which should * be a stable result for a given query since it depends only on the order @@ -2542,13 +2551,22 @@ process_function_rte_ref(RangeTblEntry *rte, AttrNumber attnum, */ bool find_temp_object(const ObjectAddresses *addrs, bool local_temp_okay, - ObjectAddress *foundobj) + bool include_gtt, ObjectAddress *foundobj) { for (int i = 0; i < addrs->numrefs; i++) { const ObjectAddress *thisobj = addrs->refs + i; Oid objnamespace; + /* Global temporary tables hold session-private data. */ + if (include_gtt && + thisobj->classId == RelationRelationId && + get_rel_persistence(thisobj->objectId) == RELPERSISTENCE_GLOBAL_TEMP) + { + *foundobj = *thisobj; + return true; + } + /* * Use get_object_namespace() to see if this object belongs to a * schema. If not, we can skip it. @@ -2573,10 +2591,12 @@ find_temp_object(const ObjectAddresses *addrs, bool local_temp_okay, * query_uses_temp_object - convenience wrapper for find_temp_object * * If the Query includes any use of a temporary object, fill *temp_object - * with the address of one such object and return true. + * with the address of one such object and return true. See + * find_temp_object for the meaning of include_gtt. */ bool -query_uses_temp_object(Query *query, ObjectAddress *temp_object) +query_uses_temp_object(Query *query, bool include_gtt, + ObjectAddress *temp_object) { bool result; ObjectAddresses *addrs; @@ -2587,7 +2607,7 @@ query_uses_temp_object(Query *query, ObjectAddress *temp_object) collectDependenciesOfExpr(addrs, (Node *) query, NIL); /* Look for one that is temp */ - result = find_temp_object(addrs, false, temp_object); + result = find_temp_object(addrs, false, include_gtt, temp_object); free_object_addresses(addrs); diff --git a/src/backend/catalog/namespace.c b/src/backend/catalog/namespace.c index 56b87d878e8..e26651099f9 100644 --- a/src/backend/catalog/namespace.c +++ b/src/backend/catalog/namespace.c @@ -869,6 +869,21 @@ RangeVarAdjustRelationPersistence(RangeVar *newRelation, Oid nspid) (errcode(ERRCODE_INVALID_TABLE_DEFINITION), errmsg("cannot create relations in temporary schemas of other sessions"))); break; + case RELPERSISTENCE_GLOBAL_TEMP: + + /* + * A global temporary table is a permanent catalog object that + * merely carries per-session data, so it has no business living + * in a temporary schema. Reject it explicitly rather than + * letting it fall through to the generic message below, which + * would wrongly imply a global temporary table is not a temporary + * relation. + */ + if (isAnyTempNamespace(nspid)) + ereport(ERROR, + (errcode(ERRCODE_INVALID_TABLE_DEFINITION), + errmsg("cannot create a global temporary table in a temporary schema"))); + break; default: if (isAnyTempNamespace(nspid)) ereport(ERROR, diff --git a/src/backend/catalog/pg_proc.c b/src/backend/catalog/pg_proc.c index 5df4b3f7a91..fa4b140bef6 100644 --- a/src/backend/catalog/pg_proc.c +++ b/src/backend/catalog/pg_proc.c @@ -676,7 +676,8 @@ ProcedureCreate(const char *procedureName, * function created in our own pg_temp namespace refers to other objects * in that namespace, since then they'll have similar lifespans anyway. */ - if (find_temp_object(addrs, isTempNamespace(procNamespace), &temp_object)) + if (find_temp_object(addrs, isTempNamespace(procNamespace), false, + &temp_object)) ereport(NOTICE, (errmsg("function \"%s\" will be effectively temporary", procedureName), diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c index e443a4993c5..febd8c246ca 100644 --- a/src/backend/catalog/storage.c +++ b/src/backend/catalog/storage.c @@ -135,6 +135,7 @@ RelationCreateStorage(RelFileLocator rlocator, char relpersistence, needs_wal = false; break; case RELPERSISTENCE_UNLOGGED: + case RELPERSISTENCE_GLOBAL_TEMP: procNumber = INVALID_PROC_NUMBER; needs_wal = false; break; diff --git a/src/backend/commands/matview.c b/src/backend/commands/matview.c index f7d8007f796..36ebc95ea60 100644 --- a/src/backend/commands/matview.c +++ b/src/backend/commands/matview.c @@ -427,6 +427,27 @@ refresh_matview_datafill(DestReceiver *dest, Query *query, /* Plan the query which will generate data for the refresh. */ plan = pg_plan_query(query, queryString, CURSOR_OPT_PARALLEL_OK, NULL, NULL); + /* + * A materialized view must not read a global temporary table: GTT + * contents are session-private, while the matview's heap is permanent and + * shared, so populating it would capture -- and publish -- one session's + * private rows. Direct references are rejected at creation time (see + * transformCreateTableAsStmt), but a GTT reached through a view only + * appears once the planner has flattened the view into the range table, + * so check the planned rtable here. This covers both CREATE MATERIALIZED + * VIEW ... WITH DATA and REFRESH. + */ + foreach_node(RangeTblEntry, rte, plan->rtable) + { + if (rte->rtekind == RTE_RELATION && + get_rel_persistence(rte->relid) == RELPERSISTENCE_GLOBAL_TEMP) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("materialized views must not use temporary objects"), + errdetail("This view depends on global temporary table \"%s\".", + get_rel_name(rte->relid)))); + } + /* * Use a snapshot with an updated command ID to ensure this query sees * results of any previously executed queries. (This could only matter if diff --git a/src/backend/commands/propgraphcmds.c b/src/backend/commands/propgraphcmds.c index cc516e27020..28ed1338f60 100644 --- a/src/backend/commands/propgraphcmds.c +++ b/src/backend/commands/propgraphcmds.c @@ -117,6 +117,12 @@ CreatePropGraph(ParseState *pstate, const CreatePropGraphStmt *stmt) (errcode(ERRCODE_SYNTAX_ERROR), errmsg("property graphs cannot be unlogged because they do not have storage"))); + /* same for global temporary, see DefineView */ + if (stmt->pgname->relpersistence == RELPERSISTENCE_GLOBAL_TEMP) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("property graphs cannot be global temporary because they do not have storage"))); + components_persistence = RELPERSISTENCE_PERMANENT; foreach(lc, stmt->vertex_tables) diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c index 551667650ba..8eef726a228 100644 --- a/src/backend/commands/sequence.c +++ b/src/backend/commands/sequence.c @@ -420,6 +420,56 @@ fill_seq_fork_with_data(Relation rel, HeapTuple tuple, ForkNumber forkNum) UnlockReleaseBuffer(buf); } +/* + * GttEnsureSequenceInitialized + * Seed per-session storage for a global temporary sequence. + * + * A GTT sequence's catalog row is shared across sessions, but each session + * has its own physical storage (allocated lazily by GttInitSessionStorage). + * That storage starts out empty — block 0 does not exist — so any attempt + * to read the sequence tuple would fail. Called from relation_open for + * every GTT sequence, so even a direct heapscan of the sequence (SELECT + * last_value FROM seq, as psql's \d emits) sees the one mandatory row. + * The first open in each session writes block 0, using the definition + * recorded in pg_sequence as the initial state (last_value = seqstart, + * log_cnt = 0, is_called = false). + */ +void +GttEnsureSequenceInitialized(Relation rel) +{ + HeapTuple pgstuple; + Form_pg_sequence pgsform; + Datum value[SEQ_COL_LASTCOL]; + bool null[SEQ_COL_LASTCOL] = {0}; + HeapTuple tuple; + + if (rel->rd_rel->relpersistence != RELPERSISTENCE_GLOBAL_TEMP) + return; + + if (RelationGetNumberOfBlocks(rel) > 0) + return; + + /* + * No pg_sequence row yet: we are inside CREATE SEQUENCE, opened from + * DefineSequence before the row is inserted. The creator fills the + * initial tuple itself via fill_seq_with_data. + */ + pgstuple = SearchSysCache1(SEQRELID, ObjectIdGetDatum(RelationGetRelid(rel))); + if (!HeapTupleIsValid(pgstuple)) + return; + pgsform = (Form_pg_sequence) GETSTRUCT(pgstuple); + + value[SEQ_COL_LASTVAL - 1] = Int64GetDatumFast(pgsform->seqstart); + value[SEQ_COL_LOG - 1] = Int64GetDatum((int64) 0); + value[SEQ_COL_CALLED - 1] = BoolGetDatum(false); + + ReleaseSysCache(pgstuple); + + tuple = heap_form_tuple(RelationGetDescr(rel), value, null); + fill_seq_fork_with_data(rel, tuple, MAIN_FORKNUM); + heap_freetuple(tuple); +} + /* * AlterSequence * @@ -1815,12 +1865,14 @@ pg_get_sequence_data(PG_FUNCTION_ARGS) /* * Return all NULLs for missing sequences, sequences for which we lack - * privileges, other sessions' temporary sequences, and unlogged sequences - * on standbys. + * privileges, other sessions' temporary sequences, global temporary + * sequences (their data is per-session and not meaningful across backends + * or in a dump), and unlogged sequences on standbys. */ if (seqrel && seqrel->rd_rel->relkind == RELKIND_SEQUENCE && pg_class_aclcheck(relid, GetUserId(), ACL_SELECT) == ACLCHECK_OK && !RELATION_IS_OTHER_TEMP(seqrel) && + seqrel->rd_rel->relpersistence != RELPERSISTENCE_GLOBAL_TEMP && (RelationIsPermanent(seqrel) || !RecoveryInProgress())) { Buffer buf; diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 265dcfe7fda..82700c49ba0 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -843,11 +843,18 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, * Check consistency of arguments */ if (stmt->oncommit != ONCOMMIT_NOOP - && stmt->relation->relpersistence != RELPERSISTENCE_TEMP) + && stmt->relation->relpersistence != RELPERSISTENCE_TEMP + && stmt->relation->relpersistence != RELPERSISTENCE_GLOBAL_TEMP) ereport(ERROR, (errcode(ERRCODE_INVALID_TABLE_DEFINITION), errmsg("ON COMMIT can only be used on temporary tables"))); + if (stmt->oncommit == ONCOMMIT_DROP + && stmt->relation->relpersistence == RELPERSISTENCE_GLOBAL_TEMP) + ereport(ERROR, + errcode(ERRCODE_INVALID_TABLE_DEFINITION), + errmsg("ON COMMIT DROP is not supported for global temporary tables")); + if (stmt->partspec != NULL) { if (relkind != RELKIND_RELATION) @@ -1095,6 +1102,23 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, accessMethodId = get_table_am_oid(default_table_access_method, false); } + /* + * Global temporary tables rely on the heap table access method. Their + * per-session storage, local buffering, and tuple visibility handling are + * all heap-specific (see storage_gtt.c), and the wraparound-safety + * reasoning for GTTs assumes heap. Reject any other access method -- + * whether requested with USING or inherited from + * default_table_access_method -- rather than create a table that cannot + * work correctly. + */ + if (stmt->relation->relpersistence == RELPERSISTENCE_GLOBAL_TEMP && + OidIsValid(accessMethodId) && + accessMethodId != HEAP_TABLE_AM_OID) + ereport(ERROR, + errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("access method \"%s\" is not supported for global temporary tables", + get_am_name(accessMethodId))); + /* * Create the relation. Inherited defaults and CHECK constraints are * passed in for immediate handling --- since they don't need parsing, @@ -2762,7 +2786,9 @@ MergeAttributes(List *columns, const List *supers, char relpersistence, */ if (is_partition && relation->rd_rel->relpersistence != RELPERSISTENCE_TEMP && - relpersistence == RELPERSISTENCE_TEMP) + relation->rd_rel->relpersistence != RELPERSISTENCE_GLOBAL_TEMP && + (relpersistence == RELPERSISTENCE_TEMP || + relpersistence == RELPERSISTENCE_GLOBAL_TEMP)) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("cannot create a temporary relation as partition of permanent relation \"%s\"", @@ -2770,7 +2796,9 @@ MergeAttributes(List *columns, const List *supers, char relpersistence, /* Permanent rels cannot inherit from temporary ones */ if (relpersistence != RELPERSISTENCE_TEMP && - relation->rd_rel->relpersistence == RELPERSISTENCE_TEMP) + relpersistence != RELPERSISTENCE_GLOBAL_TEMP && + (relation->rd_rel->relpersistence == RELPERSISTENCE_TEMP || + RelationIsGlobalTemp(relation))) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg(!is_partition @@ -2778,6 +2806,19 @@ MergeAttributes(List *columns, const List *supers, char relpersistence, : "cannot create a permanent relation as partition of temporary relation \"%s\"", RelationGetRelationName(relation)))); + /* + * Don't allow mixing global temporary tables with local temporary + * tables in inheritance or partitioning hierarchies, in either + * direction. + */ + if ((relpersistence == RELPERSISTENCE_GLOBAL_TEMP && + relation->rd_rel->relpersistence == RELPERSISTENCE_TEMP) || + (relpersistence == RELPERSISTENCE_TEMP && + RelationIsGlobalTemp(relation))) + ereport(ERROR, + errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("cannot mix global temporary and local temporary tables in inheritance")); + /* If existing rel is temp, it must belong to this session */ if (RELATION_IS_OTHER_TEMP(relation)) ereport(ERROR, @@ -6005,6 +6046,21 @@ ATRewriteTables(AlterTableStmt *parsetree, List **wqueue, LOCKMODE lockmode, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot rewrite temporary tables of other sessions"))); + /* + * A table rewrite rotates the catalog relfilenode. For a GTT, + * every session's per-session storage is keyed by the catalog + * relfilenode, so rotating it would leave other sessions pointing + * at files that no longer exist or at the wrong generation of the + * table. Block rewrites for GTTs along with the other + * relfilenode-rotating commands (CLUSTER / REINDEX / SET + * TABLESPACE / SET LOGGED|UNLOGGED). + */ + if (RelationIsGlobalTemp(OldHeap)) + ereport(ERROR, + errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("cannot rewrite global temporary table \"%s\"", + RelationGetRelationName(OldHeap))); + /* * Select destination tablespace (same as original unless user * requested a change) @@ -10235,6 +10291,12 @@ ATAddForeignKeyConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel, (errcode(ERRCODE_INVALID_TABLE_DEFINITION), errmsg("constraints on temporary tables must involve temporary tables of this session"))); break; + case RELPERSISTENCE_GLOBAL_TEMP: + if (pkrel->rd_rel->relpersistence != RELPERSISTENCE_GLOBAL_TEMP) + ereport(ERROR, + errcode(ERRCODE_INVALID_TABLE_DEFINITION), + errmsg("constraints on global temporary tables may reference only global temporary tables")); + break; } /* @@ -16873,6 +16935,18 @@ ATPrepSetTableSpace(AlteredTableInfo *tab, Relation rel, const char *tablespacen { Oid tablespaceId; + /* + * SET TABLESPACE rewrites the file and assigns a new relfilenode. For + * GTTs the catalog relfilenode is the stem of every session's local file + * name, so rotating it would desynchronize all other sessions' + * per-session storage mappings. + */ + if (RelationIsGlobalTemp(rel)) + ereport(ERROR, + errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("cannot change tablespace of global temporary table \"%s\"", + RelationGetRelationName(rel))); + /* Check that the tablespace exists */ tablespaceId = get_tablespace_oid(tablespacename, false); @@ -17538,6 +17612,23 @@ ATExecAddInherit(Relation child_rel, RangeVar *parent, LOCKMODE lockmode) errmsg("cannot inherit from temporary relation \"%s\"", RelationGetRelationName(parent_rel)))); + /* + * GTTs mix neither with permanent nor with local temporary relations. See + * MergeAttributes() for the CREATE TABLE side of this rule. + */ + if (RelationIsGlobalTemp(parent_rel) && + child_rel->rd_rel->relpersistence != RELPERSISTENCE_GLOBAL_TEMP) + ereport(ERROR, + errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("cannot inherit from global temporary relation \"%s\"", + RelationGetRelationName(parent_rel))); + if (parent_rel->rd_rel->relpersistence != RELPERSISTENCE_GLOBAL_TEMP && + RelationIsGlobalTemp(child_rel)) + ereport(ERROR, + errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("cannot inherit into global temporary relation \"%s\"", + RelationGetRelationName(child_rel))); + /* If parent rel is temp, it must belong to this session */ if (RELATION_IS_OTHER_TEMP(parent_rel)) ereport(ERROR, @@ -19087,6 +19178,13 @@ ATPrepChangePersistence(AlteredTableInfo *tab, Relation rel, bool toLogged) RelationGetRelationName(rel)), errtable(rel))); break; + case RELPERSISTENCE_GLOBAL_TEMP: + ereport(ERROR, + errcode(ERRCODE_INVALID_TABLE_DEFINITION), + errmsg("cannot change logged status of table \"%s\" because it is a global temporary table", + RelationGetRelationName(rel)), + errtable(rel)); + break; case RELPERSISTENCE_PERMANENT: if (toLogged) /* nothing to do */ @@ -20686,20 +20784,38 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd, /* If the parent is permanent, so must be all of its partitions. */ if (rel->rd_rel->relpersistence != RELPERSISTENCE_TEMP && - attachrel->rd_rel->relpersistence == RELPERSISTENCE_TEMP) + rel->rd_rel->relpersistence != RELPERSISTENCE_GLOBAL_TEMP && + (attachrel->rd_rel->relpersistence == RELPERSISTENCE_TEMP || + RelationIsGlobalTemp(attachrel))) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("cannot attach a temporary relation as partition of permanent relation \"%s\"", RelationGetRelationName(rel)))); /* Temp parent cannot have a partition that is itself not a temp */ - if (rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP && - attachrel->rd_rel->relpersistence != RELPERSISTENCE_TEMP) + if ((rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP || + RelationIsGlobalTemp(rel)) && + attachrel->rd_rel->relpersistence != RELPERSISTENCE_TEMP && + attachrel->rd_rel->relpersistence != RELPERSISTENCE_GLOBAL_TEMP) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("cannot attach a permanent relation as partition of temporary relation \"%s\"", RelationGetRelationName(rel)))); + /* GTT and local-temp cannot mix as partition parent/child */ + if (RelationIsGlobalTemp(rel) && + attachrel->rd_rel->relpersistence == RELPERSISTENCE_TEMP) + ereport(ERROR, + errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("cannot attach a local temporary relation as partition of global temporary relation \"%s\"", + RelationGetRelationName(rel))); + if (rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP && + RelationIsGlobalTemp(attachrel)) + ereport(ERROR, + errcode(ERRCODE_WRONG_OBJECT_TYPE), + errmsg("cannot attach a global temporary relation as partition of local temporary relation \"%s\"", + RelationGetRelationName(rel))); + /* If the parent is temp, it must belong to this session */ if (RELATION_IS_OTHER_TEMP(rel)) ereport(ERROR, @@ -22786,6 +22902,20 @@ createPartitionTable(List **wqueue, RangeVar *newPartName, errmsg("cannot create a permanent relation as partition of temporary relation \"%s\"", RelationGetRelationName(parent_rel))); + /* + * Splitting or merging partitions of a global temporary table is not + * supported. The new partition created here would not inherit the + * parent's global temporary persistence, so it would be given permanent, + * cluster-wide storage underneath a parent whose data is per-session. + * Reject the command rather than silently creating such an inconsistent + * partition (this function is only reached from SPLIT/MERGE PARTITION). + */ + if (parent_relform->relpersistence == RELPERSISTENCE_GLOBAL_TEMP) + ereport(ERROR, + errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("cannot split or merge partitions of global temporary table \"%s\"", + RelationGetRelationName(parent_rel))); + /* Create the relation. */ newRelId = heap_create_with_catalog(newPartName->relname, namespaceId, diff --git a/src/backend/commands/view.c b/src/backend/commands/view.c index 1bd78a4cdf0..b124ca2b514 100644 --- a/src/backend/commands/view.c +++ b/src/backend/commands/view.c @@ -476,6 +476,16 @@ DefineView(ViewStmt *stmt, const char *queryString, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("views cannot be unlogged because they do not have storage"))); + /* + * Nor are global temporary views: a view has no per-session data for the + * GTT machinery to manage, and downstream code would wrongly treat the + * relation as having session-private storage. + */ + if (stmt->view->relpersistence == RELPERSISTENCE_GLOBAL_TEMP) + ereport(ERROR, + (errcode(ERRCODE_SYNTAX_ERROR), + errmsg("views cannot be global temporary because they do not have storage"))); + /* * If the user didn't explicitly ask for a temporary view, check whether * we need one implicitly. We allow TEMP to be inserted automatically as @@ -484,7 +494,7 @@ DefineView(ViewStmt *stmt, const char *queryString, */ view = copyObject(stmt->view); /* don't corrupt original command */ if (view->relpersistence == RELPERSISTENCE_PERMANENT - && query_uses_temp_object(viewParse, &temp_object)) + && query_uses_temp_object(viewParse, false, &temp_object)) { view->relpersistence = RELPERSISTENCE_TEMP; ereport(NOTICE, diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c index 93fa66ae57c..24cc06776d2 100644 --- a/src/backend/parser/analyze.c +++ b/src/backend/parser/analyze.c @@ -3536,14 +3536,27 @@ transformCreateTableAsStmt(ParseState *pstate, CreateTableAsStmt *stmt) /* * Check whether any temporary database objects are used in the * creation query. It would be hard to refresh data or incrementally - * maintain it if a source disappeared. + * maintain it if a source disappeared. Global temporary tables + * count: their definition persists, but their contents are + * session-private, so materializing them into a permanent relation + * would capture (and publish) one session's private rows. */ - if (query_uses_temp_object(query, &temp_object)) - ereport(ERROR, - (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("materialized views must not use temporary objects"), - errdetail("This view depends on temporary %s.", - getObjectDescription(&temp_object, false)))); + if (query_uses_temp_object(query, true, &temp_object)) + { + if (temp_object.classId == RelationRelationId && + get_rel_persistence(temp_object.objectId) == RELPERSISTENCE_GLOBAL_TEMP) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("materialized views must not use temporary objects"), + errdetail("This view depends on global temporary table \"%s\".", + get_rel_name(temp_object.objectId)))); + else + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("materialized views must not use temporary objects"), + errdetail("This view depends on temporary %s.", + getObjectDescription(&temp_object, false)))); + } /* * A materialized view would either need to save parameters for use in diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y index ff4e1388c55..44e28b9d588 100644 --- a/src/backend/parser/gram.y +++ b/src/backend/parser/gram.y @@ -3913,31 +3913,17 @@ CreateStmt: CREATE OptTemp TABLE qualified_name '(' OptTableElementList ')' * Redundancy here is needed to avoid shift/reduce conflicts, * since TEMP is not a reserved word. See also OptTempTableName. * - * NOTE: we accept both GLOBAL and LOCAL options. They currently do nothing, - * but future versions might consider GLOBAL to request SQL-spec-compliant - * temp table behavior, so warn about that. Since we have no modules the - * LOCAL keyword is really meaningless; furthermore, some other products - * implement LOCAL as meaning the same as our default temp table behavior, - * so we'll probably continue to treat LOCAL as a noise word. + * NOTE: GLOBAL creates a SQL-standard global temporary table, visible to + * all sessions but with per-session data. LOCAL is treated as equivalent + * to plain TEMPORARY (session-local), as most other products implement it; + * since we have no module-level scope, LOCAL remains a noise word. */ OptTemp: TEMPORARY { $$ = RELPERSISTENCE_TEMP; } | TEMP { $$ = RELPERSISTENCE_TEMP; } | LOCAL TEMPORARY { $$ = RELPERSISTENCE_TEMP; } | LOCAL TEMP { $$ = RELPERSISTENCE_TEMP; } - | GLOBAL TEMPORARY - { - ereport(WARNING, - (errmsg("GLOBAL is deprecated in temporary table creation"), - parser_errposition(@1))); - $$ = RELPERSISTENCE_TEMP; - } - | GLOBAL TEMP - { - ereport(WARNING, - (errmsg("GLOBAL is deprecated in temporary table creation"), - parser_errposition(@1))); - $$ = RELPERSISTENCE_TEMP; - } + | GLOBAL TEMPORARY { $$ = RELPERSISTENCE_GLOBAL_TEMP; } + | GLOBAL TEMP { $$ = RELPERSISTENCE_GLOBAL_TEMP; } | UNLOGGED { $$ = RELPERSISTENCE_UNLOGGED; } | /*EMPTY*/ { $$ = RELPERSISTENCE_PERMANENT; } ; @@ -13972,19 +13958,13 @@ OptTempTableName: } | GLOBAL TEMPORARY opt_table qualified_name { - ereport(WARNING, - (errmsg("GLOBAL is deprecated in temporary table creation"), - parser_errposition(@1))); $$ = $4; - $$->relpersistence = RELPERSISTENCE_TEMP; + $$->relpersistence = RELPERSISTENCE_GLOBAL_TEMP; } | GLOBAL TEMP opt_table qualified_name { - ereport(WARNING, - (errmsg("GLOBAL is deprecated in temporary table creation"), - parser_errposition(@1))); $$ = $4; - $$->relpersistence = RELPERSISTENCE_TEMP; + $$->relpersistence = RELPERSISTENCE_GLOBAL_TEMP; } | UNLOGGED opt_table qualified_name { diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index d6c0cc1f6d4..cd0bcdf2fe8 100644 --- a/src/backend/storage/buffer/bufmgr.c +++ b/src/backend/storage/buffer/bufmgr.c @@ -1237,7 +1237,8 @@ PinBufferForBlock(Relation rel, /* Persistence should be set before */ Assert((persistence == RELPERSISTENCE_TEMP || persistence == RELPERSISTENCE_PERMANENT || - persistence == RELPERSISTENCE_UNLOGGED)); + persistence == RELPERSISTENCE_UNLOGGED || + persistence == RELPERSISTENCE_GLOBAL_TEMP)); TRACE_POSTGRESQL_BUFFER_READ_START(forkNum, blockNum, smgr->smgr_rlocator.locator.spcOid, diff --git a/src/backend/utils/adt/dbsize.c b/src/backend/utils/adt/dbsize.c index cccc4a24c84..7243ec0dfd9 100644 --- a/src/backend/utils/adt/dbsize.c +++ b/src/backend/utils/adt/dbsize.c @@ -1020,6 +1020,7 @@ pg_relation_filepath(PG_FUNCTION_ARGS) { case RELPERSISTENCE_UNLOGGED: case RELPERSISTENCE_PERMANENT: + case RELPERSISTENCE_GLOBAL_TEMP: backend = INVALID_PROC_NUMBER; break; case RELPERSISTENCE_TEMP: diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 0572ab424e7..d0219396cc4 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -1158,6 +1158,7 @@ retry: { case RELPERSISTENCE_UNLOGGED: case RELPERSISTENCE_PERMANENT: + case RELPERSISTENCE_GLOBAL_TEMP: relation->rd_backend = INVALID_PROC_NUMBER; relation->rd_islocaltemp = false; break; @@ -3653,6 +3654,7 @@ RelationBuildLocalRelation(const char *relname, { case RELPERSISTENCE_UNLOGGED: case RELPERSISTENCE_PERMANENT: + case RELPERSISTENCE_GLOBAL_TEMP: rel->rd_backend = INVALID_PROC_NUMBER; rel->rd_islocaltemp = false; break; diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c index c56437d6057..0c42d81a0be 100644 --- a/src/bin/pg_dump/pg_dump.c +++ b/src/bin/pg_dump/pg_dump.c @@ -17453,6 +17453,8 @@ dumpTableSchema(Archive *fout, const TableInfo *tbinfo) * ignore it when dumping if it was set in this case. */ appendPQExpBuffer(q, "CREATE %s%s %s", + tbinfo->relpersistence == RELPERSISTENCE_GLOBAL_TEMP ? + "GLOBAL TEMPORARY " : (tbinfo->relpersistence == RELPERSISTENCE_UNLOGGED && tbinfo->relkind != RELKIND_PARTITIONED_TABLE) ? "UNLOGGED " : "", diff --git a/src/bin/psql/describe.c b/src/bin/psql/describe.c index af3935b0078..a33b6a0bcab 100644 --- a/src/bin/psql/describe.c +++ b/src/bin/psql/describe.c @@ -4311,10 +4311,12 @@ listTables(const char *tabtypes, const char *pattern, bool verbose, bool showSys "WHEN " CppAsString2(RELPERSISTENCE_PERMANENT) " THEN '%s' " "WHEN " CppAsString2(RELPERSISTENCE_TEMP) " THEN '%s' " "WHEN " CppAsString2(RELPERSISTENCE_UNLOGGED) " THEN '%s' " + "WHEN " CppAsString2(RELPERSISTENCE_GLOBAL_TEMP) " THEN '%s' " "END as \"%s\"", gettext_noop("permanent"), gettext_noop("temporary"), gettext_noop("unlogged"), + gettext_noop("global temporary"), gettext_noop("Persistence")); translate_columns[cols_so_far] = true; diff --git a/src/include/catalog/dependency.h b/src/include/catalog/dependency.h index 2f3c1eae3c7..98de33d32a9 100644 --- a/src/include/catalog/dependency.h +++ b/src/include/catalog/dependency.h @@ -127,9 +127,11 @@ extern void recordDependencyOnSingleRelExpr(const ObjectAddress *depender, extern bool find_temp_object(const ObjectAddresses *addrs, bool local_temp_okay, + bool include_gtt, ObjectAddress *foundobj); -extern bool query_uses_temp_object(Query *query, ObjectAddress *temp_object); +extern bool query_uses_temp_object(Query *query, bool include_gtt, + ObjectAddress *temp_object); extern ObjectAddresses *new_object_addresses(void); diff --git a/src/include/catalog/pg_class.h b/src/include/catalog/pg_class.h index c4af599dc90..1f7ea2bf00b 100644 --- a/src/include/catalog/pg_class.h +++ b/src/include/catalog/pg_class.h @@ -183,6 +183,7 @@ MAKE_SYSCACHE(RELNAMENSP, pg_class_relname_nsp_index, 128); #define RELPERSISTENCE_PERMANENT 'p' /* regular table */ #define RELPERSISTENCE_UNLOGGED 'u' /* unlogged permanent table */ #define RELPERSISTENCE_TEMP 't' /* temporary table */ +#define RELPERSISTENCE_GLOBAL_TEMP 'g' /* global temporary table */ /* default selection for replica identity (primary key or nothing) */ #define REPLICA_IDENTITY_DEFAULT 'd' diff --git a/src/include/commands/sequence.h b/src/include/commands/sequence.h index 2c3c4a3f074..97914a574bf 100644 --- a/src/include/commands/sequence.h +++ b/src/include/commands/sequence.h @@ -17,6 +17,7 @@ #include "fmgr.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" +#include "utils/relcache.h" typedef struct FormData_pg_sequence_data { @@ -49,5 +50,6 @@ extern void DeleteSequenceTuple(Oid relid); extern void ResetSequence(Oid seq_relid); extern void SetSequence(Oid relid, int64 next, bool iscalled); extern void ResetSequenceCaches(void); +extern void GttEnsureSequenceInitialized(Relation rel); #endif /* SEQUENCE_H */ diff --git a/src/include/utils/rel.h b/src/include/utils/rel.h index fa07ebf8ff7..246cbfd49ba 100644 --- a/src/include/utils/rel.h +++ b/src/include/utils/rel.h @@ -641,9 +641,20 @@ RelationCloseSmgr(Relation relation) (relation->rd_createSubid == InvalidSubTransactionId && \ relation->rd_firstRelfilelocatorSubid == InvalidSubTransactionId))) +/* + * RelationIsGlobalTemp + * True if relation is a global temporary table. + */ +#define RelationIsGlobalTemp(relation) \ + ((relation)->rd_rel->relpersistence == RELPERSISTENCE_GLOBAL_TEMP) + /* * RelationUsesLocalBuffers * True if relation's pages are stored in local buffers. + * + * Note: global temporary tables will use local buffers for per-session + * data storage once that infrastructure is implemented. For now, their + * shared catalog storage uses shared buffers like permanent tables. */ #define RelationUsesLocalBuffers(relation) \ ((relation)->rd_rel->relpersistence == RELPERSISTENCE_TEMP) -- 2.43.0