Move pg_wal_replay_wait() to xlogfuncs.c

This commit moves pg_wal_replay_wait() procedure to be a neighbor of
WAL-related functions in xlogfuncs.c.  The implementation of LSN waiting
continues to reside in the same place.

By proposal from Michael Paquier.

Reported-by: Peter Eisentraut
Discussion: https://postgr.es/m/18c0fa64-0475-415e-a1bd-665d922c5201%40eisentraut.org

diff --git a/src/backend/access/transam/xlogfuncs.c b/src/backend/access/transam/xlogfuncs.c
index 4e46baaebdf7a7983f038161ef2db51d2d384135..3e3d2bb61895de8c859b7701f5d448798e5b93fe 100644 (file)
--- a/src/backend/access/transam/xlogfuncs.c
+++ b/src/backend/access/transam/xlogfuncs.c
@@ -23,15 +23,18 @@
 #include "access/xlogbackup.h"
 #include "access/xlogrecovery.h"
 #include "catalog/pg_type.h"
+#include "commands/waitlsn.h"
 #include "funcapi.h"
 #include "miscadmin.h"
 #include "pgstat.h"
 #include "replication/walreceiver.h"
 #include "storage/fd.h"
+#include "storage/proc.h"
 #include "storage/standby.h"
 #include "utils/builtins.h"
 #include "utils/memutils.h"
 #include "utils/pg_lsn.h"
+#include "utils/snapmgr.h"
 #include "utils/timestamp.h"
 
 /*
@@ -747,3 +750,56 @@ pg_promote(PG_FUNCTION_ARGS)
                           wait_seconds)));
    PG_RETURN_BOOL(false);
 }
+
+/*
+ * Waits until recovery replays the target LSN with optional timeout.
+ */
+Datum
+pg_wal_replay_wait(PG_FUNCTION_ARGS)
+{
+   XLogRecPtr  target_lsn = PG_GETARG_LSN(0);
+   int64       timeout = PG_GETARG_INT64(1);
+
+   if (timeout < 0)
+       ereport(ERROR,
+               (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+                errmsg("\"timeout\" must not be negative")));
+
+   /*
+    * We are going to wait for the LSN replay.  We should first care that we
+    * don't hold a snapshot and correspondingly our MyProc->xmin is invalid.
+    * Otherwise, our snapshot could prevent the replay of WAL records
+    * implying a kind of self-deadlock.  This is the reason why
+    * pg_wal_replay_wait() is a procedure, not a function.
+    *
+    * At first, we should check there is no active snapshot.  According to
+    * PlannedStmtRequiresSnapshot(), even in an atomic context, CallStmt is
+    * processed with a snapshot.  Thankfully, we can pop this snapshot,
+    * because PortalRunUtility() can tolerate this.
+    */
+   if (ActiveSnapshotSet())
+       PopActiveSnapshot();
+
+   /*
+    * At second, invalidate a catalog snapshot if any.  And we should be done
+    * with the preparation.
+    */
+   InvalidateCatalogSnapshot();
+
+   /* Give up if there is still an active or registered snapshot. */
+   if (GetOldestSnapshot())
+       ereport(ERROR,
+               (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+                errmsg("pg_wal_replay_wait() must be only called without an active or registered snapshot"),
+                errdetail("Make sure pg_wal_replay_wait() isn't called within a transaction with an isolation level higher than READ COMMITTED, another procedure, or a function.")));
+
+   /*
+    * As the result we should hold no snapshot, and correspondingly our xmin
+    * should be unset.
+    */
+   Assert(MyProc->xmin == InvalidTransactionId);
+
+   (void) WaitForLSNReplay(target_lsn, timeout);
+
+   PG_RETURN_VOID();
+}

diff --git a/src/backend/commands/waitlsn.c b/src/backend/commands/waitlsn.c
index ffa83a20008b9c8b3d41d216f5499dad72d2d86b..501938f4330712b5ae7bde79585dad353cf302cf 100644 (file)
--- a/src/backend/commands/waitlsn.c
+++ b/src/backend/commands/waitlsn.c
@@ -217,7 +217,7 @@ WaitLSNCleanup(void)
  * Wait using MyLatch till the given LSN is replayed, the postmaster dies or
  * timeout happens.
  */
-static void
+void
 WaitForLSNReplay(XLogRecPtr targetLSN, int64 timeout)
 {
    XLogRecPtr  currentLSN;
@@ -336,53 +336,3 @@ WaitForLSNReplay(XLogRecPtr targetLSN, int64 timeout)
                        LSN_FORMAT_ARGS(currentLSN))));
    }
 }
-
-Datum
-pg_wal_replay_wait(PG_FUNCTION_ARGS)
-{
-   XLogRecPtr  target_lsn = PG_GETARG_LSN(0);
-   int64       timeout = PG_GETARG_INT64(1);
-
-   if (timeout < 0)
-       ereport(ERROR,
-               (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
-                errmsg("\"timeout\" must not be negative")));
-
-   /*
-    * We are going to wait for the LSN replay.  We should first care that we
-    * don't hold a snapshot and correspondingly our MyProc->xmin is invalid.
-    * Otherwise, our snapshot could prevent the replay of WAL records
-    * implying a kind of self-deadlock.  This is the reason why
-    * pg_wal_replay_wait() is a procedure, not a function.
-    *
-    * At first, we should check there is no active snapshot.  According to
-    * PlannedStmtRequiresSnapshot(), even in an atomic context, CallStmt is
-    * processed with a snapshot.  Thankfully, we can pop this snapshot,
-    * because PortalRunUtility() can tolerate this.
-    */
-   if (ActiveSnapshotSet())
-       PopActiveSnapshot();
-
-   /*
-    * At second, invalidate a catalog snapshot if any.  And we should be done
-    * with the preparation.
-    */
-   InvalidateCatalogSnapshot();
-
-   /* Give up if there is still an active or registered snapshot. */
-   if (GetOldestSnapshot())
-       ereport(ERROR,
-               (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-                errmsg("pg_wal_replay_wait() must be only called without an active or registered snapshot"),
-                errdetail("Make sure pg_wal_replay_wait() isn't called within a transaction with an isolation level higher than READ COMMITTED, another procedure, or a function.")));
-
-   /*
-    * As the result we should hold no snapshot, and correspondingly our xmin
-    * should be unset.
-    */
-   Assert(MyProc->xmin == InvalidTransactionId);
-
-   (void) WaitForLSNReplay(target_lsn, timeout);
-
-   PG_RETURN_VOID();
-}

diff --git a/src/include/commands/waitlsn.h b/src/include/commands/waitlsn.h
index f719feadb050a4b25a9c74f3c4e5289fe560463f..bb5ac858dcc8765c212dfc60bbb9b893c7c0f6bf 100644 (file)
--- a/src/include/commands/waitlsn.h
+++ b/src/include/commands/waitlsn.h
@@ -76,5 +76,6 @@ extern Size WaitLSNShmemSize(void);
 extern void WaitLSNShmemInit(void);
 extern void WaitLSNSetLatches(XLogRecPtr currentLSN);
 extern void WaitLSNCleanup(void);
+extern void WaitForLSNReplay(XLogRecPtr targetLSN, int64 timeout);
 
 #endif                         /* WAIT_LSN_H */