Adds methods to clear stale transactions.

src/ZoneTree/ITransactionalZoneTree.cs

@@ -123,9 +123,4 @@ public interface ITransactionalZoneTree<TKey, TValue> : IDisposable
     /// </summary>
     /// <param name="key">Key</param>
     void DeleteAutoCommit(in TKey key);
-
-    /// <summary>
-    /// Rollbacks all uncommitted transactions.
-    /// </summary>
-    int RollbackAllUncommitted();
 }

src/ZoneTree/ITransactionalZoneTreeMaintenance.cs

@@ -40,7 +40,17 @@ public interface ITransactionalZoneTreeMaintenance<TKey, TValue>
     void DestroyTree();
 
     /// <summary>
-    /// Aborts and rollback all uncommitted transactions.
+    /// Rollbacks all uncommitted transactions.
     /// </summary>
-    void RollbackUncommittedTransactions();
+    /// <returns>Count of rollbacked transactions.</returns>
+    int RollbackAllUncommitted();
+
+    /// <summary>
+    /// Rollbacks all uncommitted transaction ids started before given date-time.
+    /// Transaction log memory usage increases by state uncommitted transaction ids.
+    /// Those must be rollbacked.
+    /// </summary>
+    /// <param name="dateTime">Max start time (exclusive)</param>
+    /// <returns>Count of rollbacked transactions.</returns>
+    int RollbackUncommittedTransactionIdsBefore(DateTime dateTime);
 }

src/ZoneTree/IZoneTreeMaintenance.cs

@@ -131,21 +131,21 @@ public interface IZoneTreeMaintenance<TKey, TValue>
     event CanNotDropReadOnlySegment<TKey, TValue> OnCanNotDropReadOnlySegment;
 
     /// <summary>
-    /// Event is fired when a write ahead log cannot be dropped.
+    /// Event is fired when a disk segment cannot be dropped.
     /// This does not harm the database consistency.
     /// The cleanup task can be done later.
     /// </summary>
     event CanNotDropDiskSegment<TKey, TValue> OnCanNotDropDiskSegment;
 
     /// <summary>
-    /// Event is fired when a write ahead log cannot be dropped.
+    /// Event is fired when a disk segment creator cannot be dropped.
     /// This does not harm the database consistency.
     /// The cleanup task can be done later.
     /// </summary>
     event CanNotDropDiskSegmentCreator<TKey, TValue> OnCanNotDropDiskSegmentCreator;
 
     /// <summary>
-    /// Event is fired the ZoneTree is disposing.
+    /// Event is fired when the ZoneTree is disposing.
     /// </summary>
     event ZoneTreeIsDisposing<TKey, TValue> OnZoneTreeIsDisposing;
 }

src/ZoneTree/Transactional/BasicTransactionLog.cs

@@ -429,4 +429,18 @@ private void DeleteTransactionFromMemory(long id)
         HistoryTable.TryDeleteFromMemory(id);
         DependencyTable.TryDeleteFromMemory(id);
     }
+
+    public IReadOnlyList<long> GetUncommittedTransactionIdsBefore(DateTime dateTime)
+    {
+        var ticks = dateTime.Ticks;
+        lock (this)
+        {
+            var transactionIds = Transactions.Keys;
+            return TransactionIds.Where(x =>
+                Transactions.TryGetValue(x, out var meta)
+                && meta.State == TransactionState.Uncommitted
+                && meta.StartedAt < ticks)
+            .ToArray();
+        }
+    }
 }

src/ZoneTree/Transactional/ITransactionLog.cs

@@ -9,12 +9,29 @@ public interface ITransactionLog<TKey, TValue> : IDisposable
     /// </summary>
     int CompactionThreshold { get; set; }
 
+    /// <summary>
+    /// Transaction count in the memory.
+    /// </summary>
     int TransactionCount { get; }
 
+    /// <summary>
+    /// Return all transaction ids that are available in memory.
+    /// </summary>
     IReadOnlyList<long> TransactionIds { get; }
 
+    /// <summary>
+    /// Returns all uncommitted transaction ids.
+    /// </summary>
     IReadOnlyList<long> UncommittedTransactionIds { get; }
 
+    /// <summary>
+    /// Retrieves all uncommitted transaction ids started before given date-time.
+    /// This method can be used to gather stale uncommitted transaction ids.
+    /// </summary>
+    /// <param name="dateTime">Max start time (exclusive)</param>
+    /// <returns>Uncommitted ids</returns>
+    IReadOnlyList<long> GetUncommittedTransactionIdsBefore(DateTime dateTime);
+
     long GetNextTransactionId();
 
     void TransactionStarted(long transactionId);

src/ZoneTree/Transactional/OptimisticZoneTree.cs

@@ -417,4 +417,16 @@ public int RollbackAllUncommitted()
         }
         return count;
     }
+
+    public int RollbackUncommittedTransactionIdsBefore(DateTime dateTime)
+    {
+        var count = 0;
+        var uncommitted = TransactionLog.GetUncommittedTransactionIdsBefore(dateTime);
+        foreach (var u in uncommitted)
+        {
+            Rollback(u);
+            ++count;
+        }
+        return count;
+    }
 }