npgsql · roji · Jan 25, 2026 · vonzshik · Jan 26, 2026 · roji
@@ -2619,8 +2619,14 @@ void Cleanup()
         _certificates = null;
     }
 
+    [MemberNotNull(nameof(_resetWithoutDeallocateMessage))]
     void GenerateResetMessage()
     {
+        // Generate a reset message that resets connection state without using DISCARD ALL.
+        // This is used in two scenarios:
+        // 1. When closing a pooled connection that has prepared statements (DISCARD ALL would deallocate them)
+        // 2. When closing a connection within an enlisted System.Transactions transaction (DISCARD ALL cannot
+        //    run inside a transaction block, but its component commands can)
         var sb = new StringBuilder("SET SESSION AUTHORIZATION DEFAULT;RESET ALL;");
         _resetWithoutDeallocateResponseCount = 2;
         if (DatabaseInfo.SupportsCloseAll)
@@ -2728,6 +2734,29 @@ internal async Task Reset(bool async)
         }
     }
 
+    /// <summary>
+    /// Called when a pooled connection with an enlisted System.Transactions transaction is closed.
+    /// Since we're inside a transaction block, we cannot send DISCARD ALL, DISCARD TEMP or DISCARD SEQUENCES;
+    /// we prepend a reset message that only includes commands that can safely run within a transaction.
+    /// </summary>
+    internal void ResetWithinEnlistedTransaction()
+    {
+        // Our buffer may contain unsent prepended messages, so clear it out.
+        WriteBuffer.Clear();
+        PendingPrependedResponses = 0;
+
+        ResetReadBuffer();
+
+        if (_resetWithoutDeallocateMessage is null)
+        {
+            GenerateResetMessage();
+        }
+
+        PrependInternalMessage(_resetWithoutDeallocateMessage, _resetWithoutDeallocateResponseCount);
+
+        DataReader.UnbindIfNecessary();
+    }
+
     /// <summary>
     /// The connector may have allocated an oversize read buffer, to hold big rows in non-sequential reading.
     /// This switches us back to the original one and returns the buffer to <see cref="ArrayPool{T}" />.

@@ -844,14 +844,13 @@ async Task CloseAsync(bool async)
 
             if (EnlistedTransaction != null)
             {
-                // A System.Transactions transaction is still in progress
-
-                connector.Connection = null;
-
-                // Close the connection and disconnect it from the resource manager but leave the
+                // A System.Transactions transaction is still in progress.
+                // Close the connection and disconnect it from the resource manager and reset the connector, but leave the
                 // connector in an enlisted pending list in the data source. If another connection is opened within
                 // the same transaction scope, we will reuse this connector to avoid escalating to a distributed
-                // transaction
+                // transaction.
+                connector.ResetWithinEnlistedTransaction();
+                connector.Connection = null;
                 _dataSource?.AddPendingEnlistedConnector(connector, EnlistedTransaction);
 
                 EnlistedTransaction = null;

@@ -873,6 +873,8 @@
             TargetSessionAttributes = targetSessionAttributes,
             ServerCompatibilityMode = ServerCompatibilityMode.NoTypeLoading,
             MaxPoolSize = 10,
+            // Our mock PG server doesn't know how to handle the reset messages
+            NoResetOnClose = true,
         };
 
         using var _ = CreateTempPool(csb, out var connString);
@@ -911,7 +913,7 @@
            .WriteCommandComplete()
            .WriteReadyForQuery()
            .FlushAsync();
        scope.Complete();

        async Task Query(string connectionString)
        {

@@ -258,6 +258,34 @@ public void Reuse_connection_rollback()
         AssertNumberOfRows(0, tableName);
     }
 
+    [Test, IssueLink("https://github.com/npgsql/npgsql/issues/3735")]
+    public void Reuse_connection_resets_temp_tables()
+    {
+        // When a connection is closed inside a TransactionScope and then reopened,
+        // temp tables should be discarded.
+        using var dataSource = CreateDataSource(csb => csb.Enlist = true);
+        using (new TransactionScope())
+        using (var conn = dataSource.CreateConnection())
+        {
+            conn.Open();
+            var processId = conn.ProcessID;
+
+            // Create a temp table
+            conn.ExecuteNonQuery("CREATE TEMP TABLE temp_test (id INT)");
+
+            conn.Close();
+
+            // Reopen - should get the same physical connection but with reset state
+            conn.Open();
+            Assert.That(conn.ProcessID, Is.EqualTo(processId), "Should reuse the same physical connection");
+
+            // The temp table should have been discarded
+            Assert.That(() => conn.ExecuteScalar("SELECT COUNT(*) FROM temp_test"),
+                Throws.Exception.TypeOf<PostgresException>()
+                    .With.Property(nameof(PostgresException.SqlState)).EqualTo(PostgresErrorCodes.UndefinedTable));
+        }
+    }
+
     [Test, Ignore("Timeout doesn't seem to fire on .NET Core / Linux")]
     public void Timeout_triggers_rollback_while_busy()
     {