agora inbox for pgsql-hackers@postgresql.orghelp / color / mirror / Atom feed
[PATCH] Asymmetric partitionwise join. 381+ messages / 3 participants [nested] [flat]
* [PATCH] Asymmetric partitionwise join. @ 2021-04-02 06:02 Andrey Lepikhov <a.lepikhov@postgrespro.ru> 0 siblings, 0 replies; 381+ 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] 381+ messages in thread
* [PATCH] Asymmetric partitionwise join. @ 2021-04-02 06:02 Andrey Lepikhov <a.lepikhov@postgrespro.ru> 0 siblings, 0 replies; 381+ 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] 381+ messages in thread
* [PATCH] Asymmetric partitionwise join. @ 2021-04-02 06:02 Andrey Lepikhov <a.lepikhov@postgrespro.ru> 0 siblings, 0 replies; 381+ 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] 381+ messages in thread
* [PATCH v3 2/4] pg_upgrade: bump minimum supported version to v10 @ 2026-04-17 18:20 Nathan Bossart <nathan@postgresql.org> 0 siblings, 0 replies; 381+ messages in thread From: Nathan Bossart @ 2026-04-17 18:20 UTC (permalink / raw) --- doc/src/sgml/ref/pgupgrade.sgml | 2 +- src/bin/pg_upgrade/check.c | 157 +---------------------- src/bin/pg_upgrade/controldata.c | 12 +- src/bin/pg_upgrade/exec.c | 23 ---- src/bin/pg_upgrade/file.c | 164 ------------------------- src/bin/pg_upgrade/multixact_rewrite.c | 11 +- src/bin/pg_upgrade/pg_upgrade.c | 31 +---- src/bin/pg_upgrade/pg_upgrade.h | 29 ----- src/bin/pg_upgrade/relfilenumber.c | 37 +----- src/bin/pg_upgrade/version.c | 127 ------------------- 10 files changed, 16 insertions(+), 577 deletions(-) diff --git a/doc/src/sgml/ref/pgupgrade.sgml b/doc/src/sgml/ref/pgupgrade.sgml index 38ca09b423c..c4ed75211db 100644 --- a/doc/src/sgml/ref/pgupgrade.sgml +++ b/doc/src/sgml/ref/pgupgrade.sgml @@ -67,7 +67,7 @@ PostgreSQL documentation </para> <para> - <application>pg_upgrade</application> supports upgrades from 9.2.X and later to the current + <application>pg_upgrade</application> supports upgrades from 10.X and later to the current major release of <productname>PostgreSQL</productname>, including snapshot and beta releases. </para> diff --git a/src/bin/pg_upgrade/check.c b/src/bin/pg_upgrade/check.c index 5a7afe62eab..0813cef2729 100644 --- a/src/bin/pg_upgrade/check.c +++ b/src/bin/pg_upgrade/check.c @@ -28,7 +28,6 @@ static void check_for_incompatible_polymorphics(ClusterInfo *cluster); static void check_for_tables_with_oids(ClusterInfo *cluster); static void check_for_not_null_inheritance(ClusterInfo *cluster); static void check_for_gist_inet_ops(ClusterInfo *cluster); -static void check_for_pg_role_prefix(ClusterInfo *cluster); static void check_for_new_tablespace_dir(void); static void check_for_user_defined_encoding_conversions(ClusterInfo *cluster); static void check_for_unicode_update(ClusterInfo *cluster); @@ -128,26 +127,6 @@ static DataTypesUsageChecks data_types_usage_checks[] = .threshold_version = ALL_VERSIONS }, - /* - * 9.3 -> 9.4 Fully implement the 'line' data type in 9.4, which - * previously returned "not enabled" by default and was only functionally - * enabled with a compile-time switch; as of 9.4 "line" has a different - * on-disk representation format. - */ - { - .status = gettext_noop("Checking for incompatible \"line\" data type"), - .report_filename = "tables_using_line.txt", - .base_query = - "SELECT 'pg_catalog.line'::pg_catalog.regtype AS oid", - .report_text = - gettext_noop("Your installation contains the \"line\" data type in user tables.\n" - "This data type changed its internal and input/output format\n" - "between your old and new versions so this\n" - "cluster cannot currently be upgraded. You can\n" - "drop the problem columns and restart the upgrade.\n"), - .threshold_version = 903 - }, - /* * pg_upgrade only preserves these system values: pg_class.oid pg_type.oid * pg_enum.oid @@ -209,30 +188,6 @@ static DataTypesUsageChecks data_types_usage_checks[] = .threshold_version = 1500 }, - /* - * It's no longer allowed to create tables or views with "unknown"-type - * columns. We do not complain about views with such columns, because - * they should get silently converted to "text" columns during the DDL - * dump and reload; it seems unlikely to be worth making users do that by - * hand. However, if there's a table with such a column, the DDL reload - * will fail, so we should pre-detect that rather than failing - * mid-upgrade. Worse, if there's a matview with such a column, the DDL - * reload will silently change it to "text" which won't match the on-disk - * storage (which is like "cstring"). So we *must* reject that. - */ - { - .status = gettext_noop("Checking for invalid \"unknown\" user columns"), - .report_filename = "tables_using_unknown.txt", - .base_query = - "SELECT 'pg_catalog.unknown'::pg_catalog.regtype AS oid", - .report_text = - gettext_noop("Your installation contains the \"unknown\" data type in user tables.\n" - "This data type is no longer allowed in tables, so this cluster\n" - "cannot currently be upgraded. You can drop the problem columns\n" - "and restart the upgrade.\n"), - .threshold_version = 906 - }, - /* * PG 12 changed the 'sql_identifier' type storage to be based on name, * not varchar, which breaks on-disk format for existing data. So we need @@ -255,23 +210,6 @@ static DataTypesUsageChecks data_types_usage_checks[] = .threshold_version = 1100 }, - /* - * JSONB changed its storage format during 9.4 beta, so check for it. - */ - { - .status = gettext_noop("Checking for incompatible \"jsonb\" data type in user tables"), - .report_filename = "tables_using_jsonb.txt", - .base_query = - "SELECT 'pg_catalog.jsonb'::pg_catalog.regtype AS oid", - .report_text = - gettext_noop("Your installation contains the \"jsonb\" data type in user tables.\n" - "The internal format of \"jsonb\" changed during 9.4 beta so this\n" - "cluster cannot currently be upgraded. You can drop the problem \n" - "columns and restart the upgrade.\n"), - .threshold_version = MANUAL_CHECK, - .version_hook = jsonb_9_4_check_applicable - }, - /* * PG 12 removed types abstime, reltime, tinterval. */ @@ -712,20 +650,6 @@ check_and_dump_old_cluster(void) if (GET_MAJOR_VERSION(old_cluster.major_version) <= 1800) check_for_gist_inet_ops(&old_cluster); - /* - * Pre-PG 10 allowed tables with 'unknown' type columns and non WAL logged - * hash indexes - */ - if (GET_MAJOR_VERSION(old_cluster.major_version) <= 906) - { - if (user_opts.check) - old_9_6_invalidate_hash_indexes(&old_cluster, true); - } - - /* 9.5 and below should not have roles starting with pg_ */ - if (GET_MAJOR_VERSION(old_cluster.major_version) <= 905) - check_for_pg_role_prefix(&old_cluster); - /* * While not a check option, we do this now because this is the only time * the old server is running. @@ -772,20 +696,6 @@ check_new_cluster(void) * system boundaries. */ check_hard_link(TRANSFER_MODE_SWAP); - - /* - * There are a few known issues with using --swap to upgrade from - * versions older than 10. For example, the sequence tuple format - * changed in v10, and the visibility map format changed in 9.6. - * While such problems are not insurmountable (and we may have to - * deal with similar problems in the future, anyway), it doesn't - * seem worth the effort to support swap mode for upgrades from - * long-unsupported versions. - */ - if (GET_MAJOR_VERSION(old_cluster.major_version) < 1000) - pg_fatal("Swap mode can only upgrade clusters from PostgreSQL version %s and later.", - "10"); - break; } @@ -831,10 +741,6 @@ issue_warnings_and_set_wal_level(void) */ start_postmaster(&new_cluster, true); - /* Reindex hash indexes for old < 10.0 */ - if (GET_MAJOR_VERSION(old_cluster.major_version) <= 906) - old_9_6_invalidate_hash_indexes(&new_cluster, false); - report_extension_updates(&new_cluster); stop_postmaster(false); @@ -892,9 +798,9 @@ check_cluster_versions(void) * upgrades */ - if (GET_MAJOR_VERSION(old_cluster.major_version) < 902) + if (GET_MAJOR_VERSION(old_cluster.major_version) < 10) pg_fatal("This utility can only upgrade from PostgreSQL version %s and later.", - "9.2"); + "10"); /* Only current PG version is supported as a target */ if (GET_MAJOR_VERSION(new_cluster.major_version) != GET_MAJOR_VERSION(PG_VERSION_NUM)) @@ -1569,12 +1475,10 @@ check_for_incompatible_polymorphics(ClusterInfo *cluster) ", 'array_cat(anyarray,anyarray)'" ", 'array_prepend(anyelement,anyarray)'"); - if (GET_MAJOR_VERSION(cluster->major_version) >= 903) appendPQExpBufferStr(&old_polymorphics, ", 'array_remove(anyarray,anyelement)'" ", 'array_replace(anyarray,anyelement,anyelement)'"); - if (GET_MAJOR_VERSION(cluster->major_version) >= 905) appendPQExpBufferStr(&old_polymorphics, ", 'array_position(anyarray,anyelement)'" ", 'array_position(anyarray,anyelement,integer)'" @@ -1870,63 +1774,6 @@ check_for_gist_inet_ops(ClusterInfo *cluster) check_ok(); } -/* - * check_for_pg_role_prefix() - * - * Versions older than 9.6 should not have any pg_* roles - */ -static void -check_for_pg_role_prefix(ClusterInfo *cluster) -{ - PGresult *res; - PGconn *conn = connectToServer(cluster, "template1"); - int ntups; - int i_roloid; - int i_rolname; - FILE *script = NULL; - char output_path[MAXPGPATH]; - - prep_status("Checking for roles starting with \"pg_\""); - - snprintf(output_path, sizeof(output_path), "%s/%s", - log_opts.basedir, - "pg_role_prefix.txt"); - - res = executeQueryOrDie(conn, - "SELECT oid AS roloid, rolname " - "FROM pg_catalog.pg_roles " - "WHERE rolname ~ '^pg_'"); - - ntups = PQntuples(res); - i_roloid = PQfnumber(res, "roloid"); - i_rolname = PQfnumber(res, "rolname"); - for (int rowno = 0; rowno < ntups; rowno++) - { - if (script == NULL && (script = fopen_priv(output_path, "w")) == NULL) - pg_fatal("could not open file \"%s\": %m", output_path); - fprintf(script, "%s (oid=%s)\n", - PQgetvalue(res, rowno, i_rolname), - PQgetvalue(res, rowno, i_roloid)); - } - - PQclear(res); - - PQfinish(conn); - - if (script) - { - fclose(script); - pg_log(PG_REPORT, "fatal"); - pg_fatal("Your installation contains roles starting with \"pg_\".\n" - "\"pg_\" is a reserved prefix for system roles. The cluster\n" - "cannot be upgraded until these roles are renamed.\n" - "A list of roles starting with \"pg_\" is in the file:\n" - " %s", output_path); - } - else - check_ok(); -} - /* * Callback function for processing results of query for * check_for_user_defined_encoding_conversions()'s UpgradeTask. If the query diff --git a/src/bin/pg_upgrade/controldata.c b/src/bin/pg_upgrade/controldata.c index cffcd4b0eba..8188355240f 100644 --- a/src/bin/pg_upgrade/controldata.c +++ b/src/bin/pg_upgrade/controldata.c @@ -602,14 +602,12 @@ get_control_data(ClusterInfo *cluster) /* verify that we got all the mandatory pg_control data */ if (!got_xid || !got_oid || !got_multi || !got_oldestxid || - (!got_oldestmulti && - cluster->controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER) || + !got_oldestmulti || !got_mxoff || (!live_check && !got_nextxlogfile) || !got_float8_pass_by_value || !got_align || !got_blocksz || !got_largesz || !got_walsz || !got_walseg || !got_ident || !got_index || !got_toast || - (!got_large_object && - cluster->controldata.ctrl_ver >= LARGE_OBJECT_SIZE_PG_CONTROL_VER) || + !got_large_object || !got_date_is_int || !got_data_checksum_version || (!got_default_char_signedness && cluster->controldata.cat_ver >= DEFAULT_CHAR_SIGNEDNESS_CAT_VER)) @@ -630,8 +628,7 @@ get_control_data(ClusterInfo *cluster) if (!got_multi) pg_log(PG_REPORT, " latest checkpoint next MultiXactId"); - if (!got_oldestmulti && - cluster->controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER) + if (!got_oldestmulti) pg_log(PG_REPORT, " latest checkpoint oldest MultiXactId"); if (!got_oldestxid) @@ -670,8 +667,7 @@ get_control_data(ClusterInfo *cluster) if (!got_toast) pg_log(PG_REPORT, " maximum TOAST chunk size"); - if (!got_large_object && - cluster->controldata.ctrl_ver >= LARGE_OBJECT_SIZE_PG_CONTROL_VER) + if (!got_large_object) pg_log(PG_REPORT, " large-object chunk size"); if (!got_date_is_int) diff --git a/src/bin/pg_upgrade/exec.c b/src/bin/pg_upgrade/exec.c index e1de61f36ee..479557abdcc 100644 --- a/src/bin/pg_upgrade/exec.c +++ b/src/bin/pg_upgrade/exec.c @@ -55,16 +55,7 @@ get_bin_version(ClusterInfo *cluster) if (sscanf(cmd_output, "%*s %*s %d.%d", &v1, &v2) < 1) pg_fatal("could not get pg_ctl version output from %s", cmd); - if (v1 < 10) - { - /* old style, e.g. 9.6.1 */ - cluster->bin_version = v1 * 10000 + v2 * 100; - } - else - { - /* new style, e.g. 10.1 */ cluster->bin_version = v1 * 10000; - } } @@ -353,17 +344,7 @@ check_data_dir(ClusterInfo *cluster) check_single_dir(pg_data, "pg_subtrans"); check_single_dir(pg_data, PG_TBLSPC_DIR); check_single_dir(pg_data, "pg_twophase"); - - /* pg_xlog has been renamed to pg_wal in v10 */ - if (GET_MAJOR_VERSION(cluster->major_version) <= 906) - check_single_dir(pg_data, "pg_xlog"); - else check_single_dir(pg_data, "pg_wal"); - - /* pg_clog has been renamed to pg_xact in v10 */ - if (GET_MAJOR_VERSION(cluster->major_version) <= 906) - check_single_dir(pg_data, "pg_clog"); - else check_single_dir(pg_data, "pg_xact"); } @@ -404,10 +385,6 @@ check_bin_dir(ClusterInfo *cluster, bool check_versions) */ get_bin_version(cluster); - /* pg_resetxlog has been renamed to pg_resetwal in version 10 */ - if (GET_MAJOR_VERSION(cluster->bin_version) <= 906) - check_exec(cluster->bindir, "pg_resetxlog", check_versions); - else check_exec(cluster->bindir, "pg_resetwal", check_versions); if (cluster == &new_cluster) diff --git a/src/bin/pg_upgrade/file.c b/src/bin/pg_upgrade/file.c index 5b276008614..af82c0de490 100644 --- a/src/bin/pg_upgrade/file.c +++ b/src/bin/pg_upgrade/file.c @@ -20,12 +20,8 @@ #include <linux/fs.h> #endif -#include "access/visibilitymapdefs.h" #include "common/file_perm.h" #include "pg_upgrade.h" -#include "storage/bufpage.h" -#include "storage/checksum.h" -#include "storage/checksum_impl.h" /* @@ -196,166 +192,6 @@ linkFile(const char *src, const char *dst, } -/* - * rewriteVisibilityMap() - * - * Transform a visibility map file, copying from src to dst. - * schemaName/relName are relation's SQL name (used for error messages only). - * - * In versions of PostgreSQL prior to catversion 201603011, PostgreSQL's - * visibility map included one bit per heap page; it now includes two. - * When upgrading a cluster from before that time to a current PostgreSQL - * version, we could refuse to copy visibility maps from the old cluster - * to the new cluster; the next VACUUM would recreate them, but at the - * price of scanning the entire table. So, instead, we rewrite the old - * visibility maps in the new format. That way, the all-visible bits - * remain set for the pages for which they were set previously. The - * all-frozen bits are never set by this conversion; we leave that to VACUUM. - */ -void -rewriteVisibilityMap(const char *fromfile, const char *tofile, - const char *schemaName, const char *relName) -{ - int src_fd; - int dst_fd; - PGIOAlignedBlock buffer; - PGIOAlignedBlock new_vmbuf; - ssize_t totalBytesRead = 0; - ssize_t src_filesize; - int rewriteVmBytesPerPage; - BlockNumber new_blkno = 0; - struct stat statbuf; - - /* Compute number of old-format bytes per new page */ - rewriteVmBytesPerPage = (BLCKSZ - SizeOfPageHeaderData) / 2; - - if ((src_fd = open(fromfile, O_RDONLY | PG_BINARY, 0)) < 0) - pg_fatal("error while copying relation \"%s.%s\": could not open file \"%s\": %m", - schemaName, relName, fromfile); - - if (fstat(src_fd, &statbuf) != 0) - pg_fatal("error while copying relation \"%s.%s\": could not stat file \"%s\": %m", - schemaName, relName, fromfile); - - if ((dst_fd = open(tofile, O_RDWR | O_CREAT | O_EXCL | PG_BINARY, - pg_file_create_mode)) < 0) - pg_fatal("error while copying relation \"%s.%s\": could not create file \"%s\": %m", - schemaName, relName, tofile); - - /* Save old file size */ - src_filesize = statbuf.st_size; - - /* - * Turn each visibility map page into 2 pages one by one. Each new page - * has the same page header as the old one. If the last section of the - * last page is empty, we skip it, mostly to avoid turning one-page - * visibility maps for small relations into two pages needlessly. - */ - while (totalBytesRead < src_filesize) - { - ssize_t bytesRead; - char *old_cur; - char *old_break; - char *old_blkend; - PageHeaderData pageheader; - bool old_lastblk; - - if ((bytesRead = read(src_fd, buffer.data, BLCKSZ)) != BLCKSZ) - { - if (bytesRead < 0) - pg_fatal("error while copying relation \"%s.%s\": could not read file \"%s\": %m", - schemaName, relName, fromfile); - else - pg_fatal("error while copying relation \"%s.%s\": partial page found in file \"%s\"", - schemaName, relName, fromfile); - } - - totalBytesRead += BLCKSZ; - old_lastblk = (totalBytesRead == src_filesize); - - /* Save the page header data */ - memcpy(&pageheader, buffer.data, SizeOfPageHeaderData); - - /* - * These old_* variables point to old visibility map page. old_cur - * points to current position on old page. old_blkend points to end of - * old block. old_break is the end+1 position on the old page for the - * data that will be transferred to the current new page. - */ - old_cur = buffer.data + SizeOfPageHeaderData; - old_blkend = buffer.data + bytesRead; - old_break = old_cur + rewriteVmBytesPerPage; - - while (old_break <= old_blkend) - { - char *new_cur; - bool empty = true; - bool old_lastpart; - - /* First, copy old page header to new page */ - memcpy(new_vmbuf.data, &pageheader, SizeOfPageHeaderData); - - /* Rewriting the last part of the last old page? */ - old_lastpart = old_lastblk && (old_break == old_blkend); - - new_cur = new_vmbuf.data + SizeOfPageHeaderData; - - /* Process old page bytes one by one, and turn it into new page. */ - while (old_cur < old_break) - { - uint8 byte = *(uint8 *) old_cur; - uint16 new_vmbits = 0; - int i; - - /* Generate new format bits while keeping old information */ - for (i = 0; i < BITS_PER_BYTE; i++) - { - if (byte & (1 << i)) - { - empty = false; - new_vmbits |= - VISIBILITYMAP_ALL_VISIBLE << (BITS_PER_HEAPBLOCK * i); - } - } - - /* Copy new visibility map bytes to new-format page */ - new_cur[0] = (char) (new_vmbits & 0xFF); - new_cur[1] = (char) (new_vmbits >> 8); - - old_cur++; - new_cur += BITS_PER_HEAPBLOCK; - } - - /* If the last part of the last page is empty, skip writing it */ - if (old_lastpart && empty) - break; - - /* Set new checksum for visibility map page, if enabled */ - if (new_cluster.controldata.data_checksum_version != PG_DATA_CHECKSUM_OFF) - ((PageHeader) new_vmbuf.data)->pd_checksum = - pg_checksum_page(new_vmbuf.data, new_blkno); - - errno = 0; - if (write(dst_fd, new_vmbuf.data, BLCKSZ) != BLCKSZ) - { - /* if write didn't set errno, assume problem is no disk space */ - if (errno == 0) - errno = ENOSPC; - pg_fatal("error while copying relation \"%s.%s\": could not write file \"%s\": %m", - schemaName, relName, tofile); - } - - /* Advance for next new page */ - old_break += rewriteVmBytesPerPage; - new_blkno++; - } - } - - /* Clean up */ - close(dst_fd); - close(src_fd); -} - void check_file_clone(void) { diff --git a/src/bin/pg_upgrade/multixact_rewrite.c b/src/bin/pg_upgrade/multixact_rewrite.c index 823984ec8f3..c45b3183684 100644 --- a/src/bin/pg_upgrade/multixact_rewrite.c +++ b/src/bin/pg_upgrade/multixact_rewrite.c @@ -25,10 +25,7 @@ static void RecordMultiXactMembers(SlruSegState *members_writer, * 32-bit offsets to the current format. * * Multixids in the range [from_multi, to_multi) are read from the old - * cluster, and written in the new format. An important edge case is that if - * from_multi == to_multi, this initializes the new pg_multixact files in the - * new format without trying to open any old files. (We rely on that when - * upgrading from PostgreSQL version 9.2 or below.) + * cluster, and written in the new format. * * Returns the new nextOffset value; the caller should set it in the new * control file. The new members always start from offset 1, regardless of @@ -42,6 +39,7 @@ rewrite_multixacts(MultiXactId from_multi, MultiXactId to_multi) SlruSegState *members_writer; char dir[MAXPGPATH] = {0}; bool prev_multixid_valid = false; + OldMultiXactReader *old_reader; /* * The range of valid multi XIDs is unchanged by the conversion (they are @@ -63,10 +61,6 @@ rewrite_multixacts(MultiXactId from_multi, MultiXactId to_multi) * Convert old multixids, if needed, by reading them one-by-one from the * old cluster. */ - if (to_multi != from_multi) - { - OldMultiXactReader *old_reader; - old_reader = AllocOldMultiXactRead(old_cluster.pgdata, old_cluster.controldata.chkpnt_nxtmulti, old_cluster.controldata.chkpnt_nxtmxoff); @@ -113,7 +107,6 @@ rewrite_multixacts(MultiXactId from_multi, MultiXactId to_multi) } FreeOldMultiXactReader(old_reader); - } /* Write the final 'next' offset to the last SLRU page */ RecordMultiXactOffset(offsets_writer, to_multi, diff --git a/src/bin/pg_upgrade/pg_upgrade.c b/src/bin/pg_upgrade/pg_upgrade.c index 2127d297bfe..e5d7920c1b1 100644 --- a/src/bin/pg_upgrade/pg_upgrade.c +++ b/src/bin/pg_upgrade/pg_upgrade.c @@ -714,13 +714,6 @@ create_new_objects(void) end_progress_output(); check_ok(); - /* - * We don't have minmxids for databases or relations in pre-9.3 clusters, - * so set those after we have restored the schema. - */ - if (GET_MAJOR_VERSION(old_cluster.major_version) <= 902) - set_frozenxids(true); - /* update new_cluster info now that we have objects in the databases */ get_db_rel_and_slot_infos(&new_cluster); } @@ -777,10 +770,7 @@ copy_xact_xlog_xid(void) * Copy old commit logs to new data dir. pg_clog has been renamed to * pg_xact in post-10 clusters. */ - copy_subdir_files(GET_MAJOR_VERSION(old_cluster.major_version) <= 906 ? - "pg_clog" : "pg_xact", - GET_MAJOR_VERSION(new_cluster.major_version) <= 906 ? - "pg_clog" : "pg_xact"); + copy_subdir_files("pg_xact", "pg_xact"); prep_status("Setting oldest XID for new cluster"); exec_prog(UTILITY_LOG_FILE, NULL, true, true, @@ -809,7 +799,6 @@ copy_xact_xlog_xid(void) check_ok(); /* Copy or convert pg_multixact files */ - Assert(new_cluster.controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER); Assert(new_cluster.controldata.cat_ver >= MULTIXACTOFFSET_FORMATCHANGE_CAT_VER); if (old_cluster.controldata.cat_ver >= MULTIXACTOFFSET_FORMATCHANGE_CAT_VER) { @@ -844,25 +833,7 @@ copy_xact_xlog_xid(void) * Determine the range of multixacts to convert. */ nxtmulti = old_cluster.controldata.chkpnt_nxtmulti; - if (old_cluster.controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER) - { - /* Versions 9.3 - 18: convert all multixids */ oldstMulti = old_cluster.controldata.chkpnt_oldstMulti; - } - else - { - /* - * In PostgreSQL 9.2 and below, multitransactions were only used - * for row locking, and as such don't need to be preserved during - * upgrade. In that case, we utilize rewrite_multixacts() just to - * initialize new, empty files in the new format. - * - * It's important that the oldest multi is set to the latest value - * used by the old system, so that multixact.c returns the empty - * set for multis that might be present on disk. - */ - oldstMulti = nxtmulti; - } /* handle wraparound */ if (nxtmulti < FirstMultiXactId) nxtmulti = FirstMultiXactId; diff --git a/src/bin/pg_upgrade/pg_upgrade.h b/src/bin/pg_upgrade/pg_upgrade.h index 1d767bbda2d..5a0d2045be5 100644 --- a/src/bin/pg_upgrade/pg_upgrade.h +++ b/src/bin/pg_upgrade/pg_upgrade.h @@ -101,19 +101,6 @@ extern char *output_files[]; #endif -/* - * The format of visibility map was changed with this 9.6 commit. - */ -#define VISIBILITY_MAP_FROZEN_BIT_CAT_VER 201603011 - -/* - * pg_multixact format changed in 9.3 commit 0ac5ad5134f2769ccbaefec73844f85, - * ("Improve concurrency of foreign key locking") which also updated catalog - * version to this value. pg_upgrade behavior depends on whether old and new - * server versions are both newer than this, or only the new one is. - */ -#define MULTIXACT_FORMATCHANGE_CAT_VER 201301231 - /* * MultiXactOffset was changed from 32-bit to 64-bit in version 19, at this * catalog version. pg_multixact files need to be converted when upgrading @@ -121,17 +108,6 @@ extern char *output_files[]; */ #define MULTIXACTOFFSET_FORMATCHANGE_CAT_VER 202512091 -/* - * large object chunk size added to pg_controldata, - * commit 5f93c37805e7485488480916b4585e098d3cc883 - */ -#define LARGE_OBJECT_SIZE_PG_CONTROL_VER 942 - -/* - * change in JSONB format during 9.4 beta - */ -#define JSONB_FORMAT_CHANGE_CAT_VER 201409291 - /* * The control file was changed to have the default char signedness, * commit 44fe30fdab6746a287163e7cc093fd36cda8eb92 @@ -429,8 +405,6 @@ void copyFileByRange(const char *src, const char *dst, const char *schemaName, const char *relName); void linkFile(const char *src, const char *dst, const char *schemaName, const char *relName); -void rewriteVisibilityMap(const char *fromfile, const char *tofile, - const char *schemaName, const char *relName); void check_file_clone(void); void check_copy_file_range(void); void check_hard_link(transferMode transfer_mode); @@ -500,10 +474,7 @@ unsigned int str2uint(const char *str); /* version.c */ -bool jsonb_9_4_check_applicable(ClusterInfo *cluster); bool protocol_negotiation_supported(const ClusterInfo *cluster); -void old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, - bool check_mode); void report_extension_updates(ClusterInfo *cluster); diff --git a/src/bin/pg_upgrade/relfilenumber.c b/src/bin/pg_upgrade/relfilenumber.c index d5088447e0d..ec2ff7acb21 100644 --- a/src/bin/pg_upgrade/relfilenumber.c +++ b/src/bin/pg_upgrade/relfilenumber.c @@ -18,7 +18,7 @@ #include "pg_upgrade.h" static void transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace, char *new_tablespace); -static void transfer_relfile(FileNameMap *map, const char *type_suffix, bool vm_must_add_frozenbit); +static void transfer_relfile(FileNameMap *map, const char *type_suffix); /* * The following set of sync_queue_* functions are used for --swap to reduce @@ -496,25 +496,10 @@ transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace, char *new_tablespace) { int mapnum; - bool vm_must_add_frozenbit = false; - - /* - * Do we need to rewrite visibilitymap? - */ - if (old_cluster.controldata.cat_ver < VISIBILITY_MAP_FROZEN_BIT_CAT_VER && - new_cluster.controldata.cat_ver >= VISIBILITY_MAP_FROZEN_BIT_CAT_VER) - vm_must_add_frozenbit = true; /* --swap has its own subroutine */ if (user_opts.transfer_mode == TRANSFER_MODE_SWAP) { - /* - * We don't support --swap to upgrade from versions that require - * rewriting the visibility map. We should've failed already if - * someone tries to do that. - */ - Assert(!vm_must_add_frozenbit); - do_swap(maps, size, old_tablespace, new_tablespace); return; } @@ -525,13 +510,13 @@ transfer_single_new_db(FileNameMap *maps, int size, strcmp(maps[mapnum].old_tablespace, old_tablespace) == 0) { /* transfer primary file */ - transfer_relfile(&maps[mapnum], "", vm_must_add_frozenbit); + transfer_relfile(&maps[mapnum], ""); /* * Copy/link any fsm and vm files, if they exist */ - transfer_relfile(&maps[mapnum], "_fsm", vm_must_add_frozenbit); - transfer_relfile(&maps[mapnum], "_vm", vm_must_add_frozenbit); + transfer_relfile(&maps[mapnum], "_fsm"); + transfer_relfile(&maps[mapnum], "_vm"); } } } @@ -540,12 +525,10 @@ transfer_single_new_db(FileNameMap *maps, int size, /* * transfer_relfile() * - * Copy or link file from old cluster to new one. If vm_must_add_frozenbit - * is true, visibility map forks are converted and rewritten, even in link - * mode. + * Copy or link file from old cluster to new one. */ static void -transfer_relfile(FileNameMap *map, const char *type_suffix, bool vm_must_add_frozenbit) +transfer_relfile(FileNameMap *map, const char *type_suffix) { char old_file[MAXPGPATH]; char new_file[MAXPGPATH]; @@ -604,14 +587,6 @@ transfer_relfile(FileNameMap *map, const char *type_suffix, bool vm_must_add_fro /* Copying files might take some time, so give feedback. */ pg_log(PG_STATUS, "%s", old_file); - if (vm_must_add_frozenbit && strcmp(type_suffix, "_vm") == 0) - { - /* Need to rewrite visibility map format */ - pg_log(PG_VERBOSE, "rewriting \"%s\" to \"%s\"", - old_file, new_file); - rewriteVisibilityMap(old_file, new_file, map->nspname, map->relname); - } - else switch (user_opts.transfer_mode) { case TRANSFER_MODE_CLONE: diff --git a/src/bin/pg_upgrade/version.c b/src/bin/pg_upgrade/version.c index 047670d4acb..9e83d4659be 100644 --- a/src/bin/pg_upgrade/version.c +++ b/src/bin/pg_upgrade/version.c @@ -12,22 +12,6 @@ #include "fe_utils/string_utils.h" #include "pg_upgrade.h" -/* - * version_hook functions for check_for_data_types_usage in order to determine - * whether a data type check should be executed for the cluster in question or - * not. - */ -bool -jsonb_9_4_check_applicable(ClusterInfo *cluster) -{ - /* JSONB changed its storage format during 9.4 beta */ - if (GET_MAJOR_VERSION(cluster->major_version) == 904 && - cluster->controldata.cat_ver < JSONB_FORMAT_CHANGE_CAT_VER) - return true; - - return false; -} - /* * Older servers can't support newer protocol versions, so their connection * strings will need to lock max_protocol_version to 3.0. @@ -46,117 +30,6 @@ protocol_negotiation_supported(const ClusterInfo *cluster) return (GET_MAJOR_VERSION(cluster->major_version) >= 1100); } -/* - * old_9_6_invalidate_hash_indexes() - * 9.6 -> 10 - * Hash index binary format has changed from 9.6->10.0 - */ -void -old_9_6_invalidate_hash_indexes(ClusterInfo *cluster, bool check_mode) -{ - int dbnum; - FILE *script = NULL; - bool found = false; - char *output_path = "reindex_hash.sql"; - - prep_status("Checking for hash indexes"); - - for (dbnum = 0; dbnum < cluster->dbarr.ndbs; dbnum++) - { - PGresult *res; - bool db_used = false; - int ntups; - int rowno; - int i_nspname, - i_relname; - DbInfo *active_db = &cluster->dbarr.dbs[dbnum]; - PGconn *conn = connectToServer(cluster, active_db->db_name); - - /* find hash indexes */ - res = executeQueryOrDie(conn, - "SELECT n.nspname, c.relname " - "FROM pg_catalog.pg_class c, " - " pg_catalog.pg_index i, " - " pg_catalog.pg_am a, " - " pg_catalog.pg_namespace n " - "WHERE i.indexrelid = c.oid AND " - " c.relam = a.oid AND " - " c.relnamespace = n.oid AND " - " a.amname = 'hash'" - ); - - ntups = PQntuples(res); - i_nspname = PQfnumber(res, "nspname"); - i_relname = PQfnumber(res, "relname"); - for (rowno = 0; rowno < ntups; rowno++) - { - found = true; - if (!check_mode) - { - if (script == NULL && (script = fopen_priv(output_path, "w")) == NULL) - pg_fatal("could not open file \"%s\": %m", output_path); - if (!db_used) - { - PQExpBufferData connectbuf; - - initPQExpBuffer(&connectbuf); - appendPsqlMetaConnect(&connectbuf, active_db->db_name); - fputs(connectbuf.data, script); - termPQExpBuffer(&connectbuf); - db_used = true; - } - fprintf(script, "REINDEX INDEX %s.%s;\n", - quote_identifier(PQgetvalue(res, rowno, i_nspname)), - quote_identifier(PQgetvalue(res, rowno, i_relname))); - } - } - - PQclear(res); - - if (!check_mode && db_used) - { - /* mark hash indexes as invalid */ - PQclear(executeQueryOrDie(conn, - "UPDATE pg_catalog.pg_index i " - "SET indisvalid = false " - "FROM pg_catalog.pg_class c, " - " pg_catalog.pg_am a, " - " pg_catalog.pg_namespace n " - "WHERE i.indexrelid = c.oid AND " - " c.relam = a.oid AND " - " c.relnamespace = n.oid AND " - " a.amname = 'hash'")); - } - - PQfinish(conn); - } - - if (script) - fclose(script); - - if (found) - { - report_status(PG_WARNING, "warning"); - if (check_mode) - pg_log(PG_WARNING, "\n" - "Your installation contains hash indexes. These indexes have different\n" - "internal formats between your old and new clusters, so they must be\n" - "reindexed with the REINDEX command. After upgrading, you will be given\n" - "REINDEX instructions."); - else - pg_log(PG_WARNING, "\n" - "Your installation contains hash indexes. These indexes have different\n" - "internal formats between your old and new clusters, so they must be\n" - "reindexed with the REINDEX command. The file\n" - " %s\n" - "when executed by psql by the database superuser will recreate all invalid\n" - "indexes; until then, none of these indexes will be used.", - output_path); - } - else - check_ok(); -} - /* * Callback function for processing results of query for * report_extension_updates()'s UpgradeTask. If the query returned any rows, -- 2.50.1 (Apple Git-155) --6vzYk1swa63ey9i6 Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename=v3-0003-psql-bump-minimum-supported-version-to-v10.patch ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
* [PATCH] Do not check the REPLICATION attribute when running REPACK. @ 2026-04-20 07:20 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 381+ messages in thread From: Antonin Houska @ 2026-04-20 07:20 UTC (permalink / raw) Although REPACK (CONCURRENTLY) uses replication slots, there is no concern that the slot will leak data of other users because the MAINTAIN privilege on the table is required anyway. The REPLICATION attribute is also not needed to prevent REPACK from stealing slots from logical replication, since commit e76d8c749c introduces a limit on the maximum number of slots used by REPACK. --- src/backend/commands/repack_worker.c | 1 - 1 file changed, 1 deletion(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index b17edd771e2..e4a4860805b 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -214,7 +214,6 @@ repack_setup_logical_decoding(Oid relid) /* * Make sure we can use logical decoding. */ - CheckSlotPermissions(); CheckLogicalDecodingRequirements(true); /* -- 2.47.3 --=-=-=-- ^ permalink raw reply [nested|flat] 381+ messages in thread
end of thread, other threads:[~2026-04-20 07:20 UTC | newest] Thread overview: 381+ 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-17 18:20 [PATCH v3 2/4] pg_upgrade: bump minimum supported version to v10 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>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox