Allow transactions that don't write WAL to commit asynchronously.

This case can arise if a transaction has written data, but only to
temporary tables.  Loss of the commit record in case of a crash won't
matter, because the temporary tables will be lost anyway.

Reviewed by Heikki Linnakangas and Simon Riggs.

diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
index 79c9c0d844618f2a3c03eac48a714fbe2d00f021..67f817ca4b8e401d8ef02fac3df4f41fea485a18 100644 (file)
--- a/src/backend/access/transam/xact.c
+++ b/src/backend/access/transam/xact.c
@@ -907,6 +907,7 @@ RecordTransactionCommit(void)
    int         nmsgs = 0;
    SharedInvalidationMessage *invalMessages = NULL;
    bool        RelcacheInitFileInval = false;
+   bool        wrote_xlog;
 
    /* Get data needed for commit record */
    nrels = smgrGetPendingDeletes(true, &rels);
@@ -914,6 +915,7 @@ RecordTransactionCommit(void)
    if (XLogStandbyInfoActive())
        nmsgs = xactGetCommittedInvalidationMessages(&invalMessages,
                                                     &RelcacheInitFileInval);
+   wrote_xlog = (XactLastRecEnd.xrecoff != 0);
 
    /*
     * If we haven't been assigned an XID yet, we neither can, nor do we want
@@ -940,7 +942,7 @@ RecordTransactionCommit(void)
         * assigned is a sequence advance record due to nextval() --- we want
         * to flush that to disk before reporting commit.)
         */
-       if (XactLastRecEnd.xrecoff == 0)
+       if (!wrote_xlog)
            goto cleanup;
    }
    else
@@ -1028,16 +1030,27 @@ RecordTransactionCommit(void)
    }
 
    /*
-    * Check if we want to commit asynchronously.  If the user has set
-    * synchronous_commit = off, and we're not doing cleanup of any non-temp
-    * rels nor committing any command that wanted to force sync commit, then
-    * we can defer flushing XLOG.  (We must not allow asynchronous commit if
-    * there are any non-temp tables to be deleted, because we might delete
-    * the files before the COMMIT record is flushed to disk.  We do allow
-    * asynchronous commit if all to-be-deleted tables are temporary though,
-    * since they are lost anyway if we crash.)
+    * Check if we want to commit asynchronously.  We can allow the XLOG flush
+    * to happen asynchronously if synchronous_commit=off, or if the current
+    * transaction has not performed any WAL-logged operation.  The latter case
+    * can arise if the current transaction wrote only to temporary tables.
+    * In case of a crash, the loss of such a transaction will be irrelevant
+    * since temp tables will be lost anyway.  (Given the foregoing, you might
+    * think that it would be unnecessary to emit the XLOG record at all in
+    * this case, but we don't currently try to do that.  It would certainly
+    * cause problems at least in Hot Standby mode, where the KnownAssignedXids
+    * machinery requires tracking every XID assignment.  It might be OK to
+    * skip it only when wal_level < hot_standby, but for now we don't.)
+    *
+    * However, if we're doing cleanup of any non-temp rels or committing any
+    * command that wanted to force sync commit, then we must flush XLOG
+    * immediately.  (We must not allow asynchronous commit if there are any
+    * non-temp tables to be deleted, because we might delete the files before
+    * the COMMIT record is flushed to disk.  We do allow asynchronous commit
+    * if all to-be-deleted tables are temporary though, since they are lost
+    * anyway if we crash.)
     */
-   if (XactSyncCommit || forceSyncCommit || nrels > 0)
+   if ((wrote_xlog && XactSyncCommit) || forceSyncCommit || nrels > 0)
    {
        /*
         * Synchronous commit case: