Revert "Refine handling of moving between replay and continue states (#3337)"

samsharma2700 · samsharma2700 · commit a2863dd2430b · 2025-08-05T16:29:57.000-07:00
This reverts commit 265f522.
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/TdsParser.cs b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/TdsParser.cs
@@ -6549,8 +6549,8 @@ private TdsOperationStatus TryReadByteArrayWithContinue(TdsParserStateObject sta
             bytes = null;
             int offset = 0;
             byte[] temp = null;
-            (bool canContinue, bool isStarting, bool isContinuing) = stateObj.GetSnapshotStatuses();
-            if (canContinue)
+            (bool isAvailable, bool isStarting, bool isContinuing) = stateObj.GetSnapshotStatuses();
+            if (isAvailable)
             {
                 if (isContinuing || isStarting)
                 {
@@ -13126,9 +13126,9 @@ internal TdsOperationStatus TryReadPlpUnicodeCharsWithContinue(TdsParserStateObj
             char[] temp = null;
             bool buffIsRented = false;
             int startOffset = 0;
-            (bool canContinue, bool isStarting, bool isContinuing) = stateObj.GetSnapshotStatuses();
+            (bool isAvailable, bool isStarting, bool isContinuing) = stateObj.GetSnapshotStatuses();
 
-            if (canContinue)
+            if (isAvailable)
             {
                 if (isContinuing || isStarting)
                 {
@@ -13147,7 +13147,7 @@ internal TdsOperationStatus TryReadPlpUnicodeCharsWithContinue(TdsParserStateObj
                 length >> 1,
                 stateObj,
                 out length,
-                supportRentedBuff: !canContinue, // do not use the arraypool if we are going to keep the buffer in the snapshot
+                supportRentedBuff: !isAvailable, // do not use the arraypool if we are going to keep the buffer in the snapshot
                 rentedBuff: ref buffIsRented,
                 startOffset,
                 isStarting || isContinuing
diff --git a/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/TdsParser.cs b/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/TdsParser.cs
@@ -6745,8 +6745,8 @@ private TdsOperationStatus TryReadByteArrayWithContinue(TdsParserStateObject sta
             bytes = null;
             int offset = 0;
             byte[] temp = null;
-            (bool canContinue, bool isStarting, bool isContinuing) = stateObj.GetSnapshotStatuses();
-            if (canContinue)
+            (bool isAvailable, bool isStarting, bool isContinuing) = stateObj.GetSnapshotStatuses();
+            if (isAvailable)
             {
                 if (isContinuing || isStarting)
                 {
@@ -13307,9 +13307,9 @@ internal TdsOperationStatus TryReadPlpUnicodeCharsWithContinue(TdsParserStateObj
             char[] temp = null;
             bool buffIsRented = false;
             int startOffset = 0;
-            (bool canContinue, bool isStarting, bool isContinuing) = stateObj.GetSnapshotStatuses();
+            (bool isAvailable, bool isStarting, bool isContinuing) = stateObj.GetSnapshotStatuses();
 
-            if (canContinue)
+            if (isAvailable)
             {
                 if (isContinuing || isStarting)
                 {
@@ -13328,7 +13328,7 @@ internal TdsOperationStatus TryReadPlpUnicodeCharsWithContinue(TdsParserStateObj
                 length >> 1, 
                 stateObj, 
                 out length, 
-                supportRentedBuff: !canContinue, // do not use the arraypool if we are going to keep the buffer in the snapshot
+                supportRentedBuff: !isAvailable, // do not use the arraypool if we are going to keep the buffer in the snapshot
                 rentedBuff: ref buffIsRented, 
                 startOffset, 
                 isStarting || isContinuing
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlCachedBuffer.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlCachedBuffer.cs
@@ -39,10 +39,10 @@ internal static TdsOperationStatus TryCreate(SqlMetaDataPriv metadata, TdsParser
         {
             buffer = null;
 
-            (bool canContinue, bool isStarting, _) = stateObj.GetSnapshotStatuses();
+            (bool isAvailable, bool isStarting, _) = stateObj.GetSnapshotStatuses();
 
             List<byte[]> cachedBytes = null;
-            if (canContinue)
+            if (isAvailable)
             {
                 cachedBytes = stateObj.TryTakeSnapshotStorage() as List<byte[]>;
                 if (isStarting)
@@ -78,10 +78,10 @@ internal static TdsOperationStatus TryCreate(SqlMetaDataPriv metadata, TdsParser
                     byte[] byteArr = new byte[cb];
                     // pass false for the writeDataSizeToSnapshot parameter because we want to only take data
                     // from the current packet and not try to do a continue-capable multi packet read
-                    result = stateObj.TryReadPlpBytes(ref byteArr, 0, cb, out cb, canContinue, writeDataSizeToSnapshot: false, compatibilityMode: false);
+                    result = stateObj.TryReadPlpBytes(ref byteArr, 0, cb, out cb, writeDataSizeToSnapshot: false, compatibilityMode: false);
                     if (result != TdsOperationStatus.Done)
                     {
-                        if (result == TdsOperationStatus.NeedMoreData && canContinue && cb == byteArr.Length)
+                        if (result == TdsOperationStatus.NeedMoreData && isAvailable && cb == byteArr.Length)
                         {
                             // succeeded in getting the data but failed to find the next plp length
                             returnAfterAdd = true;
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/TdsParserStateObject.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/TdsParserStateObject.cs
@@ -1922,7 +1922,7 @@ internal TdsOperationStatus TryReadStringWithEncoding(int length, System.Text.En
             }
             byte[] buf = null;
             int offset = 0;
-            (bool canContinue, bool isStarting, bool isContinuing) = GetSnapshotStatuses();
+            (bool isAvailable, bool isStarting, bool isContinuing) = GetSnapshotStatuses();
 
             if (isPlp)
             {
@@ -1940,7 +1940,7 @@ internal TdsOperationStatus TryReadStringWithEncoding(int length, System.Text.En
                 if (((_inBytesUsed + length) > _inBytesRead) || (_inBytesPacket < length))
                 {
                     int startOffset = 0;
-                    if (canContinue)
+                    if (isAvailable)
                     {
                         if (isContinuing || isStarting)
                         {
@@ -1958,7 +1958,7 @@ internal TdsOperationStatus TryReadStringWithEncoding(int length, System.Text.En
                         buf = new byte[length];
                     }
 
-                    TdsOperationStatus result = TryReadByteArray(buf, length, out _, startOffset, canContinue);
+                    TdsOperationStatus result = TryReadByteArray(buf, length, out _, startOffset, isAvailable);
                     
                     if (result != TdsOperationStatus.Done)
                     {
@@ -2088,23 +2088,22 @@ internal int ReadPlpBytesChunk(byte[] buff, int offset, int len)
 
         internal TdsOperationStatus TryReadPlpBytes(ref byte[] buff, int offset, int len, out int totalBytesRead)
         {
-            bool canContinue = false;
             bool isStarting = false;
             bool isContinuing = false;
             bool compatibilityMode = LocalAppContextSwitches.UseCompatibilityAsyncBehaviour;
             if (!compatibilityMode)
             {
-                (canContinue, isStarting, isContinuing) = GetSnapshotStatuses();
+                (_, isStarting, isContinuing) = GetSnapshotStatuses();
             }
-            return TryReadPlpBytes(ref buff, offset, len, out totalBytesRead, canContinue, canContinue, compatibilityMode);
+            return TryReadPlpBytes(ref buff, offset, len, out totalBytesRead, isStarting || isContinuing, compatibilityMode);
         }
         // Reads the requested number of bytes from a plp data stream, or the entire data if
         // requested length is -1 or larger than the actual length of data. First call to this method
         //  should be preceeded by a call to ReadPlpLength or ReadDataLength.
         // Returns the actual bytes read.
         // NOTE: This method must be retriable WITHOUT replaying a snapshot
         // Every time you call this method increment the offset and decrease len by the value of totalBytesRead
-        internal TdsOperationStatus TryReadPlpBytes(ref byte[] buff, int offset, int len, out int totalBytesRead, bool canContinue, bool writeDataSizeToSnapshot, bool compatibilityMode)
+        internal TdsOperationStatus TryReadPlpBytes(ref byte[] buff, int offset, int len, out int totalBytesRead, bool writeDataSizeToSnapshot, bool compatibilityMode)
         {
             totalBytesRead = 0;
 
@@ -2129,16 +2128,9 @@ internal TdsOperationStatus TryReadPlpBytes(ref byte[] buff, int offset, int len
             // If total length is known up front, allocate the whole buffer in one shot instead of realloc'ing and copying over each time
             if (buff == null && _longlen != TdsEnums.SQL_PLP_UNKNOWNLEN)
             {
-                if (compatibilityMode && _snapshot != null && _snapshotStatus != SnapshotStatus.NotActive)
-                {
-                    // legacy replay path perf optimization
-                    // if there is a snapshot which contains a stored plp buffer take it
-                    // and try to use it if it is the right length
-                    buff = TryTakeSnapshotStorage() as byte[];
-                }
-                else if (writeDataSizeToSnapshot && canContinue && _snapshot != null)
+                if (writeDataSizeToSnapshot)
                 {
-                    // if there is a snapshot which it contains a stored plp buffer take it
+                    // if there is a snapshot and it contains a stored plp buffer take it
                     // and try to use it if it is the right length
                     buff = TryTakeSnapshotStorage() as byte[];
                     if (buff != null)
@@ -2147,7 +2139,13 @@ internal TdsOperationStatus TryReadPlpBytes(ref byte[] buff, int offset, int len
                         totalBytesRead = offset;
                     }
                 }
-
+                else if (compatibilityMode && _snapshot != null && _snapshotStatus != SnapshotStatus.NotActive)
+                {
+                    // legacy replay path perf optimization
+                    // if there is a snapshot and it contains a stored plp buffer take it
+                    // and try to use it if it is the right length
+                    buff = TryTakeSnapshotStorage() as byte[];
+                }
 
                 if ((ulong)(buff?.Length ?? 0) != _longlen)
                 {
@@ -2199,49 +2197,43 @@ internal TdsOperationStatus TryReadPlpBytes(ref byte[] buff, int offset, int len
                 _longlenleft -= (ulong)bytesRead;
                 if (result != TdsOperationStatus.Done)
                 {
-                    if (compatibilityMode && _snapshot != null)
+                    if (writeDataSizeToSnapshot)
                     {
-                        // legacy replay path perf optimization
                         // a partial read has happened so store the target buffer in the snapshot
                         // so it can be re-used when another packet arrives and we read again
                         SetSnapshotStorage(buff);
+                        SetSnapshotDataSize(bytesRead);
+
                     }
-                    else if (canContinue)
+                    else if (compatibilityMode && _snapshot != null)
                     {
+                        // legacy replay path perf optimization
                         // a partial read has happened so store the target buffer in the snapshot
                         // so it can be re-used when another packet arrives and we read again
                         SetSnapshotStorage(buff);
-                        if (writeDataSizeToSnapshot)
-                        {
-                            SetSnapshotDataSize(bytesRead);
-                        }
                     }
                     return result;
                 }
-                if (writeDataSizeToSnapshot && canContinue)
-                {
-                    SetSnapshotDataSize(bytesRead);
-                }
 
                 if (_longlenleft == 0)
                 {
                     // Read the next chunk or cleanup state if hit the end
                     result = TryReadPlpLength(false, out _);
                     if (result != TdsOperationStatus.Done)
                     {
-                        if (compatibilityMode && _snapshot != null)
-                        {
-                            // a partial read has happened so store the target buffer in the snapshot
-                            // so it can be re-used when another packet arrives and we read again
-                            SetSnapshotStorage(buff);
-                        }
-                        else if (canContinue && result == TdsOperationStatus.NeedMoreData)
+                        if (writeDataSizeToSnapshot)
                         {
-                            SetSnapshotStorage(buff);
-                            if (writeDataSizeToSnapshot)
+                            if (result == TdsOperationStatus.NeedMoreData)
                             {
+                                SetSnapshotStorage(buff);
                                 SetSnapshotDataSize(bytesRead);
                             }
+                        } 
+                        else if (compatibilityMode && _snapshot != null)
+                        {
+                            // a partial read has happened so store the target buffer in the snapshot
+                            // so it can be re-used when another packet arrives and we read again
+                            SetSnapshotStorage(buff);
                         }
                         return result;
                     }
@@ -3516,17 +3508,17 @@ internal bool IsSnapshotContinuing()
                 _snapshotStatus == TdsParserStateObject.SnapshotStatus.ContinueRunning;
         }
 
-        internal (bool CanContinue, bool IsStarting, bool IsContinuing) GetSnapshotStatuses()
+        internal (bool IsAvailable, bool IsStarting, bool IsContinuing) GetSnapshotStatuses()
         {
-            bool canContinue = _snapshot != null && _snapshot.ContinueEnabled && _snapshotStatus != SnapshotStatus.NotActive;
+            bool isAvailable = _snapshot != null && _snapshot.ContinueEnabled;
             bool isStarting = false;
             bool isContinuing = false;
-            if (canContinue)
+            if (isAvailable)
             {
                 isStarting = _snapshotStatus == SnapshotStatus.ReplayStarting;
                 isContinuing = _snapshotStatus == SnapshotStatus.ContinueRunning;
             }
-            return (canContinue, isStarting, isContinuing);
+            return (isAvailable, isStarting, isContinuing);
         }
 
         internal int GetSnapshotStorageLength<T>()
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/DataReaderTest/DataReaderTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/DataReaderTest/DataReaderTest.cs
@@ -6,8 +6,6 @@
 using System.Collections.Generic;
 using System.Data;
 using System.Data.SqlTypes;
-using System.Diagnostics;
-using System.Linq;
 using System.Reflection;
 using System.Text;
 using System.Threading;
@@ -593,60 +591,6 @@ integrated into a comprehensive development
             }
         }
 
-        [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
-        public static async Task CanReadBinaryData()
-        {
-            const int Size = 20_000;
-
-            byte[] data = Enumerable.Range(0, Size)
-                .Select(i => (byte)(i % 256))
-                .ToArray();
-            string tableName = DataTestUtility.GenerateObjectName();
-
-            using (var connection = new SqlConnection(DataTestUtility.TCPConnectionString))
-            {
-                await connection.OpenAsync();
-
-                try
-                {
-                    using (var createCommand = connection.CreateCommand())
-                    {
-                        createCommand.CommandText = $@"
-DROP TABLE IF EXISTS [{tableName}]
-CREATE TABLE [{tableName}] (Id INT IDENTITY(1,1) PRIMARY KEY, Data VARBINARY(MAX));
-INSERT INTO [{tableName}] (Data) VALUES (@data);";
-                        createCommand.Parameters.Add(new SqlParameter("@data", SqlDbType.VarBinary, Size) { Value = data });
-                        await createCommand.ExecuteNonQueryAsync();
-                    }
-
-                    using (var command = connection.CreateCommand())
-                    {
-
-                        command.CommandText = $"SELECT Data FROM [{tableName}]";
-                        command.Parameters.Clear();
-                        var result = (byte[])await command.ExecuteScalarAsync();
-
-                        Assert.Equal(data, result);
-                    }
-
-                }
-                finally
-                {
-                    try
-                    {
-                        using (var dropCommand = connection.CreateCommand())
-                        {
-                            dropCommand.CommandText = $"DROP TABLE IF EXISTS [{tableName}]";
-                            dropCommand.ExecuteNonQuery();
-                        }
-                    }
-                    catch
-                    {
-                    }
-                }
-            }
-        }
-
         // Synapse: Cannot find data type 'rowversion'.
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
         public static void CheckLegacyNullRowVersionIsEmptyArray()

Original file line number	Diff line number	Diff line change
`@@ -39,10 +39,10 @@ internal static TdsOperationStatus TryCreate(SqlMetaDataPriv metadata, TdsParser`
`39`	`39`	`{`
`40`	`40`	`buffer = null;`
`41`	`41`
`42`		`- (bool canContinue, bool isStarting, _) = stateObj.GetSnapshotStatuses();`
	`42`	`+ (bool isAvailable, bool isStarting, _) = stateObj.GetSnapshotStatuses();`
`43`	`43`
`44`	`44`	`List<byte[]> cachedBytes = null;`
`45`		`- if (canContinue)`
	`45`	`+ if (isAvailable)`
`46`	`46`	`{`
`47`	`47`	`cachedBytes = stateObj.TryTakeSnapshotStorage() as List<byte[]>;`
`48`	`48`	`if (isStarting)`
`@@ -78,10 +78,10 @@ internal static TdsOperationStatus TryCreate(SqlMetaDataPriv metadata, TdsParser`
`78`	`78`	`byte[] byteArr = new byte[cb];`
`79`	`79`	`// pass false for the writeDataSizeToSnapshot parameter because we want to only take data`
`80`	`80`	`// from the current packet and not try to do a continue-capable multi packet read`
`81`		`- result = stateObj.TryReadPlpBytes(ref byteArr, 0, cb, out cb, canContinue, writeDataSizeToSnapshot: false, compatibilityMode: false);`
	`81`	`+ result = stateObj.TryReadPlpBytes(ref byteArr, 0, cb, out cb, writeDataSizeToSnapshot: false, compatibilityMode: false);`
`82`	`82`	`if (result != TdsOperationStatus.Done)`
`83`	`83`	`{`
`84`		`- if (result == TdsOperationStatus.NeedMoreData && canContinue && cb == byteArr.Length)`
	`84`	`+ if (result == TdsOperationStatus.NeedMoreData && isAvailable && cb == byteArr.Length)`
`85`	`85`	`{`
`86`	`86`	`// succeeded in getting the data but failed to find the next plp length`
`87`	`87`	`returnAfterAdd = true;`
Original file line number	Diff line number	Diff line change
`@@ -1922,7 +1922,7 @@ internal TdsOperationStatus TryReadStringWithEncoding(int length, System.Text.En`
`1922`	`1922`	`}`
`1923`	`1923`	`byte[] buf = null;`
`1924`	`1924`	`int offset = 0;`
`1925`		`- (bool canContinue, bool isStarting, bool isContinuing) = GetSnapshotStatuses();`
	`1925`	`+ (bool isAvailable, bool isStarting, bool isContinuing) = GetSnapshotStatuses();`
`1926`	`1926`
`1927`	`1927`	`if (isPlp)`
`1928`	`1928`	`{`
`@@ -1940,7 +1940,7 @@ internal TdsOperationStatus TryReadStringWithEncoding(int length, System.Text.En`
`1940`	`1940`	`if (((_inBytesUsed + length) > _inBytesRead) \|\| (_inBytesPacket < length))`
`1941`	`1941`	`{`
`1942`	`1942`	`int startOffset = 0;`
`1943`		`- if (canContinue)`
	`1943`	`+ if (isAvailable)`
`1944`	`1944`	`{`
`1945`	`1945`	`if (isContinuing \|\| isStarting)`
`1946`	`1946`	`{`
`@@ -1958,7 +1958,7 @@ internal TdsOperationStatus TryReadStringWithEncoding(int length, System.Text.En`
`1958`	`1958`	`buf = new byte[length];`
`1959`	`1959`	`}`
`1960`	`1960`
`1961`		`- TdsOperationStatus result = TryReadByteArray(buf, length, out _, startOffset, canContinue);`
	`1961`	`+ TdsOperationStatus result = TryReadByteArray(buf, length, out _, startOffset, isAvailable);`
`1962`	`1962`
`1963`	`1963`	`if (result != TdsOperationStatus.Done)`
`1964`	`1964`	`{`
`@@ -2088,23 +2088,22 @@ internal int ReadPlpBytesChunk(byte[] buff, int offset, int len)`
`2088`	`2088`
`2089`	`2089`	`internal TdsOperationStatus TryReadPlpBytes(ref byte[] buff, int offset, int len, out int totalBytesRead)`
`2090`	`2090`	`{`
`2091`		`- bool canContinue = false;`
`2092`	`2091`	`bool isStarting = false;`
`2093`	`2092`	`bool isContinuing = false;`
`2094`	`2093`	`bool compatibilityMode = LocalAppContextSwitches.UseCompatibilityAsyncBehaviour;`
`2095`	`2094`	`if (!compatibilityMode)`
`2096`	`2095`	`{`
`2097`		`- (canContinue, isStarting, isContinuing) = GetSnapshotStatuses();`
	`2096`	`+ (_, isStarting, isContinuing) = GetSnapshotStatuses();`
`2098`	`2097`	`}`
`2099`		`- return TryReadPlpBytes(ref buff, offset, len, out totalBytesRead, canContinue, canContinue, compatibilityMode);`
	`2098`	`+ return TryReadPlpBytes(ref buff, offset, len, out totalBytesRead, isStarting \|\| isContinuing, compatibilityMode);`
`2100`	`2099`	`}`
`2101`	`2100`	`// Reads the requested number of bytes from a plp data stream, or the entire data if`
`2102`	`2101`	`// requested length is -1 or larger than the actual length of data. First call to this method`
`2103`	`2102`	`// should be preceeded by a call to ReadPlpLength or ReadDataLength.`
`2104`	`2103`	`// Returns the actual bytes read.`
`2105`	`2104`	`// NOTE: This method must be retriable WITHOUT replaying a snapshot`
`2106`	`2105`	`// Every time you call this method increment the offset and decrease len by the value of totalBytesRead`
`2107`		`- internal TdsOperationStatus TryReadPlpBytes(ref byte[] buff, int offset, int len, out int totalBytesRead, bool canContinue, bool writeDataSizeToSnapshot, bool compatibilityMode)`
	`2106`	`+ internal TdsOperationStatus TryReadPlpBytes(ref byte[] buff, int offset, int len, out int totalBytesRead, bool writeDataSizeToSnapshot, bool compatibilityMode)`
`2108`	`2107`	`{`
`2109`	`2108`	`totalBytesRead = 0;`
`2110`	`2109`
`@@ -2129,16 +2128,9 @@ internal TdsOperationStatus TryReadPlpBytes(ref byte[] buff, int offset, int len`
`2129`	`2128`	`// If total length is known up front, allocate the whole buffer in one shot instead of realloc'ing and copying over each time`
`2130`	`2129`	`if (buff == null && _longlen != TdsEnums.SQL_PLP_UNKNOWNLEN)`
`2131`	`2130`	`{`
`2132`		`- if (compatibilityMode && _snapshot != null && _snapshotStatus != SnapshotStatus.NotActive)`
`2133`		`- {`
`2134`		`- // legacy replay path perf optimization`
`2135`		`- // if there is a snapshot which contains a stored plp buffer take it`
`2136`		`- // and try to use it if it is the right length`
`2137`		`- buff = TryTakeSnapshotStorage() as byte[];`
`2138`		`- }`
`2139`		`- else if (writeDataSizeToSnapshot && canContinue && _snapshot != null)`
	`2131`	`+ if (writeDataSizeToSnapshot)`
`2140`	`2132`	`{`
`2141`		`- // if there is a snapshot which it contains a stored plp buffer take it`
	`2133`	`+ // if there is a snapshot and it contains a stored plp buffer take it`
`2142`	`2134`	`// and try to use it if it is the right length`
`2143`	`2135`	`buff = TryTakeSnapshotStorage() as byte[];`
`2144`	`2136`	`if (buff != null)`
`@@ -2147,7 +2139,13 @@ internal TdsOperationStatus TryReadPlpBytes(ref byte[] buff, int offset, int len`
`2147`	`2139`	`totalBytesRead = offset;`
`2148`	`2140`	`}`
`2149`	`2141`	`}`
`2150`		`-`
	`2142`	`+ else if (compatibilityMode && _snapshot != null && _snapshotStatus != SnapshotStatus.NotActive)`
	`2143`	`+ {`
	`2144`	`+ // legacy replay path perf optimization`
	`2145`	`+ // if there is a snapshot and it contains a stored plp buffer take it`
	`2146`	`+ // and try to use it if it is the right length`
	`2147`	`+ buff = TryTakeSnapshotStorage() as byte[];`
	`2148`	`+ }`
`2151`	`2149`
`2152`	`2150`	`if ((ulong)(buff?.Length ?? 0) != _longlen)`
`2153`	`2151`	`{`
`@@ -2199,49 +2197,43 @@ internal TdsOperationStatus TryReadPlpBytes(ref byte[] buff, int offset, int len`
`2199`	`2197`	`_longlenleft -= (ulong)bytesRead;`
`2200`	`2198`	`if (result != TdsOperationStatus.Done)`
`2201`	`2199`	`{`
`2202`		`- if (compatibilityMode && _snapshot != null)`
	`2200`	`+ if (writeDataSizeToSnapshot)`
`2203`	`2201`	`{`
`2204`		`- // legacy replay path perf optimization`
`2205`	`2202`	`// a partial read has happened so store the target buffer in the snapshot`
`2206`	`2203`	`// so it can be re-used when another packet arrives and we read again`
`2207`	`2204`	`SetSnapshotStorage(buff);`
	`2205`	`+ SetSnapshotDataSize(bytesRead);`
	`2206`	`+`
`2208`	`2207`	`}`
`2209`		`- else if (canContinue)`
	`2208`	`+ else if (compatibilityMode && _snapshot != null)`
`2210`	`2209`	`{`
	`2210`	`+ // legacy replay path perf optimization`
`2211`	`2211`	`// a partial read has happened so store the target buffer in the snapshot`
`2212`	`2212`	`// so it can be re-used when another packet arrives and we read again`
`2213`	`2213`	`SetSnapshotStorage(buff);`
`2214`		`- if (writeDataSizeToSnapshot)`
`2215`		`- {`
`2216`		`- SetSnapshotDataSize(bytesRead);`
`2217`		`- }`
`2218`	`2214`	`}`
`2219`	`2215`	`return result;`
`2220`	`2216`	`}`
`2221`		`- if (writeDataSizeToSnapshot && canContinue)`
`2222`		`- {`
`2223`		`- SetSnapshotDataSize(bytesRead);`
`2224`		`- }`
`2225`	`2217`
`2226`	`2218`	`if (_longlenleft == 0)`
`2227`	`2219`	`{`
`2228`	`2220`	`// Read the next chunk or cleanup state if hit the end`
`2229`	`2221`	`result = TryReadPlpLength(false, out _);`
`2230`	`2222`	`if (result != TdsOperationStatus.Done)`
`2231`	`2223`	`{`
`2232`		`- if (compatibilityMode && _snapshot != null)`
`2233`		`- {`
`2234`		`- // a partial read has happened so store the target buffer in the snapshot`
`2235`		`- // so it can be re-used when another packet arrives and we read again`
`2236`		`- SetSnapshotStorage(buff);`
`2237`		`- }`
`2238`		`- else if (canContinue && result == TdsOperationStatus.NeedMoreData)`
	`2224`	`+ if (writeDataSizeToSnapshot)`
`2239`	`2225`	`{`
`2240`		`- SetSnapshotStorage(buff);`
`2241`		`- if (writeDataSizeToSnapshot)`
	`2226`	`+ if (result == TdsOperationStatus.NeedMoreData)`
`2242`	`2227`	`{`
	`2228`	`+ SetSnapshotStorage(buff);`
`2243`	`2229`	`SetSnapshotDataSize(bytesRead);`
`2244`	`2230`	`}`
	`2231`	`+ }`
	`2232`	`+ else if (compatibilityMode && _snapshot != null)`
	`2233`	`+ {`
	`2234`	`+ // a partial read has happened so store the target buffer in the snapshot`
	`2235`	`+ // so it can be re-used when another packet arrives and we read again`
	`2236`	`+ SetSnapshotStorage(buff);`
`2245`	`2237`	`}`
`2246`	`2238`	`return result;`
`2247`	`2239`	`}`
`@@ -3516,17 +3508,17 @@ internal bool IsSnapshotContinuing()`
`3516`	`3508`	`_snapshotStatus == TdsParserStateObject.SnapshotStatus.ContinueRunning;`
`3517`	`3509`	`}`
`3518`	`3510`
`3519`		`- internal (bool CanContinue, bool IsStarting, bool IsContinuing) GetSnapshotStatuses()`
	`3511`	`+ internal (bool IsAvailable, bool IsStarting, bool IsContinuing) GetSnapshotStatuses()`
`3520`	`3512`	`{`
`3521`		`- bool canContinue = _snapshot != null && _snapshot.ContinueEnabled && _snapshotStatus != SnapshotStatus.NotActive;`
	`3513`	`+ bool isAvailable = _snapshot != null && _snapshot.ContinueEnabled;`
`3522`	`3514`	`bool isStarting = false;`
`3523`	`3515`	`bool isContinuing = false;`
`3524`		`- if (canContinue)`
	`3516`	`+ if (isAvailable)`
`3525`	`3517`	`{`
`3526`	`3518`	`isStarting = _snapshotStatus == SnapshotStatus.ReplayStarting;`
`3527`	`3519`	`isContinuing = _snapshotStatus == SnapshotStatus.ContinueRunning;`
`3528`	`3520`	`}`
`3529`		`- return (canContinue, isStarting, isContinuing);`
	`3521`	`+ return (isAvailable, isStarting, isContinuing);`
`3530`	`3522`	`}`
`3531`	`3523`
`3532`	`3524`	`internal int GetSnapshotStorageLength<T>()`