SPOC-442: Use NULL for unknown local_origin instead of -1

Makefile

@@ -57,7 +57,7 @@ REGRESS = preseed infofuncs init_fail init preseed_check basic conflict_secondar
 		  toasted replication_set matview bidirectional primary_key \
 		  interfaces foreign_key copy sequence triggers parallel functions row_filter \
 		  row_filter_sampling att_list column_filter apply_delay \
-		  extended node_origin_cascade multiple_upstreams tuple_origin autoddl \
+		  extended progress_tracking node_origin_cascade multiple_upstreams tuple_origin autoddl \
 		  drop
 
 # The following test cases are disabled while developing.

docs/spock_release_notes.md

@@ -1,5 +1,12 @@
 # Spock Release Notes
 
+## Spock 5.0.5 on Feb 12, 2026
+
+* Fix segfault that occurs when using new Postgres minor releases like 18.2.
+* Zero Downtime Add Node (Zodan) minor bug fixes and improvements
+* Updated documentation
+
+
 ## Spock 5.0.4 on Oct 8, 2025
 
 * Reduce memory usage for transactions with many inserts.
@@ -17,7 +24,6 @@
     - Fix bug where spock incorrectly outputs a message that DDL was replicated when a transaction is executing in repair mode.
 
 
-
 ## v5.0.3 on Sep 26, 2025
 
 * Spock 5.0.3 adds support for Postgres 18.

include/spock.h

@@ -24,8 +24,8 @@
 #include "spock_fe.h"
 #include "spock_node.h"
 
-#define SPOCK_VERSION "5.0.4"
-#define SPOCK_VERSION_NUM 50004
+#define SPOCK_VERSION "5.0.5"
+#define SPOCK_VERSION_NUM 50005
 
 #define EXTENSION_NAME "spock"
 

patches/15/pg15-010-allow_logical_decoding_on_standbys.diff

@@ -247,77 +247,78 @@ index 466f30c22d..b67ad3abe4 100644
  	slot = MyReplicationSlot;
 
 diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
-index 80d96db8eb..2d5b2945ed 100644
+index 1f4aad52c4a..623967e4fa1 100644
 --- a/src/backend/replication/slot.c
 +++ b/src/backend/replication/slot.c
 @@ -40,6 +40,7 @@
  #include <sys/stat.h>
- 
+
  #include "access/transam.h"
 +#include "access/xlogrecovery.h"
  #include "access/xlog_internal.h"
  #include "common/string.h"
  #include "miscadmin.h"
-@@ -1174,37 +1175,28 @@ ReplicationSlotReserveWal(void)
- 		/*
- 		 * For logical slots log a standby snapshot and start logical decoding
- 		 * at exactly that position. That allows the slot to start up more
--		 * quickly.
-+		 * quickly. But on a standby we cannot do WAL writes, so just use the
-+		 * replay pointer; effectively, an attempt to create a logical slot on
-+		 * standby will cause it to wait for an xl_running_xact record to be
-+		 * logged independently on the primary, so that a snapshot can be
-+		 * built using the record.
- 		 *
--		 * That's not needed (or indeed helpful) for physical slots as they'll
--		 * start replay at the last logged checkpoint anyway. Instead return
--		 * the location of the last redo LSN. While that slightly increases
--		 * the chance that we have to retry, it's where a base backup has to
--		 * start replay at.
-+		 * None of this is needed (or indeed helpful) for physical slots as
-+		 * they'll start replay at the last logged checkpoint anyway. Instead
-+		 * return the location of the last redo LSN. While that slightly
-+		 * increases the chance that we have to retry, it's where a base
-+		 * backup has to start replay at.
- 		 */
--		if (!RecoveryInProgress() && SlotIsLogical(slot))
--		{
--			XLogRecPtr	flushptr;
+@@ -1238,37 +1239,29 @@ ReplicationSlotReserveWal(void)
+ 	LWLockAcquire(ReplicationSlotAllocationLock, LW_EXCLUSIVE);
+
+ 	/*
+-	 * For logical slots log a standby snapshot and start logical decoding at
+-	 * exactly that position. That allows the slot to start up more quickly.
++	 * For logical slots log a standby snapshot and start logical decoding
++	 * at exactly that position. That allows the slot to start up more
++	 * quickly. But on a standby we cannot do WAL writes, so just use the
++	 * replay pointer; effectively, an attempt to create a logical slot on
++	 * standby will cause it to wait for an xl_running_xact record to be
++	 * logged independently on the primary, so that a snapshot can be
++	 * built using the record.
+ 	 *
+-	 * That's not needed (or indeed helpful) for physical slots as they'll
+-	 * start replay at the last logged checkpoint anyway. Instead return the
+-	 * location of the last redo LSN, where a base backup has to start replay
+-	 * at.
++	 * None of this is needed (or indeed helpful) for physical slots as
++	 * they'll start replay at the last logged checkpoint anyway. Instead
++	 * return the location of the last redo LSN, where a base backup has
++	 * to start replay at.
+ 	 */
+-	if (!RecoveryInProgress() && SlotIsLogical(slot))
+-	{
+-		XLogRecPtr	flushptr;
 -
--			/* start at current insert position */
-+		if (SlotIsPhysical(slot))
-+			restart_lsn = GetRedoRecPtr();
-+		else if (RecoveryInProgress())
-+			restart_lsn = GetXLogReplayRecPtr(NULL);
-+		else
- 			restart_lsn = GetXLogInsertRecPtr();
--			SpinLockAcquire(&slot->mutex);
--			slot->data.restart_lsn = restart_lsn;
--			SpinLockRelease(&slot->mutex);
+-		/* start at current insert position */
++	if (SlotIsPhysical(slot))
++		restart_lsn = GetRedoRecPtr();
++	else if (RecoveryInProgress())
++		restart_lsn = GetXLogReplayRecPtr(NULL);
++	else
+ 		restart_lsn = GetXLogInsertRecPtr();
+-		SpinLockAcquire(&slot->mutex);
+-		slot->data.restart_lsn = restart_lsn;
+-		SpinLockRelease(&slot->mutex);
 -
--			/* make sure we have enough information to start */
--			flushptr = LogStandbySnapshot();
- 
--			/* and make sure it's fsynced to disk */
--			XLogFlush(flushptr);
--		}
--		else
--		{
--			restart_lsn = GetRedoRecPtr();
--			SpinLockAcquire(&slot->mutex);
--			slot->data.restart_lsn = restart_lsn;
--			SpinLockRelease(&slot->mutex);
--		}
-+		SpinLockAcquire(&slot->mutex);
-+		slot->data.restart_lsn = restart_lsn;
-+		SpinLockRelease(&slot->mutex);
- 
- 		/* prevent WAL removal as fast as possible */
- 		ReplicationSlotsComputeRequiredLSN();
-@@ -1220,6 +1212,17 @@ ReplicationSlotReserveWal(void)
- 		if (XLogGetLastRemovedSegno() < segno)
- 			break;
- 	}
+-		/* make sure we have enough information to start */
+-		flushptr = LogStandbySnapshot();
+
+-		/* and make sure it's fsynced to disk */
+-		XLogFlush(flushptr);
+-	}
+-	else
+-	{
+-		restart_lsn = GetRedoRecPtr();
+-		SpinLockAcquire(&slot->mutex);
+-		slot->data.restart_lsn = restart_lsn;
+-		SpinLockRelease(&slot->mutex);
+-	}
++	SpinLockAcquire(&slot->mutex);
++	slot->data.restart_lsn = restart_lsn;
++	SpinLockRelease(&slot->mutex);
+
+ 	/* prevent WAL removal as fast as possible */
+ 	ReplicationSlotsComputeRequiredLSN();
+@@ -1280,6 +1273,17 @@ ReplicationSlotReserveWal(void)
+ 			 NameStr(slot->data.name));
+
+ 	LWLockRelease(ReplicationSlotAllocationLock);
 +
 +	if (!RecoveryInProgress() && SlotIsLogical(slot))
 +	{
@@ -330,7 +331,7 @@ index 80d96db8eb..2d5b2945ed 100644
 +		XLogFlush(flushptr);
 +	}
  }
- 
+
  /*
 diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
 index 269914bce2..3c39fe20cb 100644

samples/Z0DAN/n1.pgb

@@ -0,0 +1,4 @@
+\set aid random(1, 50000)
+
+UPDATE pgbench_accounts SET abalance = abalance + :aid WHERE aid = :aid;
+UPDATE pgbench_accounts SET abalance = abalance - :aid WHERE aid = :aid;

samples/Z0DAN/n2.pgb

@@ -0,0 +1,4 @@
+\set aid random(50001, 100000)
+
+UPDATE pgbench_accounts SET abalance = abalance + :aid WHERE aid = :aid;
+UPDATE pgbench_accounts SET abalance = abalance - :aid WHERE aid = :aid;

samples/Z0DAN/wait_subscription.sql

@@ -0,0 +1,98 @@
+CREATE OR REPLACE FUNCTION wait_subscription(
+  remote_node_name Name,
+  report_it        Boolean DEFAULT false,
+  timeout          Interval DEFAULT '0 second',
+  delay            Real DEFAULT 1.
+) RETURNS bigint AS $$
+DECLARE
+  state              Record;
+  lag                Bigint := 1;
+  end_time           Timestamp := 'infinity';
+  time_remained      Interval;
+  local_node_name    Name;
+  wal_sender_timeout Bigint;
+  prev_received_lsn  pg_lsn := '0/0'::pg_lsn;
+BEGIN
+  -- spock.local_node.node_id->spock.node(node_id -> node_name)
+  SELECT node_name FROM spock.node
+  WHERE node_id = (SELECT node_id FROM spock.local_node)
+  INTO local_node_name;
+
+  SELECT EXTRACT(epoch
+    FROM (
+      SELECT (current_setting('wal_sender_timeout')::Interval))
+    )::real * 1024
+  INTO wal_sender_timeout;
+
+  -- Calculate the End Time, if requested.
+  IF timeout > '0 second' THEN
+    SELECT now() + timeout INTO end_time;
+  END IF;
+  -- SELECT EXTRACT(epoch FROM my_interval)/3600
+  WHILE lag > 0 LOOP
+
+    SELECT end_time - clock_timestamp() INTO time_remained;
+    IF time_remained < '0 second' THEN
+      RETURN state.lag;
+    END IF;
+
+    -- NOTE: Remember, an apply group may contain more than a single worker.
+    SELECT
+      MAX(remote_insert_lsn) AS remote_write_lsn,
+      MAX(received_lsn) AS received_lsn
+    FROM spock.lag_tracker
+    WHERE origin_name = remote_node_name AND receiver_name = local_node_name
+    INTO state;
+
+    -- Special case: nothing arrived yet
+    IF (state.received_lsn = '0/0'::pg_lsn) THEN
+      IF report_it = true THEN
+        raise NOTICE 'Replication % -> %: waiting WAL ... . Time remained: % (HH24:MI:SS)',
+          remote_node_name, local_node_name,
+          to_char(time_remained, 'HH24:MI:SS');
+      END IF;
+      PERFORM pg_sleep(delay);
+      CONTINUE;
+    END IF;
+
+    -- Special case: No transactions has been executed on the remote yet.
+    IF (state.remote_write_lsn = '0/0'::pg_lsn) THEN
+      IF report_it = true THEN
+        raise NOTICE 'Replication % -> %: waiting anything substantial ... Received LSN: %. Time remained: % (HH24:MI:SS)',
+          remote_node_name, local_node_name, state.received_lsn,
+          to_char(time_remained, 'HH24:MI:SS');
+        PERFORM pg_sleep(delay);
+        CONTINUE;
+      END IF;
+
+      -- Check any progress
+      IF (state.received_lsn = prev_received_lsn) THEN
+        raise EXCEPTION 'Replication % -> %: publisher seems get stuck into something',
+        remote_node_name, local_node_name;
+      END IF;
+
+      -- We have a progress, wait further.
+      prev_received_lsn = state.received_lsn;
+      -- To be sure we get a 'keepalive' message
+      PERFORM pg_sleep(wal_sender_timeout * 2);
+
+      PERFORM pg_sleep(delay);
+      CONTINUE;
+    END IF;
+
+    SELECT MAX(remote_insert_lsn - received_lsn) FROM spock.lag_tracker
+    WHERE origin_name = remote_node_name AND receiver_name = local_node_name
+    INTO lag;
+
+    IF report_it = true THEN
+      raise NOTICE 'Replication % -> %: current lag % MB, Time remained: % (HH24:MI:SS)',
+        remote_node_name, local_node_name, lag/1024/1024,
+        to_char(time_remained, 'HH24:MI:SS');
+    END IF;
+
+    PERFORM pg_sleep(delay);
+  END LOOP;
+
+  RETURN lag;
+END
+$$ LANGUAGE plpgsql VOLATILE;