Partially revoke attempt to improve performance with many savepoints.

Maintain difference between subtransaction release and commit introduced
by earlier patch.

diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
index 59685dc85ccb36749d24355c83a4cc8ed6cdca54..7c0b463067e0bf636a278c7a14b8cd66f27348e0 100644 (file)
--- a/src/backend/access/transam/xact.c
+++ b/src/backend/access/transam/xact.c
@@ -269,7 +269,7 @@ static TransactionId RecordTransactionAbort(bool isSubXact);
 static void StartTransaction(void);
 
 static void StartSubTransaction(void);
-static void CommitSubTransaction(bool isTopLevel);
+static void CommitSubTransaction(void);
 static void AbortSubTransaction(void);
 static void CleanupSubTransaction(void);
 static void PushTransaction(void);
@@ -2578,7 +2578,7 @@ CommitTransactionCommand(void)
        case TBLOCK_SUBRELEASE:
            do
            {
-               CommitSubTransaction(false);
+               CommitSubTransaction();
                s = CurrentTransactionState;    /* changed by pop */
            } while (s->blockState == TBLOCK_SUBRELEASE);
 
@@ -2588,12 +2588,17 @@ CommitTransactionCommand(void)
 
            /*
             * We were issued a COMMIT, so we end the current subtransaction
-            * hierarchy and perform final commit.
+            * hierarchy and perform final commit. We do this by rolling up
+            * any subtransactions into their parent, which leads to O(N^2)
+            * operations with respect to resource owners - this isn't that
+            * bad until we approach a thousands of savepoints but is necessary
+            * for correctness should after triggers create new resource
+            * owners.
             */
        case TBLOCK_SUBCOMMIT:
            do
            {
-               CommitSubTransaction(true);
+               CommitSubTransaction();
                s = CurrentTransactionState;    /* changed by pop */
            } while (s->blockState == TBLOCK_SUBCOMMIT);
            /* If we had a COMMIT command, finish off the main xact too */
@@ -3745,7 +3750,7 @@ ReleaseCurrentSubTransaction(void)
             BlockStateAsString(s->blockState));
    Assert(s->state == TRANS_INPROGRESS);
    MemoryContextSwitchTo(CurTransactionContext);
-   CommitSubTransaction(false);
+   CommitSubTransaction();
    s = CurrentTransactionState;    /* changed by pop */
    Assert(s->state == TRANS_INPROGRESS);
 }
@@ -4009,13 +4014,9 @@ StartSubTransaction(void)
  *
  * The caller has to make sure to always reassign CurrentTransactionState
  * if it has a local pointer to it after calling this function.
- *
- * isTopLevel means that this CommitSubTransaction() is being issued as a
- * sequence of actions leading directly to a main transaction commit
- * allowing some actions to be optimised.
  */
 static void
-CommitSubTransaction(bool isTopLevel)
+CommitSubTransaction(void)
 {
    TransactionState s = CurrentTransactionState;
 
@@ -4069,14 +4070,10 @@ CommitSubTransaction(bool isTopLevel)
 
    /*
     * Other locks should get transferred to their parent resource owner.
-    * Doing that is an O(N^2) operation, so if isTopLevel then we can just
-    * leave the lock records as they are, knowing they will all get released
-    * by the top level commit using ProcReleaseLocks(). We only optimize
-    * this for commit; aborts may need to do other cleanup.
     */
    ResourceOwnerRelease(s->curTransactionOwner,
                         RESOURCE_RELEASE_LOCKS,
-                        true, isTopLevel);
+                        true, false);
    ResourceOwnerRelease(s->curTransactionOwner,
                         RESOURCE_RELEASE_AFTER_LOCKS,
                         true, false);