From ece59bbc1ab91d38ac26dd5e1614f57e6cc538fd Mon Sep 17 00:00:00 2001
From: JKamsker <jonas@kamsker.at>
Date: Sat, 1 Jun 2024 19:03:34 +0200
Subject: [PATCH 1/5] Fixed #2471, #2435, #2483 : Releasing read lock when done
 reading

---
 LiteDB.Tests/Issues/Issue2471_Test.cs         | 49 +++++++++++++++++++
 LiteDB/Engine/Query/QueryExecutor.cs          | 28 +++++------
 .../Utils/Extensions/EnumerableExtensions.cs  | 27 ++++++++++
 3 files changed, 87 insertions(+), 17 deletions(-)
 create mode 100644 LiteDB.Tests/Issues/Issue2471_Test.cs
 create mode 100644 LiteDB/Utils/Extensions/EnumerableExtensions.cs

diff --git a/LiteDB.Tests/Issues/Issue2471_Test.cs b/LiteDB.Tests/Issues/Issue2471_Test.cs
new file mode 100644
index 000000000..c6d9ff1a2
--- /dev/null
+++ b/LiteDB.Tests/Issues/Issue2471_Test.cs
@@ -0,0 +1,49 @@
+using FluentAssertions;
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+using Xunit;
+
+namespace LiteDB.Tests.Issues;
+
+public class Issue2471_Test
+{
+    [Fact]
+    public void TestFragmentDB_FindByIDException()
+    {
+        using var db = new LiteDatabase(":memory:");
+        var collection = db.GetCollection<object>("fragtest");
+
+        var fragment = new object { };
+        var id = collection.Insert(fragment);
+
+        id.Should().BeGreaterThan(0);
+
+        var frag2 = collection.FindById(id);
+        frag2.Should().NotBeNull();
+
+        Action act = () => db.Checkpoint();
+
+        act.Should().NotThrow();
+    }
+
+    [Fact]
+    public void MultipleReadCleansUpTransaction()
+    {
+        using var database = new LiteDatabase(":memory:");
+
+        var collection = database.GetCollection("test");
+        collection.Insert(new BsonDocument { ["_id"] = 1 });
+
+        for (int i = 0; i < 500; i++)
+        {
+            collection.FindById(1);
+        }
+    }
+}
\ No newline at end of file
diff --git a/LiteDB/Engine/Query/QueryExecutor.cs b/LiteDB/Engine/Query/QueryExecutor.cs
index 10d8e034b..522eb44af 100644
--- a/LiteDB/Engine/Query/QueryExecutor.cs
+++ b/LiteDB/Engine/Query/QueryExecutor.cs
@@ -1,6 +1,9 @@
-using System;
+using LiteDB.Utils.Extensions;
+
+using System;
 using System.Collections.Generic;
 using System.Linq;
+
 using static LiteDB.Constants;
 
 namespace LiteDB.Engine
@@ -71,8 +74,14 @@ internal BsonDataReader ExecuteQuery(bool executionPlan)
 
             transaction.OpenCursors.Add(_cursor);
 
+            var enumerable = RunQuery();
+            if (isNew)
+            {
+                enumerable = enumerable.OnDispose(() => _monitor.ReleaseTransaction(transaction));
+            }
+
             // return new BsonDataReader with IEnumerable source
-            return new BsonDataReader(RunQuery(), _collection, _state);
+            return new BsonDataReader(enumerable, _collection, _state);
 
             IEnumerable<BsonDocument> RunQuery()
             {
@@ -89,11 +98,6 @@ IEnumerable<BsonDocument> RunQuery()
 
                     transaction.OpenCursors.Remove(_cursor);
 
-                    if (isNew)
-                    {
-                        _monitor.ReleaseTransaction(transaction);
-                    }
-
                     yield break;
                 }
 
@@ -111,11 +115,6 @@ IEnumerable<BsonDocument> RunQuery()
 
                     transaction.OpenCursors.Remove(_cursor);
 
-                    if (isNew)
-                    {
-                        _monitor.ReleaseTransaction(transaction);
-                    }
-
                     yield break;
                 }
 
@@ -169,11 +168,6 @@ IEnumerable<BsonDocument> RunQuery()
                 _cursor.Elapsed.Stop();
 
                 transaction.OpenCursors.Remove(_cursor);
-
-                if (isNew)
-                {
-                    _monitor.ReleaseTransaction(transaction);
-                }
             };
         }
 
diff --git a/LiteDB/Utils/Extensions/EnumerableExtensions.cs b/LiteDB/Utils/Extensions/EnumerableExtensions.cs
new file mode 100644
index 000000000..b79c1af12
--- /dev/null
+++ b/LiteDB/Utils/Extensions/EnumerableExtensions.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LiteDB.Utils.Extensions
+{
+    internal static class EnumerableExtensions
+    {
+        // calls method on dispose
+        public static IEnumerable<T> OnDispose<T>(this IEnumerable<T> source, Action onDispose)
+        {
+            try
+            {
+                foreach (var item in source)
+                {
+                    yield return item;
+                }
+            }
+            finally
+            {
+                onDispose();
+            }
+        }
+    }
+}
\ No newline at end of file

From 72b1ac28d29100d0fcb380023dba4cff89015cd4 Mon Sep 17 00:00:00 2001
From: JKamsker <11245306+JKamsker@users.noreply.github.com>
Date: Tue, 4 Jun 2024 17:48:42 +0200
Subject: [PATCH 2/5] Bump langversion to be able to use newer language
 features while all TargetFrameworks still build and run

---
 LiteDB/LiteDB.csproj | 1 +
 1 file changed, 1 insertion(+)

diff --git a/LiteDB/LiteDB.csproj b/LiteDB/LiteDB.csproj
index 721395e91..4105be0f3 100644
--- a/LiteDB/LiteDB.csproj
+++ b/LiteDB/LiteDB.csproj
@@ -28,6 +28,7 @@
     <SignAssembly Condition="'$(OS)'=='Windows_NT'">true</SignAssembly>
     <AssemblyOriginatorKeyFile Condition="'$(Configuration)' == 'Release'">LiteDB.snk</AssemblyOriginatorKeyFile>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <LangVersion>8.0</LangVersion>
   </PropertyGroup>
   
   <!--

From ad1ca029913189aec15ff8d2ae0c7c71f3ccb7fd Mon Sep 17 00:00:00 2001
From: JKamsker <11245306+JKamsker@users.noreply.github.com>
Date: Tue, 4 Jun 2024 18:01:28 +0200
Subject: [PATCH 3/5] Also remove OpenCursors after RunQuery

---
 LiteDB.Tests/Internals/Extensions_Test.cs     | 44 +++++++++++++++++++
 LiteDB/Engine/Query/QueryExecutor.cs          | 29 +++++-------
 .../Utils/Extensions/StopWatchExtensions.cs   | 31 +++++++++++++
 3 files changed, 86 insertions(+), 18 deletions(-)
 create mode 100644 LiteDB.Tests/Internals/Extensions_Test.cs
 create mode 100644 LiteDB/Utils/Extensions/StopWatchExtensions.cs

diff --git a/LiteDB.Tests/Internals/Extensions_Test.cs b/LiteDB.Tests/Internals/Extensions_Test.cs
new file mode 100644
index 000000000..ef5243d27
--- /dev/null
+++ b/LiteDB.Tests/Internals/Extensions_Test.cs
@@ -0,0 +1,44 @@
+using LiteDB.Utils.Extensions;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Xunit;
+
+namespace LiteDB.Tests.Internals;
+
+public class Extensions_Test
+{
+    // Asserts that chained IEnumerable<T>.OnDispose(()=> { }) calls the action on dispose, even when chained
+    [Fact]
+    public void EnumerableExtensions_OnDispose()
+    {
+        var disposed = false;
+        var disposed1 = false;
+        var enumerable = new[] { 1, 2, 3 }.OnDispose(() => disposed = true).OnDispose(() => disposed1 = true);
+
+        foreach (var item in enumerable)
+        {
+            // do nothing
+        }
+
+        Assert.True(disposed);
+        Assert.True(disposed1);
+    }
+
+    // tests IDisposable StartDisposable(this Stopwatch stopwatch)
+    [Fact]
+    public async Task StopWatchExtensions_StartDisposable()
+    {
+        var stopwatch = new System.Diagnostics.Stopwatch();
+        using (stopwatch.StartDisposable())
+        {
+            await Task.Delay(100);
+        }
+
+        Assert.True(stopwatch.ElapsedMilliseconds > 0);
+    }
+}
\ No newline at end of file
diff --git a/LiteDB/Engine/Query/QueryExecutor.cs b/LiteDB/Engine/Query/QueryExecutor.cs
index 522eb44af..d96956043 100644
--- a/LiteDB/Engine/Query/QueryExecutor.cs
+++ b/LiteDB/Engine/Query/QueryExecutor.cs
@@ -25,14 +25,14 @@ internal class QueryExecutor
         private readonly IEnumerable<BsonDocument> _source;
 
         public QueryExecutor(
-            LiteEngine engine, 
+            LiteEngine engine,
             EngineState state,
-            TransactionMonitor monitor, 
-            SortDisk sortDisk, 
+            TransactionMonitor monitor,
+            SortDisk sortDisk,
             DiskService disk,
-            EnginePragmas pragmas, 
-            string collection, 
-            Query query, 
+            EnginePragmas pragmas,
+            string collection,
+            Query query,
             IEnumerable<BsonDocument> source)
         {
             _engine = engine;
@@ -75,6 +75,9 @@ internal BsonDataReader ExecuteQuery(bool executionPlan)
             transaction.OpenCursors.Add(_cursor);
 
             var enumerable = RunQuery();
+
+            enumerable = enumerable.OnDispose(() => transaction.OpenCursors.Remove(_cursor));
+
             if (isNew)
             {
                 enumerable = enumerable.OnDispose(() => _monitor.ReleaseTransaction(transaction));
@@ -96,8 +99,6 @@ IEnumerable<BsonDocument> RunQuery()
                         yield return _query.Select.ExecuteScalar(_pragmas.Collation).AsDocument;
                     }
 
-                    transaction.OpenCursors.Remove(_cursor);
-
                     yield break;
                 }
 
@@ -112,9 +113,6 @@ IEnumerable<BsonDocument> RunQuery()
                 if (executionPlan)
                 {
                     yield return queryPlan.GetExecutionPlan();
-
-                    transaction.OpenCursors.Remove(_cursor);
-
                     yield break;
                 }
 
@@ -124,8 +122,8 @@ IEnumerable<BsonDocument> RunQuery()
                 // get current query pipe: normal or groupby pipe
                 var pipe = queryPlan.GetPipe(transaction, snapshot, _sortDisk, _pragmas, _disk.MAX_ITEMS_COUNT);
 
-                // start cursor elapsed timer
-                _cursor.Elapsed.Start();
+                // start cursor elapsed timer which stops on dispose
+                using var _ = _cursor.Elapsed.StartDisposable();
 
                 using (var enumerator = pipe.Pipe(nodes, queryPlan).GetEnumerator())
                 {
@@ -163,11 +161,6 @@ IEnumerable<BsonDocument> RunQuery()
                         }
                     }
                 }
-
-                // stop cursor elapsed
-                _cursor.Elapsed.Stop();
-
-                transaction.OpenCursors.Remove(_cursor);
             };
         }
 
diff --git a/LiteDB/Utils/Extensions/StopWatchExtensions.cs b/LiteDB/Utils/Extensions/StopWatchExtensions.cs
new file mode 100644
index 000000000..74c77e763
--- /dev/null
+++ b/LiteDB/Utils/Extensions/StopWatchExtensions.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Diagnostics;
+
+namespace LiteDB.Utils.Extensions
+{
+    public static class StopWatchExtensions
+    {
+        // Start the stopwatch and returns an IDisposable that will stop the stopwatch when disposed
+        public static IDisposable StartDisposable(this Stopwatch stopwatch)
+        {
+            stopwatch.Start();
+            return new DisposableAction(stopwatch.Stop);
+        }
+
+        private class DisposableAction : IDisposable
+        {
+            private readonly Action _action;
+
+            public DisposableAction(Action action)
+            {
+                _action = action;
+            }
+
+            public void Dispose()
+            {
+                _action();
+            }
+        }
+    }
+
+}
\ No newline at end of file

From 1a9d6c6a53f9b9e202bdb040693c0b32f808339e Mon Sep 17 00:00:00 2001
From: JKamsker <11245306+JKamsker@users.noreply.github.com>
Date: Tue, 4 Jun 2024 18:01:38 +0200
Subject: [PATCH 4/5] Remove unused usings

---
 LiteDB/Utils/Extensions/EnumerableExtensions.cs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/LiteDB/Utils/Extensions/EnumerableExtensions.cs b/LiteDB/Utils/Extensions/EnumerableExtensions.cs
index b79c1af12..8315e8b77 100644
--- a/LiteDB/Utils/Extensions/EnumerableExtensions.cs
+++ b/LiteDB/Utils/Extensions/EnumerableExtensions.cs
@@ -1,8 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace LiteDB.Utils.Extensions
 {

From 74e9ef1cd7d07e39e6966ea0c6e70629add340ca Mon Sep 17 00:00:00 2001
From: JKamsker <11245306+JKamsker@users.noreply.github.com>
Date: Tue, 4 Jun 2024 18:17:21 +0200
Subject: [PATCH 5/5] Add test to assert that the executionPlan query also
 releases the lock

---
 LiteDB.Tests/Issues/Issue2471_Test.cs | 48 +++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/LiteDB.Tests/Issues/Issue2471_Test.cs b/LiteDB.Tests/Issues/Issue2471_Test.cs
index c6d9ff1a2..1f50e1aff 100644
--- a/LiteDB.Tests/Issues/Issue2471_Test.cs
+++ b/LiteDB.Tests/Issues/Issue2471_Test.cs
@@ -46,4 +46,52 @@ public void MultipleReadCleansUpTransaction()
             collection.FindById(1);
         }
     }
+
+    #region Model
+
+    public class User
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public int[] Phones { get; set; }
+        public List<Address> Addresses { get; set; }
+    }
+
+    public class Address
+    {
+        public string Street { get; set; }
+    }
+
+    #endregion Model
+
+    // Copied from IndexMultiKeyIndex, but this time we ensure that the lock is released by calling  db.Checkpoint()
+    [Fact]
+    public void Ensure_Query_GetPlan_Releases_Lock()
+    {
+        using var db = new LiteDatabase(new MemoryStream());
+        var col = db.GetCollection<User>();
+
+        col.Insert(new User { Name = "John Doe", Phones = new int[] { 1, 3, 5 }, Addresses = new List<Address> { new Address { Street = "Av.1" }, new Address { Street = "Av.3" } } });
+        col.Insert(new User { Name = "Joana Mark", Phones = new int[] { 1, 4 }, Addresses = new List<Address> { new Address { Street = "Av.3" } } });
+
+        // create indexes
+        col.EnsureIndex(x => x.Phones);
+        col.EnsureIndex(x => x.Addresses.Select(z => z.Street));
+
+        // testing indexes expressions
+        var indexes = db.GetCollection("$indexes").FindAll().ToArray();
+
+        indexes[1]["expression"].AsString.Should().Be("$.Phones[*]");
+        indexes[2]["expression"].AsString.Should().Be("MAP($.Addresses[*]=>@.Street)");
+
+        // doing Phone query
+        var queryPhone = col.Query()
+            .Where(x => x.Phones.Contains(3));
+
+        var planPhone = queryPhone.GetPlan();
+
+        Action act = () => db.Checkpoint();
+
+        act.Should().NotThrow();
+    }
 }
\ No newline at end of file