rocksdb-native 3.8.0 → 3.9.0

package/CMakeLists.txt

@@ -9,7 +9,7 @@ project(rocksdb_native C CXX)
 
 bare_target(target)
 
-fetch_package("github:holepunchto/librocksdb#ac350df")
+fetch_package("github:holepunchto/librocksdb#bf9c031")
 fetch_package("github:holepunchto/libjstl#34a7894")
 
 add_bare_module(rocksdb_native_bare)

package/binding.cc

@@ -24,6 +24,7 @@ using cb_on_iterator_read_t = js_function_t<
   std::vector<js_arraybuffer_t>,
   std::vector<js_arraybuffer_t>>;
 using cb_on_compact_range_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
+using cb_on_approximate_size_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>, uint64_t>;
 }; // namespace
 
 struct rocksdb_native_column_family_t {
@@ -147,6 +148,14 @@ struct rocksdb_native_compact_range_t {
   js_persistent_t<cb_on_compact_range_t> on_compact_range;
 };
 
+struct rocksdb_native_approximate_size_t {
+  rocksdb_approximate_size_t handle;
+
+  js_env_t *env;
+  js_persistent_t<js_receiver_t> ctx;
+  js_persistent_t<cb_on_approximate_size_t> on_approximate_size;
+};
+
 static void
 rocksdb_native__on_free(js_env_t *env, char *data) {
   free(data);
@@ -319,7 +328,11 @@ rocksdb_native_init(
   int32_t max_background_jobs,
   uint64_t bytes_per_sync,
   int32_t max_open_files,
-  bool use_direct_reads
+  bool use_direct_reads,
+  bool avoid_unnecessary_blocking_io,
+  bool skip_stats_update_on_db_open,
+  bool use_direct_io_for_flush_and_compaction,
+  int32_t max_file_opening_threads
 ) {
   int err;
 
@@ -345,7 +358,11 @@ rocksdb_native_init(
     max_background_jobs,
     bytes_per_sync,
     max_open_files,
-    use_direct_reads
+    use_direct_reads,
+    avoid_unnecessary_blocking_io,
+    skip_stats_update_on_db_open,
+    use_direct_io_for_flush_and_compaction,
+    max_file_opening_threads
   };
 
   err = rocksdb_init(loop, &db->handle);
@@ -634,7 +651,10 @@ rocksdb_native_column_family_init(
   int32_t bloom_before_level,
   uint32_t top_level_index_pinning_tier,
   uint32_t partition_pinning_tier,
-  uint32_t unpartitioned_pinning_tier
+  uint32_t unpartitioned_pinning_tier,
+  bool optimize_filters_for_hits,
+  int32_t num_levels,
+  int32_t max_write_buffer_number
 ) {
   int err;
 
@@ -689,6 +709,9 @@ rocksdb_native_column_family_init(
       rocksdb_pinning_tier_t(top_level_index_pinning_tier),
       rocksdb_pinning_tier_t(partition_pinning_tier),
       rocksdb_pinning_tier_t(unpartitioned_pinning_tier),
+      optimize_filters_for_hits,
+      num_levels,
+      max_write_buffer_number
     }
   };
 
@@ -1178,6 +1201,8 @@ rocksdb_native_read(
   js_arraybuffer_span_of_t<rocksdb_native_read_batch_t, 1> req,
   js_array_t operations,
   std::optional<js_arraybuffer_t> snapshot,
+  bool async_io,
+  bool fill_cache,
   js_receiver_t ctx,
   cb_on_read_t on_read
 ) {
@@ -1233,6 +1258,8 @@ rocksdb_native_read(
 
   rocksdb_read_options_t options = {
     .version = 0,
+    .async_io = async_io,
+    .fill_cache = fill_cache
   };
 
   if (snapshot) {
@@ -1606,7 +1633,7 @@ rocksdb_native_compact_range(
   assert(err == 0);
 
   rocksdb_slice_t end_slice;
-  err = js_get_typedarray_info(env, start, end_slice.data, end_slice.len);
+  err = js_get_typedarray_info(env, end, end_slice.data, end_slice.len);
   assert(err == 0);
 
   err = rocksdb_compact_range(&db->handle, &req->handle, column_family->handle, start_slice, end_slice, &options, rocksdb_native__on_compact_range);
@@ -1615,6 +1642,102 @@ rocksdb_native_compact_range(
   return handle;
 }
 
+static void
+rocksdb_native__on_approximate_size(rocksdb_approximate_size_t *handle, int status) {
+  int err;
+
+  assert(status == 0);
+
+  rocksdb_native_approximate_size_t *req = (rocksdb_native_approximate_size_t *) handle->data;
+
+  rocksdb_native_t *db = (rocksdb_native_t *) req->handle.req.db;
+
+  js_env_t *env = req->env;
+
+  if (db->exiting) {
+    req->on_approximate_size.reset();
+    req->ctx.reset();
+  } else {
+    js_handle_scope_t *scope;
+    err = js_open_handle_scope(env, &scope);
+    assert(err == 0);
+
+    std::optional<js_string_t> error;
+
+    if (req->handle.error) {
+      err = js_create_string(env, req->handle.error, error.emplace());
+      assert(err == 0);
+    }
+
+    js_receiver_t ctx;
+    err = js_get_reference_value(env, req->ctx, ctx);
+    assert(err == 0);
+
+    cb_on_approximate_size_t cb;
+    err = js_get_reference_value(env, req->on_approximate_size, cb);
+    assert(err == 0);
+
+    req->on_approximate_size.reset();
+    req->ctx.reset();
+
+    js_call_function_with_checkpoint(env, cb, ctx, error, req->handle.result);
+
+    err = js_close_handle_scope(env, scope);
+    assert(err == 0);
+  }
+}
+
+static js_arraybuffer_t
+rocksdb_native_approximate_size(
+  js_env_t *env,
+  js_arraybuffer_span_of_t<rocksdb_native_t, 1> db,
+  js_arraybuffer_span_of_t<rocksdb_native_column_family_t, 1> column_family,
+  js_typedarray_t<> start,
+  js_typedarray_t<> end,
+  bool include_memtables,
+  bool include_files,
+  double error_margin,
+  js_receiver_t ctx,
+  cb_on_approximate_size_t on_approximate_size
+) {
+  int err;
+
+  js_arraybuffer_t handle;
+
+  rocksdb_native_approximate_size_t *req;
+  err = js_create_arraybuffer(env, req, handle);
+  assert(err == 0);
+
+  req->env = env;
+  req->handle.data = (void *) req;
+
+  err = js_create_reference(env, ctx, req->ctx);
+  assert(err == 0);
+
+  err = js_create_reference(env, on_approximate_size, req->on_approximate_size);
+  assert(err == 0);
+
+  rocksdb_approximate_size_options_t options = {
+    .version = 0,
+    .include_memtables = include_memtables,
+    .include_files = include_files,
+    .files_size_error_margin = error_margin,
+  };
+
+  rocksdb_slice_t start_slice;
+  err = js_get_typedarray_info(env, start, start_slice.data, start_slice.len);
+  assert(err == 0);
+
+  rocksdb_slice_t end_slice;
+  err = js_get_typedarray_info(env, end, end_slice.data, end_slice.len);
+  assert(err == 0);
+
+  err = rocksdb_approximate_size(&db->handle, &req->handle, column_family->handle, start_slice, end_slice, &options, rocksdb_native__on_approximate_size);
+  assert(err == 0);
+
+  return handle;
+}
+
 static js_value_t *
 rocksdb_native_exports(js_env_t *env, js_value_t *exports) {
   int err;
@@ -1652,6 +1775,7 @@ rocksdb_native_exports(js_env_t *env, js_value_t *exports) {
   V("snapshotDestroy", rocksdb_native_snapshot_destroy)
 
   V("compactRange", rocksdb_native_compact_range)
+  V("approximateSize", rocksdb_native_approximate_size)
 #undef V
 
 #define V(name, n) \

package/index.js

@@ -189,6 +189,10 @@ class RocksDB {
     await this._state.compactRange(this, start, end, opts)
   }
 
+  async approximateSize(start, end, opts = {}) {
+    return this._state.approximateSize(this, start, end, opts)
+  }
+
   _ref() {
     if (this._snapshot) this._snapshot.ref()
     this._state.handles.inc()

package/lib/batch.js

@@ -168,6 +168,15 @@ class RocksDBBatch {
 }
 
 exports.ReadBatch = class RocksDBReadBatch extends RocksDBBatch {
+  constructor(db, opts = {}) {
+    super(db, opts)
+
+    const { asyncIO = false, fillCache = true } = opts
+
+    this._asyncIO = asyncIO
+    this._fillCache = fillCache
+  }
+
   _init() {
     this._handle = binding.readInit()
     this._buffer = binding.readBuffer(this._handle, this._capacity)
@@ -190,6 +199,8 @@ exports.ReadBatch = class RocksDBReadBatch extends RocksDBBatch {
         this._handle,
         this._operations,
         this._db._snapshot ? this._db._snapshot._handle : undefined,
+        this._asyncIO,
+        this._fillCache,
         this,
         this._onread
       )

package/lib/column-family.js

@@ -19,7 +19,10 @@ class RocksDBColumnFamily {
       filterPolicy = new BloomFilterPolicy(10),
       topLevelIndexPinningTier = constants.pinningTier.ALL,
       partitionPinningTier = constants.pinningTier.ALL,
-      unpartitionedPinningTier = constants.pinningTier.ALL
+      unpartitionedPinningTier = constants.pinningTier.ALL,
+      optimizeFiltersForHits = false,
+      numLevels = 7,
+      maxWriteBufferNumber = 2
     } = opts
 
     this._name = name
@@ -37,7 +40,10 @@ class RocksDBColumnFamily {
       filterPolicy,
       topLevelIndexPinningTier,
       partitionPinningTier,
-      unpartitionedPinningTier
+      unpartitionedPinningTier,
+      optimizeFiltersForHits,
+      numLevels,
+      maxWriteBufferNumber
     }
 
     const filterPolicyArguments = [0, 0, 0]
@@ -71,7 +77,10 @@ class RocksDBColumnFamily {
       ...filterPolicyArguments,
       topLevelIndexPinningTier,
       partitionPinningTier,
-      unpartitionedPinningTier
+      unpartitionedPinningTier,
+      optimizeFiltersForHits,
+      numLevels,
+      maxWriteBufferNumber
     )
   }
 

package/lib/state.js

@@ -23,7 +23,11 @@ module.exports = class RocksDBState extends ReadyResource {
       maxBackgroundJobs = 6,
       bytesPerSync = 1048576,
       maxOpenFiles = -1,
-      useDirectReads = false
+      useDirectReads = false,
+      avoidUnnecessaryBlockingIO = false,
+      skipStatsUpdateOnOpen = false,
+      useDirectIOForFlushAndCompaction = false,
+      maxFileOpeningThreads = 16
     } = opts
 
     this.path = path
@@ -58,7 +62,11 @@ module.exports = class RocksDBState extends ReadyResource {
       maxBackgroundJobs,
       bytesPerSync,
       maxOpenFiles,
-      useDirectReads
+      useDirectReads,
+      avoidUnnecessaryBlockingIO,
+      skipStatsUpdateOnOpen,
+      useDirectIOForFlushAndCompaction,
+      maxFileOpeningThreads
     )
   }
 
@@ -348,6 +356,48 @@ module.exports = class RocksDBState extends ReadyResource {
     }
   }
 
+  async approximateSize(db, start, end, opts) {
+    if (this.opened === false) await this.ready()
+
+    this.io.inc()
+
+    const {
+      includeMemtables = false,
+      includeFiles = true,
+      filesSizeErrorMargin = -1
+    } = opts
+
+    const req = { resolve: null, reject: null, handle: null }
+
+    const promise = new Promise((resolve, reject) => {
+      req.resolve = resolve
+      req.reject = reject
+    })
+
+    try {
+      req.handle = binding.approximateSize(
+        this._handle,
+        db._columnFamily._handle,
+        this._encodeKey(start),
+        this._encodeKey(end),
+        includeMemtables,
+        includeFiles,
+        filesSizeErrorMargin,
+        req,
+        onapproximatesize
+      )
+
+      return await promise
+    } finally {
+      this.io.dec()
+    }
+
+    function onapproximatesize(err, result) {
+      if (err) req.reject(new Error(err))
+      else req.resolve(result)
+    }
+  }
+
   _encodeKey(k) {
     if (this.db._keyEncoding) return c.encode(this.db._keyEncoding, k)
     if (typeof k === 'string') return Buffer.from(k)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rocksdb-native",
-  "version": "3.8.0",
+  "version": "3.9.0",
   "description": "librocksdb bindings for JavaScript",
   "exports": {
     ".": "./index.js",