agora inbox for pgsql-hackers@postgresql.org
help / color / mirror / Atom feed[PATCH v46 4/7] rename cluster.c/h to repack.c/h
391+ messages / 1 participants
[nested] [flat]
* [PATCH v46 4/7] rename cluster.c/h to repack.c/h
@ 2026-03-27 15:40 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-03-27 15:40 UTC (permalink / raw)
---
src/backend/commands/Makefile | 2 +-
src/backend/commands/matview.c | 2 +-
src/backend/commands/meson.build | 2 +-
src/backend/commands/{cluster.c => repack.c} | 6 +++---
src/backend/commands/repack_worker.c | 2 +-
src/backend/commands/tablecmds.c | 2 +-
src/backend/commands/vacuum.c | 2 +-
src/backend/libpq/pqmq.c | 2 +-
src/backend/postmaster/bgworker.c | 2 +-
src/backend/replication/logical/decode.c | 2 +-
src/backend/storage/ipc/procsignal.c | 2 +-
src/backend/tcop/postgres.c | 2 +-
src/backend/tcop/utility.c | 2 +-
src/include/commands/{cluster.h => repack.h} | 12 ++++++------
14 files changed, 21 insertions(+), 21 deletions(-)
rename src/backend/commands/{cluster.c => repack.c} (99%)
rename src/include/commands/{cluster.h => repack.h} (92%)
diff --git a/src/backend/commands/Makefile b/src/backend/commands/Makefile
index 6926bc44818..5b9d084977e 100644
--- a/src/backend/commands/Makefile
+++ b/src/backend/commands/Makefile
@@ -18,7 +18,6 @@ OBJS = \
amcmds.o \
analyze.o \
async.o \
- cluster.o \
collationcmds.o \
comment.o \
constraint.o \
@@ -51,6 +50,7 @@ OBJS = \
proclang.o \
propgraphcmds.o \
publicationcmds.o \
+ repack.o \
repack_worker.o \
schemacmds.o \
seclabel.o \
diff --git a/src/backend/commands/matview.c b/src/backend/commands/matview.c
index 539969d6eef..146a65dae8d 100644
--- a/src/backend/commands/matview.c
+++ b/src/backend/commands/matview.c
@@ -24,8 +24,8 @@
#include "catalog/namespace.h"
#include "catalog/pg_am.h"
#include "catalog/pg_opclass.h"
-#include "commands/cluster.h"
#include "commands/matview.h"
+#include "commands/repack.h"
#include "commands/tablecmds.h"
#include "commands/tablespace.h"
#include "executor/executor.h"
diff --git a/src/backend/commands/meson.build b/src/backend/commands/meson.build
index 4a0e6f0002b..9f258d566eb 100644
--- a/src/backend/commands/meson.build
+++ b/src/backend/commands/meson.build
@@ -6,7 +6,6 @@ backend_sources += files(
'amcmds.c',
'analyze.c',
'async.c',
- 'cluster.c',
'collationcmds.c',
'comment.c',
'constraint.c',
@@ -39,6 +38,7 @@ backend_sources += files(
'proclang.c',
'propgraphcmds.c',
'publicationcmds.c',
+ 'repack.c',
'repack_worker.c',
'schemacmds.c',
'seclabel.c',
diff --git a/src/backend/commands/cluster.c b/src/backend/commands/repack.c
similarity index 99%
rename from src/backend/commands/cluster.c
rename to src/backend/commands/repack.c
index 33083a2b030..a58277bb6c1 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/repack.c
@@ -1,6 +1,6 @@
/*-------------------------------------------------------------------------
*
- * cluster.c
+ * repack.c
* REPACK a table; formerly known as CLUSTER. VACUUM FULL also uses
* parts of this code.
*
@@ -26,7 +26,7 @@
*
*
* IDENTIFICATION
- * src/backend/commands/cluster.c
+ * src/backend/commands/repack.c
*
*-------------------------------------------------------------------------
*/
@@ -52,9 +52,9 @@
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
-#include "commands/cluster.h"
#include "commands/defrem.h"
#include "commands/progress.h"
+#include "commands/repack.h"
#include "commands/repack_internal.h"
#include "commands/tablecmds.h"
#include "commands/vacuum.h"
diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c
index 35ab1a25c42..106b2b60441 100644
--- a/src/backend/commands/repack_worker.c
+++ b/src/backend/commands/repack_worker.c
@@ -20,7 +20,7 @@
#include "access/xlog_internal.h"
#include "access/xlogutils.h"
#include "access/xlogwait.h"
-#include "commands/cluster.h"
+#include "commands/repack.h"
#include "commands/repack_internal.h"
#include "libpq/pqmq.h"
#include "replication/snapbuild.h"
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index cc70439627b..e411d84c776 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -57,10 +57,10 @@
#include "catalog/storage.h"
#include "catalog/storage_xlog.h"
#include "catalog/toasting.h"
-#include "commands/cluster.h"
#include "commands/comment.h"
#include "commands/defrem.h"
#include "commands/event_trigger.h"
+#include "commands/repack.h"
#include "commands/sequence.h"
#include "commands/tablecmds.h"
#include "commands/tablespace.h"
diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
index 201835f30a4..ac41c819f65 100644
--- a/src/backend/commands/vacuum.c
+++ b/src/backend/commands/vacuum.c
@@ -38,9 +38,9 @@
#include "catalog/pg_database.h"
#include "catalog/pg_inherits.h"
#include "commands/async.h"
-#include "commands/cluster.h"
#include "commands/defrem.h"
#include "commands/progress.h"
+#include "commands/repack.h"
#include "commands/vacuum.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
diff --git a/src/backend/libpq/pqmq.c b/src/backend/libpq/pqmq.c
index 1000b7bb06e..cbf6c5a004f 100644
--- a/src/backend/libpq/pqmq.c
+++ b/src/backend/libpq/pqmq.c
@@ -14,7 +14,7 @@
#include "postgres.h"
#include "access/parallel.h"
-#include "commands/cluster.h"
+#include "commands/repack.h"
#include "libpq/libpq.h"
#include "libpq/pqformat.h"
#include "libpq/pqmq.h"
diff --git a/src/backend/postmaster/bgworker.c b/src/backend/postmaster/bgworker.c
index cb9c60dfe31..2598ed0b153 100644
--- a/src/backend/postmaster/bgworker.c
+++ b/src/backend/postmaster/bgworker.c
@@ -13,7 +13,7 @@
#include "postgres.h"
#include "access/parallel.h"
-#include "commands/cluster.h"
+#include "commands/repack.h"
#include "libpq/pqsignal.h"
#include "miscadmin.h"
#include "pgstat.h"
diff --git a/src/backend/replication/logical/decode.c b/src/backend/replication/logical/decode.c
index f172c0b2b40..8a969ddca41 100644
--- a/src/backend/replication/logical/decode.c
+++ b/src/backend/replication/logical/decode.c
@@ -33,7 +33,7 @@
#include "access/xlogreader.h"
#include "access/xlogrecord.h"
#include "catalog/pg_control.h"
-#include "commands/cluster.h"
+#include "commands/repack.h"
#include "replication/decode.h"
#include "replication/logical.h"
#include "replication/message.h"
diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c
index dd980145ced..f02b9eb8312 100644
--- a/src/backend/storage/ipc/procsignal.c
+++ b/src/backend/storage/ipc/procsignal.c
@@ -19,7 +19,7 @@
#include "access/parallel.h"
#include "commands/async.h"
-#include "commands/cluster.h"
+#include "commands/repack.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "port/pg_bitutils.h"
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 4d253eddfa0..07bf300e044 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -36,10 +36,10 @@
#include "access/xact.h"
#include "catalog/pg_type.h"
#include "commands/async.h"
-#include "commands/cluster.h"
#include "commands/event_trigger.h"
#include "commands/explain_state.h"
#include "commands/prepare.h"
+#include "commands/repack.h"
#include "common/pg_prng.h"
#include "jit/jit.h"
#include "libpq/libpq.h"
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index 2b609bfc824..5f8c766c4be 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -26,7 +26,6 @@
#include "catalog/toasting.h"
#include "commands/alter.h"
#include "commands/async.h"
-#include "commands/cluster.h"
#include "commands/collationcmds.h"
#include "commands/comment.h"
#include "commands/conversioncmds.h"
@@ -46,6 +45,7 @@
#include "commands/proclang.h"
#include "commands/propgraphcmds.h"
#include "commands/publicationcmds.h"
+#include "commands/repack.h"
#include "commands/schemacmds.h"
#include "commands/seclabel.h"
#include "commands/sequence.h"
diff --git a/src/include/commands/cluster.h b/src/include/commands/repack.h
similarity index 92%
rename from src/include/commands/cluster.h
rename to src/include/commands/repack.h
index 8ed7816e7b4..6b4ebd7fa5d 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/repack.h
@@ -1,17 +1,17 @@
/*-------------------------------------------------------------------------
*
- * cluster.h
- * header file for postgres cluster command stuff
+ * repack.h
+ * header file for the REPACK command
*
* Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
* Portions Copyright (c) 1994-5, Regents of the University of California
*
- * src/include/commands/cluster.h
+ * src/include/commands/repack.h
*
*-------------------------------------------------------------------------
*/
-#ifndef CLUSTER_H
-#define CLUSTER_H
+#ifndef REPACK_H
+#define REPACK_H
#include <signal.h>
@@ -66,4 +66,4 @@ extern void RepackWorkerMain(Datum main_arg);
extern bool IsRepackWorker(void);
-#endif /* CLUSTER_H */
+#endif /* REPACK_H */
--
2.47.3
--mdsv5bdgfjjj6d77
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v46-0005-Fix-a-few-problems-in-index-build-progress-repor.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
* [PATCH v50 5/8] support repacking tables with exclusion constraints
@ 2026-04-02 18:59 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 391+ messages in thread
From: Álvaro Herrera @ 2026-04-02 18:59 UTC (permalink / raw)
---
src/backend/commands/repack.c | 78 +++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)
diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 73eadd1ff4a..03829892d57 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -49,6 +49,7 @@
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
#include "catalog/pg_control.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
@@ -199,6 +200,8 @@ static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHea
TransactionId frozenXid,
MultiXactId cutoffMulti);
static List *build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes);
+static void copy_index_constraints(Relation old_index, Oid new_index_id,
+ Oid new_heap_id);
static Relation process_single_relation(RepackStmt *stmt,
LOCKMODE lockmode,
bool isTopLevel,
@@ -3211,6 +3214,7 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
false);
newindex = index_create_copy(NewHeap, false, oldindex,
ind->rd_rel->reltablespace, newName);
+ copy_index_constraints(ind, newindex, RelationGetRelid(NewHeap));
result = lappend_oid(result, newindex);
index_close(ind, NoLock);
@@ -3219,6 +3223,80 @@ build_new_indexes(Relation NewHeap, Relation OldHeap, List *OldIndexes)
return result;
}
+/*
+ * Create a transient copy of a constraint -- supported by a transient
+ * copy of the index that supports the original constraint.
+ *
+ * When repacking a table that contains exclusion constraints, the executor
+ * relies on these constraints being properly catalogued. These copies are
+ * to support that.
+ *
+ * We don't need the constraints for anything else (the original constraints
+ * will be there once repack completes), so we add pg_depend entries so that
+ * the are dropped when the transient table is dropped.
+ */
+static void
+copy_index_constraints(Relation old_index, Oid new_index_id, Oid new_heap_id)
+{
+ ScanKeyData skey;
+ Relation rel;
+ TupleDesc desc;
+ SysScanDesc scan;
+ HeapTuple tup;
+ ObjectAddress objrel;
+
+ rel = table_open(ConstraintRelationId, RowExclusiveLock);
+ ObjectAddressSet(objrel, RelationRelationId, new_heap_id);
+
+ /*
+ * Retrieve the constraints supported by the old index and create an
+ * identical one that points to the new index.
+ */
+ ScanKeyInit(&skey,
+ Anum_pg_constraint_conrelid,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(old_index->rd_index->indrelid));
+ scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true,
+ NULL, 1, &skey);
+ desc = RelationGetDescr(rel);
+ while (HeapTupleIsValid(tup = systable_getnext(scan)))
+ {
+ Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
+ Oid oid;
+ Datum values[Natts_pg_constraint] = {0};
+ bool nulls[Natts_pg_constraint] = {0};
+ bool replaces[Natts_pg_constraint] = {0};
+ HeapTuple new_tup;
+ ObjectAddress objcon;
+
+ if (conform->conindid != RelationGetRelid(old_index))
+ continue;
+
+ oid = GetNewOidWithIndex(rel, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(oid);
+ replaces[Anum_pg_constraint_oid - 1] = true;
+ values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(new_heap_id);
+ replaces[Anum_pg_constraint_conrelid - 1] = true;
+ values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(new_index_id);
+ replaces[Anum_pg_constraint_conindid - 1] = true;
+
+ new_tup = heap_modify_tuple(tup, desc, values, nulls, replaces);
+
+ /* Insert it into the catalog. */
+ CatalogTupleInsert(rel, new_tup);
+
+ /* Create a dependency so it's removed when we drop the new heap. */
+ ObjectAddressSet(objcon, ConstraintRelationId, oid);
+ recordDependencyOn(&objcon, &objrel, DEPENDENCY_AUTO);
+ }
+ systable_endscan(scan);
+
+ table_close(rel, RowExclusiveLock);
+
+ CommandCounterIncrement();
+}
+
/*
* Try to start a background worker to perform logical decoding of data
* changes applied to relation while REPACK CONCURRENTLY is copying its
--
2.47.3
--brnevsqjnuzpyok4
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v50-0006-Error-out-any-process-that-would-block-at-REPACK.patch"
^ permalink raw reply [nested|flat] 391+ messages in thread
end of thread, other threads:[~2026-04-02 18:59 UTC | newest]
Thread overview: 391+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
2026-03-27 15:40 [PATCH v46 4/7] rename cluster.c/h to repack.c/h Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
2026-04-02 18:59 [PATCH v50 5/8] support repacking tables with exclusion constraints Álvaro Herrera <alvherre@kurilemu.de>
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox