Ensure external streams checkpoint on commit (#2652)

* Fix checkpoint persistence for external streams

* Restore checkpoint pragma after stream sessions

Author: JKamsker

LiteDB.Tests/Issues/IssueCheckpointFlush_Tests.cs

@@ -0,0 +1,104 @@
+using System;
+using System.IO;
+using FluentAssertions;
+using LiteDB;
+using LiteDB.Tests;
+using Xunit;
+
+namespace LiteDB.Tests.Issues
+{
+    public class IssueCheckpointFlush_Tests
+    {
+        private class Entity
+        {
+            public int Id { get; set; }
+
+            public string Value { get; set; } = string.Empty;
+        }
+
+        [Fact]
+        public void CommittedChangesAreLostWhenClosingExternalStreamWithoutCheckpoint()
+        {
+            using var tempFile = new TempFile();
+
+            using (var createStream = new FileStream(tempFile.Filename, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite))
+            {
+                using var createDb = new LiteDatabase(createStream);
+                var collection = createDb.GetCollection<Entity>("entities");
+
+                collection.Upsert(new Entity { Id = 1, Value = "initial" });
+
+                createDb.Commit();
+                createStream.Flush(true);
+            }
+
+            var updateStream = new FileStream(tempFile.Filename, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
+            var updateDb = new LiteDatabase(updateStream);
+            var updateCollection = updateDb.GetCollection<Entity>("entities");
+
+            updateCollection.Upsert(new Entity { Id = 1, Value = "updated" });
+
+            updateDb.Commit();
+            updateStream.Flush(true);
+            updateStream.Dispose();
+            updateDb = null;
+
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+
+            using (var verifyStream = new FileStream(tempFile.Filename, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite))
+            using (var verifyDb = new LiteDatabase(verifyStream))
+            {
+                var document = verifyDb.GetCollection<Entity>("entities").FindById(1);
+
+                document.Should().NotBeNull();
+                document!.Value.Should().Be("updated");
+            }
+        }
+
+        [Fact]
+        public void StreamConstructorRestoresCheckpointSizeAfterDisposal()
+        {
+            using var tempFile = new TempFile();
+
+            using (var fileDb = new LiteDatabase(tempFile.Filename))
+            {
+                fileDb.CheckpointSize.Should().Be(1000);
+            }
+
+            using (var stream = new FileStream(tempFile.Filename, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite))
+            using (var streamDb = new LiteDatabase(stream))
+            {
+                streamDb.CheckpointSize.Should().Be(1);
+            }
+
+            using (var reopened = new LiteDatabase(tempFile.Filename))
+            {
+                reopened.CheckpointSize.Should().Be(1000);
+            }
+        }
+
+        [Fact]
+        public void StreamConstructorAllowsReadOnlyStreams()
+        {
+            using var tempFile = new TempFile();
+
+            using (var setup = new LiteDatabase(tempFile.Filename))
+            {
+                var collection = setup.GetCollection<Entity>("entities");
+
+                collection.Insert(new Entity { Id = 1, Value = "initial" });
+
+                setup.Checkpoint();
+            }
+
+            using var readOnlyStream = new FileStream(tempFile.Filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            using var readOnlyDb = new LiteDatabase(readOnlyStream);
+
+            var document = readOnlyDb.GetCollection<Entity>("entities").FindById(1);
+
+            document.Should().NotBeNull();
+            document!.Value.Should().Be("initial");
+        }
+    }
+}

LiteDB/Client/Database/LiteDatabase.cs

@@ -19,6 +19,7 @@ public partial class LiteDatabase : ILiteDatabase
         private readonly ILiteEngine _engine;
         private readonly BsonMapper _mapper;
         private readonly bool _disposeOnClose;
+        private readonly int? _checkpointOverride;
 
         /// <summary>
         /// Get current instance of BsonMapper used in this database instance (can be BsonMapper.Global)
@@ -66,6 +67,27 @@ public LiteDatabase(Stream stream, BsonMapper mapper = null, Stream logStream =
             _engine = new LiteEngine(settings);
             _mapper = mapper ?? BsonMapper.Global;
             _disposeOnClose = true;
+
+            if (logStream == null && stream is not MemoryStream)
+            {
+                if (!stream.CanWrite)
+                {
+                    // Read-only streams cannot participate in eager checkpointing because the process
+                    // writes pages back to the underlying data stream immediately.
+                }
+                else
+                {
+                    // Without a dedicated log stream the WAL lives purely in memory; force
+                    // checkpointing to ensure commits reach the underlying data stream.
+                    var originalCheckpointSize = _engine.Pragma(Pragmas.CHECKPOINT);
+
+                    if (originalCheckpointSize != 1)
+                    {
+                        _engine.Pragma(Pragmas.CHECKPOINT, 1);
+                        _checkpointOverride = originalCheckpointSize;
+                    }
+                }
+            }
         }
 
         /// <summary>
@@ -373,6 +395,11 @@ protected virtual void Dispose(bool disposing)
         {
             if (disposing && _disposeOnClose)
             {
+                if (_checkpointOverride.HasValue)
+                {
+                    _engine.Pragma(Pragmas.CHECKPOINT, _checkpointOverride.Value);
+                }
+
                 _engine.Dispose();
             }
         }

LiteDB/Engine/Engine/Transaction.cs

@@ -112,8 +112,8 @@ private void CommitAndReleaseTransaction(TransactionService transaction)
             _monitor.ReleaseTransaction(transaction);
 
             // try checkpoint when finish transaction and log file are bigger than checkpoint pragma value (in pages)
-            if (_header.Pragmas.Checkpoint > 0 && 
-                _disk.GetFileLength(FileOrigin.Log) > (_header.Pragmas.Checkpoint * PAGE_SIZE))
+            if (_header.Pragmas.Checkpoint > 0 &&
+                _disk.GetFileLength(FileOrigin.Log) >= (_header.Pragmas.Checkpoint * PAGE_SIZE))
             {
                 _walIndex.TryCheckpoint();
             }