agora inbox for pgsql-hackers@postgresql.orghelp / color / mirror / Atom feed
[PATCH] Asymmetric partitionwise join. 383+ messages / 3 participants [nested] [flat]
* [PATCH] Asymmetric partitionwise join. @ 2021-04-02 06:02 Andrey Lepikhov <a.lepikhov@postgrespro.ru> 0 siblings, 0 replies; 383+ messages in thread From: Andrey Lepikhov @ 2021-04-02 06:02 UTC (permalink / raw) Teach optimizer to consider partitionwise join of non-partitioned table with each partition of partitioned table. This technique cause changes of 'reparameterize by child' machinery. --- src/backend/optimizer/path/joinpath.c | 9 + src/backend/optimizer/path/joinrels.c | 151 ++++++++++++++ src/backend/optimizer/util/appendinfo.c | 28 ++- src/backend/optimizer/util/pathnode.c | 9 +- src/backend/optimizer/util/relnode.c | 14 +- src/include/optimizer/paths.h | 7 +- src/test/regress/expected/partition_join.out | 209 +++++++++++++++++++ src/test/regress/sql/partition_join.sql | 99 +++++++++ 8 files changed, 509 insertions(+), 17 deletions(-) diff --git a/src/backend/optimizer/path/joinpath.c b/src/backend/optimizer/path/joinpath.c index e9b6968b1d..6ba6d32ae4 100644 --- a/src/backend/optimizer/path/joinpath.c +++ b/src/backend/optimizer/path/joinpath.c @@ -335,6 +335,15 @@ add_paths_to_joinrel(PlannerInfo *root, if (set_join_pathlist_hook) set_join_pathlist_hook(root, joinrel, outerrel, innerrel, jointype, &extra); + + /* + * 7. If outer relation is delivered from partition-tables, consider + * distributing inner relation to every partition-leaf prior to + * append these leafs. + */ + try_asymmetric_partitionwise_join(root, joinrel, + outerrel, innerrel, + jointype, &extra); } /* diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c index 0dbe2ac726..6f900475bb 100644 --- a/src/backend/optimizer/path/joinrels.c +++ b/src/backend/optimizer/path/joinrels.c @@ -16,6 +16,7 @@ #include "miscadmin.h" #include "optimizer/appendinfo.h" +#include "optimizer/cost.h" #include "optimizer/joininfo.h" #include "optimizer/pathnode.h" #include "optimizer/paths.h" @@ -1551,6 +1552,156 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2, } } +/* + * Build RelOptInfo on JOIN of each partition of the outer relation and the inner + * relation. Return List of such RelOptInfo's. Return NIL, if at least one of + * these JOINs are impossible to build. + */ +static List * +extract_asymmetric_partitionwise_subjoin(PlannerInfo *root, + RelOptInfo *joinrel, + AppendPath *append_path, + RelOptInfo *inner_rel, + JoinType jointype, + JoinPathExtraData *extra) +{ + List *result = NIL; + ListCell *lc; + + foreach (lc, append_path->subpaths) + { + Path *child_path = lfirst(lc); + RelOptInfo *child_rel = child_path->parent; + Relids child_join_relids; + RelOptInfo *child_join_rel; + SpecialJoinInfo *child_sjinfo; + List *child_restrictlist; + AppendRelInfo **appinfos; + int nappinfos; + + child_join_relids = bms_union(child_rel->relids, + inner_rel->relids); + appinfos = find_appinfos_by_relids(root, child_join_relids, + &nappinfos); + child_sjinfo = build_child_join_sjinfo(root, extra->sjinfo, + child_rel->relids, + inner_rel->relids); + child_restrictlist = (List *) + adjust_appendrel_attrs(root, (Node *)extra->restrictlist, + nappinfos, appinfos); + pfree(appinfos); + + child_join_rel = find_join_rel(root, child_join_relids); + if (!child_join_rel) + { + child_join_rel = build_child_join_rel(root, + child_rel, + inner_rel, + joinrel, + child_restrictlist, + child_sjinfo, + jointype); + if (!child_join_rel) + { + /* + * If can't build JOIN between inner relation and one of the outer + * partitions - return immediately. + */ + return NIL; + } + } + else + { + /* + * TODO: + * Can't imagine situation when join relation already exists. But in + * the 'partition_join' regression test it happens. + * It may be an indicator of possible problems. + */ + } + + populate_joinrel_with_paths(root, + child_rel, + inner_rel, + child_join_rel, + child_sjinfo, + child_restrictlist); + + /* Give up if asymmetric partition-wise join is not available */ + if (child_join_rel->pathlist == NIL) + return NIL; + + set_cheapest(child_join_rel); + result = lappend(result, child_join_rel); + } + return result; +} + +void +try_asymmetric_partitionwise_join(PlannerInfo *root, + RelOptInfo *joinrel, + RelOptInfo *outer_rel, + RelOptInfo *inner_rel, + JoinType jointype, + JoinPathExtraData *extra) +{ + ListCell *lc; + + if (!enable_partitionwise_join) + return; + + if (IS_OTHER_REL(outer_rel) || IS_OTHER_REL(inner_rel)) + return; + + if (jointype != JOIN_INNER && jointype != JOIN_LEFT) + return; + + foreach (lc, outer_rel->pathlist) + { + AppendPath *append_path = lfirst(lc); + + /* + * MEMO: We assume this pathlist keeps at least one AppendPath that + * represents partitioned table-scan, symmetric or asymmetric + * partition-wise join. It is not correct right now, however, a hook + * on add_path() to give additional decision for path removel allows + * to retain this kind of AppendPath, regardless of its cost. + */ + if (IsA(append_path, AppendPath)) + { + List **join_rel_level_saved; + List *live_childrels = NIL; + + join_rel_level_saved = root->join_rel_level; + PG_TRY(); + { + /* temporary disables "dynamic programming" algorithm */ + root->join_rel_level = NULL; + + live_childrels = + extract_asymmetric_partitionwise_subjoin(root, + joinrel, + append_path, + inner_rel, + jointype, + extra); + } + PG_CATCH(); + { + root->join_rel_level = join_rel_level_saved; + PG_RE_THROW(); + } + PG_END_TRY(); + root->join_rel_level = join_rel_level_saved; + + if (live_childrels != NIL) + add_paths_to_append_rel(root, joinrel, live_childrels); + + break; + } + } +} + /* * Construct the SpecialJoinInfo for a child-join by translating * SpecialJoinInfo for the join between parents. left_relids and right_relids diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c index af46f581ac..be4624b619 100644 --- a/src/backend/optimizer/util/appendinfo.c +++ b/src/backend/optimizer/util/appendinfo.c @@ -202,7 +202,9 @@ adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos, context.appinfos = appinfos; /* If there's nothing to adjust, don't call this function. */ - Assert(nappinfos >= 1 && appinfos != NULL); + /* If there's nothing to adjust, just return a duplication */ + if (nappinfos == 0) + return copyObject(node); /* Should never be translating a Query tree. */ Assert(node == NULL || !IsA(node, Query)); @@ -494,8 +496,6 @@ adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, int nappinfos; int cnt; - Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids)); - appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos); /* Construct relids set for the immediate parent of given child. */ @@ -506,8 +506,13 @@ adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, parent_relids = bms_add_member(parent_relids, appinfo->parent_relid); } - /* Recurse if immediate parent is not the top parent. */ - if (!bms_equal(parent_relids, top_parent_relids)) + /* + * Recurse if immediate parent is not the top parent. Keep in mind that in a + * case of asymmetric JOIN top_parent_relids can contain relids which aren't + * part of an append node. + */ + if (!bms_equal(parent_relids, top_parent_relids) && + !bms_is_subset(parent_relids, top_parent_relids)) node = adjust_appendrel_attrs_multilevel(root, node, parent_relids, top_parent_relids); @@ -565,6 +570,7 @@ adjust_child_relids_multilevel(PlannerInfo *root, Relids relids, AppendRelInfo **appinfos; int nappinfos; Relids parent_relids = NULL; + Relids normal_relids = NULL; Relids result; Relids tmp_result = NULL; int cnt; @@ -579,12 +585,17 @@ adjust_child_relids_multilevel(PlannerInfo *root, Relids relids, appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos); /* Construct relids set for the immediate parent of the given child. */ + normal_relids = bms_copy(child_relids); for (cnt = 0; cnt < nappinfos; cnt++) { AppendRelInfo *appinfo = appinfos[cnt]; parent_relids = bms_add_member(parent_relids, appinfo->parent_relid); + normal_relids = bms_del_member(normal_relids, appinfo->child_relid); } + parent_relids = bms_union(parent_relids, normal_relids); + if (normal_relids) + bms_free(normal_relids); /* Recurse if immediate parent is not the top parent. */ if (!bms_equal(parent_relids, top_parent_relids)) @@ -715,11 +726,11 @@ AppendRelInfo ** find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos) { AppendRelInfo **appinfos; + int nrooms = bms_num_members(relids); int cnt = 0; int i; - *nappinfos = bms_num_members(relids); - appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos); + appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * nrooms); i = -1; while ((i = bms_next_member(relids, i)) >= 0) @@ -727,10 +738,11 @@ find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos) AppendRelInfo *appinfo = root->append_rel_array[i]; if (!appinfo) - elog(ERROR, "child rel %d not found in append_rel_array", i); + continue; appinfos[cnt++] = appinfo; } + *nappinfos = cnt; return appinfos; } diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c index b248b038e0..73cfb4748d 100644 --- a/src/backend/optimizer/util/pathnode.c +++ b/src/backend/optimizer/util/pathnode.c @@ -4209,7 +4209,14 @@ do { \ MemoryContextSwitchTo(oldcontext); } - bms_free(required_outer); + + /* + * If adjust_child_relids_multilevel don't do replacements it returns + * the original set, not a copy. It is possible in the case of asymmetric + * JOIN and child_rel->relids contains relids only of plane relations. + */ + if (required_outer != old_ppi->ppi_req_outer) + bms_free(required_outer); new_path->param_info = new_ppi; diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c index e105a4d5f1..f98a82e725 100644 --- a/src/backend/optimizer/util/relnode.c +++ b/src/backend/optimizer/util/relnode.c @@ -790,11 +790,8 @@ build_child_join_rel(PlannerInfo *root, RelOptInfo *outer_rel, AppendRelInfo **appinfos; int nappinfos; - /* Only joins between "other" relations land here. */ - Assert(IS_OTHER_REL(outer_rel) && IS_OTHER_REL(inner_rel)); - - /* The parent joinrel should have consider_partitionwise_join set. */ - Assert(parent_joinrel->consider_partitionwise_join); + /* Either of relations must be "other" relation at least. */ + Assert(IS_OTHER_REL(outer_rel) || IS_OTHER_REL(inner_rel)); joinrel->reloptkind = RELOPT_OTHER_JOINREL; joinrel->relids = bms_union(outer_rel->relids, inner_rel->relids); @@ -851,8 +848,11 @@ build_child_join_rel(PlannerInfo *root, RelOptInfo *outer_rel, joinrel->partexprs = NULL; joinrel->nullable_partexprs = NULL; - joinrel->top_parent_relids = bms_union(outer_rel->top_parent_relids, - inner_rel->top_parent_relids); + joinrel->top_parent_relids = + bms_union(IS_OTHER_REL(outer_rel) ? + outer_rel->top_parent_relids : outer_rel->relids, + IS_OTHER_REL(inner_rel) ? + inner_rel->top_parent_relids : inner_rel->relids); /* Compute information relevant to foreign relations. */ set_foreign_rel_properties(joinrel, outer_rel, inner_rel); diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h index 035d3e1206..d64aa37f80 100644 --- a/src/include/optimizer/paths.h +++ b/src/include/optimizer/paths.h @@ -109,7 +109,12 @@ extern bool have_join_order_restriction(PlannerInfo *root, extern bool have_dangerous_phv(PlannerInfo *root, Relids outer_relids, Relids inner_params); extern void mark_dummy_rel(RelOptInfo *rel); - +extern void try_asymmetric_partitionwise_join(PlannerInfo *root, + RelOptInfo *joinrel, + RelOptInfo *outer_rel, + RelOptInfo *inner_rel, + JoinType jointype, + JoinPathExtraData *extra); /* * equivclass.c * routines for managing EquivalenceClasses diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out index 27f7525b3e..2bc7ad70d9 100644 --- a/src/test/regress/expected/partition_join.out +++ b/src/test/regress/expected/partition_join.out @@ -2320,6 +2320,215 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a = 375 | 0375 | 375 | 0375 (8 rows) +-- +-- For asymmetric partition-wise join +-- +CREATE TABLE prt5 (hkey int, a int, b int) PARTITION BY HASH(hkey); +CREATE TABLE prt5_p0 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 0); +CREATE TABLE prt5_p1 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 1); +CREATE TABLE prt5_p2 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 2); +CREATE TABLE t5_1 (aid int, alabel text); +CREATE TABLE t5_2 (bid int, blabel text); +INSERT INTO prt5 (SELECT x, (1000.0 * random())::int, + (1000.0 * random())::int + FROM generate_series(1,1000000) x); +INSERT INTO t5_1 (SELECT x, md5(x::text) FROM generate_series(-200, 800) x); +INSERT INTO t5_2 (SELECT x, md5(x::text) FROM generate_series(-200, 800) x); +VACUUM ANALYZE prt5; +VACUUM ANALYZE t5_1; +VACUUM ANALYZE t5_2; +SET max_parallel_workers_per_gather = 0; +EXPLAIN (COSTS OFF) +SELECT * + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +------------------------------------------------------- + Append + -> Hash Join + Hash Cond: (prt5_1.a = t5_1.aid) + -> Seq Scan on prt5_p0 prt5_1 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) + -> Hash Join + Hash Cond: (prt5_2.a = t5_1.aid) + -> Seq Scan on prt5_p1 prt5_2 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) + -> Hash Join + Hash Cond: (prt5_3.a = t5_1.aid) + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) +(19 rows) + +EXPLAIN (COSTS OFF) +SELECT * + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + QUERY PLAN +------------------------------------------------------------ + Append + -> Hash Join + Hash Cond: (prt5_1.a = t5_1.aid) + -> Hash Join + Hash Cond: (prt5_1.b = t5_2.bid) + -> Seq Scan on prt5_p0 prt5_1 + -> Hash + -> Seq Scan on t5_2 + Filter: (blabel ~~ '%cd%'::text) + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%ab%'::text) + -> Hash Join + Hash Cond: (prt5_2.a = t5_1.aid) + -> Hash Join + Hash Cond: (prt5_2.b = t5_2.bid) + -> Seq Scan on prt5_p1 prt5_2 + -> Hash + -> Seq Scan on t5_2 + Filter: (blabel ~~ '%cd%'::text) + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%ab%'::text) + -> Hash Join + Hash Cond: (prt5_3.a = t5_1.aid) + -> Hash Join + Hash Cond: (prt5_3.b = t5_2.bid) + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Seq Scan on t5_2 + Filter: (blabel ~~ '%cd%'::text) + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%ab%'::text) +(34 rows) + +-- unable to extract non-partitioned right relation +EXPLAIN (COSTS OFF) +SELECT * FROM prt5 RIGHT JOIN t5_1 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +----------------------------------------------- + Hash Right Join + Hash Cond: (prt5.a = t5_1.aid) + Join Filter: (t5_1.alabel ~~ '%abc%'::text) + -> Append + -> Seq Scan on prt5_p0 prt5_1 + -> Seq Scan on prt5_p1 prt5_2 + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Seq Scan on t5_1 +(9 rows) + +-- left side can be extracted, but no cost benefit +EXPLAIN (COSTS OFF) +SELECT * FROM prt5 LEFT JOIN t5_1 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +------------------------------------------------- + Hash Left Join + Hash Cond: (prt5.a = t5_1.aid) + -> Append + -> Seq Scan on prt5_p0 prt5_1 + -> Seq Scan on prt5_p1 prt5_2 + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) +(9 rows) + +-- validation of the results with/without asymmetric partition-wise join +SELECT * INTO pg_temp.result01a + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; +SELECT * INTO pg_temp.result02a + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; +SET enable_partitionwise_join = off; +SELECT * INTO pg_temp.result01b + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; +SELECT * INTO pg_temp.result02b + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; +SELECT * FROM pg_temp.result01a EXCEPT SELECT * FROM pg_temp.result01b; + hkey | a | b | aid | alabel +------+---+---+-----+-------- +(0 rows) + +SELECT * FROM pg_temp.result02a EXCEPT SELECT * FROM pg_temp.result02b; + hkey | a | b | aid | alabel | bid | blabel +------+---+---+-----+--------+-----+-------- +(0 rows) + +RESET max_parallel_workers_per_gather; +SET enable_partitionwise_join = true; +-- Parameterized path examples. +CREATE TABLE prta (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE prta1 PARTITION OF prta FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prta2 PARTITION OF prta FOR VALUES WITH (modulus 2, remainder 1); +CREATE UNIQUE INDEX ON prta1 (id); +CREATE UNIQUE INDEX ON prta2 (id); +INSERT INTO prta (id, payload) + (SELECT *, ('abc' || id)::text AS payload + FROM generate_series(1,1) AS id); +CREATE TABLE prtb (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE prtb1 PARTITION OF prtb FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prtb2 PARTITION OF prtb FOR VALUES WITH (modulus 2, remainder 1); +CREATE UNIQUE INDEX ON prtb1 (id); +CREATE UNIQUE INDEX ON prtb2 (id); +INSERT INTO prtb (id, payload) + (SELECT *, ('def' || id)::text AS payload + FROM generate_series(1,1000) AS id); +CREATE TABLE e (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE e1 PARTITION OF e FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE e2 PARTITION OF e FOR VALUES WITH (modulus 2, remainder 1); +INSERT INTO e (id, payload) + (SELECT *, ('ghi' || id)::text AS payload + FROM generate_series(1,1000) AS id); +CREATE UNIQUE INDEX ON e1 (id); +CREATE UNIQUE INDEX ON e2 (id); +ANALYZE prta,prtb,e; +EXPLAIN (COSTS OFF) +SELECT * FROM prta,prtb WHERE prta.id=prtb.id; + QUERY PLAN +----------------------------------------------------------- + Append + -> Nested Loop + -> Seq Scan on prta1 prta_1 + -> Index Scan using prtb1_id_idx on prtb1 prtb_1 + Index Cond: (id = prta_1.id) + -> Nested Loop + -> Seq Scan on prta2 prta_2 + -> Index Scan using prtb2_id_idx on prtb2 prtb_2 + Index Cond: (id = prta_2.id) +(9 rows) + +EXPLAIN (COSTS OFF) +SELECT * FROM prta,prtb,e WHERE prta.id=prtb.id AND prta.id=e.id; + QUERY PLAN +----------------------------------------------------------------- + Append + -> Nested Loop + Join Filter: (prta_1.id = e_1.id) + -> Nested Loop + -> Seq Scan on prta1 prta_1 + -> Index Scan using prtb1_id_idx on prtb1 prtb_1 + Index Cond: (id = prta_1.id) + -> Index Scan using e1_id_idx on e1 e_1 + Index Cond: (id = prtb_1.id) + -> Nested Loop + Join Filter: (prta_2.id = e_2.id) + -> Nested Loop + -> Seq Scan on prta2 prta_2 + -> Index Scan using prtb2_id_idx on prtb2 prtb_2 + Index Cond: (id = prta_2.id) + -> Index Scan using e2_id_idx on e2 e_2 + Index Cond: (id = prtb_2.id) +(17 rows) + -- semi join EXPLAIN (COSTS OFF) SELECT t1.* FROM prt1_adv t1 WHERE EXISTS (SELECT 1 FROM prt2_adv t2 WHERE t1.a = t2.b) AND t1.b = 0 ORDER BY t1.a; diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql index d97b5b69ff..c206fd736a 100644 --- a/src/test/regress/sql/partition_join.sql +++ b/src/test/regress/sql/partition_join.sql @@ -536,6 +536,105 @@ EXPLAIN (COSTS OFF) SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a = t2.b) WHERE t1.b = 0 ORDER BY t1.a, t2.b; SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a = t2.b) WHERE t1.b = 0 ORDER BY t1.a, t2.b; +-- +-- For asymmetric partition-wise join +-- +CREATE TABLE prt5 (hkey int, a int, b int) PARTITION BY HASH(hkey); +CREATE TABLE prt5_p0 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 0); +CREATE TABLE prt5_p1 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 1); +CREATE TABLE prt5_p2 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 2); +CREATE TABLE t5_1 (aid int, alabel text); +CREATE TABLE t5_2 (bid int, blabel text); + +INSERT INTO prt5 (SELECT x, (1000.0 * random())::int, + (1000.0 * random())::int + FROM generate_series(1,1000000) x); +INSERT INTO t5_1 (SELECT x, md5(x::text) FROM generate_series(-200, 800) x); +INSERT INTO t5_2 (SELECT x, md5(x::text) FROM generate_series(-200, 800) x); + +VACUUM ANALYZE prt5; +VACUUM ANALYZE t5_1; +VACUUM ANALYZE t5_2; + +SET max_parallel_workers_per_gather = 0; +EXPLAIN (COSTS OFF) +SELECT * + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +EXPLAIN (COSTS OFF) +SELECT * + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + +-- unable to extract non-partitioned right relation +EXPLAIN (COSTS OFF) +SELECT * FROM prt5 RIGHT JOIN t5_1 ON a = aid AND alabel like '%abc%'; +-- left side can be extracted, but no cost benefit +EXPLAIN (COSTS OFF) +SELECT * FROM prt5 LEFT JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +-- validation of the results with/without asymmetric partition-wise join +SELECT * INTO pg_temp.result01a + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +SELECT * INTO pg_temp.result02a + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + +SET enable_partitionwise_join = off; + +SELECT * INTO pg_temp.result01b + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +SELECT * INTO pg_temp.result02b + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + +SELECT * FROM pg_temp.result01a EXCEPT SELECT * FROM pg_temp.result01b; +SELECT * FROM pg_temp.result02a EXCEPT SELECT * FROM pg_temp.result02b; + +RESET max_parallel_workers_per_gather; +SET enable_partitionwise_join = true; + +-- Parameterized path examples. +CREATE TABLE prta (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE prta1 PARTITION OF prta FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prta2 PARTITION OF prta FOR VALUES WITH (modulus 2, remainder 1); +CREATE UNIQUE INDEX ON prta1 (id); +CREATE UNIQUE INDEX ON prta2 (id); +INSERT INTO prta (id, payload) + (SELECT *, ('abc' || id)::text AS payload + FROM generate_series(1,1) AS id); + +CREATE TABLE prtb (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE prtb1 PARTITION OF prtb FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prtb2 PARTITION OF prtb FOR VALUES WITH (modulus 2, remainder 1); +CREATE UNIQUE INDEX ON prtb1 (id); +CREATE UNIQUE INDEX ON prtb2 (id); +INSERT INTO prtb (id, payload) + (SELECT *, ('def' || id)::text AS payload + FROM generate_series(1,1000) AS id); + +CREATE TABLE e (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE e1 PARTITION OF e FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE e2 PARTITION OF e FOR VALUES WITH (modulus 2, remainder 1); +INSERT INTO e (id, payload) + (SELECT *, ('ghi' || id)::text AS payload + FROM generate_series(1,1000) AS id); +CREATE UNIQUE INDEX ON e1 (id); +CREATE UNIQUE INDEX ON e2 (id); + +ANALYZE prta,prtb,e; + +EXPLAIN (COSTS OFF) +SELECT * FROM prta,prtb WHERE prta.id=prtb.id; + +EXPLAIN (COSTS OFF) +SELECT * FROM prta,prtb,e WHERE prta.id=prtb.id AND prta.id=e.id; + -- semi join EXPLAIN (COSTS OFF) SELECT t1.* FROM prt1_adv t1 WHERE EXISTS (SELECT 1 FROM prt2_adv t2 WHERE t1.a = t2.b) AND t1.b = 0 ORDER BY t1.a; -- 2.25.1 --------------8EB2F9A6243C623F4024291E-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Asymmetric partitionwise join. @ 2021-04-02 06:02 Andrey Lepikhov <a.lepikhov@postgrespro.ru> 0 siblings, 0 replies; 383+ messages in thread From: Andrey Lepikhov @ 2021-04-02 06:02 UTC (permalink / raw) Teach optimizer to consider partitionwise join of non-partitioned table with each partition of partitioned table. Disallow asymmetric machinery for joining of two partitioned (or appended) relations because it could cause huge consumption of CPU and memory during reparameterization of NestLoop path. Change logic of the multilevel child relids adjustment, because this feature allows the optimizer to plan in new way. --- src/backend/optimizer/path/joinpath.c | 9 + src/backend/optimizer/path/joinrels.c | 187 ++++++++ src/backend/optimizer/plan/setrefs.c | 17 +- src/backend/optimizer/util/appendinfo.c | 44 +- src/backend/optimizer/util/pathnode.c | 9 +- src/backend/optimizer/util/relnode.c | 19 +- src/include/optimizer/paths.h | 7 +- src/test/regress/expected/partition_join.out | 425 +++++++++++++++++++ src/test/regress/sql/partition_join.sql | 180 ++++++++ 9 files changed, 867 insertions(+), 30 deletions(-) diff --git a/src/backend/optimizer/path/joinpath.c b/src/backend/optimizer/path/joinpath.c index 6407ede12a..32618ebbd5 100644 --- a/src/backend/optimizer/path/joinpath.c +++ b/src/backend/optimizer/path/joinpath.c @@ -335,6 +335,15 @@ add_paths_to_joinrel(PlannerInfo *root, if (set_join_pathlist_hook) set_join_pathlist_hook(root, joinrel, outerrel, innerrel, jointype, &extra); + + /* + * 7. If outer relation is delivered from partition-tables, consider + * distributing inner relation to every partition-leaf prior to + * append these leafs. + */ + try_asymmetric_partitionwise_join(root, joinrel, + outerrel, innerrel, + jointype, &extra); } /* diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c index 8b69870cf4..9453258f83 100644 --- a/src/backend/optimizer/path/joinrels.c +++ b/src/backend/optimizer/path/joinrels.c @@ -16,6 +16,7 @@ #include "miscadmin.h" #include "optimizer/appendinfo.h" +#include "optimizer/cost.h" #include "optimizer/joininfo.h" #include "optimizer/pathnode.h" #include "optimizer/paths.h" @@ -1552,6 +1553,192 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2, } } +/* + * Build RelOptInfo on JOIN of each partition of the outer relation and the inner + * relation. Return List of such RelOptInfo's. Return NIL, if at least one of + * these JOINs is impossible to build. + */ +static List * +extract_asymmetric_partitionwise_subjoin(PlannerInfo *root, + RelOptInfo *joinrel, + AppendPath *append_path, + RelOptInfo *inner_rel, + JoinType jointype, + JoinPathExtraData *extra) +{ + List *result = NIL; + ListCell *lc; + + foreach (lc, append_path->subpaths) + { + Path *child_path = lfirst(lc); + RelOptInfo *child_rel = child_path->parent; + Relids child_joinrelids; + Relids parent_relids; + RelOptInfo *child_joinrel; + SpecialJoinInfo *child_sjinfo; + List *child_restrictlist; + + child_joinrelids = bms_union(child_rel->relids, inner_rel->relids); + parent_relids = bms_union(append_path->path.parent->relids, + inner_rel->relids); + + child_sjinfo = build_child_join_sjinfo(root, extra->sjinfo, + child_rel->relids, + inner_rel->relids); + child_restrictlist = (List *) + adjust_appendrel_attrs_multilevel(root, (Node *)extra->restrictlist, + child_joinrelids, parent_relids); + + child_joinrel = find_join_rel(root, child_joinrelids); + if (!child_joinrel) + child_joinrel = build_child_join_rel(root, + child_rel, + inner_rel, + joinrel, + child_restrictlist, + child_sjinfo, + jointype); + else + { + /* + * The join relation already exists. For example, it could happen if + * we join two plane tables with partitioned table(s). + * Populating this join with additional paths could push out some + * previously added paths which could be pointed in a subplans list + * of an higher level append. + * Of course, we could save such paths before generating new. But it + * can increase too much the number of paths in complex queries. It + * can be a task for future work. + */ + return NIL; + } + + populate_joinrel_with_paths(root, + child_rel, + inner_rel, + child_joinrel, + child_sjinfo, + child_restrictlist); + + /* Give up if asymmetric partition-wise join is not available */ + if (child_joinrel->pathlist == NIL) + return NIL; + + set_cheapest(child_joinrel); + result = lappend(result, child_joinrel); + } + return result; +} + +static bool +is_asymmetric_join_feasible(PlannerInfo *root, + RelOptInfo *outer_rel, + RelOptInfo *inner_rel, + JoinType jointype) +{ + ListCell *lc; + + if (jointype != JOIN_INNER && jointype != JOIN_LEFT) + return false; + + if (IS_OTHER_REL(outer_rel) || IS_OTHER_REL(inner_rel)) + return false; + + /* Disallow recursive usage of asymmertic join machinery */ + if (root->join_rel_level == NULL) + return false; + + /* + * Don't allow asymmetric JOIN of two append subplans. + * In the case of a parameterized NL join, a reparameterization procedure + * will lead to large memory allocations and a CPU consumption: + * each reparameterization will induce subpath duplication, creating new + * ParamPathInfo instance and increasing of ppilist up to number of + * partitions in the inner. Also, if we have many partitions, each bitmapset + * variable will be large and many leaks of such variable (caused by relid + * replacement) will highly increase memory consumption. + * So, we deny such paths for now. + */ + foreach(lc, inner_rel->pathlist) + { + if (IsA(lfirst(lc), AppendPath)) + return false; + } + + return true; +} + +void +try_asymmetric_partitionwise_join(PlannerInfo *root, + RelOptInfo *joinrel, + RelOptInfo *outer_rel, + RelOptInfo *inner_rel, + JoinType jointype, + JoinPathExtraData *extra) +{ + ListCell *lc; + + /* + * Try this kind of paths if we allow complex partitionwise joins and we know + * we can build this join safely. + */ + if (!enable_partitionwise_join || + !is_asymmetric_join_feasible(root, outer_rel, inner_rel, jointype)) + return; + + foreach (lc, outer_rel->pathlist) + { + AppendPath *append_path = lfirst(lc); + + /* + * We assume this pathlist keeps at least one AppendPath that + * represents partitioned table-scan, symmetric or asymmetric + * partition-wise join. Asymmetric join isn't needed if the append node + * has only one child. + */ + if (IsA(append_path, AppendPath) && + list_length(append_path->subpaths) > 1) + { + List **join_rel_level_saved; + List *live_childrels = NIL; + + join_rel_level_saved = root->join_rel_level; + PG_TRY(); + { + /* temporary disables "dynamic programming" algorithm */ + root->join_rel_level = NULL; + + live_childrels = + extract_asymmetric_partitionwise_subjoin(root, + joinrel, + append_path, + inner_rel, + jointype, + extra); + } + PG_FINALLY(); + { + root->join_rel_level = join_rel_level_saved; + } + PG_END_TRY(); + + if (live_childrels != NIL) + { + /* + * Add new append relation. We must choose cheapest paths after + * this operation because the pathlist possibly contains + * joinrels and appendrels that can be suboptimal. + */ + add_paths_to_append_rel(root, joinrel, live_childrels); + set_cheapest(joinrel); + } + + break; + } + } +} + /* * Construct the SpecialJoinInfo for a child-join by translating * SpecialJoinInfo for the join between parents. left_relids and right_relids diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c index e50624c465..fccc0685d7 100644 --- a/src/backend/optimizer/plan/setrefs.c +++ b/src/backend/optimizer/plan/setrefs.c @@ -281,24 +281,29 @@ set_plan_references(PlannerInfo *root, Plan *plan) /* * Adjust RT indexes of AppendRelInfos and add to final appendrels list. - * We assume the AppendRelInfos were built during planning and don't need - * to be copied. + * The AppendRelInfos are copied, because as a part of a subplan they could + * be visited many times in the case of asymmetric join. */ foreach(lc, root->append_rel_list) { AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc); + AppendRelInfo *newappinfo; + + /* flat copy is enough since all valuable fields are scalars */ + newappinfo = (AppendRelInfo *) palloc(sizeof(AppendRelInfo)); + memcpy(newappinfo, appinfo, sizeof(AppendRelInfo)); /* adjust RT indexes */ - appinfo->parent_relid += rtoffset; - appinfo->child_relid += rtoffset; + newappinfo->parent_relid += rtoffset; + newappinfo->child_relid += rtoffset; /* * Rather than adjust the translated_vars entries, just drop 'em. * Neither the executor nor EXPLAIN currently need that data. */ - appinfo->translated_vars = NIL; + newappinfo->translated_vars = NIL; - glob->appendRelations = lappend(glob->appendRelations, appinfo); + glob->appendRelations = lappend(glob->appendRelations, newappinfo); } /* Now fix the Plan tree */ diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c index af46f581ac..f4d12f76e1 100644 --- a/src/backend/optimizer/util/appendinfo.c +++ b/src/backend/optimizer/util/appendinfo.c @@ -202,7 +202,9 @@ adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos, context.appinfos = appinfos; /* If there's nothing to adjust, don't call this function. */ - Assert(nappinfos >= 1 && appinfos != NULL); + /* If there's nothing to adjust, just return a duplication */ + if (nappinfos == 0) + return copyObject(node); /* Should never be translating a Query tree. */ Assert(node == NULL || !IsA(node, Query)); @@ -490,12 +492,10 @@ adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, Relids top_parent_relids) { AppendRelInfo **appinfos; - Bitmapset *parent_relids = NULL; + Relids parent_relids = NULL; int nappinfos; int cnt; - Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids)); - appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos); /* Construct relids set for the immediate parent of given child. */ @@ -506,8 +506,13 @@ adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, parent_relids = bms_add_member(parent_relids, appinfo->parent_relid); } - /* Recurse if immediate parent is not the top parent. */ - if (!bms_equal(parent_relids, top_parent_relids)) + /* + * Recurse if immediate parent is not the top parent. Keep in mind that in a + * case of asymmetric JOIN top_parent_relids can contain relids which aren't + * part of an append node. + */ + if (!bms_equal(parent_relids, top_parent_relids) && + !bms_is_subset(parent_relids, top_parent_relids)) node = adjust_appendrel_attrs_multilevel(root, node, parent_relids, top_parent_relids); @@ -515,12 +520,13 @@ adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, node = adjust_appendrel_attrs(root, node, nappinfos, appinfos); pfree(appinfos); + pfree(parent_relids); return node; } /* - * Substitute child relids for parent relids in a Relid set. The array of + * Substitute child relids for parent relids in a Relid set. The array of * appinfos specifies the substitutions to be performed. */ Relids @@ -565,6 +571,7 @@ adjust_child_relids_multilevel(PlannerInfo *root, Relids relids, AppendRelInfo **appinfos; int nappinfos; Relids parent_relids = NULL; + Relids normal_relids = NULL; Relids result; Relids tmp_result = NULL; int cnt; @@ -579,13 +586,24 @@ adjust_child_relids_multilevel(PlannerInfo *root, Relids relids, appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos); /* Construct relids set for the immediate parent of the given child. */ + normal_relids = bms_copy(child_relids); for (cnt = 0; cnt < nappinfos; cnt++) { AppendRelInfo *appinfo = appinfos[cnt]; parent_relids = bms_add_member(parent_relids, appinfo->parent_relid); + normal_relids = bms_del_member(normal_relids, appinfo->child_relid); } + if (bms_is_subset(relids, normal_relids)) + { + /* Nothing to do. Parameters set points to plain relations only. */ + result = relids; + goto cleanup; + } + + parent_relids = bms_union(parent_relids, normal_relids); + /* Recurse if immediate parent is not the top parent. */ if (!bms_equal(parent_relids, top_parent_relids)) { @@ -597,10 +615,11 @@ adjust_child_relids_multilevel(PlannerInfo *root, Relids relids, result = adjust_child_relids(relids, nappinfos, appinfos); +cleanup: /* Free memory consumed by any intermediate result. */ - if (tmp_result) - bms_free(tmp_result); + bms_free(tmp_result); bms_free(parent_relids); + bms_free(normal_relids); pfree(appinfos); return result; @@ -715,11 +734,11 @@ AppendRelInfo ** find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos) { AppendRelInfo **appinfos; + int nrooms = bms_num_members(relids); int cnt = 0; int i; - *nappinfos = bms_num_members(relids); - appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos); + appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * nrooms); i = -1; while ((i = bms_next_member(relids, i)) >= 0) @@ -727,10 +746,11 @@ find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos) AppendRelInfo *appinfo = root->append_rel_array[i]; if (!appinfo) - elog(ERROR, "child rel %d not found in append_rel_array", i); + continue; appinfos[cnt++] = appinfo; } + *nappinfos = cnt; return appinfos; } diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c index cedb3848dd..17e215b72d 100644 --- a/src/backend/optimizer/util/pathnode.c +++ b/src/backend/optimizer/util/pathnode.c @@ -4225,7 +4225,14 @@ do { \ MemoryContextSwitchTo(oldcontext); } - bms_free(required_outer); + + /* + * If adjust_child_relids_multilevel don't do replacements it returns + * the original set, not a copy. It is possible in the case of asymmetric + * JOIN and child_rel->relids contains relids only of plane relations. + */ + if (required_outer != old_ppi->ppi_req_outer) + bms_free(required_outer); new_path->param_info = new_ppi; diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c index 47769cea45..ddf0f5a876 100644 --- a/src/backend/optimizer/util/relnode.c +++ b/src/backend/optimizer/util/relnode.c @@ -792,11 +792,8 @@ build_child_join_rel(PlannerInfo *root, RelOptInfo *outer_rel, AppendRelInfo **appinfos; int nappinfos; - /* Only joins between "other" relations land here. */ - Assert(IS_OTHER_REL(outer_rel) && IS_OTHER_REL(inner_rel)); - - /* The parent joinrel should have consider_partitionwise_join set. */ - Assert(parent_joinrel->consider_partitionwise_join); + /* Either of relations must be "other" relation at least. */ + Assert(IS_OTHER_REL(outer_rel) || IS_OTHER_REL(inner_rel)); joinrel->reloptkind = RELOPT_OTHER_JOINREL; joinrel->relids = bms_union(outer_rel->relids, inner_rel->relids); @@ -854,8 +851,11 @@ build_child_join_rel(PlannerInfo *root, RelOptInfo *outer_rel, joinrel->partexprs = NULL; joinrel->nullable_partexprs = NULL; - joinrel->top_parent_relids = bms_union(outer_rel->top_parent_relids, - inner_rel->top_parent_relids); + joinrel->top_parent_relids = + bms_union(IS_OTHER_REL(outer_rel) ? + outer_rel->top_parent_relids : outer_rel->relids, + IS_OTHER_REL(inner_rel) ? + inner_rel->top_parent_relids : inner_rel->relids); /* Compute information relevant to foreign relations. */ set_foreign_rel_properties(joinrel, outer_rel, inner_rel); @@ -2036,9 +2036,8 @@ build_child_join_reltarget(PlannerInfo *root, { /* Build the targetlist */ childrel->reltarget->exprs = (List *) - adjust_appendrel_attrs(root, - (Node *) parentrel->reltarget->exprs, - nappinfos, appinfos); + adjust_appendrel_attrs_multilevel(root, (Node *)parentrel->reltarget->exprs, + childrel->relids, parentrel->relids); /* Set the cost and width fields */ childrel->reltarget->cost.startup = parentrel->reltarget->cost.startup; diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h index f1d111063c..a0106dc539 100644 --- a/src/include/optimizer/paths.h +++ b/src/include/optimizer/paths.h @@ -109,7 +109,12 @@ extern bool have_join_order_restriction(PlannerInfo *root, extern bool have_dangerous_phv(PlannerInfo *root, Relids outer_relids, Relids inner_params); extern void mark_dummy_rel(RelOptInfo *rel); - +extern void try_asymmetric_partitionwise_join(PlannerInfo *root, + RelOptInfo *joinrel, + RelOptInfo *outer_rel, + RelOptInfo *inner_rel, + JoinType jointype, + JoinPathExtraData *extra); /* * equivclass.c * routines for managing EquivalenceClasses diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out index 27f7525b3e..3eddd9bec3 100644 --- a/src/test/regress/expected/partition_join.out +++ b/src/test/regress/expected/partition_join.out @@ -2320,6 +2320,431 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a = 375 | 0375 | 375 | 0375 (8 rows) +-- +-- For asymmetric partition-wise join +-- +CREATE TABLE prt5 (hkey int, a int, b int) PARTITION BY HASH(hkey); +CREATE TABLE prt5_p0 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 0); +CREATE TABLE prt5_p1 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 1); +CREATE TABLE prt5_p2 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 2); +CREATE TABLE prt6 (aid int, alabel text) PARTITION BY HASH(aid); +CREATE TABLE prt6_p0 PARTITION OF prt6 + FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prt6_p1 PARTITION OF prt6 + FOR VALUES WITH (modulus 2, remainder 1); +CREATE TABLE t5_1 (aid int, alabel text); +CREATE TABLE t5_2 (bid int, blabel text); +INSERT INTO prt5 (SELECT x, (x % 1000)::int, + ((x+1) % 1000)::int + FROM generate_series(1,1000000) x); +INSERT INTO t5_1 (SELECT x, md5(x::text) FROM generate_series(-200, 1500) x); +INSERT INTO t5_2 (SELECT x, md5(x::text) FROM generate_series(-200, 1500) x); +INSERT INTO prt6 (SELECT * FROM t5_1); +VACUUM ANALYZE prt5,prt6,t5_1,t5_2; +SET max_parallel_workers_per_gather = 0; +-- Trivial asymmetric JOIN of partitioned table with a relation +EXPLAIN (COSTS OFF) +SELECT * + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +------------------------------------------------------- + Append + -> Hash Join + Hash Cond: (prt5_1.a = t5_1.aid) + -> Seq Scan on prt5_p0 prt5_1 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) + -> Hash Join + Hash Cond: (prt5_2.a = t5_1.aid) + -> Seq Scan on prt5_p1 prt5_2 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) + -> Hash Join + Hash Cond: (prt5_3.a = t5_1.aid) + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) +(19 rows) + +-- The same, but appended with UNION ALL +EXPLAIN (COSTS OFF) +SELECT * FROM ( + (SELECT * FROM prt5_p0) + UNION ALL + (SELECT * FROM prt5_p1) + UNION ALL + (SELECT * FROM prt5_p2) + ) AS sq1 +JOIN t5_1 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +------------------------------------------------------- + Append + -> Hash Join + Hash Cond: (prt5_p0.a = t5_1.aid) + -> Seq Scan on prt5_p0 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) + -> Hash Join + Hash Cond: (prt5_p1.a = t5_1.aid) + -> Seq Scan on prt5_p1 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) + -> Hash Join + Hash Cond: (prt5_p2.a = t5_1.aid) + -> Seq Scan on prt5_p2 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) +(19 rows) + +-- Don't allow asymmetric JOIN of two partitioned tables. +EXPLAIN (COSTS OFF) +SELECT count(*) FROM prt5 JOIN prt6 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +------------------------------------------------------------- + Aggregate + -> Hash Join + Hash Cond: (prt5.a = prt6.aid) + -> Append + -> Seq Scan on prt5_p0 prt5_1 + -> Seq Scan on prt5_p1 prt5_2 + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Append + -> Seq Scan on prt6_p0 prt6_1 + Filter: (alabel ~~ '%abc%'::text) + -> Seq Scan on prt6_p1 prt6_2 + Filter: (alabel ~~ '%abc%'::text) +(13 rows) + +SELECT count(*) FROM prt5 JOIN prt6 ON a = aid AND alabel like '%abc%'; + count +------- + 4000 +(1 row) + +-- Check asymmetric JOIN with Subquery +EXPLAIN (COSTS OFF) +SELECT count(*) FROM prt5 JOIN ( + SELECT * FROM prt6 LIMIT 1000 +) AS sq1 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +---------------------------------------------------------------------- + Aggregate + -> Append + -> Hash Join + Hash Cond: (prt5_1.a = sq1.aid) + -> Seq Scan on prt5_p0 prt5_1 + -> Hash + -> Subquery Scan on sq1 + Filter: (sq1.alabel ~~ '%abc%'::text) + -> Limit + -> Append + -> Seq Scan on prt6_p0 prt6_1 + -> Seq Scan on prt6_p1 prt6_2 + -> Hash Join + Hash Cond: (prt5_2.a = sq1.aid) + -> Seq Scan on prt5_p1 prt5_2 + -> Hash + -> Subquery Scan on sq1 + Filter: (sq1.alabel ~~ '%abc%'::text) + -> Limit + -> Append + -> Seq Scan on prt6_p0 prt6_4 + -> Seq Scan on prt6_p1 prt6_5 + -> Hash Join + Hash Cond: (prt5_3.a = sq1.aid) + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Subquery Scan on sq1 + Filter: (sq1.alabel ~~ '%abc%'::text) + -> Limit + -> Append + -> Seq Scan on prt6_p0 prt6_7 + -> Seq Scan on prt6_p1 prt6_8 +(32 rows) + +SELECT count(*) FROM prt5 JOIN (SELECT * FROM prt6 LIMIT 1000) AS sq1 + ON a = aid AND alabel like '%abc%'; + count +------- + 2000 +(1 row) + +-- Asymmetric JOIN of two plane tables and one partitioned +EXPLAIN (COSTS OFF) +SELECT count(*) + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + QUERY PLAN +------------------------------------------------------------------ + Aggregate + -> Append + -> Hash Join + Hash Cond: (prt5_1.b = t5_2.bid) + -> Hash Join + Hash Cond: (prt5_1.a = t5_1.aid) + -> Seq Scan on prt5_p0 prt5_1 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%ab%'::text) + -> Hash + -> Seq Scan on t5_2 + Filter: (blabel ~~ '%cd%'::text) + -> Hash Join + Hash Cond: (prt5_2.b = t5_2.bid) + -> Hash Join + Hash Cond: (prt5_2.a = t5_1.aid) + -> Seq Scan on prt5_p1 prt5_2 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%ab%'::text) + -> Hash + -> Seq Scan on t5_2 + Filter: (blabel ~~ '%cd%'::text) + -> Hash Join + Hash Cond: (prt5_3.b = t5_2.bid) + -> Hash Join + Hash Cond: (prt5_3.a = t5_1.aid) + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%ab%'::text) + -> Hash + -> Seq Scan on t5_2 + Filter: (blabel ~~ '%cd%'::text) +(35 rows) + +SELECT count(*) + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + count +------- + 11000 +(1 row) + +-- unable to extract non-partitioned right relation +EXPLAIN (COSTS OFF) +SELECT * FROM prt5 RIGHT JOIN t5_1 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +----------------------------------------------- + Hash Right Join + Hash Cond: (prt5.a = t5_1.aid) + Join Filter: (t5_1.alabel ~~ '%abc%'::text) + -> Append + -> Seq Scan on prt5_p0 prt5_1 + -> Seq Scan on prt5_p1 prt5_2 + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Seq Scan on t5_1 +(9 rows) + +-- left side can be extracted, but no cost benefit +EXPLAIN (COSTS OFF) +SELECT * FROM prt5 LEFT JOIN t5_1 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +------------------------------------------------- + Hash Left Join + Hash Cond: (prt5.a = t5_1.aid) + -> Append + -> Seq Scan on prt5_p0 prt5_1 + -> Seq Scan on prt5_p1 prt5_2 + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) +(9 rows) + +-- validation of the results with/without asymmetric partition-wise join +SELECT * INTO pg_temp.result01a + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; +SELECT * INTO pg_temp.result02a + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; +SET enable_partitionwise_join = off; +SELECT * INTO pg_temp.result01b + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; +SELECT * INTO pg_temp.result02b + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; +SELECT * FROM pg_temp.result01a EXCEPT SELECT * FROM pg_temp.result01b; + hkey | a | b | aid | alabel +------+---+---+-----+-------- +(0 rows) + +SELECT * FROM pg_temp.result02a EXCEPT SELECT * FROM pg_temp.result02b; + hkey | a | b | aid | alabel | bid | blabel +------+---+---+-----+--------+-----+-------- +(0 rows) + +SET enable_partitionwise_join = on; +-- Check reparameterization code when an optimizer have to make two level relids +-- adjustment. +SET enable_hashjoin = 'off'; +SET enable_mergejoin = 'off'; +SET enable_material = 'off'; +CREATE TABLE big AS SELECT x AS x FROM generate_series(1,1E4) x; +CREATE INDEX ON big(x); +CREATE TABLE small AS SELECT x, -x AS y FROM generate_series(1,100) x; +CREATE TABLE part_l0 (x int, y int, z int) PARTITION BY HASH (y); +CREATE TABLE part0_l1 PARTITION OF part_l0 (y) + FOR VALUES WITH (modulus 2, remainder 0) PARTITION BY HASH (z); +CREATE TABLE part0_l2 PARTITION OF part0_l1 (z) + FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE part1_l2 PARTITION OF part0_l1 (z) + FOR VALUES WITH (modulus 2, remainder 1); +CREATE TABLE part1_l1 PARTITION OF part_l0 (y) + FOR VALUES WITH (modulus 2, remainder 1); +INSERT INTO part_l0 (x, y, z) (SELECT x,x,x FROM generate_series(1,1E4) x); +ANALYZE big,small,part_l0; +-- Parameter have to be reparameterized by a plane relation. +EXPLAIN (COSTS OFF) +SELECT small.* FROM small + JOIN part_l0 ON small.y = part_l0.y AND small.y + part_l0.y < 10 + LEFT JOIN big ON big.x = small.x; + QUERY PLAN +----------------------------------------------------------------------------------------- + Nested Loop Left Join + -> Append + -> Nested Loop + Join Filter: ((small.y = part_l0_1.y) AND ((small.y + part_l0_1.y) < 10)) + -> Seq Scan on small + -> Seq Scan on part0_l2 part_l0_1 + -> Nested Loop + Join Filter: ((small.y = part_l0_2.y) AND ((small.y + part_l0_2.y) < 10)) + -> Seq Scan on part1_l2 part_l0_2 + -> Seq Scan on small + -> Nested Loop + Join Filter: ((small.y = part_l0_3.y) AND ((small.y + part_l0_3.y) < 10)) + -> Seq Scan on small + -> Seq Scan on part1_l1 part_l0_3 + -> Index Only Scan using big_x_idx on big + Index Cond: (x = (small.x)::numeric) +(16 rows) + +SELECT small.* FROM small + JOIN part_l0 ON small.y = part_l0.y AND small.y + part_l0.y < 10 + LEFT JOIN big ON big.x = small.x; + x | y +---+--- +(0 rows) + +-- Parameters have to be reparameterized by plane and partitioned relations. +EXPLAIN (COSTS OFF) +SELECT count(*) FROM small + JOIN part_l0 ON small.y = part_l0.y AND small.y + part_l0.y < 10 + LEFT JOIN big ON big.x = small.x OR big.x = part_l0.x; + QUERY PLAN +----------------------------------------------------------------------------------------------- + Aggregate + -> Nested Loop Left Join + -> Append + -> Nested Loop + Join Filter: ((small.y = part_l0_1.y) AND ((small.y + part_l0_1.y) < 10)) + -> Seq Scan on small + -> Seq Scan on part0_l2 part_l0_1 + -> Nested Loop + Join Filter: ((small.y = part_l0_2.y) AND ((small.y + part_l0_2.y) < 10)) + -> Seq Scan on part1_l2 part_l0_2 + -> Seq Scan on small + -> Nested Loop + Join Filter: ((small.y = part_l0_3.y) AND ((small.y + part_l0_3.y) < 10)) + -> Seq Scan on small + -> Seq Scan on part1_l1 part_l0_3 + -> Bitmap Heap Scan on big + Recheck Cond: ((x = (small.x)::numeric) OR (x = (part_l0.x)::numeric)) + -> BitmapOr + -> Bitmap Index Scan on big_x_idx + Index Cond: (x = (small.x)::numeric) + -> Bitmap Index Scan on big_x_idx + Index Cond: (x = (part_l0.x)::numeric) +(22 rows) + +SELECT count(*) FROM small + JOIN part_l0 ON small.y = part_l0.y AND small.y + part_l0.y < 10 + LEFT JOIN big ON big.x = small.x OR big.x = part_l0.x; + count +------- + 0 +(1 row) + +DROP TABLE IF EXISTS big,small,part_l0 CASCADE; +RESET enable_hashjoin; +RESET enable_mergejoin; +RESET enable_material; +RESET max_parallel_workers_per_gather; +-- Parameterized path examples. +CREATE TABLE prta (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE prta1 PARTITION OF prta FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prta2 PARTITION OF prta FOR VALUES WITH (modulus 2, remainder 1); +CREATE UNIQUE INDEX ON prta1 (id); +CREATE UNIQUE INDEX ON prta2 (id); +INSERT INTO prta (id, payload) + (SELECT *, ('abc' || id)::text AS payload + FROM generate_series(1,1) AS id); +CREATE TABLE prtb (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE prtb1 PARTITION OF prtb FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prtb2 PARTITION OF prtb FOR VALUES WITH (modulus 2, remainder 1); +CREATE UNIQUE INDEX ON prtb1 (id); +CREATE UNIQUE INDEX ON prtb2 (id); +INSERT INTO prtb (id, payload) + (SELECT *, ('def' || id)::text AS payload + FROM generate_series(1,1000) AS id); +CREATE TABLE e (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE e1 PARTITION OF e FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE e2 PARTITION OF e FOR VALUES WITH (modulus 2, remainder 1); +INSERT INTO e (id, payload) + (SELECT *, ('ghi' || id)::text AS payload + FROM generate_series(1,1000) AS id); +CREATE UNIQUE INDEX ON e1 (id); +CREATE UNIQUE INDEX ON e2 (id); +ANALYZE prta,prtb,e; +EXPLAIN (COSTS OFF) +SELECT * FROM prta,prtb WHERE prta.id=prtb.id; + QUERY PLAN +----------------------------------------------------------- + Append + -> Nested Loop + -> Seq Scan on prta1 prta_1 + -> Index Scan using prtb1_id_idx on prtb1 prtb_1 + Index Cond: (id = prta_1.id) + -> Nested Loop + -> Seq Scan on prta2 prta_2 + -> Index Scan using prtb2_id_idx on prtb2 prtb_2 + Index Cond: (id = prta_2.id) +(9 rows) + +EXPLAIN (COSTS OFF) +SELECT * FROM prta,prtb,e WHERE prta.id=prtb.id AND prta.id=e.id; + QUERY PLAN +----------------------------------------------------------------- + Append + -> Nested Loop + Join Filter: (prta_1.id = e_1.id) + -> Nested Loop + -> Seq Scan on prta1 prta_1 + -> Index Scan using prtb1_id_idx on prtb1 prtb_1 + Index Cond: (id = prta_1.id) + -> Index Scan using e1_id_idx on e1 e_1 + Index Cond: (id = prtb_1.id) + -> Nested Loop + Join Filter: (prta_2.id = e_2.id) + -> Nested Loop + -> Seq Scan on prta2 prta_2 + -> Index Scan using prtb2_id_idx on prtb2 prtb_2 + Index Cond: (id = prta_2.id) + -> Index Scan using e2_id_idx on e2 e_2 + Index Cond: (id = prtb_2.id) +(17 rows) + -- semi join EXPLAIN (COSTS OFF) SELECT t1.* FROM prt1_adv t1 WHERE EXISTS (SELECT 1 FROM prt2_adv t2 WHERE t1.a = t2.b) AND t1.b = 0 ORDER BY t1.a; diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql index d97b5b69ff..4d1dd5bec1 100644 --- a/src/test/regress/sql/partition_join.sql +++ b/src/test/regress/sql/partition_join.sql @@ -536,6 +536,186 @@ EXPLAIN (COSTS OFF) SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a = t2.b) WHERE t1.b = 0 ORDER BY t1.a, t2.b; SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a = t2.b) WHERE t1.b = 0 ORDER BY t1.a, t2.b; +-- +-- For asymmetric partition-wise join +-- +CREATE TABLE prt5 (hkey int, a int, b int) PARTITION BY HASH(hkey); +CREATE TABLE prt5_p0 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 0); +CREATE TABLE prt5_p1 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 1); +CREATE TABLE prt5_p2 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 2); +CREATE TABLE prt6 (aid int, alabel text) PARTITION BY HASH(aid); +CREATE TABLE prt6_p0 PARTITION OF prt6 + FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prt6_p1 PARTITION OF prt6 + FOR VALUES WITH (modulus 2, remainder 1); +CREATE TABLE t5_1 (aid int, alabel text); +CREATE TABLE t5_2 (bid int, blabel text); + +INSERT INTO prt5 (SELECT x, (x % 1000)::int, + ((x+1) % 1000)::int + FROM generate_series(1,1000000) x); +INSERT INTO t5_1 (SELECT x, md5(x::text) FROM generate_series(-200, 1500) x); +INSERT INTO t5_2 (SELECT x, md5(x::text) FROM generate_series(-200, 1500) x); +INSERT INTO prt6 (SELECT * FROM t5_1); + +VACUUM ANALYZE prt5,prt6,t5_1,t5_2; + +SET max_parallel_workers_per_gather = 0; + +-- Trivial asymmetric JOIN of partitioned table with a relation +EXPLAIN (COSTS OFF) +SELECT * + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +-- The same, but appended with UNION ALL +EXPLAIN (COSTS OFF) +SELECT * FROM ( + (SELECT * FROM prt5_p0) + UNION ALL + (SELECT * FROM prt5_p1) + UNION ALL + (SELECT * FROM prt5_p2) + ) AS sq1 +JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +-- Don't allow asymmetric JOIN of two partitioned tables. +EXPLAIN (COSTS OFF) +SELECT count(*) FROM prt5 JOIN prt6 ON a = aid AND alabel like '%abc%'; +SELECT count(*) FROM prt5 JOIN prt6 ON a = aid AND alabel like '%abc%'; + +-- Check asymmetric JOIN with Subquery +EXPLAIN (COSTS OFF) +SELECT count(*) FROM prt5 JOIN ( + SELECT * FROM prt6 LIMIT 1000 +) AS sq1 ON a = aid AND alabel like '%abc%'; +SELECT count(*) FROM prt5 JOIN (SELECT * FROM prt6 LIMIT 1000) AS sq1 + ON a = aid AND alabel like '%abc%'; + +-- Asymmetric JOIN of two plane tables and one partitioned +EXPLAIN (COSTS OFF) +SELECT count(*) + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; +SELECT count(*) + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + +-- unable to extract non-partitioned right relation +EXPLAIN (COSTS OFF) +SELECT * FROM prt5 RIGHT JOIN t5_1 ON a = aid AND alabel like '%abc%'; +-- left side can be extracted, but no cost benefit +EXPLAIN (COSTS OFF) +SELECT * FROM prt5 LEFT JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +-- validation of the results with/without asymmetric partition-wise join +SELECT * INTO pg_temp.result01a + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +SELECT * INTO pg_temp.result02a + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + +SET enable_partitionwise_join = off; + +SELECT * INTO pg_temp.result01b + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +SELECT * INTO pg_temp.result02b + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + +SELECT * FROM pg_temp.result01a EXCEPT SELECT * FROM pg_temp.result01b; +SELECT * FROM pg_temp.result02a EXCEPT SELECT * FROM pg_temp.result02b; + +SET enable_partitionwise_join = on; + +-- Check reparameterization code when an optimizer have to make two level relids +-- adjustment. + +SET enable_hashjoin = 'off'; +SET enable_mergejoin = 'off'; +SET enable_material = 'off'; + +CREATE TABLE big AS SELECT x AS x FROM generate_series(1,1E4) x; +CREATE INDEX ON big(x); +CREATE TABLE small AS SELECT x, -x AS y FROM generate_series(1,100) x; + +CREATE TABLE part_l0 (x int, y int, z int) PARTITION BY HASH (y); +CREATE TABLE part0_l1 PARTITION OF part_l0 (y) + FOR VALUES WITH (modulus 2, remainder 0) PARTITION BY HASH (z); +CREATE TABLE part0_l2 PARTITION OF part0_l1 (z) + FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE part1_l2 PARTITION OF part0_l1 (z) + FOR VALUES WITH (modulus 2, remainder 1); +CREATE TABLE part1_l1 PARTITION OF part_l0 (y) + FOR VALUES WITH (modulus 2, remainder 1); +INSERT INTO part_l0 (x, y, z) (SELECT x,x,x FROM generate_series(1,1E4) x); + +ANALYZE big,small,part_l0; + +-- Parameter have to be reparameterized by a plane relation. +EXPLAIN (COSTS OFF) +SELECT small.* FROM small + JOIN part_l0 ON small.y = part_l0.y AND small.y + part_l0.y < 10 + LEFT JOIN big ON big.x = small.x; +SELECT small.* FROM small + JOIN part_l0 ON small.y = part_l0.y AND small.y + part_l0.y < 10 + LEFT JOIN big ON big.x = small.x; + +-- Parameters have to be reparameterized by plane and partitioned relations. +EXPLAIN (COSTS OFF) +SELECT count(*) FROM small + JOIN part_l0 ON small.y = part_l0.y AND small.y + part_l0.y < 10 + LEFT JOIN big ON big.x = small.x OR big.x = part_l0.x; +SELECT count(*) FROM small + JOIN part_l0 ON small.y = part_l0.y AND small.y + part_l0.y < 10 + LEFT JOIN big ON big.x = small.x OR big.x = part_l0.x; + +DROP TABLE IF EXISTS big,small,part_l0 CASCADE; +RESET enable_hashjoin; +RESET enable_mergejoin; +RESET enable_material; +RESET max_parallel_workers_per_gather; + +-- Parameterized path examples. +CREATE TABLE prta (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE prta1 PARTITION OF prta FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prta2 PARTITION OF prta FOR VALUES WITH (modulus 2, remainder 1); +CREATE UNIQUE INDEX ON prta1 (id); +CREATE UNIQUE INDEX ON prta2 (id); +INSERT INTO prta (id, payload) + (SELECT *, ('abc' || id)::text AS payload + FROM generate_series(1,1) AS id); + +CREATE TABLE prtb (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE prtb1 PARTITION OF prtb FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prtb2 PARTITION OF prtb FOR VALUES WITH (modulus 2, remainder 1); +CREATE UNIQUE INDEX ON prtb1 (id); +CREATE UNIQUE INDEX ON prtb2 (id); +INSERT INTO prtb (id, payload) + (SELECT *, ('def' || id)::text AS payload + FROM generate_series(1,1000) AS id); + +CREATE TABLE e (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE e1 PARTITION OF e FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE e2 PARTITION OF e FOR VALUES WITH (modulus 2, remainder 1); +INSERT INTO e (id, payload) + (SELECT *, ('ghi' || id)::text AS payload + FROM generate_series(1,1000) AS id); +CREATE UNIQUE INDEX ON e1 (id); +CREATE UNIQUE INDEX ON e2 (id); + +ANALYZE prta,prtb,e; + +EXPLAIN (COSTS OFF) +SELECT * FROM prta,prtb WHERE prta.id=prtb.id; + +EXPLAIN (COSTS OFF) +SELECT * FROM prta,prtb,e WHERE prta.id=prtb.id AND prta.id=e.id; + -- semi join EXPLAIN (COSTS OFF) SELECT t1.* FROM prt1_adv t1 WHERE EXISTS (SELECT 1 FROM prt2_adv t2 WHERE t1.a = t2.b) AND t1.b = 0 ORDER BY t1.a; -- 2.33.0 --------------9DCA5E9A07F91111D4169DAB-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Asymmetric partitionwise join. @ 2021-04-02 06:02 Andrey Lepikhov <a.lepikhov@postgrespro.ru> 0 siblings, 0 replies; 383+ messages in thread From: Andrey Lepikhov @ 2021-04-02 06:02 UTC (permalink / raw) Teach optimizer to consider partitionwise join of non-partitioned table with each partition of partitioned table. Disallow asymmetric machinery for joining of two partitioned (or appended) relations because it could cause huge consumption of CPU and memory during reparameterization of NestLoop path. Change logic of the multilevel child relids adjustment, because this feature allows the optimizer to plan in new way. --- src/backend/optimizer/path/joinpath.c | 9 + src/backend/optimizer/path/joinrels.c | 187 +++++++++ src/backend/optimizer/plan/setrefs.c | 17 +- src/backend/optimizer/util/appendinfo.c | 51 ++- src/backend/optimizer/util/pathnode.c | 9 +- src/backend/optimizer/util/relnode.c | 19 +- src/include/optimizer/paths.h | 7 +- src/test/regress/expected/partition_join.out | 378 +++++++++++++++++++ src/test/regress/sql/partition_join.sql | 167 ++++++++ 9 files changed, 808 insertions(+), 36 deletions(-) diff --git a/src/backend/optimizer/path/joinpath.c b/src/backend/optimizer/path/joinpath.c index 6407ede12a..32618ebbd5 100644 --- a/src/backend/optimizer/path/joinpath.c +++ b/src/backend/optimizer/path/joinpath.c @@ -335,6 +335,15 @@ add_paths_to_joinrel(PlannerInfo *root, if (set_join_pathlist_hook) set_join_pathlist_hook(root, joinrel, outerrel, innerrel, jointype, &extra); + + /* + * 7. If outer relation is delivered from partition-tables, consider + * distributing inner relation to every partition-leaf prior to + * append these leafs. + */ + try_asymmetric_partitionwise_join(root, joinrel, + outerrel, innerrel, + jointype, &extra); } /* diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c index 8b69870cf4..9453258f83 100644 --- a/src/backend/optimizer/path/joinrels.c +++ b/src/backend/optimizer/path/joinrels.c @@ -16,6 +16,7 @@ #include "miscadmin.h" #include "optimizer/appendinfo.h" +#include "optimizer/cost.h" #include "optimizer/joininfo.h" #include "optimizer/pathnode.h" #include "optimizer/paths.h" @@ -1552,6 +1553,192 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2, } } +/* + * Build RelOptInfo on JOIN of each partition of the outer relation and the inner + * relation. Return List of such RelOptInfo's. Return NIL, if at least one of + * these JOINs is impossible to build. + */ +static List * +extract_asymmetric_partitionwise_subjoin(PlannerInfo *root, + RelOptInfo *joinrel, + AppendPath *append_path, + RelOptInfo *inner_rel, + JoinType jointype, + JoinPathExtraData *extra) +{ + List *result = NIL; + ListCell *lc; + + foreach (lc, append_path->subpaths) + { + Path *child_path = lfirst(lc); + RelOptInfo *child_rel = child_path->parent; + Relids child_joinrelids; + Relids parent_relids; + RelOptInfo *child_joinrel; + SpecialJoinInfo *child_sjinfo; + List *child_restrictlist; + + child_joinrelids = bms_union(child_rel->relids, inner_rel->relids); + parent_relids = bms_union(append_path->path.parent->relids, + inner_rel->relids); + + child_sjinfo = build_child_join_sjinfo(root, extra->sjinfo, + child_rel->relids, + inner_rel->relids); + child_restrictlist = (List *) + adjust_appendrel_attrs_multilevel(root, (Node *)extra->restrictlist, + child_joinrelids, parent_relids); + + child_joinrel = find_join_rel(root, child_joinrelids); + if (!child_joinrel) + child_joinrel = build_child_join_rel(root, + child_rel, + inner_rel, + joinrel, + child_restrictlist, + child_sjinfo, + jointype); + else + { + /* + * The join relation already exists. For example, it could happen if + * we join two plane tables with partitioned table(s). + * Populating this join with additional paths could push out some + * previously added paths which could be pointed in a subplans list + * of an higher level append. + * Of course, we could save such paths before generating new. But it + * can increase too much the number of paths in complex queries. It + * can be a task for future work. + */ + return NIL; + } + + populate_joinrel_with_paths(root, + child_rel, + inner_rel, + child_joinrel, + child_sjinfo, + child_restrictlist); + + /* Give up if asymmetric partition-wise join is not available */ + if (child_joinrel->pathlist == NIL) + return NIL; + + set_cheapest(child_joinrel); + result = lappend(result, child_joinrel); + } + return result; +} + +static bool +is_asymmetric_join_feasible(PlannerInfo *root, + RelOptInfo *outer_rel, + RelOptInfo *inner_rel, + JoinType jointype) +{ + ListCell *lc; + + if (jointype != JOIN_INNER && jointype != JOIN_LEFT) + return false; + + if (IS_OTHER_REL(outer_rel) || IS_OTHER_REL(inner_rel)) + return false; + + /* Disallow recursive usage of asymmertic join machinery */ + if (root->join_rel_level == NULL) + return false; + + /* + * Don't allow asymmetric JOIN of two append subplans. + * In the case of a parameterized NL join, a reparameterization procedure + * will lead to large memory allocations and a CPU consumption: + * each reparameterization will induce subpath duplication, creating new + * ParamPathInfo instance and increasing of ppilist up to number of + * partitions in the inner. Also, if we have many partitions, each bitmapset + * variable will be large and many leaks of such variable (caused by relid + * replacement) will highly increase memory consumption. + * So, we deny such paths for now. + */ + foreach(lc, inner_rel->pathlist) + { + if (IsA(lfirst(lc), AppendPath)) + return false; + } + + return true; +} + +void +try_asymmetric_partitionwise_join(PlannerInfo *root, + RelOptInfo *joinrel, + RelOptInfo *outer_rel, + RelOptInfo *inner_rel, + JoinType jointype, + JoinPathExtraData *extra) +{ + ListCell *lc; + + /* + * Try this kind of paths if we allow complex partitionwise joins and we know + * we can build this join safely. + */ + if (!enable_partitionwise_join || + !is_asymmetric_join_feasible(root, outer_rel, inner_rel, jointype)) + return; + + foreach (lc, outer_rel->pathlist) + { + AppendPath *append_path = lfirst(lc); + + /* + * We assume this pathlist keeps at least one AppendPath that + * represents partitioned table-scan, symmetric or asymmetric + * partition-wise join. Asymmetric join isn't needed if the append node + * has only one child. + */ + if (IsA(append_path, AppendPath) && + list_length(append_path->subpaths) > 1) + { + List **join_rel_level_saved; + List *live_childrels = NIL; + + join_rel_level_saved = root->join_rel_level; + PG_TRY(); + { + /* temporary disables "dynamic programming" algorithm */ + root->join_rel_level = NULL; + + live_childrels = + extract_asymmetric_partitionwise_subjoin(root, + joinrel, + append_path, + inner_rel, + jointype, + extra); + } + PG_FINALLY(); + { + root->join_rel_level = join_rel_level_saved; + } + PG_END_TRY(); + + if (live_childrels != NIL) + { + /* + * Add new append relation. We must choose cheapest paths after + * this operation because the pathlist possibly contains + * joinrels and appendrels that can be suboptimal. + */ + add_paths_to_append_rel(root, joinrel, live_childrels); + set_cheapest(joinrel); + } + + break; + } + } +} + /* * Construct the SpecialJoinInfo for a child-join by translating * SpecialJoinInfo for the join between parents. left_relids and right_relids diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c index e50624c465..fccc0685d7 100644 --- a/src/backend/optimizer/plan/setrefs.c +++ b/src/backend/optimizer/plan/setrefs.c @@ -281,24 +281,29 @@ set_plan_references(PlannerInfo *root, Plan *plan) /* * Adjust RT indexes of AppendRelInfos and add to final appendrels list. - * We assume the AppendRelInfos were built during planning and don't need - * to be copied. + * The AppendRelInfos are copied, because as a part of a subplan they could + * be visited many times in the case of asymmetric join. */ foreach(lc, root->append_rel_list) { AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc); + AppendRelInfo *newappinfo; + + /* flat copy is enough since all valuable fields are scalars */ + newappinfo = (AppendRelInfo *) palloc(sizeof(AppendRelInfo)); + memcpy(newappinfo, appinfo, sizeof(AppendRelInfo)); /* adjust RT indexes */ - appinfo->parent_relid += rtoffset; - appinfo->child_relid += rtoffset; + newappinfo->parent_relid += rtoffset; + newappinfo->child_relid += rtoffset; /* * Rather than adjust the translated_vars entries, just drop 'em. * Neither the executor nor EXPLAIN currently need that data. */ - appinfo->translated_vars = NIL; + newappinfo->translated_vars = NIL; - glob->appendRelations = lappend(glob->appendRelations, appinfo); + glob->appendRelations = lappend(glob->appendRelations, newappinfo); } /* Now fix the Plan tree */ diff --git a/src/backend/optimizer/util/appendinfo.c b/src/backend/optimizer/util/appendinfo.c index af46f581ac..3ae25f3444 100644 --- a/src/backend/optimizer/util/appendinfo.c +++ b/src/backend/optimizer/util/appendinfo.c @@ -202,7 +202,9 @@ adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos, context.appinfos = appinfos; /* If there's nothing to adjust, don't call this function. */ - Assert(nappinfos >= 1 && appinfos != NULL); + /* If there's nothing to adjust, just return a duplication */ + if (nappinfos == 0) + return copyObject(node); /* Should never be translating a Query tree. */ Assert(node == NULL || !IsA(node, Query)); @@ -489,12 +491,10 @@ adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, Relids child_relids, Relids top_parent_relids) { - AppendRelInfo **appinfos; - Bitmapset *parent_relids = NULL; - int nappinfos; - int cnt; - - Assert(bms_num_members(child_relids) == bms_num_members(top_parent_relids)); + AppendRelInfo **appinfos; + Relids parent_relids = NULL; + int nappinfos; + int cnt; appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos); @@ -506,8 +506,13 @@ adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, parent_relids = bms_add_member(parent_relids, appinfo->parent_relid); } - /* Recurse if immediate parent is not the top parent. */ - if (!bms_equal(parent_relids, top_parent_relids)) + /* + * Recurse if immediate parent is not the top parent. Keep in mind that in a + * case of asymmetric JOIN top_parent_relids can contain relids which aren't + * part of an append node. + */ + if (!bms_equal(parent_relids, top_parent_relids) && + !bms_is_subset(parent_relids, top_parent_relids)) node = adjust_appendrel_attrs_multilevel(root, node, parent_relids, top_parent_relids); @@ -515,12 +520,13 @@ adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, node = adjust_appendrel_attrs(root, node, nappinfos, appinfos); pfree(appinfos); + pfree(parent_relids); return node; } /* - * Substitute child relids for parent relids in a Relid set. The array of + * Substitute child relids for parent relids in a Relid set. The array of * appinfos specifies the substitutions to be performed. */ Relids @@ -565,8 +571,9 @@ adjust_child_relids_multilevel(PlannerInfo *root, Relids relids, AppendRelInfo **appinfos; int nappinfos; Relids parent_relids = NULL; + Relids normal_relids = NULL; Relids result; - Relids tmp_result = NULL; + Relids tmp_result = relids; int cnt; /* @@ -579,12 +586,17 @@ adjust_child_relids_multilevel(PlannerInfo *root, Relids relids, appinfos = find_appinfos_by_relids(root, child_relids, &nappinfos); /* Construct relids set for the immediate parent of the given child. */ + normal_relids = bms_copy(child_relids); for (cnt = 0; cnt < nappinfos; cnt++) { AppendRelInfo *appinfo = appinfos[cnt]; parent_relids = bms_add_member(parent_relids, appinfo->parent_relid); + normal_relids = bms_del_member(normal_relids, appinfo->child_relid); } + parent_relids = bms_union(parent_relids, normal_relids); + if (normal_relids) + bms_free(normal_relids); /* Recurse if immediate parent is not the top parent. */ if (!bms_equal(parent_relids, top_parent_relids)) @@ -592,13 +604,15 @@ adjust_child_relids_multilevel(PlannerInfo *root, Relids relids, tmp_result = adjust_child_relids_multilevel(root, relids, parent_relids, top_parent_relids); - relids = tmp_result; } - result = adjust_child_relids(relids, nappinfos, appinfos); + result = adjust_child_relids(tmp_result, nappinfos, appinfos); - /* Free memory consumed by any intermediate result. */ - if (tmp_result) + /* + * Free memory consumed by any intermediate result. If recursive pass did't + * replace any relids, tmp_result point to the original set, not a copy. + */ + if (tmp_result != relids) bms_free(tmp_result); bms_free(parent_relids); pfree(appinfos); @@ -715,11 +729,11 @@ AppendRelInfo ** find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos) { AppendRelInfo **appinfos; + int nrooms = bms_num_members(relids); int cnt = 0; int i; - *nappinfos = bms_num_members(relids); - appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * *nappinfos); + appinfos = (AppendRelInfo **) palloc(sizeof(AppendRelInfo *) * nrooms); i = -1; while ((i = bms_next_member(relids, i)) >= 0) @@ -727,10 +741,11 @@ find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos) AppendRelInfo *appinfo = root->append_rel_array[i]; if (!appinfo) - elog(ERROR, "child rel %d not found in append_rel_array", i); + continue; appinfos[cnt++] = appinfo; } + *nappinfos = cnt; return appinfos; } diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c index cedb3848dd..17e215b72d 100644 --- a/src/backend/optimizer/util/pathnode.c +++ b/src/backend/optimizer/util/pathnode.c @@ -4225,7 +4225,14 @@ do { \ MemoryContextSwitchTo(oldcontext); } - bms_free(required_outer); + + /* + * If adjust_child_relids_multilevel don't do replacements it returns + * the original set, not a copy. It is possible in the case of asymmetric + * JOIN and child_rel->relids contains relids only of plane relations. + */ + if (required_outer != old_ppi->ppi_req_outer) + bms_free(required_outer); new_path->param_info = new_ppi; diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c index 47769cea45..ddf0f5a876 100644 --- a/src/backend/optimizer/util/relnode.c +++ b/src/backend/optimizer/util/relnode.c @@ -792,11 +792,8 @@ build_child_join_rel(PlannerInfo *root, RelOptInfo *outer_rel, AppendRelInfo **appinfos; int nappinfos; - /* Only joins between "other" relations land here. */ - Assert(IS_OTHER_REL(outer_rel) && IS_OTHER_REL(inner_rel)); - - /* The parent joinrel should have consider_partitionwise_join set. */ - Assert(parent_joinrel->consider_partitionwise_join); + /* Either of relations must be "other" relation at least. */ + Assert(IS_OTHER_REL(outer_rel) || IS_OTHER_REL(inner_rel)); joinrel->reloptkind = RELOPT_OTHER_JOINREL; joinrel->relids = bms_union(outer_rel->relids, inner_rel->relids); @@ -854,8 +851,11 @@ build_child_join_rel(PlannerInfo *root, RelOptInfo *outer_rel, joinrel->partexprs = NULL; joinrel->nullable_partexprs = NULL; - joinrel->top_parent_relids = bms_union(outer_rel->top_parent_relids, - inner_rel->top_parent_relids); + joinrel->top_parent_relids = + bms_union(IS_OTHER_REL(outer_rel) ? + outer_rel->top_parent_relids : outer_rel->relids, + IS_OTHER_REL(inner_rel) ? + inner_rel->top_parent_relids : inner_rel->relids); /* Compute information relevant to foreign relations. */ set_foreign_rel_properties(joinrel, outer_rel, inner_rel); @@ -2036,9 +2036,8 @@ build_child_join_reltarget(PlannerInfo *root, { /* Build the targetlist */ childrel->reltarget->exprs = (List *) - adjust_appendrel_attrs(root, - (Node *) parentrel->reltarget->exprs, - nappinfos, appinfos); + adjust_appendrel_attrs_multilevel(root, (Node *)parentrel->reltarget->exprs, + childrel->relids, parentrel->relids); /* Set the cost and width fields */ childrel->reltarget->cost.startup = parentrel->reltarget->cost.startup; diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h index f1d111063c..a0106dc539 100644 --- a/src/include/optimizer/paths.h +++ b/src/include/optimizer/paths.h @@ -109,7 +109,12 @@ extern bool have_join_order_restriction(PlannerInfo *root, extern bool have_dangerous_phv(PlannerInfo *root, Relids outer_relids, Relids inner_params); extern void mark_dummy_rel(RelOptInfo *rel); - +extern void try_asymmetric_partitionwise_join(PlannerInfo *root, + RelOptInfo *joinrel, + RelOptInfo *outer_rel, + RelOptInfo *inner_rel, + JoinType jointype, + JoinPathExtraData *extra); /* * equivclass.c * routines for managing EquivalenceClasses diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out index 27f7525b3e..327505676c 100644 --- a/src/test/regress/expected/partition_join.out +++ b/src/test/regress/expected/partition_join.out @@ -2320,6 +2320,384 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a = 375 | 0375 | 375 | 0375 (8 rows) +-- +-- For asymmetric partition-wise join +-- +CREATE TABLE prt5 (hkey int, a int, b int) PARTITION BY HASH(hkey); +CREATE TABLE prt5_p0 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 0); +CREATE TABLE prt5_p1 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 1); +CREATE TABLE prt5_p2 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 2); +CREATE TABLE prt6 (aid int, alabel text) PARTITION BY HASH(aid); +CREATE TABLE prt6_p0 PARTITION OF prt6 + FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prt6_p1 PARTITION OF prt6 + FOR VALUES WITH (modulus 2, remainder 1); +CREATE TABLE t5_1 (aid int, alabel text); +CREATE TABLE t5_2 (bid int, blabel text); +INSERT INTO prt5 (SELECT x, (x % 1000)::int, + ((x+1) % 1000)::int + FROM generate_series(1,1000000) x); +INSERT INTO t5_1 (SELECT x, md5(x::text) FROM generate_series(-200, 1500) x); +INSERT INTO t5_2 (SELECT x, md5(x::text) FROM generate_series(-200, 1500) x); +INSERT INTO prt6 (SELECT * FROM t5_1); +VACUUM ANALYZE prt5,prt6,t5_1,t5_2; +SET max_parallel_workers_per_gather = 0; +-- Trivial asymmetric JOIN of partitioned table with a relation +EXPLAIN (COSTS OFF) +SELECT * + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +------------------------------------------------------- + Append + -> Hash Join + Hash Cond: (prt5_1.a = t5_1.aid) + -> Seq Scan on prt5_p0 prt5_1 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) + -> Hash Join + Hash Cond: (prt5_2.a = t5_1.aid) + -> Seq Scan on prt5_p1 prt5_2 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) + -> Hash Join + Hash Cond: (prt5_3.a = t5_1.aid) + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) +(19 rows) + +-- The same, but appended with UNION ALL +EXPLAIN (COSTS OFF) +SELECT * FROM ( + (SELECT * FROM prt5_p0) + UNION ALL + (SELECT * FROM prt5_p1) + UNION ALL + (SELECT * FROM prt5_p2) + ) AS sq1 +JOIN t5_1 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +------------------------------------------------------- + Append + -> Hash Join + Hash Cond: (prt5_p0.a = t5_1.aid) + -> Seq Scan on prt5_p0 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) + -> Hash Join + Hash Cond: (prt5_p1.a = t5_1.aid) + -> Seq Scan on prt5_p1 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) + -> Hash Join + Hash Cond: (prt5_p2.a = t5_1.aid) + -> Seq Scan on prt5_p2 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) +(19 rows) + +-- Don't allow asymmetric JOIN of two partitioned tables. +EXPLAIN (COSTS OFF) +SELECT count(*) FROM prt5 JOIN prt6 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +------------------------------------------------------------- + Aggregate + -> Hash Join + Hash Cond: (prt5.a = prt6.aid) + -> Append + -> Seq Scan on prt5_p0 prt5_1 + -> Seq Scan on prt5_p1 prt5_2 + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Append + -> Seq Scan on prt6_p0 prt6_1 + Filter: (alabel ~~ '%abc%'::text) + -> Seq Scan on prt6_p1 prt6_2 + Filter: (alabel ~~ '%abc%'::text) +(13 rows) + +SELECT count(*) FROM prt5 JOIN prt6 ON a = aid AND alabel like '%abc%'; + count +------- + 4000 +(1 row) + +-- Check asymmetric JOIN with Subquery +EXPLAIN (COSTS OFF) +SELECT count(*) FROM prt5 JOIN ( + SELECT * FROM prt6 LIMIT 1000 +) AS sq1 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +---------------------------------------------------------------------- + Aggregate + -> Append + -> Hash Join + Hash Cond: (prt5_1.a = sq1.aid) + -> Seq Scan on prt5_p0 prt5_1 + -> Hash + -> Subquery Scan on sq1 + Filter: (sq1.alabel ~~ '%abc%'::text) + -> Limit + -> Append + -> Seq Scan on prt6_p0 prt6_1 + -> Seq Scan on prt6_p1 prt6_2 + -> Hash Join + Hash Cond: (prt5_2.a = sq1.aid) + -> Seq Scan on prt5_p1 prt5_2 + -> Hash + -> Subquery Scan on sq1 + Filter: (sq1.alabel ~~ '%abc%'::text) + -> Limit + -> Append + -> Seq Scan on prt6_p0 prt6_4 + -> Seq Scan on prt6_p1 prt6_5 + -> Hash Join + Hash Cond: (prt5_3.a = sq1.aid) + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Subquery Scan on sq1 + Filter: (sq1.alabel ~~ '%abc%'::text) + -> Limit + -> Append + -> Seq Scan on prt6_p0 prt6_7 + -> Seq Scan on prt6_p1 prt6_8 +(32 rows) + +SELECT count(*) FROM prt5 JOIN (SELECT * FROM prt6 LIMIT 1000) AS sq1 + ON a = aid AND alabel like '%abc%'; + count +------- + 2000 +(1 row) + +-- Asymmetric JOIN of two plane tables and one partitioned +EXPLAIN (COSTS OFF) +SELECT count(*) + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + QUERY PLAN +------------------------------------------------------------------ + Aggregate + -> Append + -> Hash Join + Hash Cond: (prt5_1.b = t5_2.bid) + -> Hash Join + Hash Cond: (prt5_1.a = t5_1.aid) + -> Seq Scan on prt5_p0 prt5_1 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%ab%'::text) + -> Hash + -> Seq Scan on t5_2 + Filter: (blabel ~~ '%cd%'::text) + -> Hash Join + Hash Cond: (prt5_2.b = t5_2.bid) + -> Hash Join + Hash Cond: (prt5_2.a = t5_1.aid) + -> Seq Scan on prt5_p1 prt5_2 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%ab%'::text) + -> Hash + -> Seq Scan on t5_2 + Filter: (blabel ~~ '%cd%'::text) + -> Hash Join + Hash Cond: (prt5_3.b = t5_2.bid) + -> Hash Join + Hash Cond: (prt5_3.a = t5_1.aid) + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%ab%'::text) + -> Hash + -> Seq Scan on t5_2 + Filter: (blabel ~~ '%cd%'::text) +(35 rows) + +SELECT count(*) + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + count +------- + 11000 +(1 row) + +-- unable to extract non-partitioned right relation +EXPLAIN (COSTS OFF) +SELECT * FROM prt5 RIGHT JOIN t5_1 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +----------------------------------------------- + Hash Right Join + Hash Cond: (prt5.a = t5_1.aid) + Join Filter: (t5_1.alabel ~~ '%abc%'::text) + -> Append + -> Seq Scan on prt5_p0 prt5_1 + -> Seq Scan on prt5_p1 prt5_2 + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Seq Scan on t5_1 +(9 rows) + +-- left side can be extracted, but no cost benefit +EXPLAIN (COSTS OFF) +SELECT * FROM prt5 LEFT JOIN t5_1 ON a = aid AND alabel like '%abc%'; + QUERY PLAN +------------------------------------------------- + Hash Left Join + Hash Cond: (prt5.a = t5_1.aid) + -> Append + -> Seq Scan on prt5_p0 prt5_1 + -> Seq Scan on prt5_p1 prt5_2 + -> Seq Scan on prt5_p2 prt5_3 + -> Hash + -> Seq Scan on t5_1 + Filter: (alabel ~~ '%abc%'::text) +(9 rows) + +-- validation of the results with/without asymmetric partition-wise join +SELECT * INTO pg_temp.result01a + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; +SELECT * INTO pg_temp.result02a + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; +SET enable_partitionwise_join = off; +SELECT * INTO pg_temp.result01b + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; +SELECT * INTO pg_temp.result02b + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; +SELECT * FROM pg_temp.result01a EXCEPT SELECT * FROM pg_temp.result01b; + hkey | a | b | aid | alabel +------+---+---+-----+-------- +(0 rows) + +SELECT * FROM pg_temp.result02a EXCEPT SELECT * FROM pg_temp.result02b; + hkey | a | b | aid | alabel | bid | blabel +------+---+---+-----+--------+-----+-------- +(0 rows) + +SET enable_partitionwise_join = on; +-- Check reparameterization code when required_outer set contains relid of plain +-- relation entry, not 'other' entry. +SET enable_hashjoin = 'off'; +SET enable_mergejoin = 'off'; +SET enable_material = 'off'; +CREATE TABLE big AS SELECT x AS x FROM generate_series(1,1E4) x; +CREATE INDEX ON big(x); +CREATE TABLE small AS SELECT x, -x AS y FROM generate_series(1,100) x; +CREATE TABLE part_l0 (x int, y int, z int) PARTITION BY HASH (y); +CREATE TABLE part0_l1 PARTITION OF part_l0 (y) + FOR VALUES WITH (modulus 2, remainder 0) PARTITION BY HASH (z); +CREATE TABLE part0_l2 PARTITION OF part0_l1 (z) + FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE part1_l2 PARTITION OF part0_l1 (z) + FOR VALUES WITH (modulus 2, remainder 1); +CREATE TABLE part1_l1 PARTITION OF part_l0 (y) + FOR VALUES WITH (modulus 2, remainder 1); +INSERT INTO part_l0 (x, y, z) (SELECT x,x,x FROM generate_series(1,1E4) x); +ANALYZE big,small,part_l0; +EXPLAIN +SELECT small.* FROM small + JOIN part_l0 ON small.y = part_l0.y AND small.y + part_l0.y < 10 + LEFT JOIN big ON big.x = small.x; + QUERY PLAN +----------------------------------------------------------------------------------------- + Nested Loop Left Join (cost=0.29..33230.19 rows=33 width=8) + -> Append (cost=0.00..33008.08 rows=67 width=8) + -> Nested Loop (cost=0.00..16604.25 rows=33 width=8) + Join Filter: ((small.y = part_l0_1.y) AND ((small.y + part_l0_1.y) < 10)) + -> Seq Scan on small (cost=0.00..2.00 rows=100 width=8) + -> Seq Scan on part0_l2 part_l0_1 (cost=0.00..78.19 rows=5019 width=4) + -> Nested Loop (cost=0.00..3.75 rows=1 width=8) + Join Filter: ((small.y = part_l0_2.y) AND ((small.y + part_l0_2.y) < 10)) + -> Seq Scan on part1_l2 part_l0_2 (cost=0.00..0.00 rows=1 width=4) + -> Seq Scan on small (cost=0.00..2.00 rows=100 width=8) + -> Nested Loop (cost=0.00..16399.75 rows=33 width=8) + Join Filter: ((small.y = part_l0_3.y) AND ((small.y + part_l0_3.y) < 10)) + -> Seq Scan on small (cost=0.00..2.00 rows=100 width=8) + -> Seq Scan on part1_l1 part_l0_3 (cost=0.00..76.81 rows=4981 width=4) + -> Index Only Scan using big_x_idx on big (cost=0.29..3.31 rows=1 width=5) + Index Cond: (x = (small.x)::numeric) +(16 rows) + +DROP TABLE IF EXISTS big,small,part_l0 CASCADE; +RESET enable_hashjoin; +RESET enable_mergejoin; +RESET enable_material; +RESET max_parallel_workers_per_gather; +-- Parameterized path examples. +CREATE TABLE prta (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE prta1 PARTITION OF prta FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prta2 PARTITION OF prta FOR VALUES WITH (modulus 2, remainder 1); +CREATE UNIQUE INDEX ON prta1 (id); +CREATE UNIQUE INDEX ON prta2 (id); +INSERT INTO prta (id, payload) + (SELECT *, ('abc' || id)::text AS payload + FROM generate_series(1,1) AS id); +CREATE TABLE prtb (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE prtb1 PARTITION OF prtb FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prtb2 PARTITION OF prtb FOR VALUES WITH (modulus 2, remainder 1); +CREATE UNIQUE INDEX ON prtb1 (id); +CREATE UNIQUE INDEX ON prtb2 (id); +INSERT INTO prtb (id, payload) + (SELECT *, ('def' || id)::text AS payload + FROM generate_series(1,1000) AS id); +CREATE TABLE e (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE e1 PARTITION OF e FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE e2 PARTITION OF e FOR VALUES WITH (modulus 2, remainder 1); +INSERT INTO e (id, payload) + (SELECT *, ('ghi' || id)::text AS payload + FROM generate_series(1,1000) AS id); +CREATE UNIQUE INDEX ON e1 (id); +CREATE UNIQUE INDEX ON e2 (id); +ANALYZE prta,prtb,e; +EXPLAIN (COSTS OFF) +SELECT * FROM prta,prtb WHERE prta.id=prtb.id; + QUERY PLAN +----------------------------------------------------------- + Append + -> Nested Loop + -> Seq Scan on prta1 prta_1 + -> Index Scan using prtb1_id_idx on prtb1 prtb_1 + Index Cond: (id = prta_1.id) + -> Nested Loop + -> Seq Scan on prta2 prta_2 + -> Index Scan using prtb2_id_idx on prtb2 prtb_2 + Index Cond: (id = prta_2.id) +(9 rows) + +EXPLAIN (COSTS OFF) +SELECT * FROM prta,prtb,e WHERE prta.id=prtb.id AND prta.id=e.id; + QUERY PLAN +----------------------------------------------------------------- + Append + -> Nested Loop + Join Filter: (prta_1.id = e_1.id) + -> Nested Loop + -> Seq Scan on prta1 prta_1 + -> Index Scan using prtb1_id_idx on prtb1 prtb_1 + Index Cond: (id = prta_1.id) + -> Index Scan using e1_id_idx on e1 e_1 + Index Cond: (id = prtb_1.id) + -> Nested Loop + Join Filter: (prta_2.id = e_2.id) + -> Nested Loop + -> Seq Scan on prta2 prta_2 + -> Index Scan using prtb2_id_idx on prtb2 prtb_2 + Index Cond: (id = prta_2.id) + -> Index Scan using e2_id_idx on e2 e_2 + Index Cond: (id = prtb_2.id) +(17 rows) + -- semi join EXPLAIN (COSTS OFF) SELECT t1.* FROM prt1_adv t1 WHERE EXISTS (SELECT 1 FROM prt2_adv t2 WHERE t1.a = t2.b) AND t1.b = 0 ORDER BY t1.a; diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql index d97b5b69ff..364b3216f8 100644 --- a/src/test/regress/sql/partition_join.sql +++ b/src/test/regress/sql/partition_join.sql @@ -536,6 +536,173 @@ EXPLAIN (COSTS OFF) SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a = t2.b) WHERE t1.b = 0 ORDER BY t1.a, t2.b; SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_adv t1 INNER JOIN prt2_adv t2 ON (t1.a = t2.b) WHERE t1.b = 0 ORDER BY t1.a, t2.b; +-- +-- For asymmetric partition-wise join +-- +CREATE TABLE prt5 (hkey int, a int, b int) PARTITION BY HASH(hkey); +CREATE TABLE prt5_p0 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 0); +CREATE TABLE prt5_p1 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 1); +CREATE TABLE prt5_p2 PARTITION OF prt5 + FOR VALUES WITH (modulus 3, remainder 2); +CREATE TABLE prt6 (aid int, alabel text) PARTITION BY HASH(aid); +CREATE TABLE prt6_p0 PARTITION OF prt6 + FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prt6_p1 PARTITION OF prt6 + FOR VALUES WITH (modulus 2, remainder 1); +CREATE TABLE t5_1 (aid int, alabel text); +CREATE TABLE t5_2 (bid int, blabel text); + +INSERT INTO prt5 (SELECT x, (x % 1000)::int, + ((x+1) % 1000)::int + FROM generate_series(1,1000000) x); +INSERT INTO t5_1 (SELECT x, md5(x::text) FROM generate_series(-200, 1500) x); +INSERT INTO t5_2 (SELECT x, md5(x::text) FROM generate_series(-200, 1500) x); +INSERT INTO prt6 (SELECT * FROM t5_1); + +VACUUM ANALYZE prt5,prt6,t5_1,t5_2; + +SET max_parallel_workers_per_gather = 0; + +-- Trivial asymmetric JOIN of partitioned table with a relation +EXPLAIN (COSTS OFF) +SELECT * + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +-- The same, but appended with UNION ALL +EXPLAIN (COSTS OFF) +SELECT * FROM ( + (SELECT * FROM prt5_p0) + UNION ALL + (SELECT * FROM prt5_p1) + UNION ALL + (SELECT * FROM prt5_p2) + ) AS sq1 +JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +-- Don't allow asymmetric JOIN of two partitioned tables. +EXPLAIN (COSTS OFF) +SELECT count(*) FROM prt5 JOIN prt6 ON a = aid AND alabel like '%abc%'; +SELECT count(*) FROM prt5 JOIN prt6 ON a = aid AND alabel like '%abc%'; + +-- Check asymmetric JOIN with Subquery +EXPLAIN (COSTS OFF) +SELECT count(*) FROM prt5 JOIN ( + SELECT * FROM prt6 LIMIT 1000 +) AS sq1 ON a = aid AND alabel like '%abc%'; +SELECT count(*) FROM prt5 JOIN (SELECT * FROM prt6 LIMIT 1000) AS sq1 + ON a = aid AND alabel like '%abc%'; + +-- Asymmetric JOIN of two plane tables and one partitioned +EXPLAIN (COSTS OFF) +SELECT count(*) + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; +SELECT count(*) + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + +-- unable to extract non-partitioned right relation +EXPLAIN (COSTS OFF) +SELECT * FROM prt5 RIGHT JOIN t5_1 ON a = aid AND alabel like '%abc%'; +-- left side can be extracted, but no cost benefit +EXPLAIN (COSTS OFF) +SELECT * FROM prt5 LEFT JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +-- validation of the results with/without asymmetric partition-wise join +SELECT * INTO pg_temp.result01a + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +SELECT * INTO pg_temp.result02a + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + +SET enable_partitionwise_join = off; + +SELECT * INTO pg_temp.result01b + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%abc%'; + +SELECT * INTO pg_temp.result02b + FROM prt5 JOIN t5_1 ON a = aid AND alabel like '%ab%' + JOIN t5_2 ON b = bid AND blabel like '%cd%'; + +SELECT * FROM pg_temp.result01a EXCEPT SELECT * FROM pg_temp.result01b; +SELECT * FROM pg_temp.result02a EXCEPT SELECT * FROM pg_temp.result02b; + +SET enable_partitionwise_join = on; + +-- Check reparameterization code when required_outer set contains relid of plain +-- relation entry, not 'other' entry. + +SET enable_hashjoin = 'off'; +SET enable_mergejoin = 'off'; +SET enable_material = 'off'; + +CREATE TABLE big AS SELECT x AS x FROM generate_series(1,1E4) x; +CREATE INDEX ON big(x); +CREATE TABLE small AS SELECT x, -x AS y FROM generate_series(1,100) x; + +CREATE TABLE part_l0 (x int, y int, z int) PARTITION BY HASH (y); +CREATE TABLE part0_l1 PARTITION OF part_l0 (y) + FOR VALUES WITH (modulus 2, remainder 0) PARTITION BY HASH (z); +CREATE TABLE part0_l2 PARTITION OF part0_l1 (z) + FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE part1_l2 PARTITION OF part0_l1 (z) + FOR VALUES WITH (modulus 2, remainder 1); +CREATE TABLE part1_l1 PARTITION OF part_l0 (y) + FOR VALUES WITH (modulus 2, remainder 1); +INSERT INTO part_l0 (x, y, z) (SELECT x,x,x FROM generate_series(1,1E4) x); + +ANALYZE big,small,part_l0; + +EXPLAIN +SELECT small.* FROM small + JOIN part_l0 ON small.y = part_l0.y AND small.y + part_l0.y < 10 + LEFT JOIN big ON big.x = small.x; + +DROP TABLE IF EXISTS big,small,part_l0 CASCADE; +RESET enable_hashjoin; +RESET enable_mergejoin; +RESET enable_material; +RESET max_parallel_workers_per_gather; + +-- Parameterized path examples. +CREATE TABLE prta (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE prta1 PARTITION OF prta FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prta2 PARTITION OF prta FOR VALUES WITH (modulus 2, remainder 1); +CREATE UNIQUE INDEX ON prta1 (id); +CREATE UNIQUE INDEX ON prta2 (id); +INSERT INTO prta (id, payload) + (SELECT *, ('abc' || id)::text AS payload + FROM generate_series(1,1) AS id); + +CREATE TABLE prtb (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE prtb1 PARTITION OF prtb FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE prtb2 PARTITION OF prtb FOR VALUES WITH (modulus 2, remainder 1); +CREATE UNIQUE INDEX ON prtb1 (id); +CREATE UNIQUE INDEX ON prtb2 (id); +INSERT INTO prtb (id, payload) + (SELECT *, ('def' || id)::text AS payload + FROM generate_series(1,1000) AS id); + +CREATE TABLE e (id integer, payload text) PARTITION BY HASH (id); +CREATE TABLE e1 PARTITION OF e FOR VALUES WITH (modulus 2, remainder 0); +CREATE TABLE e2 PARTITION OF e FOR VALUES WITH (modulus 2, remainder 1); +INSERT INTO e (id, payload) + (SELECT *, ('ghi' || id)::text AS payload + FROM generate_series(1,1000) AS id); +CREATE UNIQUE INDEX ON e1 (id); +CREATE UNIQUE INDEX ON e2 (id); + +ANALYZE prta,prtb,e; + +EXPLAIN (COSTS OFF) +SELECT * FROM prta,prtb WHERE prta.id=prtb.id; + +EXPLAIN (COSTS OFF) +SELECT * FROM prta,prtb,e WHERE prta.id=prtb.id AND prta.id=e.id; + -- semi join EXPLAIN (COSTS OFF) SELECT t1.* FROM prt1_adv t1 WHERE EXISTS (SELECT 1 FROM prt2_adv t2 WHERE t1.a = t2.b) AND t1.b = 0 ORDER BY t1.a; -- 2.25.1 --------------3592BFA68FFAC61CCE0AF115-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH v4 1/1] remove toast reloptions @ 2026-04-07 20:30 Nathan Bossart <nathan@postgresql.org> 0 siblings, 0 replies; 383+ messages in thread From: Nathan Bossart @ 2026-04-07 20:30 UTC (permalink / raw) --- doc/src/sgml/ref/create_table.sgml | 51 ++++++------- src/backend/access/common/reloptions.c | 49 +++++------- src/backend/catalog/toasting.c | 31 ++++---- src/backend/commands/createas.c | 13 +--- src/backend/commands/repack.c | 15 +--- src/backend/commands/tablecmds.c | 19 +---- src/backend/commands/vacuum.c | 14 +--- src/backend/postmaster/autovacuum.c | 48 +++++------- src/backend/tcop/utility.c | 19 +---- src/bin/pg_upgrade/check.c | 75 +++++++++++++++++++ src/include/access/reloptions.h | 24 +++--- src/include/catalog/toasting.h | 6 +- .../injection_points/expected/vacuum.out | 24 +++--- .../modules/injection_points/sql/vacuum.sql | 20 ++--- src/test/regress/expected/alter_table.out | 9 --- src/test/regress/expected/reloptions.out | 56 ++------------ src/test/regress/expected/vacuum.out | 8 -- src/test/regress/sql/alter_table.sql | 4 - src/test/regress/sql/reloptions.sql | 32 +------- src/test/regress/sql/vacuum.sql | 8 -- 20 files changed, 199 insertions(+), 326 deletions(-) diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index e342585c7f0..b8d2a657d10 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -1589,14 +1589,10 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM Storage parameters for indexes are documented in <xref linkend="sql-createindex"/>. The storage parameters currently - available for tables are listed below. For many of these parameters, as - shown, there is an additional parameter with the same name prefixed with - <literal>toast.</literal>, which controls the behavior of the + available for tables are listed below. Unless otherwise noted, a table's + parameter value also controls the behavior of the table's secondary <acronym>TOAST</acronym> table, if any (see <xref linkend="storage-toast"/> for more information about TOAST). - If a table parameter value is set and the - equivalent <literal>toast.</literal> parameter is not, the TOAST table - will use the table's parameter value. Specifying these parameters for partitioned tables is not supported, but you may specify them for individual leaf partitions. </para> @@ -1622,7 +1618,8 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM updates</link> more likely. For a table whose entries are never updated, complete packing is the best choice, but in heavily updated tables smaller fillfactors are - appropriate. This parameter cannot be set for TOAST tables. + appropriate. This parameter does not affect the table's secondary TOAST + table. </para> </listitem> </varlistentry> @@ -1648,7 +1645,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM Note that the default setting is often close to optimal, and it is possible that setting this parameter could have negative effects in some cases. - This parameter cannot be set for TOAST tables. + This parameter does not affect the table's secondary TOAST table. </para> </listitem> </varlistentry> @@ -1671,7 +1668,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-enabled" xreflabel="autovacuum_enabled"> - <term><literal>autovacuum_enabled</literal>, <literal>toast.autovacuum_enabled</literal> (<type>boolean</type>) + <term><literal>autovacuum_enabled</literal> (<type>boolean</type>) <indexterm> <primary><varname>autovacuum_enabled</varname> storage parameter</primary> </indexterm> @@ -1696,7 +1693,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-vacuum-index-cleanup" xreflabel="vacuum_index_cleanup"> - <term><literal>vacuum_index_cleanup</literal>, <literal>toast.vacuum_index_cleanup</literal> (<type>enum</type>) + <term><literal>vacuum_index_cleanup</literal> (<type>enum</type>) <indexterm> <primary><varname>vacuum_index_cleanup</varname> storage parameter</primary> </indexterm> @@ -1722,7 +1719,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-vacuum-truncate" xreflabel="vacuum_truncate"> - <term><literal>vacuum_truncate</literal>, <literal>toast.vacuum_truncate</literal> (<type>boolean</type>) + <term><literal>vacuum_truncate</literal> (<type>boolean</type>) <indexterm> <primary><varname>vacuum_truncate</varname></primary> <secondary>storage parameter</secondary> @@ -1755,7 +1752,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-vacuum-threshold" xreflabel="autovacuum_vacuum_threshold"> - <term><literal>autovacuum_vacuum_threshold</literal>, <literal>toast.autovacuum_vacuum_threshold</literal> (<type>integer</type>) + <term><literal>autovacuum_vacuum_threshold</literal> (<type>integer</type>) <indexterm> <primary><varname>autovacuum_vacuum_threshold</varname></primary> <secondary>storage parameter</secondary> @@ -1770,7 +1767,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-vacuum-max-threshold" xreflabel="autovacuum_vacuum_max_threshold"> - <term><literal>autovacuum_vacuum_max_threshold</literal>, <literal>toast.autovacuum_vacuum_max_threshold</literal> (<type>integer</type>) + <term><literal>autovacuum_vacuum_max_threshold</literal> (<type>integer</type>) <indexterm> <primary><varname>autovacuum_vacuum_max_threshold</varname></primary> <secondary>storage parameter</secondary> @@ -1785,7 +1782,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-vacuum-scale-factor" xreflabel="autovacuum_vacuum_scale_factor"> - <term><literal>autovacuum_vacuum_scale_factor</literal>, <literal>toast.autovacuum_vacuum_scale_factor</literal> (<type>floating point</type>) + <term><literal>autovacuum_vacuum_scale_factor</literal> (<type>floating point</type>) <indexterm> <primary><varname>autovacuum_vacuum_scale_factor</varname> </primary> <secondary>storage parameter</secondary> @@ -1800,7 +1797,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-vacuum-insert-threshold" xreflabel="autovacuum_vacuum_insert_threshold"> - <term><literal>autovacuum_vacuum_insert_threshold</literal>, <literal>toast.autovacuum_vacuum_insert_threshold</literal> (<type>integer</type>) + <term><literal>autovacuum_vacuum_insert_threshold</literal> (<type>integer</type>) <indexterm> <primary><varname>autovacuum_vacuum_insert_threshold</varname></primary> <secondary>storage parameter</secondary> @@ -1815,7 +1812,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-vacuum-insert-scale-factor" xreflabel="autovacuum_vacuum_insert_scale_factor"> - <term><literal>autovacuum_vacuum_insert_scale_factor</literal>, <literal>toast.autovacuum_vacuum_insert_scale_factor</literal> (<type>floating point</type>) + <term><literal>autovacuum_vacuum_insert_scale_factor</literal> (<type>floating point</type>) <indexterm> <primary><varname>autovacuum_vacuum_insert_scale_factor</varname> </primary> <secondary>storage parameter</secondary> @@ -1860,7 +1857,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-vacuum-cost-delay" xreflabel="autovacuum_vacuum_cost_delay"> - <term><literal>autovacuum_vacuum_cost_delay</literal>, <literal>toast.autovacuum_vacuum_cost_delay</literal> (<type>floating point</type>) + <term><literal>autovacuum_vacuum_cost_delay</literal> (<type>floating point</type>) <indexterm> <primary><varname>autovacuum_vacuum_cost_delay</varname></primary> <secondary>storage parameter</secondary> @@ -1875,7 +1872,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-vacuum-cost-limit" xreflabel="autovacuum_vacuum_cost_limit"> - <term><literal>autovacuum_vacuum_cost_limit</literal>, <literal>toast.autovacuum_vacuum_cost_limit</literal> (<type>integer</type>) + <term><literal>autovacuum_vacuum_cost_limit</literal> (<type>integer</type>) <indexterm> <primary><varname>autovacuum_vacuum_cost_limit</varname></primary> <secondary>storage parameter</secondary> @@ -1890,7 +1887,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-freeze-min-age" xreflabel="autovacuum_freeze_min_age"> - <term><literal>autovacuum_freeze_min_age</literal>, <literal>toast.autovacuum_freeze_min_age</literal> (<type>integer</type>) + <term><literal>autovacuum_freeze_min_age</literal> (<type>integer</type>) <indexterm> <primary><varname>autovacuum_freeze_min_age</varname> storage parameter</primary> </indexterm> @@ -1907,7 +1904,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-freeze-max-age" xreflabel="autovacuum_freeze_max_age"> - <term><literal>autovacuum_freeze_max_age</literal>, <literal>toast.autovacuum_freeze_max_age</literal> (<type>integer</type>) + <term><literal>autovacuum_freeze_max_age</literal> (<type>integer</type>) <indexterm> <primary><varname>autovacuum_freeze_max_age</varname></primary> <secondary>storage parameter</secondary> @@ -1924,7 +1921,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-freeze-table-age" xreflabel="autovacuum_freeze_table_age"> - <term><literal>autovacuum_freeze_table_age</literal>, <literal>toast.autovacuum_freeze_table_age</literal> (<type>integer</type>) + <term><literal>autovacuum_freeze_table_age</literal> (<type>integer</type>) <indexterm> <primary><varname>autovacuum_freeze_table_age</varname> storage parameter</primary> </indexterm> @@ -1938,7 +1935,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-multixact-freeze-min-age" xreflabel="autovacuum_multixact_freeze_min_age"> - <term><literal>autovacuum_multixact_freeze_min_age</literal>, <literal>toast.autovacuum_multixact_freeze_min_age</literal> (<type>integer</type>) + <term><literal>autovacuum_multixact_freeze_min_age</literal> (<type>integer</type>) <indexterm> <primary><varname>autovacuum_multixact_freeze_min_age</varname> storage parameter</primary> </indexterm> @@ -1956,7 +1953,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-multixact-freeze-max-age" xreflabel="autovacuum_multixact_freeze_max_age"> - <term><literal>autovacuum_multixact_freeze_max_age</literal>, <literal>toast.autovacuum_multixact_freeze_max_age</literal> (<type>integer</type>) + <term><literal>autovacuum_multixact_freeze_max_age</literal> (<type>integer</type>) <indexterm> <primary><varname>autovacuum_multixact_freeze_max_age</varname></primary> <secondary>storage parameter</secondary> @@ -1975,7 +1972,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-autovacuum-multixact-freeze-table-age" xreflabel="autovacuum_multixact_freeze_table_age"> - <term><literal>autovacuum_multixact_freeze_table_age</literal>, <literal>toast.autovacuum_multixact_freeze_table_age</literal> (<type>integer</type>) + <term><literal>autovacuum_multixact_freeze_table_age</literal> (<type>integer</type>) <indexterm> <primary><varname>autovacuum_multixact_freeze_table_age</varname> storage parameter</primary> </indexterm> @@ -1989,7 +1986,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-log-autovacuum-min-duration" xreflabel="log_autovacuum_min_duration"> - <term><literal>log_autovacuum_min_duration</literal>, <literal>toast.log_autovacuum_min_duration</literal> (<type>integer</type>) + <term><literal>log_autovacuum_min_duration</literal> (<type>integer</type>) <indexterm> <primary><varname>log_autovacuum_min_duration</varname></primary> <secondary>storage parameter</secondary> @@ -2019,7 +2016,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM </varlistentry> <varlistentry id="reloption-vacuum-max-eager-freeze-failure-rate" xreflabel="vacuum_max_eager_freeze_failure_rate"> - <term><literal>vacuum_max_eager_freeze_failure_rate</literal>, <literal>toast.vacuum_max_eager_freeze_failure_rate</literal> (<type>floating point</type>) + <term><literal>vacuum_max_eager_freeze_failure_rate</literal> (<type>floating point</type>) <indexterm> <primary><varname>vacuum_max_eager_freeze_failure_rate</varname></primary> <secondary>storage parameter</secondary> @@ -2044,7 +2041,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM Declare the table as an additional catalog table for purposes of logical replication. See <xref linkend="logicaldecoding-capabilities"/> for details. - This parameter cannot be set for TOAST tables. + This parameter does not affect the table's secondary TOAST table. </para> </listitem> </varlistentry> diff --git a/src/backend/access/common/reloptions.c b/src/backend/access/common/reloptions.c index 3e832c3797e..50d9805f3d8 100644 --- a/src/backend/access/common/reloptions.c +++ b/src/backend/access/common/reloptions.c @@ -111,7 +111,7 @@ static relopt_bool boolRelOpts[] = { "autovacuum_enabled", "Enables autovacuum in this relation", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, true @@ -172,7 +172,7 @@ static relopt_ternary ternaryRelOpts[] = { "vacuum_truncate", "Enables vacuum to truncate empty pages at the end of this table", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock } }, @@ -249,7 +249,7 @@ static relopt_int intRelOpts[] = { "autovacuum_vacuum_threshold", "Minimum number of tuple updates or deletes prior to vacuum", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -1, 0, INT_MAX @@ -258,7 +258,7 @@ static relopt_int intRelOpts[] = { "autovacuum_vacuum_max_threshold", "Maximum number of tuple updates or deletes prior to vacuum", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -2, -1, INT_MAX @@ -267,7 +267,7 @@ static relopt_int intRelOpts[] = { "autovacuum_vacuum_insert_threshold", "Minimum number of tuple inserts prior to vacuum, or -1 to disable insert vacuums", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -2, -1, INT_MAX @@ -285,7 +285,7 @@ static relopt_int intRelOpts[] = { "autovacuum_vacuum_cost_limit", "Vacuum cost amount available before napping, for autovacuum", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -1, 1, 10000 @@ -294,7 +294,7 @@ static relopt_int intRelOpts[] = { "autovacuum_freeze_min_age", "Minimum age at which VACUUM should freeze a table row, for autovacuum", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -1, 0, 1000000000 @@ -303,7 +303,7 @@ static relopt_int intRelOpts[] = { "autovacuum_multixact_freeze_min_age", "Minimum multixact age at which VACUUM should freeze a row multixact's, for autovacuum", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -1, 0, 1000000000 @@ -312,7 +312,7 @@ static relopt_int intRelOpts[] = { "autovacuum_freeze_max_age", "Age at which to autovacuum a table to prevent transaction ID wraparound", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -1, 100000, 2000000000 @@ -321,7 +321,7 @@ static relopt_int intRelOpts[] = { "autovacuum_multixact_freeze_max_age", "Multixact age at which to autovacuum a table to prevent multixact wraparound", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -1, 10000, 2000000000 @@ -330,7 +330,7 @@ static relopt_int intRelOpts[] = { "autovacuum_freeze_table_age", "Age at which VACUUM should perform a full table sweep to freeze row versions", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -1, 0, 2000000000 }, @@ -338,7 +338,7 @@ static relopt_int intRelOpts[] = { "autovacuum_multixact_freeze_table_age", "Age of multixact at which VACUUM should perform a full table sweep to freeze row versions", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -1, 0, 2000000000 }, @@ -346,7 +346,7 @@ static relopt_int intRelOpts[] = { "log_autovacuum_min_duration", "Sets the minimum execution time above which vacuum actions by autovacuum will be logged", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -1, -1, INT_MAX @@ -424,7 +424,7 @@ static relopt_real realRelOpts[] = { "autovacuum_vacuum_cost_delay", "Vacuum cost delay in milliseconds, for autovacuum", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -1, 0.0, 100.0 @@ -433,7 +433,7 @@ static relopt_real realRelOpts[] = { "autovacuum_vacuum_scale_factor", "Number of tuple updates or deletes prior to vacuum as a fraction of reltuples", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -1, 0.0, 100.0 @@ -442,7 +442,7 @@ static relopt_real realRelOpts[] = { "autovacuum_vacuum_insert_scale_factor", "Number of tuple inserts prior to vacuum as a fraction of reltuples", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -1, 0.0, 100.0 @@ -460,7 +460,7 @@ static relopt_real realRelOpts[] = { "vacuum_max_eager_freeze_failure_rate", "Fraction of pages in a relation vacuum can scan and fail to freeze before disabling eager scanning.", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, -1, 0.0, 1.0 @@ -554,7 +554,7 @@ static relopt_enum enumRelOpts[] = { "vacuum_index_cleanup", "Controls index vacuuming and index cleanup", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, + RELOPT_KIND_HEAP, ShareUpdateExclusiveLock }, StdRdOptIndexCleanupValues, @@ -2163,21 +2163,8 @@ view_reloptions(Datum reloptions, bool validate) bytea * heap_reloptions(char relkind, Datum reloptions, bool validate) { - StdRdOptions *rdopts; - switch (relkind) { - case RELKIND_TOASTVALUE: - rdopts = (StdRdOptions *) - default_reloptions(reloptions, validate, RELOPT_KIND_TOAST); - if (rdopts != NULL) - { - /* adjust default-only parameters for TOAST relations */ - rdopts->fillfactor = 100; - rdopts->autovacuum.analyze_threshold = -1; - rdopts->autovacuum.analyze_scale_factor = -1; - } - return (bytea *) rdopts; case RELKIND_RELATION: case RELKIND_MATVIEW: return default_reloptions(reloptions, validate, RELOPT_KIND_HEAP); diff --git a/src/backend/catalog/toasting.c b/src/backend/catalog/toasting.c index 4aa52a4bd25..9f1f822702c 100644 --- a/src/backend/catalog/toasting.c +++ b/src/backend/catalog/toasting.c @@ -34,11 +34,11 @@ #include "utils/rel.h" #include "utils/syscache.h" -static void CheckAndCreateToastTable(Oid relOid, Datum reloptions, +static void CheckAndCreateToastTable(Oid relOid, LOCKMODE lockmode, bool check, Oid OIDOldToast); static bool create_toast_table(Relation rel, Oid toastOid, Oid toastIndexOid, - Datum reloptions, LOCKMODE lockmode, bool check, + LOCKMODE lockmode, bool check, Oid OIDOldToast); static bool needs_toast_table(Relation rel); @@ -48,35 +48,30 @@ static bool needs_toast_table(Relation rel); * If the table needs a toast table, and doesn't already have one, * then create a toast table for it. * - * reloptions for the toast table can be passed, too. Pass (Datum) 0 - * for default reloptions. - * * We expect the caller to have verified that the relation is a table and have * already done any necessary permission checks. Callers expect this function * to end with CommandCounterIncrement if it makes any changes. */ void -AlterTableCreateToastTable(Oid relOid, Datum reloptions, LOCKMODE lockmode) +AlterTableCreateToastTable(Oid relOid, LOCKMODE lockmode) { - CheckAndCreateToastTable(relOid, reloptions, lockmode, true, InvalidOid); + CheckAndCreateToastTable(relOid, lockmode, true, InvalidOid); } void -NewHeapCreateToastTable(Oid relOid, Datum reloptions, LOCKMODE lockmode, - Oid OIDOldToast) +NewHeapCreateToastTable(Oid relOid, LOCKMODE lockmode, Oid OIDOldToast) { - CheckAndCreateToastTable(relOid, reloptions, lockmode, false, OIDOldToast); + CheckAndCreateToastTable(relOid, lockmode, false, OIDOldToast); } void -NewRelationCreateToastTable(Oid relOid, Datum reloptions) +NewRelationCreateToastTable(Oid relOid) { - CheckAndCreateToastTable(relOid, reloptions, AccessExclusiveLock, false, - InvalidOid); + CheckAndCreateToastTable(relOid, AccessExclusiveLock, false, InvalidOid); } static void -CheckAndCreateToastTable(Oid relOid, Datum reloptions, LOCKMODE lockmode, +CheckAndCreateToastTable(Oid relOid, LOCKMODE lockmode, bool check, Oid OIDOldToast) { Relation rel; @@ -84,7 +79,7 @@ CheckAndCreateToastTable(Oid relOid, Datum reloptions, LOCKMODE lockmode, rel = table_open(relOid, lockmode); /* create_toast_table does all the work */ - (void) create_toast_table(rel, InvalidOid, InvalidOid, reloptions, lockmode, + (void) create_toast_table(rel, InvalidOid, InvalidOid, lockmode, check, OIDOldToast); table_close(rel, NoLock); @@ -108,7 +103,7 @@ BootstrapToastTable(char *relName, Oid toastOid, Oid toastIndexOid) relName); /* create_toast_table does all the work */ - if (!create_toast_table(rel, toastOid, toastIndexOid, (Datum) 0, + if (!create_toast_table(rel, toastOid, toastIndexOid, AccessExclusiveLock, false, InvalidOid)) elog(ERROR, "\"%s\" does not require a toast table", relName); @@ -126,7 +121,7 @@ BootstrapToastTable(char *relName, Oid toastOid, Oid toastIndexOid) */ static bool create_toast_table(Relation rel, Oid toastOid, Oid toastIndexOid, - Datum reloptions, LOCKMODE lockmode, bool check, + LOCKMODE lockmode, bool check, Oid OIDOldToast) { Oid relOid = RelationGetRelid(rel); @@ -266,7 +261,7 @@ create_toast_table(Relation rel, Oid toastOid, Oid toastIndexOid, shared_relation, mapped_relation, ONCOMMIT_NOOP, - reloptions, + (Datum) 0, false, true, true, diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c index 6dbb831ca89..188e167999b 100644 --- a/src/backend/commands/createas.c +++ b/src/backend/commands/createas.c @@ -84,8 +84,6 @@ create_ctas_internal(List *attrList, IntoClause *into) CreateStmt *create = makeNode(CreateStmt); bool is_matview; char relkind; - Datum toast_options; - const char *const validnsps[] = HEAP_RELOPT_NAMESPACES; ObjectAddress intoRelationAddr; /* This code supports both CREATE TABLE AS and CREATE MATERIALIZED VIEW */ @@ -120,16 +118,7 @@ create_ctas_internal(List *attrList, IntoClause *into) */ CommandCounterIncrement(); - /* parse and validate reloptions for the toast table */ - toast_options = transformRelOptions((Datum) 0, - create->options, - "toast", - validnsps, - true, false); - - (void) heap_reloptions(RELKIND_TOASTVALUE, toast_options, true); - - NewRelationCreateToastTable(intoRelationAddr.objectId, toast_options); + NewRelationCreateToastTable(intoRelationAddr.objectId); /* Create the "view" part of a materialized view. */ if (is_matview) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 9a199dd9bfb..3b80d331815 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -1201,20 +1201,7 @@ make_new_heap(Oid OIDOldHeap, Oid NewTableSpace, Oid NewAccessMethod, */ toastid = OldHeap->rd_rel->reltoastrelid; if (OidIsValid(toastid)) - { - /* keep the existing toast table's reloptions, if any */ - tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(toastid)); - if (!HeapTupleIsValid(tuple)) - elog(ERROR, "cache lookup failed for relation %u", toastid); - reloptions = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_reloptions, - &isNull); - if (isNull) - reloptions = (Datum) 0; - - NewHeapCreateToastTable(OIDNewHeap, reloptions, lockmode, toastid); - - ReleaseSysCache(tuple); - } + NewHeapCreateToastTable(OIDNewHeap, lockmode, toastid); table_close(OldHeap, NoLock); diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index d8d7969bf30..a254509cbb5 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -827,7 +827,6 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, ListCell *listptr; AttrNumber attnum; bool partitioned; - const char *const validnsps[] = HEAP_RELOPT_NAMESPACES; Oid ofTypeId; ObjectAddress address; LOCKMODE parentLockmode; @@ -976,7 +975,7 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, /* * Parse and validate reloptions, if any. */ - reloptions = transformRelOptions((Datum) 0, stmt->options, NULL, validnsps, + reloptions = transformRelOptions((Datum) 0, stmt->options, NULL, NULL, true, false); switch (relkind) @@ -5433,7 +5432,7 @@ ATRewriteCatalogs(List **wqueue, LOCKMODE lockmode, tab->relkind == RELKIND_PARTITIONED_TABLE) && tab->partition_constraint == NULL) || tab->relkind == RELKIND_MATVIEW) - AlterTableCreateToastTable(tab->relid, (Datum) 0, lockmode); + AlterTableCreateToastTable(tab->relid, lockmode); } } @@ -16927,7 +16926,6 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation, Datum repl_val[Natts_pg_class]; bool repl_null[Natts_pg_class]; bool repl_repl[Natts_pg_class]; - const char *const validnsps[] = HEAP_RELOPT_NAMESPACES; if (defList == NIL && operation != AT_ReplaceRelOptions) return; /* nothing to do */ @@ -16960,7 +16958,7 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation, } /* Generate new proposed reloptions (text array) */ - newOptions = transformRelOptions(datum, defList, NULL, validnsps, false, + newOptions = transformRelOptions(datum, defList, NULL, NULL, false, operation == AT_ResetRelOptions); /* Validate */ @@ -17083,20 +17081,11 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation, datum = (Datum) 0; } - newOptions = transformRelOptions(datum, defList, "toast", validnsps, - false, operation == AT_ResetRelOptions); - - (void) heap_reloptions(RELKIND_TOASTVALUE, newOptions, true); - memset(repl_val, 0, sizeof(repl_val)); memset(repl_null, false, sizeof(repl_null)); memset(repl_repl, false, sizeof(repl_repl)); - if (newOptions != (Datum) 0) - repl_val[Anum_pg_class_reloptions - 1] = newOptions; - else - repl_null[Anum_pg_class_reloptions - 1] = true; - + repl_null[Anum_pg_class_reloptions - 1] = true; repl_repl[Anum_pg_class_reloptions - 1] = true; newtuple = heap_modify_tuple(tuple, RelationGetDescr(pgclass), diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c index a4abb29cf64..2b44afdbf25 100644 --- a/src/backend/commands/vacuum.c +++ b/src/backend/commands/vacuum.c @@ -2020,13 +2020,6 @@ vacuum_rel(Oid relid, RangeVar *relation, VacuumParams params, Oid save_userid; int save_sec_context; int save_nestlevel; - VacuumParams toast_vacuum_params; - - /* - * This function scribbles on the parameters, so make a copy early to - * avoid affecting the TOAST table (if we do end up recursing to it). - */ - memcpy(&toast_vacuum_params, ¶ms, sizeof(VacuumParams)); /* Begin a transaction for vacuuming this relation */ StartTransactionCommand(); @@ -2341,11 +2334,10 @@ vacuum_rel(Oid relid, RangeVar *relation, VacuumParams params, * relation. NB: This is only safe to do because we hold a session * lock on the main relation that prevents concurrent deletion. */ - toast_vacuum_params.options |= VACOPT_PROCESS_MAIN; - toast_vacuum_params.toast_parent = relid; + params.options |= VACOPT_PROCESS_MAIN; + params.toast_parent = relid; - vacuum_rel(toast_relid, NULL, toast_vacuum_params, bstrategy, - isTopLevel); + vacuum_rel(toast_relid, NULL, params, bstrategy, isTopLevel); } /* diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index a5a8db2ff88..c0e7cbf2cb8 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -2139,8 +2139,9 @@ do_autovacuum(void) { Form_pg_class classForm = (Form_pg_class) GETSTRUCT(tuple); Oid relid; - AutoVacOpts *relopts; - bool free_relopts = false; + av_relation *hentry; + bool found; + AutoVacOpts *relopts = NULL; bool dovacuum; bool doanalyze; bool wraparound; @@ -2154,22 +2155,10 @@ do_autovacuum(void) relid = classForm->oid; - /* - * fetch reloptions -- if this toast table does not have them, try the - * main rel - */ - relopts = extract_autovac_opts(tuple, pg_class_desc); - if (relopts) - free_relopts = true; - else - { - av_relation *hentry; - bool found; - - hentry = hash_search(table_toast_map, &relid, HASH_FIND, &found); - if (found && hentry->ar_hasrelopts) - relopts = &hentry->ar_reloptions; - } + /* Use reloptions from main rel. */ + hentry = hash_search(table_toast_map, &relid, HASH_FIND, &found); + if (found && hentry->ar_hasrelopts) + relopts = &hentry->ar_reloptions; relation_needs_vacanalyze(relid, relopts, classForm, effective_multixact_freeze_max_age, @@ -2186,10 +2175,6 @@ do_autovacuum(void) table->score = scores.max; tables_to_process = lappend(tables_to_process, table); } - - /* Release stuff to avoid leakage */ - if (free_relopts) - pfree(relopts); } table_endscan(relScan); @@ -2826,7 +2811,7 @@ table_recheck_autovac(Oid relid, HTAB *table_toast_map, bool doanalyze; autovac_table *tab = NULL; bool wraparound; - AutoVacOpts *avopts; + AutoVacOpts *avopts = NULL; bool free_avopts = false; AutoVacuumScores scores; @@ -2838,13 +2823,15 @@ table_recheck_autovac(Oid relid, HTAB *table_toast_map, /* * Get the applicable reloptions. If it is a TOAST table, try to get the - * main table reloptions if the toast table itself doesn't have. + * main table reloptions. */ - avopts = extract_autovac_opts(classTup, pg_class_desc); - if (avopts) - free_avopts = true; - else if (classForm->relkind == RELKIND_TOASTVALUE && - table_toast_map != NULL) + if (classForm->relkind != RELKIND_TOASTVALUE) + { + avopts = extract_autovac_opts(classTup, pg_class_desc); + if (avopts) + free_avopts = true; + } + else if (table_toast_map) { av_relation *hentry; bool found; @@ -3127,8 +3114,7 @@ relation_needs_vacanalyze(Oid relid, /* * Determine vacuum/analyze equation parameters. We have two possible - * sources: the passed reloptions (which could be a main table or a toast - * table), or the autovacuum GUC variables. + * sources: the passed reloptions or the autovacuum GUC variables. */ /* -1 in autovac setting means use plain vacuum_scale_factor */ diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c index 73a56f1df1d..d089e02c216 100644 --- a/src/backend/tcop/utility.c +++ b/src/backend/tcop/utility.c @@ -1159,8 +1159,6 @@ ProcessUtilitySlow(ParseState *pstate, if (IsA(stmt, CreateStmt)) { CreateStmt *cstmt = (CreateStmt *) stmt; - Datum toast_options; - const char *const validnsps[] = HEAP_RELOPT_NAMESPACES; /* Remember transformed RangeVar for LIKE */ table_rv = cstmt->relation; @@ -1180,22 +1178,7 @@ ProcessUtilitySlow(ParseState *pstate, */ CommandCounterIncrement(); - /* - * parse and validate reloptions for the toast - * table - */ - toast_options = transformRelOptions((Datum) 0, - cstmt->options, - "toast", - validnsps, - true, - false); - (void) heap_reloptions(RELKIND_TOASTVALUE, - toast_options, - true); - - NewRelationCreateToastTable(address.objectId, - toast_options); + NewRelationCreateToastTable(address.objectId); } else if (IsA(stmt, CreateForeignTableStmt)) { diff --git a/src/bin/pg_upgrade/check.c b/src/bin/pg_upgrade/check.c index 5a7afe62eab..18d49a6fc17 100644 --- a/src/bin/pg_upgrade/check.c +++ b/src/bin/pg_upgrade/check.c @@ -37,6 +37,7 @@ static void check_new_cluster_subscription_configuration(void); static void check_old_cluster_for_valid_slots(void); static void check_old_cluster_subscription_state(void); static void check_old_cluster_global_names(ClusterInfo *cluster); +static void check_for_toast_reloptions(ClusterInfo *cluster); /* * DataTypesUsageChecks - definitions of data type checks for the old cluster @@ -634,6 +635,9 @@ check_and_dump_old_cluster(void) check_for_prepared_transactions(&old_cluster); check_for_isn_and_int8_passing_mismatch(&old_cluster); + if (GET_MAJOR_VERSION(old_cluster.major_version) < 2000) + check_for_toast_reloptions(&old_cluster); + if (GET_MAJOR_VERSION(old_cluster.major_version) >= 1700) { /* @@ -2644,3 +2648,74 @@ check_old_cluster_global_names(ClusterInfo *cluster) else check_ok(); } + +/* + * Callback function for processing results of query for + * check_for_toast_reloptions()'s UpgradeTask. If the query returned any rows + * (i.e., the check failed), write the details to the report file. + */ +static void +process_toast_relopts_check(DbInfo *dbinfo, PGresult *res, void *arg) +{ + UpgradeTaskReport *report = (UpgradeTaskReport *) arg; + int ntups = PQntuples(res); + int i_nspname = PQfnumber(res, "nspname"); + int i_relname = PQfnumber(res, "relname"); + + if (ntups == 0) + return; + + if (report->file == NULL && + (report->file = fopen_priv(report->path, "w")) == NULL) + pg_fatal("could not open file \"%s\": %m", report->path); + + fprintf(report->file, "In database: %s\n", dbinfo->db_name); + + for (int rowno = 0; rowno < ntups; rowno++) + fprintf(report->file, " %s.%s\n", + PQgetvalue(res, rowno, i_nspname), + PQgetvalue(res, rowno, i_relname)); +} + +/* + * Verify that no storage parameters (a.k.a. reloptions) are defined for TOAST + * tables. + */ +static void +check_for_toast_reloptions(ClusterInfo *cluster) +{ + UpgradeTaskReport report; + UpgradeTask *task = upgrade_task_create(); + const char *query = "SELECT n.nspname, c.relname " + "FROM pg_catalog.pg_class c, " + " pg_catalog.pg_class tc, " + " pg_catalog.pg_namespace n " + "WHERE c.reltoastrelid = tc.oid AND " + " c.relnamespace = n.oid AND " + " tc.reloptions IS NOT NULL"; + + prep_status("Check for tables with TOAST storage parameters"); + + report.file = NULL; + snprintf(report.path, sizeof(report.path), "%s/%s", + log_opts.basedir, + "tables_with_toast_storage_parameters.txt"); + + upgrade_task_add_step(task, query, process_toast_relopts_check, + true, &report); + upgrade_task_run(task, cluster); + upgrade_task_free(task); + + if (report.file) + { + fclose(report.file); + pg_log(PG_REPORT, "fatal"); + pg_fatal("Your installation contains tables with TOAST storage parameters set, which is\n" + "not supported anymore. Consider remove the TOAST storage parameters using\n" + " ALTER TABLE ... RESET ( ... );\n" + "A list of tables with the problem is in the file:\n" + " %s", report.path); + } + else + check_ok(); +} diff --git a/src/include/access/reloptions.h b/src/include/access/reloptions.h index e8cb7f7a627..4415c1ca9b5 100644 --- a/src/include/access/reloptions.h +++ b/src/include/access/reloptions.h @@ -40,26 +40,22 @@ typedef enum relopt_kind { RELOPT_KIND_LOCAL = 0, RELOPT_KIND_HEAP = (1 << 0), - RELOPT_KIND_TOAST = (1 << 1), - RELOPT_KIND_BTREE = (1 << 2), - RELOPT_KIND_HASH = (1 << 3), - RELOPT_KIND_GIN = (1 << 4), - RELOPT_KIND_GIST = (1 << 5), - RELOPT_KIND_ATTRIBUTE = (1 << 6), - RELOPT_KIND_TABLESPACE = (1 << 7), - RELOPT_KIND_SPGIST = (1 << 8), - RELOPT_KIND_VIEW = (1 << 9), - RELOPT_KIND_BRIN = (1 << 10), - RELOPT_KIND_PARTITIONED = (1 << 11), + RELOPT_KIND_BTREE = (1 << 1), + RELOPT_KIND_HASH = (1 << 2), + RELOPT_KIND_GIN = (1 << 3), + RELOPT_KIND_GIST = (1 << 4), + RELOPT_KIND_ATTRIBUTE = (1 << 5), + RELOPT_KIND_TABLESPACE = (1 << 6), + RELOPT_KIND_SPGIST = (1 << 7), + RELOPT_KIND_VIEW = (1 << 8), + RELOPT_KIND_BRIN = (1 << 9), + RELOPT_KIND_PARTITIONED = (1 << 10), /* if you add a new kind, make sure you update "last_default" too */ RELOPT_KIND_LAST_DEFAULT = RELOPT_KIND_PARTITIONED, /* some compilers treat enums as signed ints, so we can't use 1 << 31 */ RELOPT_KIND_MAX = (1 << 30) } relopt_kind; -/* reloption namespaces allowed for heaps -- currently only TOAST */ -#define HEAP_RELOPT_NAMESPACES { "toast", NULL } - /* generic struct to hold shared data */ typedef struct relopt_gen { diff --git a/src/include/catalog/toasting.h b/src/include/catalog/toasting.h index 0bc61a8fee9..13e5a8affcb 100644 --- a/src/include/catalog/toasting.h +++ b/src/include/catalog/toasting.h @@ -19,10 +19,10 @@ /* * toasting.c prototypes */ -extern void NewRelationCreateToastTable(Oid relOid, Datum reloptions); -extern void NewHeapCreateToastTable(Oid relOid, Datum reloptions, +extern void NewRelationCreateToastTable(Oid relOid); +extern void NewHeapCreateToastTable(Oid relOid, LOCKMODE lockmode, Oid OIDOldToast); -extern void AlterTableCreateToastTable(Oid relOid, Datum reloptions, +extern void AlterTableCreateToastTable(Oid relOid, LOCKMODE lockmode); extern void BootstrapToastTable(char *relName, Oid toastOid, Oid toastIndexOid); diff --git a/src/test/modules/injection_points/expected/vacuum.out b/src/test/modules/injection_points/expected/vacuum.out index 58df59fa927..dcfa729d05e 100644 --- a/src/test/modules/injection_points/expected/vacuum.out +++ b/src/test/modules/injection_points/expected/vacuum.out @@ -43,29 +43,29 @@ SELECT injection_points_attach('vacuum-truncate-enabled', 'notice'); (1 row) -- Check state of index_cleanup and truncate in VACUUM. -CREATE TABLE vac_tab_on_toast_off(i int, j text) WITH +CREATE TABLE vac_tab_on_toast(i int, j text) WITH (autovacuum_enabled=false, - vacuum_index_cleanup=true, toast.vacuum_index_cleanup=false, - vacuum_truncate=true, toast.vacuum_truncate=false); -CREATE TABLE vac_tab_off_toast_on(i int, j text) WITH + vacuum_index_cleanup=true, + vacuum_truncate=true); +CREATE TABLE vac_tab_off_toast(i int, j text) WITH (autovacuum_enabled=false, - vacuum_index_cleanup=false, toast.vacuum_index_cleanup=true, - vacuum_truncate=false, toast.vacuum_truncate=true); + vacuum_index_cleanup=false, + vacuum_truncate=false); -- Multiple relations should use their options in isolation. -VACUUM vac_tab_on_toast_off, vac_tab_off_toast_on; +VACUUM vac_tab_on_toast, vac_tab_off_toast; +NOTICE: notice triggered for injection point vacuum-index-cleanup-enabled +NOTICE: notice triggered for injection point vacuum-truncate-enabled NOTICE: notice triggered for injection point vacuum-index-cleanup-enabled NOTICE: notice triggered for injection point vacuum-truncate-enabled NOTICE: notice triggered for injection point vacuum-index-cleanup-disabled NOTICE: notice triggered for injection point vacuum-truncate-disabled NOTICE: notice triggered for injection point vacuum-index-cleanup-disabled NOTICE: notice triggered for injection point vacuum-truncate-disabled -NOTICE: notice triggered for injection point vacuum-index-cleanup-enabled -NOTICE: notice triggered for injection point vacuum-truncate-enabled -- Check "auto" case of index_cleanup and "truncate" controlled by -- its GUC. CREATE TABLE vac_tab_auto(i int, j text) WITH (autovacuum_enabled=false, - vacuum_index_cleanup=auto, toast.vacuum_index_cleanup=auto); + vacuum_index_cleanup=auto); SET vacuum_truncate = false; VACUUM vac_tab_auto; NOTICE: notice triggered for injection point vacuum-index-cleanup-auto @@ -80,8 +80,8 @@ NOTICE: notice triggered for injection point vacuum-index-cleanup-auto NOTICE: notice triggered for injection point vacuum-truncate-enabled RESET vacuum_truncate; DROP TABLE vac_tab_auto; -DROP TABLE vac_tab_on_toast_off; -DROP TABLE vac_tab_off_toast_on; +DROP TABLE vac_tab_on_toast; +DROP TABLE vac_tab_off_toast; -- Cleanup SELECT injection_points_detach('vacuum-index-cleanup-auto'); injection_points_detach diff --git a/src/test/modules/injection_points/sql/vacuum.sql b/src/test/modules/injection_points/sql/vacuum.sql index 23760dd0f38..ee7a2e0566e 100644 --- a/src/test/modules/injection_points/sql/vacuum.sql +++ b/src/test/modules/injection_points/sql/vacuum.sql @@ -11,22 +11,22 @@ SELECT injection_points_attach('vacuum-truncate-disabled', 'notice'); SELECT injection_points_attach('vacuum-truncate-enabled', 'notice'); -- Check state of index_cleanup and truncate in VACUUM. -CREATE TABLE vac_tab_on_toast_off(i int, j text) WITH +CREATE TABLE vac_tab_on_toast(i int, j text) WITH (autovacuum_enabled=false, - vacuum_index_cleanup=true, toast.vacuum_index_cleanup=false, - vacuum_truncate=true, toast.vacuum_truncate=false); -CREATE TABLE vac_tab_off_toast_on(i int, j text) WITH + vacuum_index_cleanup=true, + vacuum_truncate=true); +CREATE TABLE vac_tab_off_toast(i int, j text) WITH (autovacuum_enabled=false, - vacuum_index_cleanup=false, toast.vacuum_index_cleanup=true, - vacuum_truncate=false, toast.vacuum_truncate=true); + vacuum_index_cleanup=false, + vacuum_truncate=false); -- Multiple relations should use their options in isolation. -VACUUM vac_tab_on_toast_off, vac_tab_off_toast_on; +VACUUM vac_tab_on_toast, vac_tab_off_toast; -- Check "auto" case of index_cleanup and "truncate" controlled by -- its GUC. CREATE TABLE vac_tab_auto(i int, j text) WITH (autovacuum_enabled=false, - vacuum_index_cleanup=auto, toast.vacuum_index_cleanup=auto); + vacuum_index_cleanup=auto); SET vacuum_truncate = false; VACUUM vac_tab_auto; SET vacuum_truncate = true; @@ -34,8 +34,8 @@ VACUUM vac_tab_auto; RESET vacuum_truncate; DROP TABLE vac_tab_auto; -DROP TABLE vac_tab_on_toast_off; -DROP TABLE vac_tab_off_toast_on; +DROP TABLE vac_tab_on_toast; +DROP TABLE vac_tab_off_toast; -- Cleanup SELECT injection_points_detach('vacuum-index-cleanup-auto'); diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out index 6dd22be0e8d..435e6beea0f 100644 --- a/src/test/regress/expected/alter_table.out +++ b/src/test/regress/expected/alter_table.out @@ -2860,15 +2860,6 @@ select * from my_locks order by 1; pg_toast | ShareUpdateExclusiveLock (2 rows) -commit; -begin; alter table alterlock set (toast.autovacuum_enabled = off); -select * from my_locks order by 1; - relname | max_lockmode ------------+-------------------------- - alterlock | ShareUpdateExclusiveLock - pg_toast | ShareUpdateExclusiveLock -(2 rows) - commit; begin; alter table alterlock set (autovacuum_enabled = off); select * from my_locks order by 1; diff --git a/src/test/regress/expected/reloptions.out b/src/test/regress/expected/reloptions.out index e3a974f2611..eff5fbece60 100644 --- a/src/test/regress/expected/reloptions.out +++ b/src/test/regress/expected/reloptions.out @@ -120,7 +120,6 @@ SELECT reloptions FROM pg_class WHERE oid = 'reloptions_test'::regclass; DROP TABLE reloptions_test; CREATE TEMP TABLE reloptions_test(i INT NOT NULL, j text) WITH (vacuum_truncate=false, - toast.vacuum_truncate=false, autovacuum_enabled=false); SELECT reloptions FROM pg_class WHERE oid = 'reloptions_test'::regclass; reloptions @@ -142,9 +141,9 @@ SELECT pg_relation_size('reloptions_test') > 0; SELECT reloptions FROM pg_class WHERE oid = (SELECT reltoastrelid FROM pg_class WHERE oid = 'reloptions_test'::regclass); - reloptions -------------------------- - {vacuum_truncate=false} + reloptions +------------ + (1 row) ALTER TABLE reloptions_test RESET (vacuum_truncate); @@ -165,56 +164,11 @@ SELECT pg_relation_size('reloptions_test') = 0; t (1 row) --- Test toast.* options -DROP TABLE reloptions_test; -CREATE TABLE reloptions_test (s VARCHAR) - WITH (toast.autovacuum_vacuum_cost_delay = 23); -SELECT reltoastrelid as toast_oid - FROM pg_class WHERE oid = 'reloptions_test'::regclass \gset -SELECT reloptions FROM pg_class WHERE oid = :toast_oid; - reloptions ------------------------------------ - {autovacuum_vacuum_cost_delay=23} -(1 row) - -ALTER TABLE reloptions_test SET (toast.autovacuum_vacuum_cost_delay = 24); -SELECT reloptions FROM pg_class WHERE oid = :toast_oid; - reloptions ------------------------------------ - {autovacuum_vacuum_cost_delay=24} -(1 row) - -ALTER TABLE reloptions_test RESET (toast.autovacuum_vacuum_cost_delay); -SELECT reloptions FROM pg_class WHERE oid = :toast_oid; - reloptions ------------- - -(1 row) - --- Fail on non-existent options in toast namespace -CREATE TABLE reloptions_test2 (i int) WITH (toast.not_existing_option = 42); -ERROR: unrecognized parameter "not_existing_option" --- Mix TOAST & heap -DROP TABLE reloptions_test; -CREATE TABLE reloptions_test (s VARCHAR) WITH - (toast.autovacuum_vacuum_cost_delay = 23, - autovacuum_vacuum_cost_delay = 24, fillfactor = 40); -SELECT reloptions FROM pg_class WHERE oid = 'reloptions_test'::regclass; - reloptions -------------------------------------------------- - {autovacuum_vacuum_cost_delay=24,fillfactor=40} -(1 row) - -SELECT reloptions FROM pg_class WHERE oid = ( - SELECT reltoastrelid FROM pg_class WHERE oid = 'reloptions_test'::regclass); - reloptions ------------------------------------ - {autovacuum_vacuum_cost_delay=23} -(1 row) - -- -- CREATE INDEX, ALTER INDEX for btrees -- +DROP TABLE reloptions_test; +CREATE TABLE reloptions_test (s VARCHAR); CREATE INDEX reloptions_test_idx ON reloptions_test (s) WITH (fillfactor=30); SELECT reloptions FROM pg_class WHERE oid = 'reloptions_test_idx'::regclass; reloptions diff --git a/src/test/regress/expected/vacuum.out b/src/test/regress/expected/vacuum.out index d4696bc3325..d551ef57d50 100644 --- a/src/test/regress/expected/vacuum.out +++ b/src/test/regress/expected/vacuum.out @@ -209,14 +209,6 @@ VACUUM no_index_cleanup; INSERT INTO no_index_cleanup(i, t) VALUES (generate_series(31,60), repeat('1234567890',269)); DELETE FROM no_index_cleanup WHERE i < 45; --- Only toast index is cleaned up. -ALTER TABLE no_index_cleanup SET (vacuum_index_cleanup = off, - toast.vacuum_index_cleanup = yes); -VACUUM no_index_cleanup; --- Only parent is cleaned up. -ALTER TABLE no_index_cleanup SET (vacuum_index_cleanup = true, - toast.vacuum_index_cleanup = false); -VACUUM no_index_cleanup; -- Test some extra relations. VACUUM (INDEX_CLEANUP FALSE) vaccluster; VACUUM (INDEX_CLEANUP AUTO) vactst; -- index cleanup option is ignored if no indexes diff --git a/src/test/regress/sql/alter_table.sql b/src/test/regress/sql/alter_table.sql index f5f13bbd3e7..410465dc022 100644 --- a/src/test/regress/sql/alter_table.sql +++ b/src/test/regress/sql/alter_table.sql @@ -1784,10 +1784,6 @@ begin; alter table alterlock reset (fillfactor); select * from my_locks order by 1; commit; -begin; alter table alterlock set (toast.autovacuum_enabled = off); -select * from my_locks order by 1; -commit; - begin; alter table alterlock set (autovacuum_enabled = off); select * from my_locks order by 1; commit; diff --git a/src/test/regress/sql/reloptions.sql b/src/test/regress/sql/reloptions.sql index 680c8bf8614..0809a2ae0e4 100644 --- a/src/test/regress/sql/reloptions.sql +++ b/src/test/regress/sql/reloptions.sql @@ -75,7 +75,6 @@ DROP TABLE reloptions_test; CREATE TEMP TABLE reloptions_test(i INT NOT NULL, j text) WITH (vacuum_truncate=false, - toast.vacuum_truncate=false, autovacuum_enabled=false); SELECT reloptions FROM pg_class WHERE oid = 'reloptions_test'::regclass; INSERT INTO reloptions_test VALUES (1, NULL), (NULL, NULL); @@ -94,39 +93,12 @@ INSERT INTO reloptions_test VALUES (1, NULL), (NULL, NULL); VACUUM (FREEZE, DISABLE_PAGE_SKIPPING) reloptions_test; SELECT pg_relation_size('reloptions_test') = 0; --- Test toast.* options -DROP TABLE reloptions_test; - -CREATE TABLE reloptions_test (s VARCHAR) - WITH (toast.autovacuum_vacuum_cost_delay = 23); -SELECT reltoastrelid as toast_oid - FROM pg_class WHERE oid = 'reloptions_test'::regclass \gset -SELECT reloptions FROM pg_class WHERE oid = :toast_oid; - -ALTER TABLE reloptions_test SET (toast.autovacuum_vacuum_cost_delay = 24); -SELECT reloptions FROM pg_class WHERE oid = :toast_oid; - -ALTER TABLE reloptions_test RESET (toast.autovacuum_vacuum_cost_delay); -SELECT reloptions FROM pg_class WHERE oid = :toast_oid; - --- Fail on non-existent options in toast namespace -CREATE TABLE reloptions_test2 (i int) WITH (toast.not_existing_option = 42); - --- Mix TOAST & heap -DROP TABLE reloptions_test; - -CREATE TABLE reloptions_test (s VARCHAR) WITH - (toast.autovacuum_vacuum_cost_delay = 23, - autovacuum_vacuum_cost_delay = 24, fillfactor = 40); - -SELECT reloptions FROM pg_class WHERE oid = 'reloptions_test'::regclass; -SELECT reloptions FROM pg_class WHERE oid = ( - SELECT reltoastrelid FROM pg_class WHERE oid = 'reloptions_test'::regclass); - -- -- CREATE INDEX, ALTER INDEX for btrees -- +DROP TABLE reloptions_test; +CREATE TABLE reloptions_test (s VARCHAR); CREATE INDEX reloptions_test_idx ON reloptions_test (s) WITH (fillfactor=30); SELECT reloptions FROM pg_class WHERE oid = 'reloptions_test_idx'::regclass; diff --git a/src/test/regress/sql/vacuum.sql b/src/test/regress/sql/vacuum.sql index 247b8e23b23..37a84fd9145 100644 --- a/src/test/regress/sql/vacuum.sql +++ b/src/test/regress/sql/vacuum.sql @@ -175,14 +175,6 @@ VACUUM no_index_cleanup; INSERT INTO no_index_cleanup(i, t) VALUES (generate_series(31,60), repeat('1234567890',269)); DELETE FROM no_index_cleanup WHERE i < 45; --- Only toast index is cleaned up. -ALTER TABLE no_index_cleanup SET (vacuum_index_cleanup = off, - toast.vacuum_index_cleanup = yes); -VACUUM no_index_cleanup; --- Only parent is cleaned up. -ALTER TABLE no_index_cleanup SET (vacuum_index_cleanup = true, - toast.vacuum_index_cleanup = false); -VACUUM no_index_cleanup; -- Test some extra relations. VACUUM (INDEX_CLEANUP FALSE) vaccluster; VACUUM (INDEX_CLEANUP AUTO) vactst; -- index cleanup option is ignored if no indexes -- 2.50.1 (Apple Git-155) --g1KZ71ry6DNksXN0-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 383+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 383+ messages in thread
end of thread, other threads:[~2026-04-20 07:20 UTC | newest] Thread overview: 383+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2021-04-02 06:02 [PATCH] Asymmetric partitionwise join. Andrey Lepikhov <a.lepikhov@postgrespro.ru> 2021-04-02 06:02 [PATCH] Asymmetric partitionwise join. Andrey Lepikhov <a.lepikhov@postgrespro.ru> 2021-04-02 06:02 [PATCH] Asymmetric partitionwise join. Andrey Lepikhov <a.lepikhov@postgrespro.ru> 2026-04-07 20:30 [PATCH v4 1/1] remove toast reloptions Nathan Bossart <nathan@postgresql.org> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at> 2026-04-20 07:20 [PATCH] Do not check the REPLICATION attribute when running REPACK. Antonin Houska <ah@cybertec.at>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox