Implement SingleDelete and DeleteRange in C# API

Tests/NewApiTests.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using RocksDbSharp;
+
+namespace Tests
+{
+    [TestClass]
+    public class NewApiTests
+    {
+        public TestContext TestContext { get; set; }
+
+        private string GetTempPath()
+        {
+            return Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        }
+
+        [TestMethod]
+        public void SingleDelete_Works()
+        {
+            var dbPath = GetTempPath();
+            try
+            {
+                var options = new DbOptions().SetCreateIfMissing(true);
+                using (var db = RocksDb.Open(options, dbPath))
+                {
+                    db.Put("key1", "value1");
+                    Assert.AreEqual("value1", db.Get("key1"));
+
+                    db.SingleDelete("key1");
+                    Assert.IsNull(db.Get("key1"));
+                }
+            }
+            finally
+            {
+                if (Directory.Exists(dbPath))
+                {
+                    Directory.Delete(dbPath, true);
+                }
+            }
+        }
+
+        [TestMethod]
+        public void DeleteRange_Works()
+        {
+            var dbPath = GetTempPath();
+            try
+            {
+                var options = new DbOptions().SetCreateIfMissing(true);
+                using (var db = RocksDb.Open(options, dbPath))
+                {
+                    db.Put("a", "1");
+                    db.Put("b", "2");
+                    db.Put("c", "3");
+                    db.Put("d", "4");
+                    db.Put("e", "5");
+
+                    // Delete range [b, d) -> deletes b, c. d remains.
+                    db.DeleteRange("b", "d");
+
+                    Assert.AreEqual("1", db.Get("a"));
+                    Assert.IsNull(db.Get("b"));
+                    Assert.IsNull(db.Get("c"));
+                    Assert.AreEqual("4", db.Get("d"));
+                    Assert.AreEqual("5", db.Get("e"));
+                }
+            }
+            finally
+            {
+                if (Directory.Exists(dbPath))
+                {
+                    Directory.Delete(dbPath, true);
+                }
+            }
+        }
+
+        [TestMethod]
+        public void SstFileWriter_DeleteRange_Works()
+        {
+            var dbPath = GetTempPath();
+            var sstPath = Path.Combine(GetTempPath(), "test.sst");
+            Directory.CreateDirectory(Path.GetDirectoryName(sstPath));
+
+            try
+            {
+                var options = new DbOptions().SetCreateIfMissing(true);
+                using (var db = RocksDb.Open(options, dbPath))
+                {
+                    db.Put("key1", "value1");
+                    db.Put("key2", "value2");
+                    db.Put("key3", "value3");
+
+                    // Create SST file with range deletion [key1, key3) -> delete key1, key2
+                    var envOptions = new EnvOptions();
+                    var ioOptions = new ColumnFamilyOptions();
+                    using (var writer = new SstFileWriter(envOptions, ioOptions))
+                    {
+                        writer.Open(sstPath);
+                        writer.DeleteRange(Encoding.UTF8.GetBytes("key1"), Encoding.UTF8.GetBytes("key3"));
+                        writer.Finish();
+                    }
+
+                    db.IngestExternalFiles(new[] { sstPath }, new IngestExternalFileOptions());
+
+                    Assert.IsNull(db.Get("key1"));
+                    Assert.IsNull(db.Get("key2"));
+                    Assert.AreEqual("value3", db.Get("key3"));
+                }
+            }
+            finally
+            {
+                if (Directory.Exists(dbPath))
+                {
+                    Directory.Delete(dbPath, true);
+                }
+                if (File.Exists(sstPath))
+                {
+                    File.Delete(sstPath);
+                }
+                var sstDir = Path.GetDirectoryName(sstPath);
+                if (Directory.Exists(sstDir))
+                {
+                    Directory.Delete(sstDir, true);
+                }
+            }
+        }
+    }
+}

csharp/src/Native.Marshaled.cs

@@ -576,6 +576,26 @@ public void rocksdb_delete(
             }
         }
 
+        public void rocksdb_singledelete(
+            /*rocksdb_t**/ IntPtr db,
+            /*const rocksdb_writeoptions_t**/ IntPtr writeOptions,
+            /*const*/ string key,
+            out IntPtr errptr,
+            ColumnFamilyHandle cf,
+            Encoding encoding = null)
+        {
+            var bkey = (encoding ?? Encoding.UTF8).GetBytes(key);
+            UIntPtr kLength = (UIntPtr)bkey.GetLongLength(0);
+            if (cf is null)
+            {
+                rocksdb_singledelete(db, writeOptions, bkey, kLength, out errptr);
+            }
+            else
+            {
+                rocksdb_singledelete_cf(db, writeOptions, cf.Handle, bkey, kLength, out errptr);
+            }
+        }
+
         public string rocksdb_options_statistics_get_string_marshaled(IntPtr opts)
         {
             return MarshalNullTermAsciiStr(rocksdb_options_statistics_get_string(opts));

csharp/src/Native.Wrap.cs

@@ -384,6 +384,72 @@ public void rocksdb_delete(
             }
         }
 
+        public void rocksdb_singledelete(
+            /*rocksdb_t**/ IntPtr db,
+            /*const rocksdb_writeoptions_t**/ IntPtr writeOptions,
+            /*const*/ string key,
+            ColumnFamilyHandle cf)
+        {
+            rocksdb_singledelete(db, writeOptions, key, out IntPtr errptr, cf);
+            if (errptr != IntPtr.Zero)
+            {
+                throw new RocksDbException(errptr);
+            }
+        }
+
+        public void rocksdb_singledelete(
+            IntPtr db,
+            IntPtr writeOptions,
+            byte[] key,
+            long keyLength,
+            ColumnFamilyHandle cf)
+        {
+            IntPtr errptr;
+            UIntPtr sklength = (UIntPtr)keyLength;
+            if (cf is null)
+            {
+                rocksdb_singledelete(db, writeOptions, key, sklength, out errptr);
+            }
+            else
+            {
+                rocksdb_singledelete_cf(db, writeOptions, cf.Handle, key, sklength, out errptr);
+            }
+
+            if (errptr != IntPtr.Zero)
+            {
+                throw new RocksDbException(errptr);
+            }
+        }
+
+#if !NETSTANDARD2_0
+        public unsafe void rocksdb_singledelete(
+            IntPtr db,
+            IntPtr writeOptions,
+            ReadOnlySpan<byte> key,
+            ColumnFamilyHandle cf)
+        {
+            IntPtr errptr;
+            UIntPtr sklength = (UIntPtr)key.Length;
+
+            fixed (byte* keyPtr = &MemoryMarshal.GetReference(key))
+            {
+                if (cf is null)
+                {
+                    rocksdb_singledelete(db, writeOptions, keyPtr, sklength, out errptr);
+                }
+                else
+                {
+                    rocksdb_singledelete_cf(db, writeOptions, cf.Handle, keyPtr, sklength, out errptr);
+                }
+
+                if (errptr != IntPtr.Zero)
+                {
+                    throw new RocksDbException(errptr);
+                }
+            }
+        }
+#endif
+
         [Obsolete("Use UIntPtr version instead")]
         public void rocksdb_delete(
             /*rocksdb_t**/ IntPtr db,
@@ -399,6 +465,43 @@ public void rocksdb_delete(
             }
         }
 
+        public void rocksdb_sstfilewriter_delete_range(
+            IntPtr writer,
+            byte[] startKey,
+            ulong startKeyLen,
+            byte[] endKey,
+            ulong endKeyLen)
+        {
+            UIntPtr sklength = (UIntPtr)startKeyLen;
+            UIntPtr eklength = (UIntPtr)endKeyLen;
+            rocksdb_sstfilewriter_delete_range(writer, startKey, sklength, endKey, eklength, out IntPtr errptr);
+            if (errptr != IntPtr.Zero)
+            {
+                throw new RocksDbException(errptr);
+            }
+        }
+
+#if !NETSTANDARD2_0
+        public unsafe void rocksdb_sstfilewriter_delete_range(
+            IntPtr writer,
+            ReadOnlySpan<byte> startKey,
+            ReadOnlySpan<byte> endKey)
+        {
+            UIntPtr sklength = (UIntPtr)startKey.Length;
+            UIntPtr eklength = (UIntPtr)endKey.Length;
+
+            fixed (byte* startKeyPtr = &MemoryMarshal.GetReference(startKey))
+            fixed (byte* endKeyPtr = &MemoryMarshal.GetReference(endKey))
+            {
+                rocksdb_sstfilewriter_delete_range(writer, startKeyPtr, sklength, endKeyPtr, eklength, out IntPtr errptr);
+                if (errptr != IntPtr.Zero)
+                {
+                    throw new RocksDbException(errptr);
+                }
+            }
+        }
+#endif
+
         [Obsolete("Use UIntPtr version instead")]
         public void rocksdb_delete_cf(
             /*rocksdb_t**/ IntPtr db,

csharp/src/RocksDb.cs

@@ -347,6 +347,58 @@ public void Remove(byte[] key, long keyLength, ColumnFamilyHandle cf = null, Wri
             }
         }
 
+        public void SingleDelete(string key, ColumnFamilyHandle cf = null, WriteOptions writeOptions = null)
+        {
+            Native.Instance.rocksdb_singledelete(Handle, (writeOptions ?? DefaultWriteOptions).Handle, key, cf);
+        }
+
+        public void SingleDelete(byte[] key, ColumnFamilyHandle cf = null, WriteOptions writeOptions = null)
+        {
+            SingleDelete(key, key.Length, cf, writeOptions);
+        }
+
+#if !NETSTANDARD2_0
+        public unsafe void SingleDelete(ReadOnlySpan<byte> key, ColumnFamilyHandle cf = null, WriteOptions writeOptions = null)
+        {
+            Native.Instance.rocksdb_singledelete(Handle, (writeOptions ?? DefaultWriteOptions).Handle, key, cf);
+        }
+#endif
+
+        public void SingleDelete(byte[] key, long keyLength, ColumnFamilyHandle cf = null, WriteOptions writeOptions = null)
+        {
+            Native.Instance.rocksdb_singledelete(Handle, (writeOptions ?? DefaultWriteOptions).Handle, key, keyLength, cf);
+        }
+
+        public void DeleteRange(string startKey, string endKey, ColumnFamilyHandle cf = null, WriteOptions writeOptions = null, Encoding encoding = null)
+        {
+            var start = (encoding ?? DefaultEncoding).GetBytes(startKey);
+            var end = (encoding ?? DefaultEncoding).GetBytes(endKey);
+            DeleteRange(start, start.Length, end, end.Length, cf, writeOptions);
+        }
+
+        public void DeleteRange(byte[] startKey, byte[] endKey, ColumnFamilyHandle cf = null, WriteOptions writeOptions = null)
+        {
+            DeleteRange(startKey, startKey.Length, endKey, endKey.Length, cf, writeOptions);
+        }
+
+#if !NETSTANDARD2_0
+        public unsafe void DeleteRange(ReadOnlySpan<byte> startKey, ReadOnlySpan<byte> endKey, ColumnFamilyHandle cf = null, WriteOptions writeOptions = null)
+        {
+            fixed (byte* startPtr = startKey)
+            fixed (byte* endPtr = endKey)
+            {
+                var cfHandle = cf ?? GetDefaultColumnFamily();
+                Native.Instance.rocksdb_delete_range_cf(Handle, (writeOptions ?? DefaultWriteOptions).Handle, cfHandle.Handle, startPtr, (UIntPtr)startKey.Length, endPtr, (UIntPtr)endKey.Length);
+            }
+        }
+#endif
+
+        public void DeleteRange(byte[] startKey, long startKeyLength, byte[] endKey, long endKeyLength, ColumnFamilyHandle cf = null, WriteOptions writeOptions = null)
+        {
+            var cfHandle = cf ?? GetDefaultColumnFamily();
+            Native.Instance.rocksdb_delete_range_cf(Handle, (writeOptions ?? DefaultWriteOptions).Handle, cfHandle.Handle, startKey, (UIntPtr)startKeyLength, endKey, (UIntPtr)endKeyLength);
+        }
+
         public void Put(string key, string value, ColumnFamilyHandle cf = null, WriteOptions writeOptions = null, Encoding encoding = null)
         {
             Native.Instance.rocksdb_put(Handle, (writeOptions ?? DefaultWriteOptions).Handle, key, value, cf, encoding ?? DefaultEncoding);

csharp/src/SstFileWriter.cs

@@ -66,5 +66,17 @@ public void Delete(byte[] key)
         {
             Native.Instance.rocksdb_sstfilewriter_delete(Handle, key, (UIntPtr)key.Length);
         }
+
+        public void DeleteRange(byte[] startKey, byte[] endKey)
+        {
+            Native.Instance.rocksdb_sstfilewriter_delete_range(Handle, startKey, (ulong)startKey.Length, endKey, (ulong)endKey.Length);
+        }
+
+#if !NETSTANDARD2_0
+        public void DeleteRange(ReadOnlySpan<byte> startKey, ReadOnlySpan<byte> endKey)
+        {
+            Native.Instance.rocksdb_sstfilewriter_delete_range(Handle, startKey, endKey);
+        }
+#endif
     }
 }