MIME-Version: 1.0
References: 
 <CAA36mso9zgvMVr4UNHMMAQyU-dQy33EqxjZ=yEDG8SAB6yYDJw@mail.gmail.com>
In-Reply-To: 
 <CAA36mso9zgvMVr4UNHMMAQyU-dQy33EqxjZ=yEDG8SAB6yYDJw@mail.gmail.com>
From: Cagri Biroglu <cagri.biroglu@adyen.com>
Date: Wed, 8 Jul 2026 12:54:42 +0200
Message-ID: 
 <CAA36msq+KWyQPqJjZ-+fzefdC_9GLLLYX1ZvR49-CQ7yMeB=0Q@mail.gmail.com>
Subject: Re: Per-table resync for logical replication subscriptions
To: pgsql-hackers@lists.postgresql.org
Content-Type: multipart/mixed; boundary="000000000000693c570656175610"
Archived-At: 
 <https://www.postgresql.org/message-id/CAA36msq%2BKWyQPqJjZ-%2BfzefdC_9GLLLYX1ZvR49-CQ7yMeB%3D0Q%40mail.gmail.com>
Precedence: bulk

--000000000000693c570656175610
Content-Type: multipart/alternative; boundary="000000000000693c56065617560e"

--000000000000693c56065617560e
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

here is the WIP patch for the disabled-subscription case.
It adds:

    ALTER SUBSCRIPTION name REFRESH TABLE table_name
        [ WITH (copy_data =3D true, truncate =3D true) ]

The command is subscriber-local: it resets just the named relation in
pg_subscription_rel back to the initial sync state (optionally
truncating the local copy first), so a tablesync worker re-copies that
one table on the next enable, reusing the existing tablesync machinery.
Publication membership and other tables are left untouched.  As
discussed, this first version requires the subscription to be disabled.

The tests are included in the same patch: a TAP test at
src/test/subscription/t/039_refresh_table.pl that

  - resyncs one drifted table on a two-node setup and confirms it
    matches the publisher again after re-enabling;
  - confirms only the targeted relation is reset (a sibling table is
    left in 'r' state);
  - checks the rejection cases: enabled subscription, table not in the
    subscription, a sequence, truncate without copy_data, and running
    inside a transaction block.

The full src/test/subscription suite and the core regression tests pass
with the patch applied.

Open questions if this direction makes sense ,I would still like feedback
on: the command spelling
(REFRESH TABLE vs RESYNC TABLE), and whether the enabled-subscription
case is worth doing as a follow-up (it needs the running apply worker to
notice and re-read the reset relation state).

Regards,
Cagri Biroglu

On Tue, Jul 7, 2026 at 11:41=E2=80=AFAM Cagri Biroglu <cagri.biroglu@adyen.=
com>
wrote:

> Hi hackers,
>
> I would like to propose a subscriber-side way to re-copy a single table
> that is already part of a logical replication subscription.
>
> At the moment, I do not think PostgreSQL has a supported way to do this
> for one table on one subscriber. ALTER SUBSCRIPTION ... REFRESH
> PUBLICATION only handles tables that were added to the subscribed
> publications since the subscription was created, or since the last refres=
h.
> It does not re-copy tables that are already known to the subscription.
>
> That is fine for the normal =E2=80=9Cnew table was added to the publicati=
on=E2=80=9D case,
> but it leaves a gap when only one subscriber needs one table to be
> re-seeded. Some examples are:
>
>    -
>
>    the subscriber table became inconsistent;
>    -
>
>    a row filter changed and the subscriber needs a fresh copy;
>    -
>
>    a forwarder/subscriber needs to repair one table without disturbing
>    other subscribers.
>
> The usual workaround is to temporarily change publication membership,
> refresh the subscription, truncate the local table, add the table back, a=
nd
> refresh again. That works in simple topologies, but it is not really loca=
l
> to the subscriber. In a fan-out topology it can affect sibling subscriber=
s,
> and in a forwarding topology the truncate can be replicated further
> downstream if truncates are published.
>
> There is also the unsupported option of updating pg_subscription_rel by
> hand to put the table back into the initial sync state. That is not safe
> either, because it races with the apply worker and does not handle the
> surrounding cleanup and invalidation work.
>
> There is already a similar mechanism for sequences. ALTER SUBSCRIPTION
> ... REFRESH SEQUENCES can re-synchronize sequence data for sequences
> already known to the subscription, while REFRESH PUBLICATION only
> discovers newly added ones. This proposal is essentially the table-side
> equivalent of that idea.
>
> What I am proposing is something like:
>
> ALTER SUBSCRIPTION name REFRESH TABLE table_name
>     [ WITH (copy_data =3D true, truncate =3D true) ];
>
> or, if people prefer the wording:
>
> ALTER SUBSCRIPTION name RESYNC TABLE table_name
>     [ WITH (copy_data =3D true, truncate =3D true) ];
>
> The command would be subscriber-local and would not change publication
> membership. Internally, it would reuse the existing table synchronization
> machinery by resetting the selected relation back to the initial sync
> state, so that a tablesync worker copies it again and moves it through th=
e
> normal i -> d -> s -> r states.
>
> I tested the current behavior on current devel with a small three-node
> setup:
>
>    -
>
>    upstream publisher U;
>    -
>
>    forwarding subscriber/publisher F;
>    -
>
>    downstream subscriber D;
>    -
>
>    sibling subscriber S.
>
> The test script keeps a writer running and prints per-table checksums at
> each step.
>
> The important observations were:
>
>    1.
>
>    ALTER SUBSCRIPTION ... REFRESH PUBLICATION on F is a no-op for an
>    already subscribed table. The table remained in ready state, the tuple
>    metadata did not change, no WAL was generated, and no sync worker was
>    started.
>    2.
>
>    The publication-membership workaround is not local. In the forwarding
>    case, truncating the table on F also wiped the table on D. In the
>    fan-out case, the sibling subscriber S was left behind because the
>    publication changes were global but the repair was only intended for F=
.
>    3.
>
>    A controlled subscriber-local reset of only the selected table on F
>    produced matching checksums again without touching the publication or =
S.
>    Doing the same thing as a bare catalog update while the subscription
>    remained enabled was not reliable; the apply worker could continue wit=
h
>    cached state and the table diverged.
>
> So I do not think the hard part is inventing a new synchronization
> mechanism. The existing tablesync path already does most of the work. The
> missing piece is a supported command that performs the reset safely:
> stopping or coordinating with workers, cleaning up per-table sync state a=
nd
> slots/origins where needed, optionally truncating the target table,
> invalidating caches, taking the right locks, and validating that the
> requested table is actually part of the subscription.
>
> For a first version, I think it would be reasonable to require the
> subscription to be disabled. That avoids the apply-worker race and keeps
> the patch smaller. A later version could support the enabled case, probab=
ly
> by making the running worker notice and re-read the changed relation stat=
e.
>
> I have a WIP patch for the disabled-subscription, executor changes, and a
> TAP test. Before polishing it further, I would like to get feedback on
> whether this direction makes sense ?
>
> Regards,
>
> Cagri Biroglu
>

--000000000000693c56065617560e
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">here is the WIP patch for the disabled-subscription case.<=
br>It adds:<br><br>=C2=A0 =C2=A0 ALTER SUBSCRIPTION name REFRESH TABLE tabl=
e_name<br>=C2=A0 =C2=A0 =C2=A0 =C2=A0 [ WITH (copy_data =3D true, truncate =
=3D true) ]<br><br>The command is subscriber-local: it resets just the name=
d relation in<br>pg_subscription_rel back to the initial sync state (option=
ally<br>truncating the local copy first), so a tablesync worker re-copies t=
hat<br>one table on the next enable, reusing the existing tablesync machine=
ry.<br>Publication membership and other tables are left untouched.=C2=A0 As=
<br>discussed, this first version requires the subscription to be disabled.=
<br><br>The tests are included in the same patch: a TAP test at<br>src/test=
/subscription/t/<a href=3D"http://039_refresh_table.pl">039_refresh_table.p=
l</a> that<br><br>=C2=A0 - resyncs one drifted table on a two-node setup an=
d confirms it<br>=C2=A0 =C2=A0 matches the publisher again after re-enablin=
g;<br>=C2=A0 - confirms only the targeted relation is reset (a sibling tabl=
e is<br>=C2=A0 =C2=A0 left in &#39;r&#39; state);<br>=C2=A0 - checks the re=
jection cases: enabled subscription, table not in the<br>=C2=A0 =C2=A0 subs=
cription, a sequence, truncate without copy_data, and running<br>=C2=A0 =C2=
=A0 inside a transaction block.<br><br>The full src/test/subscription suite=
 and the core regression tests pass<br>with the patch applied.<br><br>Open =
questions if this direction makes sense ,I would still like feedback on: th=
e command spelling<br>(REFRESH TABLE vs RESYNC TABLE), and whether the enab=
led-subscription<br>case is worth doing as a follow-up (it needs the runnin=
g apply worker to<br>notice and re-read the reset relation state).<br><br>R=
egards,<br>Cagri Biroglu<br></div><br><div class=3D"gmail_quote gmail_quote=
_container"><div dir=3D"ltr" class=3D"gmail_attr">On Tue, Jul 7, 2026 at 11=
:41=E2=80=AFAM Cagri Biroglu &lt;<a href=3D"mailto:cagri.biroglu@adyen.com"=
>cagri.biroglu@adyen.com</a>&gt; wrote:<br></div><blockquote class=3D"gmail=
_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204=
,204);padding-left:1ex"><div dir=3D"ltr"><p>Hi hackers,</p><p>I would like =
to propose a subscriber-side way to re-copy a single table that is already =
part of a logical replication subscription.</p><p>At the moment, I do not t=
hink PostgreSQL has a supported way to do this for one table on one subscri=
ber. <code>ALTER SUBSCRIPTION ... REFRESH PUBLICATION</code> only handles t=
ables that were added to the subscribed publications since the subscription=
 was created, or since the last refresh. It does not re-copy tables that ar=
e already known to the subscription.</p><p>That is fine for the normal =E2=
=80=9Cnew table was added to the publication=E2=80=9D case, but it leaves a=
 gap when only one subscriber needs one table to be re-seeded. Some example=
s are:</p><ul><li><p>the subscriber table became inconsistent;</p></li><li>=
<p>a row filter changed and the subscriber needs a fresh copy;</p></li><li>=
<p>a forwarder/subscriber needs to repair one table without disturbing othe=
r subscribers.</p></li></ul><p>The usual workaround is to temporarily chang=
e publication membership, refresh the subscription, truncate the local tabl=
e, add the table back, and refresh again. That works in simple topologies, =
but it is not really local to the subscriber. In a fan-out topology it can =
affect sibling subscribers, and in a forwarding topology the truncate can b=
e replicated further downstream if truncates are published.</p><p>There is =
also the unsupported option of updating <code>pg_subscription_rel</code> by=
 hand to put the table back into the initial sync state. That is not safe e=
ither, because it races with the apply worker and does not handle the surro=
unding cleanup and invalidation work.</p><p>There is already a similar mech=
anism for sequences. <code>ALTER SUBSCRIPTION ... REFRESH SEQUENCES</code> =
can re-synchronize sequence data for sequences already known to the subscri=
ption, while <code>REFRESH PUBLICATION</code> only discovers newly added on=
es. This proposal is essentially the table-side equivalent of that idea.</p=
><p>What I am proposing is something like:</p><pre><code>ALTER SUBSCRIPTION=
 name REFRESH TABLE table_name
    [ WITH (copy_data =3D true, truncate =3D true) ];
</code></pre><p>or, if people prefer the wording:</p><pre><code>ALTER SUBSC=
RIPTION name RESYNC TABLE table_name
    [ WITH (copy_data =3D true, truncate =3D true) ];
</code></pre><p>The command would be subscriber-local and would not change =
publication membership. Internally, it would reuse the existing table synch=
ronization machinery by resetting the selected relation back to the initial=
 sync state, so that a tablesync worker copies it again and moves it throug=
h the normal <code>i -&gt; d -&gt; s -&gt; r</code> states.</p><p>I tested =
the current behavior on current devel with a small three-node setup:</p><ul=
><li><p>upstream publisher <code>U</code>;</p></li><li><p>forwarding subscr=
iber/publisher <code>F</code>;</p></li><li><p>downstream subscriber <code>D=
</code>;</p></li><li><p>sibling subscriber <code>S</code>.</p></li></ul><p>=
The test script keeps a writer running and prints per-table checksums at ea=
ch step.</p><p>The important observations were:</p><ol><li><p><code>ALTER S=
UBSCRIPTION ... REFRESH PUBLICATION</code> on <code>F</code> is a no-op for=
 an already subscribed table. The table remained in ready state, the tuple =
metadata did not change, no WAL was generated, and no sync worker was start=
ed.</p></li><li><p>The publication-membership workaround is not local. In t=
he forwarding case, truncating the table on <code>F</code> also wiped the t=
able on <code>D</code>. In the fan-out case, the sibling subscriber <code>S=
</code> was left behind because the publication changes were global but the=
 repair was only intended for <code>F</code>.</p></li><li><p>A controlled s=
ubscriber-local reset of only the selected table on <code>F</code> produced=
 matching checksums again without touching the publication or <code>S</code=
>. Doing the same thing as a bare catalog update while the subscription rem=
ained enabled was not reliable; the apply worker could continue with cached=
 state and the table diverged.</p></li></ol><p>So I do not think the hard p=
art is inventing a new synchronization mechanism. The existing tablesync pa=
th already does most of the work. The missing piece is a supported command =
that performs the reset safely: stopping or coordinating with workers, clea=
ning up per-table sync state and slots/origins where needed, optionally tru=
ncating the target table, invalidating caches, taking the right locks, and =
validating that the requested table is actually part of the subscription.</=
p><p>For a first version, I think it would be reasonable to require the sub=
scription to be disabled. That avoids the apply-worker race and keeps the p=
atch smaller. A later version could support the enabled case, probably by m=
aking the running worker notice and re-read the changed relation state.</p>=
<p>I have a WIP patch for the disabled-subscription, executor changes, and =
a TAP test. Before polishing it further, I would like to get feedback on wh=
ether this direction makes sense ?</p><p>Regards,<br></p><p>Cagri Biroglu</=
p></div>
</blockquote></div>

--000000000000693c56065617560e--

--000000000000693c570656175610
Content-Type: application/octet-stream; name="v1-0001-refresh-table.patch"
Content-Disposition: attachment; filename="v1-0001-refresh-table.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mrbyntvd0>
X-Attachment-Id: f_mrbyntvd0
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--000000000000693c570656175610--