Use configured FlushOptions and WriteOptions in RocksDbContext

src/RocksDb.Extensions/RocksDbAccessor.cs

@@ -56,7 +56,7 @@ public void Remove(TKey key)
                 keySpan = keyBufferWriter.WrittenSpan;
             }
 
-            _rocksDbContext.Db.Remove(keySpan, _columnFamily.Handle);
+            _rocksDbContext.Db.Remove(keySpan, _columnFamily.Handle, _rocksDbContext.WriteOptions);
         }
         finally
         {
@@ -119,7 +119,7 @@ public void Put(TKey key, TValue value)
                 valueSpan = valueBufferWriter.WrittenSpan;
             }
 
-            _rocksDbContext.Db.Put(keySpan, valueSpan, _columnFamily.Handle);
+            _rocksDbContext.Db.Put(keySpan, valueSpan, _columnFamily.Handle, _rocksDbContext.WriteOptions);
         }
         finally
         {
@@ -202,7 +202,7 @@ public void PutRange(ReadOnlySpan<TKey> keys, ReadOnlySpan<TValue> values)
             AddToBatch(keys[i], values[i], batch);
         }
 
-        _rocksDbContext.Db.Write(batch);
+        _rocksDbContext.Db.Write(batch, _rocksDbContext.WriteOptions);
     }
 
     public void PutRange(ReadOnlySpan<TValue> values, Func<TValue, TKey> keySelector)
@@ -215,7 +215,7 @@ public void PutRange(ReadOnlySpan<TValue> values, Func<TValue, TKey> keySelector
             AddToBatch(key, value, batch);
         }
 
-        _rocksDbContext.Db.Write(batch);
+        _rocksDbContext.Db.Write(batch, _rocksDbContext.WriteOptions);
     }
 
     public void PutRange(IReadOnlyList<(TKey key, TValue value)> items)
@@ -227,7 +227,7 @@ public void PutRange(IReadOnlyList<(TKey key, TValue value)> items)
             AddToBatch(key, value, batch);
         }
 
-        _rocksDbContext.Db.Write(batch);
+        _rocksDbContext.Db.Write(batch, _rocksDbContext.WriteOptions);
     }
 
     private void AddToBatch(TKey key, TValue value, WriteBatch batch)

src/RocksDb.Extensions/RocksDbContext.cs

@@ -8,6 +8,8 @@ internal class RocksDbContext : IDisposable
     private readonly RocksDbSharp.RocksDb _rocksDb;
     private readonly Cache _cache;
     private readonly ColumnFamilyOptions _userSpecifiedOptions;
+    private readonly FlushOptions _flushOptions;
+    private readonly WriteOptions _writeOptions;
 
     private const long BlockCacheSize = 50 * 1024 * 1024L;
     private const long BlockSize = 4096L;
@@ -48,11 +50,11 @@ public RocksDbContext(IOptions<RocksDbOptions> options)
         dbOptions.SetUseDirectReads(options.Value.UseDirectReads);
         dbOptions.SetUseDirectIoForFlushAndCompaction(options.Value.UseDirectIoForFlushAndCompaction);
 
-        var fOptions = new FlushOptions();
-        fOptions.SetWaitForFlush(options.Value.WaitForFlush);
+        _flushOptions = new FlushOptions();
+        _flushOptions.SetWaitForFlush(options.Value.WaitForFlush);
 
-        var writeOptions = new WriteOptions();
-        writeOptions.DisableWal(1);
+        _writeOptions = new WriteOptions();
+        _writeOptions.DisableWal(1);
 
         _userSpecifiedOptions.EnableStatistics();
 
@@ -76,6 +78,10 @@ private static void DestroyDatabase(string path)
 
     public ColumnFamilyOptions ColumnFamilyOptions => _userSpecifiedOptions;
 
+    public WriteOptions WriteOptions => _writeOptions;
+
+    public FlushOptions FlushOptions => _flushOptions;
+
     private static ColumnFamilies CreateColumnFamilies(IReadOnlyList<string> columnFamilyNames,
         ColumnFamilyOptions columnFamilyOptions)
     {

test/RocksDb.Extensions.Tests/WriteOptionsTests.cs

@@ -0,0 +1,81 @@
+using NUnit.Framework;
+using RocksDb.Extensions.Tests.Utils;
+using Shouldly;
+
+namespace RocksDb.Extensions.Tests;
+
+public class WriteOptionsTests
+{
+    [Test]
+    public void should_configure_wait_for_flush_option()
+    {
+        using var testFixture = TestFixture.Create(rockDb =>
+        {
+            _ = rockDb.AddStore<int, int, RocksDbGenericStore<int, int>>("my-store");
+        }, options =>
+        {
+            options.WaitForFlush = false;
+        });
+
+        var store = testFixture.GetStore<RocksDbGenericStore<int, int>>();
+
+        // Verify that write operations work with the configured options
+        store.Put(1, 100);
+        store.TryGet(1, out var value).ShouldBeTrue();
+        value.ShouldBe(100);
+    }
+
+    [Test]
+    public void should_use_write_options_for_put_operations()
+    {
+        using var testFixture = TestFixture.Create(rockDb =>
+        {
+            _ = rockDb.AddStore<string, string, RocksDbGenericStore<string, string>>("my-store");
+        });
+
+        var store = testFixture.GetStore<RocksDbGenericStore<string, string>>();
+
+        // Verify that Put operation works (uses WriteOptions internally)
+        store.Put("key1", "value1");
+        store.TryGet("key1", out var value).ShouldBeTrue();
+        value.ShouldBe("value1");
+    }
+
+    [Test]
+    public void should_use_write_options_for_remove_operations()
+    {
+        using var testFixture = TestFixture.Create(rockDb =>
+        {
+            _ = rockDb.AddStore<string, string, RocksDbGenericStore<string, string>>("my-store");
+        });
+
+        var store = testFixture.GetStore<RocksDbGenericStore<string, string>>();
+
+        // Verify that Remove operation works (uses WriteOptions internally)
+        store.Put("key1", "value1");
+        store.Remove("key1");
+        store.TryGet("key1", out _).ShouldBeFalse();
+    }
+
+    [Test]
+    public void should_use_write_options_for_put_range_operations()
+    {
+        using var testFixture = TestFixture.Create(rockDb =>
+        {
+            _ = rockDb.AddStore<int, int, RocksDbGenericStore<int, int>>("my-store");
+        });
+
+        var store = testFixture.GetStore<RocksDbGenericStore<int, int>>();
+
+        // Verify that PutRange operation works (uses WriteOptions internally)
+        var items = new[] { (1, 100), (2, 200), (3, 300) };
+        store.PutRange(items);
+
+        store.TryGet(1, out var value1).ShouldBeTrue();
+        value1.ShouldBe(100);
+        store.TryGet(2, out var value2).ShouldBeTrue();
+        value2.ShouldBe(200);
+        store.TryGet(3, out var value3).ShouldBeTrue();
+        value3.ShouldBe(300);
+    }
+}