A pipeline's tables
A PostgreSQL pipeline syncs as many tables as you pick, from as many schemas as you like, through one publication and one replication slot on your source. Each table has its own state, and when one table has a problem, that table stops and the others keep syncing, unless the pipeline is set to stop every table when one stops (see When a source table’s shape changes).
On the pipeline’s Schema tab each table is one row of a grid: its name and where it lands, its state, a link to its columns and filter, and how its changes land. Its name opens its drawer: what it waits for or why it stopped, the statement to run where there is one, its notes and counts, and its actions.
Where each table lands
Section titled “Where each table lands”Each table lands in the destination schema its own source schema names: with Fivetran naming
sales.orders lands in <pipeline>_sales; with source naming in sales. A PostgreSQL destination
writes each table in the schema of the same name. Two tables your destination would write as one
(such as Orders and ORDERS into Snowflake) are refused when you create the pipeline, both named.
What each state means
Section titled “What each state means”| State | What it means | What brings it on |
|---|---|---|
| Waiting | Picked, not copied yet. Its drawer says why: the source does not publish it yet (with the statement that does), a partition of it does not carry its key, copying it now would hold more of the source’s change log than it keeps, it has no primary key and waits for what syncing it needs (its drawer says what, with the statement that does it where there is one; see A table without a key), its PostgreSQL 17 release is older than 17.6, or a transaction on your source that may have changed it before it was published is still open (its drawer names the session; the other tables stream meanwhile). | It is copied as soon as the reason clears: the pipeline checks about once a minute while it runs. A table waiting for a transaction is copied once the transactions its copy first saw have ended; one that began later is never waited for. An old PostgreSQL 17 release is checked again when the pipeline next starts, which an upgrade of the source causes. |
| Copying | Its existing rows are being copied. While a table is being copied, the pipeline’s other tables pause, then catch up; nothing is lost. Tables copied at the same start (a new pipeline’s, for example) are copied one after another, and the others catch up once the last of them is copied. A large table pauses them for longer. On a source that limits the change log it keeps for the slot (max_slot_wal_keep_size), a copy that has used half of that room stops between batches: the table waits, the other tables catch up and free the log, and it is copied once more when there is room. Stopped a second time, it is parked, naming max_slot_wal_keep_size: raise it on the source, or remove the table. |
The copy ends. |
| Catching up | Copied (or resumed), and replaying the changes made since, before it joins the others. | It reaches the others. |
| Streaming | Up to date, and its changes arrive as they happen. | |
| Parked | Stopped on its own, with what happened and what brings it back. The other tables keep syncing, unless the pipeline is set to stop every table when one stops. | Resume, once the cause is fixed. A table waiting for your answer to a change: answer it, then Resume with these answers. |
| Removed | No longer synced. Its rows stay in your destination. | Add it back. |
A parked table either keeps its place in the source’s change log (a cause on the destination side, such as a value its column cannot take, or a change to the table’s shape the pipeline is set to ask you about): Resume replays its changes from there, with no copy. Or lets its place go (a cause on the source side, such as the table being replaced, or the source keeping too much log for it): Resume copies it again. A parked table that keeps its place lets it go if your source runs short of room for its log, and its drawer says so.
How current your destination is
Section titled “How current your destination is”A pipeline whose source is PostgreSQL (by logical replication) shows how current its destination is
in the pipeline’s header on every tab of its page but Overview, which says it under About this pipeline
with the clock and standby details, and the API gives the same on the pipeline (freshness) and on each
streaming table (caught_up_as_of, behind_by_seconds). It is for a PostgreSQL source read by logical
replication only: a MySQL source, and a PostgreSQL pipeline that reads by queries, do not report their
clock, so nothing about their freshness is shown and no freshness threshold can be set for them. A
threshold set before a full re-sync switched a pipeline to queries is kept but does nothing, and
Settings › Notifications and when to warn me no longer shows it. It is kept only until the pipeline’s
notifications are next saved, which clears it: a save replaces every threshold, and the form sends none for a
field it does not show. If a re-sync switches the pipeline back to logical replication while the threshold is
still kept, it applies again from then, and the form shows it again.
- Current as of 10:05 (2 minutes behind). Your destination holds every change your source had committed by 10:05, by our clock. A moment more than a day old carries its date, and a long gap is said in hours or days.
- Held by your schedule. A PostgreSQL pipeline into Snowflake gathers changes and writes them on its schedule, so it is behind by up to the schedule’s gap by design. Said only while the pipeline runs with nothing wrong: a paused, broken or retrying pipeline shows how far behind it is, never “held”.
- Freshness not measured yet. The pipeline has not read its source’s clock yet (it has not started, it is starting, or its worker is from a release before this one). It is never shown as “0 minutes behind”.
A quiet source is current: about once a minute the pipeline reads your source’s end of log and its clock, and once replication has passed that point with everything written, the destination is proved current as of then, though nothing changed. That proof can take a second minute when other applications write to the same database, so a quiet pipeline reads up to about two minutes behind. A large transaction still being read, or a backlog after the pipeline was stopped, is not current until it is written. A pipeline whose worker restarts (a deploy, a change you make, a retry) keeps the proof it had. The figure covers the tables that are streaming: a table that is copying, waiting or parked is not counted in it.
On a standby (a read replica) as the source, the figure is measured to the last change the standby replayed, by your primary’s clock: the standby can only hold what it has replayed. So a standby that lags its primary, or whose replay is paused, reads behind by that much, and so does a quiet primary with no changes at all; the page says “measured on a standby” beside the figure. A freshness threshold on such a pipeline therefore also raises when your primary has had no changes for that long.
Your source’s clock is measured, not trusted. A commit time is your source server’s clock. The pipeline reads that clock directly and removes the difference from ours, so a source whose clock is a few minutes off still reads its true age; when the difference is a minute or more, the page says so (“the source’s clock is 180 seconds ahead of ours, and is corrected for”). On a standby source the commit times are your primary’s, while the clock the pipeline reads is the standby’s, so a difference between those two is NOT corrected: keep your primary and standby on the same time (NTP).
To be told when the data is too old, set Data older than on the pipeline’s notifications
(freshness_minutes, 5 minutes to a week): data_stale then raises when the destination is that
much older than its schedule allows. See Notifications.
Adding, removing, resuming and copying again
Section titled “Adding, removing, resuming and copying again”On the pipeline’s Schema tab, or through the API (/v1/pipelines/{id}/tables):
- Add a table (or add back a removed one): run the statement shown on your source to publish it. It is copied as soon as the publication lists it, then streams.
- Remove a table: it stops syncing; its rows stay in your destination. The optional statement shown takes it out of the publication.
- Resume a parked table, once its cause is fixed. A table at a PostgreSQL destination stopped because its
source rewrote a column of its key (
type_change_rewrote_key) is not resumed unless it is kept in soft delete: it offers Re-sync and Re-sync and delete them instead (what each does). - Re-sync (once named Copy again): the table’s rows are copied again over what your destination holds. Re-sync and sync modes has the rest.
Each is applied by the pipeline itself, within about a minute if it is running. A Re-sync or a Remove asked of a table the source has just dropped, renamed away, replaced or taken out of the publication waits until the pipeline has written the changes it still holds for that table, so they are not lost to the request; the history says so (“A request waits for a table’s last changes”), and the request is applied then. Where nothing the pipeline recorded lets it read those changes, the table’s drawer says they did not arrive, and the request is applied once the table has stopped.
Rows your source no longer has
Section titled “Rows your source no longer has”A table copied again over rows the pipeline may have written before (it streamed, or an earlier copy of it began and was stopped to free your source’s change log, or was parked) is checked for the rows your source no longer has. It is copied by its mode: in soft delete keeping every row your destination already has, a row your source no longer has marked deleted; kept live, replacing what your destination holds, a row your source no longer has removed, unless the table has a primary key and its destination is PostgreSQL, which keeps it, and a row a new row filter leaves out is, by the table’s mode and your answer to that filter’s change, kept, marked deleted or removed (below). What becomes of the rows your source no longer has, at each destination:
- Snowflake, with or without a primary key: they are marked deleted (
_REYANSH_DELETED_AT) in soft delete, as a re-sync marks them in Fivetran, and removed in live. - PostgreSQL: in soft delete they are marked deleted (
_reyansh_deleted_at). Kept live, a table with no primary key has them removed; a table with a primary key is yours and may hold rows you wrote, so they are kept and counted: the table’s drawer says how many. Re-sync and delete them deletes exactly those, and says how many it deleted. A count that could not be made says so; it is never shown as 0. The one place it is offered before any count is a table stopped because its source rewrote a column of its key, where it is one of the two copies to choose between, and its confirmation says what it deletes in words.
A copy under a row filter that was added or narrowed since the table last streamed counts the rows the filter leaves out apart from the rows deleted at your source, judging the filter on your table’s own values: those are told as removed, marked deleted or kept, by the table’s mode and your answer for them, and never counted as missing at your source. Re-sync and delete them never deletes a row outside the filter. Where the filter cannot be judged on your table’s values (it reads a column this pipeline hashes, or one your table declares differently from your source), and always on Snowflake, the two cannot be told apart, and the table’s drawer says so instead of a count.
Copying a table again into PostgreSQL keeps the keys it wrote in a table of its own beside yours
while it runs (see Where the copy keeps its place), which needs
CREATE on that schema. Where the role cannot create it, the copy counts in a temporary table
instead, so the destination role needs TEMPORARY on its database, which every role has unless it
was revoked.
Verifying a table’s row counts
Section titled “Verifying a table’s row counts”Verify row counts in a table’s drawer on the Schema tab (press the table’s name), or
POST /v1/pipelines/{id}/tables/{table_id}/verify, asks the running
pipeline to count the table’s rows at your source and at your destination and say whether they agree. It
compares counts only: a row missing and another held twice count the same, so the destination’s
distinct keys are counted too, but the values in the rows are not compared.
It is offered for a pipeline that reads its source’s change log; a pipeline that reads by queries is
refused (verify_not_offered), and its Schema tab says so once instead of offering it on each table.
It never restarts the pipeline and never holds another request of the table. The table shows the request
while it waits, then the answer, which the activity feed also tells (table_verified):
- Row counts match, on a check the table did not change during. Where they match only once the rows
your destination discarded (a trigger or rule that skipped them, reported as
rows_discarded) or the rows a re-copy kept that your source no longer has (above) are counted, the answer says so and shows both numbers. A discard reported more than once (the same row skipped by a replay or a re-copy) is counted each time, so such a match says the difference is no larger than what your destination reported skipping, not which rows they were. - Row counts differ, only when three checks, at least 30 seconds apart, that the table did not change during, all differ the same way. A table that keeps changing is never called different on one count. The answer shows both counts and says whether a key is held more than once.
- Could not be compared, and why: the table kept changing, so in 6 checks no verdict could be read; a
count ran past its bound or was refused (a row-level security policy on your source applies to the
pipeline’s role, for example: give it
BYPASSRLS); or the table is being copied, catching up or parked. - Counts cannot judge this table: a table with no primary key, one kept in history or append, or one your publication does not send whole (a row filter on the publication, or one that does not publish inserts, updates and deletes).
What it costs, said before it runs. Each check counts the table at your source in ONE read-only statement of at most 60 seconds, on its own connection, with the table’s row filter applied: never a long snapshot, so your database’s clean-up (vacuum) is held back no longer than that statement, and it takes no parallel workers. A table that cannot be counted in 60 seconds is told so and not counted again. At a Snowflake destination the destination’s count runs right after a write the pipeline makes anyway, so it never wakes the warehouse on its own; a pipeline with nothing to write waits for its next write, for up to a day. A row marked deleted at the destination is never counted.
While a count runs the pipeline writes nothing: at most 2 minutes for each count, at the source or at the destination (a count that would take longer is stopped there, by the database itself where it can be, and told as not compared, never left running). So the pipeline counts at most once between two of its writes while it has changes to write, and several tables asked together take turns rather than pausing it back to back. At a Snowflake destination the warehouse stays running for as long as the count takes, which adds to the time it runs for the write it woke for.
When a copy is interrupted
Section titled “When a copy is interrupted”A large table’s copy can take hours, and the pipeline can stop or restart in the middle of it: you stopped it, it was restarted, a connection was lost, its worker failed. An interrupted copy carries on from where it had got. It does not start again from the first row, and the rows already copied are counted once.
- A PostgreSQL destination saves the copy’s place after every batch; Snowflake saves it about once a minute, because each save is a statement your warehouse runs.
- A stop is taken between two batches, after the copy has saved its place, so nothing is read again. If the worker fails, or is ended before it gets there, at most the last batch (PostgreSQL) or about the last minute of rows (Snowflake) is read again and written over the same rows.
- Re-sync is refused while a table is being copied, a new pipeline’s first copy included (“The table … is being copied now. Ask again once its copy has finished.”): the copy carries on where it is, and you can ask once it has finished.
- A copy stopped because your source was running short of room for its change log (see Copying above) gives its place up, so it is copied again from the first row when there is room.
- An interrupted copy that carries on is the same copy, so it is not checked for rows your source no longer has on account of the interruption.
What you see
Section titled “What you see”While a table is copied, the pipeline’s page says so above its tabs, on every tab: Overview says it whole, with the rows copied so far, and every other tab in one line that links to it. After an interruption, Overview adds one of these:
-
“Copy resumed after an interruption, at {n} rows.” The count carries on from there. On Snowflake it can step back by up to a minute of rows, to the place that was saved.
-
That the copy started again from the first row, and why:
Why The page says The table’s key changed “The table’s key changed while it was being copied, so its copy started again from the first row.” A column being copied was dropped or changed type “Columns being copied changed at the source, so the copy started again from the first row.” The destination table was dropped, replaced or emptied “{table} in your destination is not the table this copy was writing (it was dropped, replaced or emptied), so the copy started again from the first row.” The saved place did not read back exactly “Where the copy had reached could not be read back exactly, so it started again from the first row.” The keys kept for a table copied again were lost “The record of rows this copy wrote was lost from your destination, so the copy started again from the first row.” The order of the table’s key changed at the source (its collation changed version) “The order of this table’s key changed at the source, so the copy started again from the first row.” It is then copied as one statement, so the page also says that an interruption starts it again from the first row. -
“Interrupted once since it began {date}.” (or “Interrupted {n} times …”), only when the page has loaded the pipeline’s whole history (Show older until there is no more), not narrowed to one run. A copy that started again from the first row within one run, because its saved place did not read back, was not interrupted and is not counted. On a long copy the history is many pages, so this line is usually not shown.
Through the API, each attempt of a copy is a snapshot_started row of
GET /v1/pipelines/{id}/observations. It carries copy (an id shared by every attempt of one
table’s copy) and, when they apply, resumed.rows_copied, restarted.reason and
not_resumable.reason.
A copy that cannot carry on
Section titled “A copy that cannot carry on”Some copies cannot keep a place to carry on from. Such a table is copied in one statement, as every
table was before, and from its first attempt the page says “If this copy is interrupted it starts
again from the first row”, followed by the reason below in a few words (since 2026-10-11 (IST), for
every reason; before, four of them had the first half only). not_resumable.reason always names it:
reason |
What it means |
|---|---|
key_index_order |
The index behind the table’s key is not a plain ascending one with each column’s own collation and default operator class (a DESC column, or text_pattern_ops, for example), or a key column’s type compares through operators that are not PostgreSQL’s own (an extension’s type, such as citext or ltree; since 2026-10-26 (IST)). |
collation_version |
The collation of a key column, or your database’s default collation, has changed version since it was recorded. |
plan |
Your database would not read the table in key order through that index. |
key_literal |
A value of the table’s key does not read back exactly as it was written. |
progress_table |
The copy’s place cannot be kept in your destination (see below). |
reconcile_keys |
On a PostgreSQL destination, for a table copied again: the role cannot create the table that keeps the keys this copy wrote. |
Where the copy keeps its place
Section titled “Where the copy keeps its place”In your destination, never with us: the place is a key value of one of your own rows.
- PostgreSQL: a small table,
_reyansh_copy_v1, in the schema the table is written in, beside your tables. The pipeline creates it the first time a table is copied there, which needsCREATEon that schema. It holds one row for each table being copied (which copy it is, the last key copied, the table’s highest key when the copy began, and the counts), removed when the copy ends. If the role cannot create it, the copy still runs and completes, but cannot carry on after an interruption (progress_table); grant the roleCREATEon the schema and the next attempt creates it. - A table copied again on PostgreSQL also gets a table of its own beside it while it is copied,
_reyansh_recopy_followed by 32 characters: the keys this copy wrote, which the check for rows your source no longer has reads. It is dropped when the copy ends. - Snowflake:
_REYANSH_COPY, in the pipeline’s working schema (_REYANSH_<SCHEMA>, see Where a pipeline writes).
Dropping _reyansh_copy_v1 or _REYANSH_COPY is safe when no copy is running. A copy that was
under way then starts again from its first row. Do not change a row in it: the copy trusts the
place it saved, and a place moved forward leaves the rows before it uncopied.
The copy also remembers which destination table it was writing and the last row that table kept. If the table was dropped, recreated, replaced or emptied between two attempts, the copy starts again from the first row. Rows you delete from it while it is being copied, other than that last row, are not noticed.
On your source
Section titled “On your source”- Before a copy reads a table, it waits for every transaction that may have changed the table before the
pipeline’s publication sent it: each one holding a lock that writing to the table takes (
ROW EXCLUSIVE, which everyINSERT,UPDATE,DELETE,MERGEandCOPY FROMtakes, orACCESS EXCLUSIVE, whichTRUNCATEtakes). PostgreSQL never sends a change a transaction made to a table before the table was published, so only a copy taken after that transaction ended holds it. A reader, an index build,ANALYZE, a trigger or a foreign key being added is never waited for. This usually takes milliseconds. If such a transaction is still open after one second, that table waits (its drawer names the session by process id, andpg_stat_activityshows it), the other tables stream meanwhile, and the table is copied on its own once the transactions its copy first saw have ended; a transaction that began later is never waited for. Behind a synchronous standby the copy also waits, at most that second, for a commit of the same table that the pipeline’s stream has already passed and the standby has not confirmed, never for a transaction on another table. Past that second that table alone waits until the commit is confirmed; its drawer names the session and says the commit waits for the standby named insynchronous_standby_names. None of this needs a privilege beyond the role this guide asks for. - On a standby, the copy cannot see the primary’s locks, so it waits for every transaction the primary was
running when it first looked, as far as the standby can tell. One case it cannot tell: a transaction whose
first write came while your own
ALTER PUBLICATION ... ADD TABLE(or the transaction it ran in) was still open, when no later transaction on the primary has finished by the time the copy first looks (a later attempt keeps that first look). That transaction’s writes to the table made before the publication change committed can be missing from the copy. Publish the table in a statement of its own (the window is then milliseconds); on a primary that writes anything at all, it closes as soon as another transaction finishes. - The pipeline keeps its place in your source’s change log from the moment a table’s copy begins until the copy ends, across interruptions too, as before: the log your source keeps for the replication slot grows for that long, also while the pipeline is stopped in the middle of a copy.
- A copy that can carry on reads the table in key order through its key’s index, a slice at a time
(at most 100,000 rows). Each slice takes the lock a
SELECTtakes (ACCESS SHARE) and holds it only until its rows have been read, so anALTER TABLEon the table waits for one slice of the copy, not for the whole copy. If the copy cannot get that lock within 60 seconds, three times running, that run ends and the pipeline tries again by itself, from the place the copy saved. - A column added during a copy does not disturb it. A column the copy reads that is dropped or changes type ends that run; the pipeline restarts by itself and copies the table again from the first row.
Partitioned tables
Section titled “Partitioned tables”A partitioned table syncs through its root: one destination table, named after the root, holding
every partition’s rows. Publish it with the statement the setup shows for it: the setup creates the
pipeline’s publication with its publish_via_partition_root option on, which a partitioned table
needs. The role needs SELECT on the root only.
If the publication lists the table but its publish_via_partition_root option is off, PostgreSQL
sends the table’s changes under each partition’s name, and none reach the pipeline: the table
waits (root_sent_as_partitions), and its drawer shows the statement that turns the option on, the
setting the pipeline’s publication is created with. With it on, a partition the publication also
lists by its own name is sent under the root’s name too, and judged without its own column list and
without its own row filter, so rows such a filter leaves out are published from then on: on
PostgreSQL 18 or later, where that partition’s replica identity holds a generated column the
publication does not send, PostgreSQL would then refuse its UPDATE and DELETE, so the statement
changes nothing there and says why. A table with no primary key that syncs and
then finds the option off is parked, and resuming it once the option is on copies it again.
- A row moved from one partition to another arrives as a delete and an insert, and is held once, under its new key.
- A partition attached later is told on the pipeline’s history, whether the pipeline was running then or not (a start compares the partitions with those the last start found, and tells an attach or a detach it finds). PostgreSQL does not send the rows a partition held when it was attached: copy the table again to include them.
- A partition detached is told too. Its rows stay in your destination: PostgreSQL sends no delete for a detach.
- A partition detached or dropped while the table is being copied, or while its copy was interrupted, is told as well, saying which. The copy reads none of its other rows and carries on; any of its rows the copy wrote before then stay in your destination. A partition attached during the copy is read whole before the copy ends.
- Emptying a partition (
TRUNCATEon the partition) is not sent by PostgreSQL either. - Every partition must carry the table’s key in its replica identity; one that does not keeps the table waiting, with the statement to run.
An ordinary table that other tables inherit from (INHERITS) is copied without its children’s rows,
as its changes are streamed.
A table without a key
Section titled “A table without a key”When you create a pipeline, such a table can be picked like any other: the form marks it “No primary key: each row is identified by a hash of all its values”. Copied again (resumed after a stop that let its place go, or re-synced), it is copied by its mode: in soft delete keeping every row your destination already has, a row your source no longer has, or one a new row filter leaves out, marked deleted; kept live, replacing what your destination holds, so both are removed.
A table with no primary key, and no unique index on NOT NULL columns made its replica identity,
is synced by the whole row: each destination row is one distinct row of the table, found by a hash
of the row, with a count of how many source rows are that row (the columns _REYANSH_ID and
_REYANSH_COUNT on Snowflake, _reyansh_id and _reyansh_count on PostgreSQL). It
syncs every change from the pipeline’s publication once the table and each of its partitions is
REPLICA IDENTITY FULL, which makes each update and delete carry the whole old row. That costs
your database something for as long as the table keeps it: every UPDATE and DELETE on it writes
the whole old row to the write-ahead log, so your WAL and your replication traffic grow. (Syncing
only its new rows, through a second, insert-only publication, is not offered in this release.) Never
add it to the pipeline’s main publication as it is: published there with no replica identity, your
database refuses every UPDATE and DELETE on it. While it waits, its drawer on the pipeline’s Schema tab
(press the table’s name) says what it waits for, and shows the statement to run where one is to be run: the
statement that gives it REPLICA IDENTITY FULL changes nothing, and says why, where your database
would refuse its UPDATE and DELETE even under that (a publication that sends them has a column
list for it, or, on PostgreSQL 18 or later, does not send one of its generated columns).
Once a table with no key holds rows, a column’s setting can only stay as the destination holds it: blocking, hashing or un-hashing a column would give every row already there a new identity, so it is refused, and such a table is never filled (see “What is not offered yet” in the guide to blocking, hashing and filtering). Set columns before its first copy, or give it a primary key.
On a pipeline created without copying existing rows, a table with no key is not copied either, and what its first start does depends on whether it can sync yet:
- Every change: it syncs from the pipeline’s first start, as a table with a key does. A change to a row that was there before the first start arrives as the row’s new values; the old row, never copied, is counted as a removal that found no row in your destination.
- A table that would wait for a change at your source (no publication lists it, or the source does not yet send its changes in a form that can be matched) is parked at the first start instead, because waiting there would end in a copy of the rows you chose not to copy. To sync it, Resume it first: it then waits, and its drawer names the change and shows the statement to run where there is one (for a table no publication lists, the statement shows only once it waits). Make that change, or add a primary key; it is then copied, and streams.
A change to a table’s shape
Section titled “A change to a table’s shape”What the pipeline does when a source table gains a column, loses one, changes a type, is truncated or is replaced is set by its change policy: see When a source table’s shape changes. This section is what the table’s drawer shows for it.
A table that waits for your answer
Section titled “A table that waits for your answer”A table stops and waits when its policy answers a change Ask me, or when the destination cannot make a change itself (a PostgreSQL destination then shows the statement to run). Its drawer lists each change it waits on, in one line each, such as “Column {column} was added at the source.” or “The table was truncated at the source.”, and under each a button for every answer that change takes:
| Answer | Button | On a PostgreSQL destination |
|---|---|---|
| Add the column | Add it and copy its values | |
| Leave the column out | Leave it out | |
| Keep a removed column | Keep it and its values | |
| Keep a narrowed type | Leave the column as it is | |
| Drop a removed column | Drop it from the destination | I dropped it |
| Widen the column’s type | Widen the destination column | I changed it |
| Convert the column’s type | Convert the destination column | I changed it |
| After a truncate | Mark its rows deleted, Delete its rows, Keep its rows | Delete its rows, Keep its rows |
Choose one answer for each change, then press Resume with these answers. It can be pressed only once every change the table waits on has an answer.
On a PostgreSQL destination, I dropped it and I changed it mean you ran the statement the drawer shows, as it is shown. The pipeline checks your table, and if the change is not there yet the table waits again and says so.
A table whose destination table was dropped stops with its place let go when the pipeline finds it gone. At PostgreSQL that is when a start reads it, or when the pipeline next writes to it, and its drawer says the table does not exist. At Snowflake it is when the pipeline next starts, or you resume the table: the start looks for the table first, and its drawer says it is not there any more or the pipeline’s role can no longer see it. A write that meets it at Snowflake before then is refused as a table that does not exist or that the role may not use: either the table stops with its place kept, or the pipeline’s run ends and its next start finds the table gone. Resume a table stopped with its place kept without making the table again, and that start finds it gone and stops it with its place let go. Resume it then and it is copied again from your source: at PostgreSQL make the table again first, as it was; at Snowflake the copy makes it. Every row your source holds now is written into it; what only the dropped table held is not, and went with it: rows your source no longer has (kept marked deleted in soft delete), and, in a table kept in history mode or append-only, its earlier versions or change rows.
A destination table you made again is found too, at the pipeline’s next start. The pipeline records which table it
writes each of your tables into (at PostgreSQL the table’s identity in the catalogue and the identifier of the
database server it lives on, at Snowflake the instant the table was created), every copy records the table it fills,
and every start compares. A table dropped and made again,
another table put under its name, a Snowflake CREATE OR REPLACE TABLE, a clone or a swap into its place: each is
another table, and a table that was syncing from where it had reached stops with its place let go, nothing written to
it. Its drawer says the table is not the one the pipeline last wrote into. Resume it and the source is copied into the
table as it is now. A table nobody touched, in a destination nobody moved, is never stopped by this.
One rule: after any restore or move of your destination, ask for a Re-sync of every table (or a re-sync of all of the pipeline) before the pipeline writes into it. Some of those keep every table’s identity, so the pipeline cannot tell them from the tables it wrote into, and none of them is a reason to skip the rule. What it can and cannot see:
- It cannot see a restored or promoted copy of your destination. A backup or a snapshot restored, a point-in-time
recovery, a replica promoted after a failover at PostgreSQL, or a Snowflake
UNDROPkeeps every table’s identity, and at PostgreSQL the server’s too, so the pipeline takes it for the same tables and goes on from where it had reached: the rows written after the copy’s moment are missing from it, with no error. A Snowflake replica promoted after a failover has not been checked either way. - At PostgreSQL, a copy on another server is usually found: a dump restored onto a new server, or a logical copy made there, lives on a server with another identifier, and every table that was syncing stops with its place let go. Each needs a resume, which copies it again. A dump restored into the same server gives its tables new identities, and is found the same way.
- At PostgreSQL, an upgrade to a new major version is found too, although it keeps every row: it is made with
pg_upgrade, which managed services also use when you upgrade there, and the upgraded server has a new identifier, as does a standby turned into a subscriber bypg_createsubscriber. Every table that was syncing stops, in words that name the upgrade, and its resume copies it again. The pipeline cannot tell an upgrade from a restore onto another server, and a copy it did not need costs time, where rows missing with no error cost data. - Emptying a table (
TRUNCATE, or deleting its rows) keeps it the same table, and so does a table renamed away and back. After emptying a destination table, ask for a Re-sync of it. - Several PostgreSQL nodes behind one address (a multi-writer system such as EDB Postgres Distributed or pgEdge, or a proxy that moves the writer between nodes) give each node its own identifier and its own table identities, so every change of writer stops every table that was syncing, and each resume copies it again.
The comparison happens when the pipeline starts (a restart, an update of the service, a resume, or a pipeline started again), not between two writes: a table replaced while the pipeline is running is written on until the next start, which then stops it and its resume copies it again. So if you replace a destination table yourself, the quickest way back is to ask for a Re-sync of that table straight away.
The copy brings back what the source has now. A row your source no longer has, and, for a table kept in history or append-only, the earlier versions or log rows the dropped table held, went with that table: they are still in it if you kept it under another name or, at Snowflake, can bring it back from Time Travel.
A pipeline whose source sends only new changes (MySQL, Stripe) copies nothing: it stops when its destination table is gone, and a table made again empty would be given only the changes from where it stopped. Put the table back as it was, with its rows, from your own copy of it, then start the pipeline. When the table there is another one than the pipeline last wrote into, it stops once and says so. If you put the table back from your own copy, as that stop for a missing table asks, nothing more is needed: start the pipeline again. If it was made again empty, the rows the pipeline wrote before are not in it, and a row is written again only when it changes at the source: put back what you have of them, then start the pipeline again. Either way it continues from where it stopped, into the table as it is now. At PostgreSQL, a destination upgraded to a new major version stops each such pipeline once the same way, saying the server is another one now: nothing more is needed then either.
A history export pipeline (the platform source) stops the same way, once, with one difference: a new export
pipeline of the same stream reads it from its beginning, so the rows the export still serves can come back. A row the
export no longer serves (one past what it keeps) does not come back this way, so keep your own copy of anything you
need beyond that. Remove the pipeline, then export the stream again into the same destination. The pipelines
stream is read whole at every sync, so a pipelines table made again is filled again by the next sync with what the
export serves now, and that pipeline is never stopped for it.
The table’s drawer also says what brings the table back. Where that copies the table again, it says what the copy does for that table, by its mode: in soft delete keeping every row your destination already has, a row your source no longer has marked deleted; kept live, replacing what your destination holds, a row your source no longer has removed, unless the table has a primary key and its destination is PostgreSQL, which keeps it, and a row a new row filter leaves out is, by the table’s mode and your answer to that filter’s change, kept, marked deleted or removed. A PostgreSQL table kept live whose key the pipeline has not read yet (one stopped at its first start before its key was read, or one your source no longer has) is told both, because its copy keys it as your source keys it then. The quotes below are a PostgreSQL table’s with a primary key, kept live, with no row filter’s change waiting:
- waiting for your answer: “Answer each change it waits on, then resume it.”, then either “It catches up from where it stopped, and nothing is copied again.” or, when it had to let its place in the change log go, “It is copied again, keeping every row your destination already has.”;
- waiting on a change that takes no answer (one this destination cannot make at all, so the drawer shows no Resume): “No answer to a change it waits on can be made at this destination, so it cannot be resumed. Re-sync it: every row is read again, keeping every row your destination already has, and that copy is billed like any other work. Or remove it.”;
- stopped because another table stopped, by that table as it is when you look:
- it kept its place and that table is still parked: “It resumes on its own when the table that stopped it is resumed, removed or copied again.”;
- it kept its place and that table is no longer parked: “The table that stopped it is no longer parked, so resume it.” then “It catches up from where it stopped, and nothing is copied again.”;
- its place was let go: “Its place in the source’s change log was let go, so it does not resume with the table that stopped it. Resume it: it is copied again, keeping every row your destination already has, and that copy is billed like any other work.”;
- another session held its destination table: “End the session that holds the table at the destination, or wait for it to end, then resume it.”;
- dropped at the source: “If a table of that name comes back at the source, resume it: it is copied again, keeping every row your destination already has. Otherwise remove it.”;
- renamed at the source: “Remove it: under its new name it is a table of its own to this pipeline. If a table of this name comes back, resume it.”
What a stopped table means for the rest of the pipeline
Section titled “What a stopped table means for the rest of the pipeline”After a stopped table’s own sentence, its drawer says what that means for the pipeline’s other tables. That sentence is written when you look, from the pipeline as it is then, because it can stop being true after the table stopped:
| When you look | The drawer says |
|---|---|
| The pipeline runs, no table stopped with this one, and another table syncs | “{table} has stopped syncing; the pipeline’s other tables carry on.” |
| The pipeline runs, and every other table stopped with this one | “{table} has stopped syncing, and every other table of this pipeline stopped with it.” |
| The pipeline runs, and some other tables stopped with this one | “{table} has stopped syncing, and so have the {n} other tables parked with it; the pipeline’s tables that are not parked carry on.” (one table: “and so has the one other table parked with it”; the last part only while a table is not parked) |
| The pipeline runs, and no other table syncs | “{table} has stopped syncing.” |
| The table stopped because {first} did, which is still parked | “{table} has stopped syncing with {first}, which is still parked.” |
| The same, but its own place was let go | “{table} has stopped syncing with {first}, which is still parked; its place in the source’s change log was let go, so resuming {first} does not resume it, and it waits for you to resume it.” |
| The table stopped because {first} did, which is no longer parked | “{table} has stopped syncing with {first}, which is no longer parked, so {table} waits for you to resume it.” |
| You stopped the pipeline | “{table} is waiting; the pipeline is stopped.” |
| The pipeline itself stopped for a cause and waits for you | “{table} is waiting; the pipeline has stopped and needs you (see above).” |
Which tables stopped with a table is read from the tables themselves (each one stopped with another
names it), never from the pipeline’s rules: a table that stopped while the pipeline was set to stop
every table still says so after the rule is changed, and a pipeline set to stop every table does not
claim that tables stopped which kept syncing (a table being copied, or one that stopped as the
pipeline started under an earlier release). Through the API, parked.with_table gives the table it
stopped with and whether that table is still parked.
A table that stopped before this was released keeps the words it stopped with.
Notes in a table’s drawer
Section titled “Notes in a table’s drawer”While they hold, a table’s drawer carries these notes:
-
“Copying the existing values of column {column}.” The column was added at the source, and the values its existing rows hold are being copied into your destination.
-
“Waiting while the existing values of column {column} of {table} are copied.” On every other table that is streaming or catching up while that copy runs: they pause, then catch up. A table that is parked, waiting or copying does not carry it, because it is not held up by the copy.
-
“Column {column} is left out of this table.” The source added it, and this pipeline leaves it out.
-
What the publication does not send, when it sends less of the table than before and the pipeline is set to sync what it sends: for example that delete changes made at the source do not reach the destination table.
-
A table waiting to be copied whose destination table another session held: “Waiting to be copied: another session held its destination table for more than five seconds, so a change the pipeline must make there could not run. The pipeline’s history names the statement.” It is followed by when the pipeline tries again, written when you look:
When you look The drawer says The pipeline is meant to run “Every five minutes while the pipeline runs, it tries again on its own and copies {table} once it can.” You stopped the pipeline “The pipeline is stopped; it tries again when you start it.” The pipeline itself stopped for a cause and waits for you “The pipeline has stopped and needs you (see above); it tries again once it runs.”
Tables found in the publication
Section titled “Tables found in the publication”When the publication sends a table this pipeline does not sync (you added it to the publication, or a table you sync was renamed), the pipeline finds it within about a minute and its policy decides:
- Add it (the default): the table appears on the Schema tab as waiting, and is copied with its existing rows when the pipeline next starts, which a running pipeline does on its own within a minute. A pipeline created with “Sync only changes from now on” adds and copies it the same way: that answer was about the tables picked when the pipeline was created, so a table added to the publication later, or one of those tables renamed at the source, is copied with its existing rows unless this rule is set to Tell me. The history says “{table} is published by {publication} and was added to this pipeline.”, or, when the add is refused, “… and was not added:” with the reason. A table you removed is never added back.
- Tell me: nothing is added. The history says “{table} is published by {publication} and is not synced. Add it to the pipeline to sync it.”, and the table is listed under Tables found in the publication with a button, Add {table}, until it is added.
While the pipeline is stopped
Section titled “While the pipeline is stopped”A table’s badge says what its own state is while the pipeline runs. While the pipeline is not running, the badge says the table is not syncing, and why:
- “Not syncing: the pipeline is stopped.” when you stopped it;
- “Not syncing: the pipeline stopped and needs you.” when it stopped for a cause and waits for you.
The table’s own state is then in its details: “Its own state, kept for when the pipeline runs again: {state}.”
Nothing is said to be moving then, because nothing is: a table catching up is not said to be applying changes, a table being copied is not said to make the others wait (it is copied again from where it stopped once the pipeline runs; the rows copied so far are still shown), a column’s values are not said to be copied, and the pipeline is not said to be paused for a copy. The line above the tables says the same: “3 tables, none syncing while the pipeline does not run. Their own states, kept for when it runs again: …” with each count. This holds while you stopped it, while it stopped for a cause and waits for you, and while a manual pipeline rests after its sync.
A request on a table says when it takes effect, from the pipeline as it is: “This takes effect when the pipeline restarts, within a minute.” while it runs, “This takes effect when the pipeline next starts.” when you stopped it, and “This takes effect when you start the pipeline again.” when it stopped for a cause and waits for you.
On the pipelines list
Section titled “On the pipelines list”Beside a pipeline’s health, the list shows how many of its tables have stopped and wait for you, such as “2 tables waiting for you”: an answer to a change, a statement to run, or anything else a table stops for. A table dropped or renamed at the source is not counted there; it is a warning of its own. The health word itself does not change, because the pipeline’s other tables run.