prepare for future auto-generated Native.Raw.cs

Author: warrenfalk

RocksDbSharp/ColumnFamilyOptions.cs

@@ -285,9 +285,40 @@ public ColumnFamilyOptions SetUint64addMergeOperator()
         /// and L4 using compression_per_level[3]. Compaction for each level can
         /// change when data grows.
         /// </summary>
+        public ColumnFamilyOptions SetCompressionPerLevel(Compression[] levelValues, ulong numLevels)
+        {
+            var values = levelValues.Select(x => (int)x).ToArray();
+            Native.Instance.rocksdb_options_set_compression_per_level(Handle, values, numLevels);
+            return this;
+        }
+
+        /// <summary>
+        /// Different levels can have different compression policies. There
+        /// are cases where most lower levels would like to use quick compression
+        /// algorithms while the higher levels (which have more data) use
+        /// compression algorithms that have better compression but could
+        /// be slower. This array, if non-empty, should have an entry for
+        /// each level of the database; these override the value specified in
+        /// the previous field 'compression'.
+        ///
+        /// NOTICE if level_compaction_dynamic_level_bytes=true,
+        /// compression_per_level[0] still determines L0, but other elements
+        /// of the array are based on base level (the level L0 files are merged
+        /// to), and may not match the level users see from info log for metadata.
+        /// If L0 files are merged to level-n, then, for i>0, compression_per_level[i]
+        /// determines compaction type for level n+i-1.
+        /// For example, if we have three 5 levels, and we determine to merge L0
+        /// data to L4 (which means L1..L3 will be empty), then the new files go to
+        /// L4 uses compression type compression_per_level[1].
+        /// If now L0 is merged to L2. Data goes to L2 will be compressed
+        /// according to compression_per_level[1], L3 using compression_per_level[2]
+        /// and L4 using compression_per_level[3]. Compaction for each level can
+        /// change when data grows.
+        /// </summary>
+        [Obsolete("Use Compression enum")]
         public ColumnFamilyOptions SetCompressionPerLevel(CompressionTypeEnum[] levelValues, ulong numLevels)
         {
-            var values = levelValues.Select(x => (int) x).ToArray();
+            var values = levelValues.Select(x => (int)x).ToArray();
             Native.Instance.rocksdb_options_set_compression_per_level(Handle, values, numLevels);
             return this;
         }
@@ -942,6 +973,29 @@ public ColumnFamilyOptions SetReportBgIoStats(bool value)
         /// incompressible, the kSnappyCompression implementation will
         /// efficiently detect that and will switch to uncompressed mode.
         /// </summary>
+        public ColumnFamilyOptions SetCompression(Compression value)
+        {
+            Native.Instance.rocksdb_options_set_compression(Handle, value);
+            return this;
+        }
+
+        /// <summary>
+        /// Compress blocks using the specified compression algorithm.  This
+        /// parameter can be changed dynamically.
+        ///
+        /// Default: kSnappyCompression, if it's supported. If snappy is not linked
+        /// with the library, the default is kNoCompression.
+        ///
+        /// Typical speeds of kSnappyCompression on an Intel(R) Core(TM)2 2.4GHz:
+        ///    ~200-500MB/s compression
+        ///    ~400-800MB/s decompression
+        /// Note that these speeds are significantly faster than most
+        /// persistent storage speeds, and therefore it is typically never
+        /// worth switching to kNoCompression.  Even if the input data is
+        /// incompressible, the kSnappyCompression implementation will
+        /// efficiently detect that and will switch to uncompressed mode.
+        /// </summary>
+        [Obsolete("Use Compression enum")]
         public ColumnFamilyOptions SetCompression(CompressionTypeEnum value)
         {
             Native.Instance.rocksdb_options_set_compression(Handle, value);
@@ -951,6 +1005,16 @@ public ColumnFamilyOptions SetCompression(CompressionTypeEnum value)
         /// <summary>
         /// The compaction style. Default: kCompactionStyleLevel
         /// </summary>
+        public ColumnFamilyOptions SetCompactionStyle(Compaction value)
+        {
+            Native.Instance.rocksdb_options_set_compaction_style(Handle, value);
+            return this;
+        }
+
+        /// <summary>
+        /// The compaction style. Default: kCompactionStyleLevel
+        /// </summary>
+        [Obsolete("Use Compaction enum")]
         public ColumnFamilyOptions SetCompactionStyle(CompactionStyleEnum value)
         {
             Native.Instance.rocksdb_options_set_compaction_style(Handle, value);

RocksDbSharp/DbOptions.cs

@@ -148,12 +148,25 @@ public DbOptions SetMaxTotalWalSize(ulong n)
         /// </summary>
         /// <param name="mode"></param>
         /// <returns></returns>
+        [Obsolete("Use Recovery enum")]
         public DbOptions SetWalRecoveryMode(WalRecoveryMode mode)
         {
             Native.Instance.rocksdb_options_set_wal_recovery_mode(Handle, mode);
             return this;
         }
 
+        /// <summary>
+        /// Recovery mode to control the consistency while replaying WAL
+        /// Default: kPointInTimeRecovery
+        /// </summary>
+        /// <param name="mode"></param>
+        /// <returns></returns>
+        public DbOptions SetWalRecoveryMode(Recovery mode)
+        {
+            Native.Instance.rocksdb_options_set_wal_recovery_mode(Handle, mode);
+            return this;
+        }
+
         /// <summary>
         /// Enables statistics so that you can call GetStatisticsString() later
         /// </summary>

RocksDbSharp/Native.Raw.cs

@@ -40,10 +40,19 @@ namespace RocksDbSharp
 {
     using size_t = System.UIntPtr;
 
+    public delegate void PutDelegate(IntPtr p0, IntPtr k, size_t klen, IntPtr v, size_t vlen);
+    public delegate void DeletedDelegate(IntPtr p0, IntPtr k, size_t klen);
+    public delegate void DestructorDelegate(IntPtr p0);
+    public delegate IntPtr NameDelegate(IntPtr p0);
+    public delegate int CompareDelegate(IntPtr p0, IntPtr a, size_t alen, IntPtr b, size_t blen);
+
     //void (*put)(IntPtr s, /*(const char*)*/ IntPtr k, /*(size_t)*/ UIntPtr klen, /*(const char*)*/ IntPtr v, /*(size_t)*/ UIntPtr vlen),
+    [Obsolete("Use PutDelegate")]
     public delegate void WriteBatchIteratePutCallback(IntPtr s, /*(const char*)*/ IntPtr k, /*(size_t)*/ size_t klen, /*(const char*)*/ IntPtr v, /*(size_t)*/ size_t vlen);
 //void (*deleted)(void*, const char* k, /*(size_t)*/ UIntPtr klen)
+[Obsolete("Use DeletedDelegate")]
 public delegate void WriteBatchIterateDeleteCallback(IntPtr s, /*(const char*)*/ IntPtr k, /*(size_t)*/ size_t klen);
+
 public abstract partial class Native
 {
 /* BEGIN c.h */
@@ -567,12 +576,19 @@ public unsafe abstract void rocksdb_writebatch_delete_rangev_cf(
     /*(const size_t)*/ IntPtr end_keys_list_sizes);
 public abstract void rocksdb_writebatch_put_log_data(
     /*(rocksdb_writebatch_t*)*/ IntPtr writeBatch, byte[] blob, UIntPtr len);
+[Obsolete("Use PutDelegate and DeletedDelegate overload")]
 public abstract void rocksdb_writebatch_iterate(
     /*(rocksdb_writebatch_t*)*/ IntPtr writeBatch, /*(void*)*/ IntPtr state,
     //void (*put)(IntPtr s, /*(const char*)*/ IntPtr k, /*(size_t)*/ ulong klen, /*(const char*)*/ IntPtr v, /*(size_t)*/ ulong vlen),
     WriteBatchIteratePutCallback put,
     //void (*deleted)(void*, const char* k, /*(size_t)*/ ulong klen)
     WriteBatchIterateDeleteCallback deleted);
+public abstract void rocksdb_writebatch_iterate(
+    /*(rocksdb_writebatch_t*)*/ IntPtr writeBatch, /*(void*)*/ IntPtr state,
+    //void (*put)(IntPtr s, /*(const char*)*/ IntPtr k, /*(size_t)*/ ulong klen, /*(const char*)*/ IntPtr v, /*(size_t)*/ ulong vlen),
+    PutDelegate put,
+    //void (*deleted)(void*, const char* k, /*(size_t)*/ ulong klen)
+    DeletedDelegate deleted);
 public abstract /* const char* */ IntPtr rocksdb_writebatch_data(
     /*(rocksdb_writebatch_t*)*/ IntPtr writeBatch, /*(size_t*)*/ out size_t size);
 public abstract void rocksdb_writebatch_set_save_point(
@@ -691,11 +707,17 @@ public abstract void rocksdb_writebatch_wi_put_log_data(
     /*(rocksdb_writebatch_wi_t*)*/ IntPtr b, /*(const char*)*/ byte[] blob, /*(size_t)*/ size_t len);
 public abstract void rocksdb_writebatch_wi_put_log_data(
     /*(rocksdb_writebatch_wi_t*)*/ IntPtr b, /*(const char*)*/ IntPtr blob, /*(size_t)*/ size_t len);
+[Obsolete("Use PutDelegate and DeletedDelegate overload")]
 public abstract void rocksdb_writebatch_wi_iterate(
     /*(rocksdb_writebatch_wi_t*)*/ IntPtr b,
     /*(void*)*/ IntPtr state,
     /*(void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen))*/ WriteBatchIteratePutCallback put,
     /*(void (*deleted)(void*, const char* k, size_t klen))*/ WriteBatchIterateDeleteCallback deleted);
+public abstract void rocksdb_writebatch_wi_iterate(
+    /*(rocksdb_writebatch_wi_t*)*/ IntPtr b,
+    /*(void*)*/ IntPtr state,
+    /*(void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen))*/ PutDelegate put,
+    /*(void (*deleted)(void*, const char* k, size_t klen))*/ DeletedDelegate deleted);
 public abstract /*(const char*)*/ IntPtr rocksdb_writebatch_wi_data(
     /*(rocksdb_writebatch_wi_t*)*/ IntPtr b,
     /*(size_t*)*/ out size_t size);
@@ -809,9 +831,15 @@ public abstract void rocksdb_block_based_options_set_format_version(
     /*(rocksdb_block_based_table_options_t*)*/ IntPtr bbto, int format_version);
 }
 public enum BlockBasedTableIndexType {
+  [Obsolete("Use Binary")]
   BinarySearch = 0,
+  Binary = 0,
+  [Obsolete("Use Hash")]
   HashSearch = 1,
+  Hash = 1,
+  [Obsolete("Use TwoLevelIndex")]
   TwoLevelIndexSearch = 2,
+  TwoLevelIndex = 2,
 };
 public abstract partial class Native {
 public abstract void rocksdb_block_based_options_set_index_type(
@@ -936,8 +964,6 @@ public abstract void rocksdb_options_set_max_bytes_for_level_multiplier_addition
             /* rocksdb_options_t* */ IntPtr options, /*(int*)*/ int[] level_values, UIntPtr num_levels);
 public abstract void rocksdb_options_enable_statistics(
     /* rocksdb_options_t* */ IntPtr options);
-public abstract void rocksdb_options_set_skip_stats_update_on_db_open(
-    /* rocksdb_options_t* */ IntPtr opt, /* unsigned char */ bool val);
 
 /* returns a pointer to a malloc()-ed, null terminated string */
 public abstract /* char* */ IntPtr rocksdb_options_statistics_get_string(
@@ -1073,17 +1099,39 @@ public abstract void rocksdb_options_set_report_bg_io_stats(
             /* rocksdb_options_t* */ IntPtr options, int value);
 
 }
+public enum Recovery
+{
+    TolerateCorruptedTailRecords = 0,
+    AbsoluteConsistency = 1,
+    PointInTime = 2,
+    SkipAnyCorruptedRecords = 3,
+}
+[Obsolete("Use Recovery")]
 public enum WalRecoveryMode {  
   rocksdb_tolerate_corrupted_tail_records_recovery = 0,
   rocksdb_absolute_consistency_recovery = 1,
   rocksdb_point_in_time_recovery = 2,
   rocksdb_skip_any_corrupted_records_recovery = 3
 }
 public abstract partial class Native {
+[Obsolete("Use Recovery enum")]
 public abstract void rocksdb_options_set_wal_recovery_mode(
     /* rocksdb_options_t* */ IntPtr options, WalRecoveryMode mode);
+public abstract void rocksdb_options_set_wal_recovery_mode(
+    /* rocksdb_options_t* */ IntPtr options, Recovery mode);
 }
-
+public enum Compression
+{
+    No = 0,
+    Snappy = 1,
+    Zlib = 2,
+    Bz2 = 3,
+    Lz4 = 4,
+    Lz4hc = 5,
+    Xpress = 6,
+    Zstd = 7,
+}
+[Obsolete("Use Compression")]
 public enum CompressionTypeEnum {
   rocksdb_no_compression = 0,
   rocksdb_snappy_compression = 1,
@@ -1095,17 +1143,30 @@ public enum CompressionTypeEnum {
   rocksdb_zstd_compression = 7
 }
 public abstract partial class Native {
+[Obsolete("Use Compression enum")]
 public abstract void rocksdb_options_set_compression(
             /* rocksdb_options_t* */ IntPtr options, CompressionTypeEnum value);
+public abstract void rocksdb_options_set_compression(
+            /* rocksdb_options_t* */ IntPtr options, Compression value);
 }
+public enum Compaction
+{
+    Level = 0,
+    Universal = 1,
+    Fifo = 2,
+}
+[Obsolete("Use Compaction")]
 public enum CompactionStyleEnum {
   rocksdb_level_compaction = 0,
   rocksdb_universal_compaction = 1,
   rocksdb_fifo_compaction = 2,
 }
 public abstract partial class Native {
+[Obsolete("Use Compaction enum")]
 public abstract void rocksdb_options_set_compaction_style(
     /* rocksdb_options_t* */ IntPtr options, CompactionStyleEnum value);
+public abstract void rocksdb_options_set_compaction_style(
+    /* rocksdb_options_t* */ IntPtr options, Compaction value);
 public abstract void rocksdb_options_set_universal_compaction_options(
             /* rocksdb_options_t* */ IntPtr options, /*(rocksdb_universal_compaction_options_t*)*/ IntPtr universal_compaction_options);
 public abstract void rocksdb_options_set_fifo_compaction_options(
@@ -1275,6 +1336,11 @@ public abstract void rocksdb_compactionfilterfactory_destroy(
                    /*(int (*compare)(void*, const char* a, size_t alen, const char* b,
                                   size_t blen))*/ IntPtr compare,
     /*(const char* (*name)(void*))*/ IntPtr getName);
+public abstract /* rocksdb_comparator_t* */ IntPtr rocksdb_comparator_create(
+    /*(void*)*/ IntPtr state, /*(void (*destructor)(void*))*/ DestructorDelegate destructor,
+                   /*(int (*compare)(void*, const char* a, size_t alen, const char* b,
+                                  size_t blen))*/ CompareDelegate compare,
+    /*(const char* (*name)(void*))*/ NameDelegate name);
 public abstract void rocksdb_comparator_destroy(
     /*(rocksdb_comparator_t*)*/IntPtr comparator);
 
@@ -1416,19 +1482,17 @@ public abstract void rocksdb_flushoptions_set_wait(
 #endregion
 
 #region Cache
-#if ROCKSDB_CACHE
 
 public abstract /* rocksdb_cache_t* */ IntPtr rocksdb_cache_create_lru(
     size_t capacity);
-public abstract void rocksdb_cache_destroy(rocksdb_cache_t* cache);
+public abstract void rocksdb_cache_destroy(/* rocksdb_cache_t* */ IntPtr cache);
 public abstract void rocksdb_cache_set_capacity(
-    rocksdb_cache_t* cache, size_t capacity);
-public abstract /*(size_t)*/ ulong
+    /* rocksdb_cache_t* */ IntPtr cache, size_t capacity);
+public abstract /*(size_t)*/ UIntPtr
 rocksdb_cache_get_usage(/*(rocksdb_cache_t*)*/ IntPtr cache);
-public abstract /*(size_t)*/ ulong
+public abstract /*(size_t)*/ UIntPtr
 rocksdb_cache_get_pinned_usage(/*(rocksdb_cache_t*)*/ IntPtr cache);
 
-#endif
 #endregion
 
 #region DBPath

RocksDbSharp/WriteBatch.cs

@@ -28,7 +28,9 @@ public interface IWriteBatch : IDisposable
         unsafe void DeleteRange(byte* startKey, ulong sklen, byte* endKey, ulong eklen, ColumnFamilyHandle cf = null);
         unsafe void DeleteRangev(int numKeys, IntPtr startKeysList, IntPtr startKeysListSizes, IntPtr endKeysList, IntPtr endKeysListSizes, ColumnFamilyHandle cf = null);
         IWriteBatch PutLogData(byte[] blob, ulong len);
+        [Obsolete("Use PutDelegate and DeletedDelegate")]
         IWriteBatch Iterate(IntPtr state, WriteBatchIteratePutCallback put, WriteBatchIterateDeleteCallback deleted);
+        IWriteBatch Iterate(IntPtr state, PutDelegate put, DeletedDelegate deleted);
         byte[] ToBytes();
         byte[] ToBytes(byte[] buffer, int offset = 0, int size = -1);
         void SetSavePoint();
@@ -222,12 +224,19 @@ public WriteBatch PutLogData(byte[] blob, ulong len)
             return this;
         }
 
+        [Obsolete("Use PutDelegate and DeletedDelegate")]
         public WriteBatch Iterate(IntPtr state, WriteBatchIteratePutCallback put, WriteBatchIterateDeleteCallback deleted)
         {
             Native.Instance.rocksdb_writebatch_iterate(handle, state, put, deleted);
             return this;
         }
 
+        public WriteBatch Iterate(IntPtr state, PutDelegate put, DeletedDelegate deleted)
+        {
+            Native.Instance.rocksdb_writebatch_iterate(handle, state, put, deleted);
+            return this;
+        }
+
         /// <summary>
         /// Get the write batch as bytes
         /// </summary>
@@ -296,7 +305,10 @@ IWriteBatch IWriteBatch.DeleteRange(byte[] startKey, ulong sklen, byte[] endKey,
             => DeleteRange(startKey, sklen, endKey, eklen, cf);
         IWriteBatch IWriteBatch.PutLogData(byte[] blob, ulong len)
             => PutLogData(blob, len);
+        [Obsolete("Use PutDelegate and DeletedDelegate")]
         IWriteBatch IWriteBatch.Iterate(IntPtr state, WriteBatchIteratePutCallback put, WriteBatchIterateDeleteCallback deleted)
             => Iterate(state, put, deleted);
+        IWriteBatch IWriteBatch.Iterate(IntPtr state, PutDelegate put, DeletedDelegate deleted)
+            => Iterate(state, put, deleted);
     }
 }

RocksDbSharp/WriteBatchWithIndex.cs

@@ -270,12 +270,19 @@ public WriteBatchWithIndex PutLogData(byte[] blob, ulong len)
             return this;
         }
 
+        [Obsolete("Use PutDelegate and DeletedDelegate")]
         public WriteBatchWithIndex Iterate(IntPtr state, WriteBatchIteratePutCallback put, WriteBatchIterateDeleteCallback deleted)
         {
             Native.Instance.rocksdb_writebatch_wi_iterate(handle, state, put, deleted);
             return this;
         }
 
+        public WriteBatchWithIndex Iterate(IntPtr state, PutDelegate put, DeletedDelegate deleted)
+        {
+            Native.Instance.rocksdb_writebatch_wi_iterate(handle, state, put, deleted);
+            return this;
+        }
+
         /// <summary>
         /// Get the write batch as bytes
         /// </summary>
@@ -340,7 +347,10 @@ IWriteBatch IWriteBatch.DeleteRange(byte[] startKey, ulong sklen, byte[] endKey,
             => DeleteRange(startKey, sklen, endKey, eklen, cf);
         IWriteBatch IWriteBatch.PutLogData(byte[] blob, ulong len)
             => PutLogData(blob, len);
+        [Obsolete("Use PutDelegate and DeletedDelegate")]
         IWriteBatch IWriteBatch.Iterate(IntPtr state, WriteBatchIteratePutCallback put, WriteBatchIterateDeleteCallback deleted)
             => Iterate(state, put, deleted);
+        IWriteBatch IWriteBatch.Iterate(IntPtr state, PutDelegate put, DeletedDelegate deleted)
+            => Iterate(state, put, deleted);
     }
 }