Expose AdvancedColumnFamilyOptions::memtable_batch_lookup_optimization in the C API

The skip-list memtable gained an opt-in batch-lookup optimization that
caches the search path between consecutive MultiGet keys, reducing
per-key cost from O(log N) to O(log d) where d is the distance between
consecutive keys. The optimization is gated by a new immutable
AdvancedColumnFamilyOptions field (default: false) which had no C API
setter, so the optimization was unreachable from C/Rust.

Add a setter/getter pair mirroring the existing
rocksdb_options_{set,get}_memtable_huge_page_size — the closest sibling
on both the C API side (adjacent memtable knob) and the C++ side (same
AdvancedColumnFamilyOptions parent struct).

The field is immutable on the C++ side, so the setter only takes effect
on options used to open a column family.

No change to the C++ API.

Author: zaidoon1

db/c.cc

@@ -5398,6 +5398,16 @@ size_t rocksdb_options_get_memtable_huge_page_size(rocksdb_options_t* opt) {
   return opt->rep.memtable_huge_page_size;
 }
 
+void rocksdb_options_set_memtable_batch_lookup_optimization(
+    rocksdb_options_t* opt, unsigned char v) {
+  opt->rep.memtable_batch_lookup_optimization = v;
+}
+
+unsigned char rocksdb_options_get_memtable_batch_lookup_optimization(
+    rocksdb_options_t* opt) {
+  return opt->rep.memtable_batch_lookup_optimization;
+}
+
 void rocksdb_options_set_hash_skip_list_rep(rocksdb_options_t* opt,
                                             size_t bucket_count,
                                             int32_t skiplist_height,

db/c_test.c

@@ -2812,6 +2812,15 @@ int main(int argc, char** argv) {
     rocksdb_options_set_memtable_huge_page_size(o, 25);
     CheckCondition(25 == rocksdb_options_get_memtable_huge_page_size(o));
 
+    // memtable_batch_lookup_optimization defaults to 0; flip to 1 to verify
+    // the setter is wired through to the underlying C++ ColumnFamilyOptions
+    // field.
+    CheckCondition(0 ==
+                   rocksdb_options_get_memtable_batch_lookup_optimization(o));
+    rocksdb_options_set_memtable_batch_lookup_optimization(o, 1);
+    CheckCondition(1 ==
+                   rocksdb_options_get_memtable_batch_lookup_optimization(o));
+
     rocksdb_options_set_max_successive_merges(o, 26);
     CheckCondition(26 == rocksdb_options_get_max_successive_merges(o));
 
@@ -2998,6 +3007,8 @@ int main(int argc, char** argv) {
                    rocksdb_options_get_memtable_prefix_bloom_size_ratio(copy));
     CheckCondition(24 == rocksdb_options_get_max_compaction_bytes(copy));
     CheckCondition(25 == rocksdb_options_get_memtable_huge_page_size(copy));
+    CheckCondition(
+        1 == rocksdb_options_get_memtable_batch_lookup_optimization(copy));
     CheckCondition(26 == rocksdb_options_get_max_successive_merges(copy));
     CheckCondition(27 == rocksdb_options_get_bloom_locality(copy));
     CheckCondition(1 == rocksdb_options_get_inplace_update_support(copy));

include/rocksdb/c.h

@@ -1990,6 +1990,12 @@ extern ROCKSDB_LIBRARY_API void rocksdb_options_set_memtable_huge_page_size(
 extern ROCKSDB_LIBRARY_API size_t
 rocksdb_options_get_memtable_huge_page_size(rocksdb_options_t*);
 
+extern ROCKSDB_LIBRARY_API void
+rocksdb_options_set_memtable_batch_lookup_optimization(rocksdb_options_t*,
+                                                       unsigned char);
+extern ROCKSDB_LIBRARY_API unsigned char
+rocksdb_options_get_memtable_batch_lookup_optimization(rocksdb_options_t*);
+
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_max_successive_merges(
     rocksdb_options_t*, size_t);
 extern ROCKSDB_LIBRARY_API size_t

unreleased_history/public_api_changes/c_api_memtable_batch_lookup_optimization.md

@@ -0,0 +1 @@
+Added `rocksdb_options_set_memtable_batch_lookup_optimization()` and `rocksdb_options_get_memtable_batch_lookup_optimization()` to the C API, exposing the existing `AdvancedColumnFamilyOptions::memtable_batch_lookup_optimization` field. This allows C API users (and downstream language bindings) to enable the skip-list memtable's batch-lookup optimization for `MultiGet`, which caches the search path between consecutive keys and reduces per-key cost from O(log N) to O(log d) where d is the distance between consecutive keys.