rocksdb-native 3.11.1 → 3.11.3

package/binding.cc

@@ -1,3 +1,5 @@
+#include <set>
+
 #include <assert.h>
 #include <bare.h>
 #include <js.h>
@@ -21,14 +23,23 @@ using rocksdb_native_on_iterator_read_t = js_function_t<void, js_receiver_t, std
 using rocksdb_native_on_compact_range_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>>;
 using rocksdb_native_on_approximate_size_t = js_function_t<void, js_receiver_t, std::optional<js_string_t>, uint64_t>;
 
+struct rocksdb_native_t;
+
 struct rocksdb_native_column_family_t {
   rocksdb_column_family_t *handle;
   rocksdb_column_family_descriptor_t descriptor;
 
-  rocksdb_t *db;
+  rocksdb_native_t *db;
 
-  js_env_t *env;
-  js_persistent_t<js_receiver_t> ctx;
+  js_persistent_t<js_arraybuffer_t> ctx;
+};
+
+struct rocksdb_native_snapshot_t {
+  rocksdb_snapshot_t handle;
+
+  rocksdb_native_t *db;
+
+  js_persistent_t<js_arraybuffer_t> ctx;
 };
 
 struct rocksdb_native_t {
@@ -41,6 +52,9 @@ struct rocksdb_native_t {
   bool closing;
   bool exiting;
 
+  std::set<rocksdb_native_column_family_t *> column_families;
+  std::set<rocksdb_native_snapshot_t *> snapshots;
+
   js_deferred_teardown_t *teardown;
 };
 
@@ -59,6 +73,7 @@ struct rocksdb_native_close_t {
 
   js_env_t *env;
   js_persistent_t<js_receiver_t> ctx;
+  js_persistent_t<js_arraybuffer_t> self;
   js_persistent_t<rocksdb_native_on_close_t> on_close;
 };
 
@@ -90,7 +105,7 @@ struct rocksdb_native_iterator_t {
   js_persistent_t<rocksdb_native_on_iterator_close_t> on_close;
   js_persistent_t<rocksdb_native_on_iterator_read_t> on_read;
 
-  bool active;
+  bool closing;
   bool exiting;
 
   js_deferred_teardown_t *teardown;
@@ -130,10 +145,6 @@ struct rocksdb_native_flush_t {
   js_persistent_t<rocksdb_native_column_family_t> column_family;
 };
 
-struct rocksdb_native_snapshot_t {
-  rocksdb_snapshot_t handle;
-};
-
 struct rocksdb_native_compact_range_t {
   rocksdb_compact_range_t handle;
 
@@ -170,9 +181,6 @@ rocksdb_native__try_create_external_arraybuffer(js_env_t *env, char *data, size_
   return 0;
 }
 
-static void
-rocksdb_native__on_column_family_teardown(void *data);
-
 static void
 rocksdb_native__on_open(rocksdb_open_t *handle, int status) {
   int err;
@@ -186,50 +194,43 @@ rocksdb_native__on_open(rocksdb_open_t *handle, int status) {
   auto env = req->env;
 
   auto descriptors = handle->column_families;
-
   auto handles = handle->handles;
 
-  if (db->exiting) {
-    req->on_open.reset();
-    req->ctx.reset();
-  } else {
-    js_handle_scope_t *scope;
-    err = js_open_handle_scope(env, &scope);
-    assert(err == 0);
-
-    js_receiver_t ctx;
-    err = js_get_reference_value(env, req->ctx, ctx);
-    assert(err == 0);
-
-    rocksdb_native_on_open_t cb;
-    err = js_get_reference_value(env, req->on_open, cb);
-    assert(err == 0);
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
 
-    js_array_t column_families;
-    err = js_get_reference_value(env, req->column_families, column_families);
-    assert(err == 0);
+  js_receiver_t ctx;
+  err = js_get_reference_value(env, req->ctx, ctx);
+  assert(err == 0);
 
-    req->on_open.reset();
-    req->column_families.reset();
-    req->ctx.reset();
+  rocksdb_native_on_open_t cb;
+  err = js_get_reference_value(env, req->on_open, cb);
+  assert(err == 0);
 
-    std::optional<js_string_t> error;
+  js_array_t column_families;
+  err = js_get_reference_value(env, req->column_families, column_families);
+  assert(err == 0);
 
-    if (req->handle.error) {
-      err = js_create_string(env, req->handle.error, error.emplace());
-      assert(err == 0);
-    }
+  req->on_open.reset();
+  req->column_families.reset();
+  req->ctx.reset();
 
-    rocksdb_column_family_t **handles = handle->handles;
+  std::optional<js_string_t> error;
 
-    if (req->handle.error == nullptr) {
-      std::vector<js_arraybuffer_t> elements;
-      err = js_get_array_elements(env, column_families, elements);
-      assert(err == 0);
+  if (req->handle.error) {
+    err = js_create_string(env, req->handle.error, error.emplace());
+    assert(err == 0);
+  } else {
+    std::vector<js_arraybuffer_t> elements;
+    err = js_get_array_elements(env, column_families, elements);
+    assert(err == 0);
 
-      const auto len = elements.size();
+    const auto len = elements.size();
 
-      for (uint32_t i = 0; i < len; i++) {
+    for (uint32_t i = 0; i < len; i++) {
+      if (db->exiting) rocksdb_column_family_destroy(&db->handle, handles[i]);
+      else {
         js_arraybuffer_t handle = elements[i];
 
         rocksdb_native_column_family_t *column_family;
@@ -238,22 +239,49 @@ rocksdb_native__on_open(rocksdb_open_t *handle, int status) {
 
         column_family->handle = handles[i];
 
-        err = js_create_reference(env, ctx, column_family->ctx);
+        err = js_create_reference(env, handle, column_family->ctx);
         assert(err == 0);
 
-        err = js_add_teardown_callback(env, rocksdb_native__on_column_family_teardown, column_family);
-        assert(err == 0);
+        db->column_families.insert(column_family);
       }
     }
+  }
+
+  if (!db->exiting) {
+    err = js_call_function_with_checkpoint(env, cb, ctx, error);
+    (void) err;
+  }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
 
-    js_call_function_with_checkpoint(env, cb, ctx, error);
+  delete[] descriptors;
+  delete[] handles;
+}
 
-    err = js_close_handle_scope(env, scope);
+static void
+rocksdb_native__on_idle(rocksdb_t *handle) {
+  int err;
+
+  auto db = reinterpret_cast<rocksdb_native_t *>(handle);
+
+  for (auto &column_family : db->column_families) {
+    err = rocksdb_column_family_destroy(&column_family->db->handle, column_family->handle);
     assert(err == 0);
 
-    delete[] descriptors;
-    delete[] handles;
+    column_family->handle = nullptr;
+
+    column_family->ctx.reset();
   }
+
+  for (auto &snapshot : db->snapshots) {
+    rocksdb_snapshot_destroy(&snapshot->handle);
+
+    snapshot->ctx.reset();
+  }
+
+  db->column_families.~set();
+  db->snapshots.~set();
 }
 
 static void
@@ -270,61 +298,82 @@ rocksdb_native__on_close(rocksdb_close_t *handle, int status) {
 
   auto teardown = db->teardown;
 
-  if (db->exiting) {
-    if (db->closing) {
-      req->on_close.reset();
-      req->ctx.reset();
-    } else {
-      free(req);
-    }
-
-    db->ctx.reset();
-  } else {
-    js_handle_scope_t *scope;
-    err = js_open_handle_scope(env, &scope);
-    assert(err == 0);
-
-    js_receiver_t ctx;
-    err = js_get_reference_value(env, req->ctx, ctx);
-    assert(err == 0);
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
 
-    rocksdb_native_on_close_t cb;
-    err = js_get_reference_value(env, req->on_close, cb);
-    assert(err == 0);
+  js_receiver_t ctx;
+  err = js_get_reference_value(env, req->ctx, ctx);
+  assert(err == 0);
 
-    req->on_close.reset();
-    req->ctx.reset();
+  rocksdb_native_on_close_t cb;
+  err = js_get_reference_value(env, req->on_close, cb);
+  assert(err == 0);
 
-    db->ctx.reset();
+  req->on_close.reset();
+  req->self.reset();
+  req->ctx.reset();
 
-    js_call_function_with_checkpoint(env, cb, ctx);
+  db->ctx.reset();
 
-    err = js_close_handle_scope(env, scope);
-    assert(err == 0);
+  if (!db->exiting) {
+    err = js_call_function_with_checkpoint(env, cb, ctx);
+    (void) err;
   }
 
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
+
   err = js_finish_deferred_teardown_callback(teardown);
   assert(err == 0);
 }
 
 static void
-rocksdb_native__on_teardown(js_deferred_teardown_t *handle, void *data) {
+rocksdb_native__on_teardown(js_deferred_teardown_t *teardown, void *data) {
   int err;
 
   auto db = reinterpret_cast<rocksdb_native_t *>(data);
 
-  auto env = db->env;
-
   db->exiting = true;
 
   if (db->closing) return;
 
-  auto req = reinterpret_cast<rocksdb_native_close_t *>(malloc(sizeof(rocksdb_native_close_t)));
+  auto env = db->env;
+
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
+
+  js_arraybuffer_t handle;
+
+  rocksdb_native_close_t *req;
+  err = js_create_arraybuffer(env, req, handle);
+  assert(err == 0);
 
   req->env = env;
   req->handle.data = req;
 
-  err = rocksdb_close(&db->handle, &req->handle, rocksdb_native__on_close);
+  err = rocksdb_close(&db->handle, &req->handle, rocksdb_native__on_idle, rocksdb_native__on_close);
+  assert(err == 0);
+
+  js_receiver_t ctx;
+  err = js_get_null(env, static_cast<js_value_t **>(ctx));
+  assert(err == 0);
+
+  rocksdb_native_on_close_t on_close;
+  err = js_get_null(env, static_cast<js_value_t **>(on_close));
+  assert(err == 0);
+
+  err = js_create_reference(env, ctx, req->ctx);
+  assert(err == 0);
+
+  err = js_create_reference(env, handle, req->self);
+  assert(err == 0);
+
+  err = js_create_reference(env, on_close, req->on_close);
+  assert(err == 0);
+
+  err = js_close_handle_scope(env, scope);
   assert(err == 0);
 }
 
@@ -345,10 +394,6 @@ rocksdb_native_init(
 ) {
   int err;
 
-  uv_loop_t *loop;
-  err = js_get_env_loop(env, &loop);
-  assert(err == 0);
-
   js_arraybuffer_t handle;
 
   rocksdb_native_t *db;
@@ -359,6 +404,9 @@ rocksdb_native_init(
   db->closing = false;
   db->exiting = false;
 
+  new (&db->column_families) std::set<rocksdb_native_column_family_t *>();
+  new (&db->snapshots) std::set<rocksdb_native_snapshot_t *>();
+
   db->options = (rocksdb_options_t) {
     3,
     read_only,
@@ -375,15 +423,6 @@ rocksdb_native_init(
     -1,
   };
 
-  err = rocksdb_init(loop, &db->handle);
-
-  if (err < 0) {
-    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
-    assert(err == 0);
-
-    throw js_pending_exception;
-  }
-
   return handle;
 }
 
@@ -417,11 +456,15 @@ rocksdb_native_open(
 
     memcpy(&column_families[i], &column_family->descriptor, sizeof(rocksdb_column_family_descriptor_t));
 
-    column_family->db = &db->handle;
+    column_family->db = db;
   }
 
   auto handles = new rocksdb_column_family_t *[len];
 
+  uv_loop_t *loop;
+  err = js_get_env_loop(env, &loop);
+  assert(err == 0);
+
   js_arraybuffer_t handle;
 
   rocksdb_native_open_t *req;
@@ -433,7 +476,7 @@ rocksdb_native_open(
 
   db->options.lock = lock;
 
-  err = rocksdb_open(&db->handle, &req->handle, path, &db->options, column_families, handles, len, rocksdb_native__on_open);
+  err = rocksdb_open(loop, &db->handle, &req->handle, path, &db->options, column_families, handles, len, nullptr, rocksdb_native__on_open);
 
   if (err < 0) {
     err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
@@ -484,7 +527,7 @@ rocksdb_native_close(
   req->env = env;
   req->handle.data = req;
 
-  err = rocksdb_close(&db->handle, &req->handle, rocksdb_native__on_close);
+  err = rocksdb_close(&db->handle, &req->handle, rocksdb_native__on_idle, rocksdb_native__on_close);
 
   if (err < 0) {
     err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
@@ -496,6 +539,9 @@ rocksdb_native_close(
   err = js_create_reference(env, ctx, req->ctx);
   assert(err == 0);
 
+  err = js_create_reference(env, handle, req->self);
+  assert(err == 0);
+
   err = js_create_reference(env, on_close, req->on_close);
   assert(err == 0);
 
@@ -516,36 +562,35 @@ rocksdb_native__on_suspend(rocksdb_suspend_t *handle, int status) {
 
   auto env = req->env;
 
-  auto teardown = db->teardown;
-
-  if (db->exiting) {
-    req->on_suspend.reset();
-    req->ctx.reset();
-  } else {
-    js_handle_scope_t *scope;
-    err = js_open_handle_scope(env, &scope);
-    assert(err == 0);
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
 
-    js_receiver_t ctx;
-    err = js_get_reference_value(env, req->ctx, ctx);
-    assert(err == 0);
+  js_receiver_t ctx;
+  err = js_get_reference_value(env, req->ctx, ctx);
+  assert(err == 0);
 
-    rocksdb_native_on_suspend_t cb;
-    err = js_get_reference_value(env, req->on_suspend, cb);
-    assert(err == 0);
+  rocksdb_native_on_suspend_t cb;
+  err = js_get_reference_value(env, req->on_suspend, cb);
+  assert(err == 0);
 
-    std::optional<js_string_t> error;
+  req->on_suspend.reset();
+  req->ctx.reset();
 
-    if (req->handle.error) {
-      err = js_create_string(env, req->handle.error, error.emplace());
-      assert(err == 0);
-    }
+  std::optional<js_string_t> error;
 
-    js_call_function_with_checkpoint(env, cb, ctx, error);
-
-    err = js_close_handle_scope(env, scope);
+  if (req->handle.error) {
+    err = js_create_string(env, req->handle.error, error.emplace());
     assert(err == 0);
   }
+
+  if (!db->exiting) {
+    err = js_call_function_with_checkpoint(env, cb, ctx, error);
+    (void) err;
+  }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
 }
 
 static js_arraybuffer_t
@@ -596,39 +641,35 @@ rocksdb_native__on_resume(rocksdb_resume_t *handle, int status) {
 
   auto env = req->env;
 
-  auto teardown = db->teardown;
-
-  if (db->exiting) {
-    req->on_resume.reset();
-    req->ctx.reset();
-  } else {
-    js_handle_scope_t *scope;
-    err = js_open_handle_scope(env, &scope);
-    assert(err == 0);
-
-    js_receiver_t ctx;
-    err = js_get_reference_value(env, req->ctx, ctx);
-    assert(err == 0);
-
-    rocksdb_native_on_resume_t cb;
-    err = js_get_reference_value(env, req->on_resume, cb);
-    assert(err == 0);
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
 
-    req->on_resume.reset();
-    req->ctx.reset();
+  js_receiver_t ctx;
+  err = js_get_reference_value(env, req->ctx, ctx);
+  assert(err == 0);
 
-    std::optional<js_string_t> error;
+  rocksdb_native_on_resume_t cb;
+  err = js_get_reference_value(env, req->on_resume, cb);
+  assert(err == 0);
 
-    if (req->handle.error) {
-      err = js_create_string(env, req->handle.error, error.emplace());
-      assert(err == 0);
-    }
+  req->on_resume.reset();
+  req->ctx.reset();
 
-    js_call_function_with_checkpoint(env, cb, ctx, error);
+  std::optional<js_string_t> error;
 
-    err = js_close_handle_scope(env, scope);
+  if (req->handle.error) {
+    err = js_create_string(env, req->handle.error, error.emplace());
     assert(err == 0);
   }
+
+  if (!db->exiting) {
+    err = js_call_function_with_checkpoint(env, cb, ctx, error);
+    (void) err;
+  }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
 }
 
 static js_arraybuffer_t
@@ -667,20 +708,6 @@ rocksdb_native_resume(
   return handle;
 }
 
-static void
-rocksdb_native__on_column_family_teardown(void *data) {
-  int err;
-
-  auto column_family = reinterpret_cast<rocksdb_native_column_family_t *>(data);
-
-  auto env = column_family->env;
-
-  err = rocksdb_column_family_destroy(column_family->db, column_family->handle);
-  assert(err == 0);
-
-  column_family->ctx.reset();
-}
-
 static js_arraybuffer_t
 rocksdb_native_column_family_init(
   js_env_t *env,
@@ -735,7 +762,6 @@ rocksdb_native_column_family_init(
   err = js_create_arraybuffer(env, column_family, handle);
   assert(err == 0);
 
-  column_family->env = env;
   column_family->db = nullptr;
   column_family->handle = nullptr;
 
@@ -775,15 +801,14 @@ rocksdb_native_column_family_destroy(
 
   if (column_family->handle == nullptr) return;
 
-  err = rocksdb_column_family_destroy(column_family->db, column_family->handle);
+  err = rocksdb_column_family_destroy(&column_family->db->handle, column_family->handle);
   assert(err == 0);
 
-  err = js_remove_teardown_callback(env, rocksdb_native__on_column_family_teardown, column_family);
-  assert(err == 0);
+  column_family->handle = nullptr;
 
-  column_family->ctx.reset();
+  column_family->db->column_families.erase(column_family);
 
-  column_family->handle = nullptr;
+  column_family->ctx.reset();
 }
 
 static js_arraybuffer_t
@@ -797,7 +822,7 @@ rocksdb_native_iterator_init(js_env_t *env) {
   assert(err == 0);
 
   req->env = env;
-  req->active = false;
+  req->closing = false;
   req->exiting = false;
   req->handle.data = req;
 
@@ -837,48 +862,42 @@ rocksdb_native__on_iterator_close(rocksdb_iterator_t *handle, int status) {
 
   auto req = reinterpret_cast<rocksdb_native_iterator_t *>(handle->data);
 
-  req->active = false;
-
   auto env = req->env;
 
   auto teardown = req->teardown;
 
-  if (req->exiting) {
-    req->on_open.reset();
-    req->on_close.reset();
-    req->on_read.reset();
-    req->ctx.reset();
-  } else {
-    js_handle_scope_t *scope;
-    err = js_open_handle_scope(env, &scope);
-    assert(err == 0);
-
-    js_receiver_t ctx;
-    err = js_get_reference_value(env, req->ctx, ctx);
-    assert(err == 0);
-
-    rocksdb_native_on_iterator_close_t cb;
-    err = js_get_reference_value(env, req->on_close, cb);
-    assert(err == 0);
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
 
-    req->on_open.reset();
-    req->on_close.reset();
-    req->on_read.reset();
-    req->ctx.reset();
+  js_receiver_t ctx;
+  err = js_get_reference_value(env, req->ctx, ctx);
+  assert(err == 0);
 
-    std::optional<js_string_t> error;
+  rocksdb_native_on_iterator_close_t cb;
+  err = js_get_reference_value(env, req->on_close, cb);
+  assert(err == 0);
 
-    if (req->handle.error) {
-      err = js_create_string(env, req->handle.error, error.emplace());
-      assert(err == 0);
-    }
+  req->on_open.reset();
+  req->on_close.reset();
+  req->on_read.reset();
+  req->ctx.reset();
 
-    js_call_function_with_checkpoint(env, cb, ctx, error);
+  std::optional<js_string_t> error;
 
-    err = js_close_handle_scope(env, scope);
+  if (req->handle.error) {
+    err = js_create_string(env, req->handle.error, error.emplace());
     assert(err == 0);
   }
 
+  if (!req->exiting) {
+    err = js_call_function_with_checkpoint(env, cb, ctx, error);
+    (void) err;
+  }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
+
   err = js_finish_deferred_teardown_callback(teardown);
   assert(err == 0);
 }
@@ -891,49 +910,45 @@ rocksdb_native__on_iterator_open(rocksdb_iterator_t *handle, int status) {
 
   auto req = reinterpret_cast<rocksdb_native_iterator_t *>(handle->data);
 
-  req->active = false;
-
-  if (req->exiting) {
-    err = rocksdb_iterator_close(&req->handle, rocksdb_native__on_iterator_close);
-    assert(err == 0);
-  } else {
-    auto env = req->env;
-
-    js_handle_scope_t *scope;
-    err = js_open_handle_scope(env, &scope);
-    assert(err == 0);
-
-    js_receiver_t ctx;
-    err = js_get_reference_value(env, req->ctx, ctx);
-    assert(err == 0);
+  auto env = req->env;
 
-    rocksdb_native_on_iterator_open_t cb;
-    err = js_get_reference_value(env, req->on_open, cb);
-    assert(err == 0);
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
 
-    std::optional<js_string_t> error;
+  js_receiver_t ctx;
+  err = js_get_reference_value(env, req->ctx, ctx);
+  assert(err == 0);
 
-    if (req->handle.error) {
-      err = js_create_string(env, req->handle.error, error.emplace());
-      assert(err == 0);
-    }
+  rocksdb_native_on_iterator_open_t cb;
+  err = js_get_reference_value(env, req->on_open, cb);
+  assert(err == 0);
 
-    js_call_function_with_checkpoint(env, cb, ctx, error);
+  std::optional<js_string_t> error;
 
-    err = js_close_handle_scope(env, scope);
+  if (req->handle.error) {
+    err = js_create_string(env, req->handle.error, error.emplace());
     assert(err == 0);
   }
+
+  if (!req->exiting) {
+    err = js_call_function_with_checkpoint(env, cb, ctx, error);
+    (void) err;
+  }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
 }
 
 static void
-rocksdb_native__on_iterator_teardown(js_deferred_teardown_t *handle, void *data) {
+rocksdb_native__on_iterator_teardown(js_deferred_teardown_t *teardown, void *data) {
   int err;
 
   auto req = reinterpret_cast<rocksdb_native_iterator_t *>(data);
 
   req->exiting = true;
 
-  if (req->active) return;
+  if (req->closing) return;
 
   err = rocksdb_iterator_close(&req->handle, rocksdb_native__on_iterator_close);
   assert(err == 0);
@@ -951,7 +966,7 @@ rocksdb_native_iterator_open(
   js_typedarray_t<> lte,
   bool reverse,
   bool keys_only,
-  std::optional<js_arraybuffer_t> snapshot,
+  std::optional<js_arraybuffer_span_of_t<rocksdb_native_snapshot_t, 1>> snapshot,
   js_receiver_t ctx,
   rocksdb_native_on_iterator_open_t on_open,
   rocksdb_native_on_iterator_close_t on_close,
@@ -979,10 +994,7 @@ rocksdb_native_iterator_open(
     .keys_only = keys_only
   };
 
-  if (snapshot) {
-    err = js_get_arraybuffer_info(env, snapshot.value(), options.snapshot);
-    assert(err == 0);
-  }
+  if (snapshot) options.snapshot = &snapshot.value()->handle;
 
   err = rocksdb_iterator_open(&db->handle, &req->handle, column_family->handle, range, &options, rocksdb_native__on_iterator_open);
 
@@ -993,8 +1005,6 @@ rocksdb_native_iterator_open(
     throw js_pending_exception;
   }
 
-  req->active = true;
-
   err = js_create_reference(env, ctx, req->ctx);
   assert(err == 0);
 
@@ -1024,7 +1034,7 @@ rocksdb_native_iterator_close(js_env_t *env, js_arraybuffer_span_of_t<rocksdb_na
     throw js_pending_exception;
   }
 
-  req->active = true;
+  req->closing = true;
 }
 
 static void
@@ -1035,76 +1045,66 @@ rocksdb_native__on_iterator_read(rocksdb_iterator_t *handle, int status) {
 
   auto req = reinterpret_cast<rocksdb_native_iterator_t *>(handle->data);
 
-  req->active = false;
-
   auto db = reinterpret_cast<rocksdb_native_t *>(req->handle.req.db);
 
-  size_t len = req->handle.len;
-
-  if (db->exiting) {
-    if (status == 0 && req->handle.error == nullptr) {
-      for (size_t i = 0; i < len; i++) {
-        js_value_t *result;
+  auto len = req->handle.len;
 
-        rocksdb_slice_destroy(&req->keys[i]);
-
-        rocksdb_slice_destroy(&req->values[i]);
-      }
-    }
+  auto env = req->env;
 
-    err = rocksdb_iterator_close(&req->handle, rocksdb_native__on_iterator_close);
-    assert(err == 0);
-  } else {
-    auto env = req->env;
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
 
-    js_handle_scope_t *scope;
-    err = js_open_handle_scope(env, &scope);
-    assert(err == 0);
+  js_receiver_t ctx;
+  err = js_get_reference_value(env, req->ctx, ctx);
+  assert(err == 0);
 
-    js_receiver_t ctx;
-    err = js_get_reference_value(env, req->ctx, ctx);
-    assert(err == 0);
+  rocksdb_native_on_iterator_read_t cb;
+  err = js_get_reference_value(env, req->on_read, cb);
+  assert(err == 0);
 
-    rocksdb_native_on_iterator_read_t cb;
-    err = js_get_reference_value(env, req->on_read, cb);
-    assert(err == 0);
+  std::optional<js_string_t> error;
 
-    std::optional<js_string_t> error;
+  std::vector<js_arraybuffer_t> keys;
+  keys.reserve(len);
 
-    std::vector<js_arraybuffer_t> keys;
-    keys.reserve(len);
+  std::vector<js_arraybuffer_t> values;
+  values.reserve(len);
 
-    std::vector<js_arraybuffer_t> values;
-    values.reserve(len);
+  if (req->handle.error) {
+    err = js_create_string(env, req->handle.error, error.emplace());
+    assert(err == 0);
+  } else {
+    for (size_t i = 0; i < len; i++) {
+      rocksdb_slice_t *key = &req->keys[i];
+      rocksdb_slice_t *value = &req->values[i];
 
-    if (req->handle.error) {
-      err = js_create_string(env, req->handle.error, error.emplace());
-      assert(err == 0);
-    } else {
-      for (size_t i = 0; i < len; i++) {
+      if (req->exiting) {
+        rocksdb_slice_destroy(key);
+        rocksdb_slice_destroy(value);
+      } else {
         js_arraybuffer_t result;
 
-        rocksdb_slice_t *key = &req->keys[i];
-
         err = rocksdb_native__try_create_external_arraybuffer(env, const_cast<char *>(key->data), key->len, result);
         assert(err == 0);
 
         keys.push_back(result);
 
-        rocksdb_slice_t *value = &req->values[i];
-
         err = rocksdb_native__try_create_external_arraybuffer(env, const_cast<char *>(value->data), value->len, result);
         assert(err == 0);
 
         values.push_back(result);
       }
     }
+  }
 
-    js_call_function_with_checkpoint(env, cb, ctx, error, keys, values);
-
-    err = js_close_handle_scope(env, scope);
-    assert(err == 0);
+  if (!req->exiting) {
+    err = js_call_function_with_checkpoint(env, cb, ctx, error, keys, values);
+    (void) err;
   }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
 }
 
 static void
@@ -1123,8 +1123,6 @@ rocksdb_native_iterator_read(
 
     throw js_pending_exception;
   }
-
-  req->active = true;
 }
 
 static js_arraybuffer_t
@@ -1173,57 +1171,56 @@ rocksdb_native__on_read(rocksdb_read_batch_t *handle, int status) {
 
   auto db = reinterpret_cast<rocksdb_native_t *>(req->handle.req.db);
 
+  auto len = req->handle.len;
+
   auto env = req->env;
 
-  size_t len = req->handle.len;
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
 
-  if (db->exiting) {
-    if (status == 0) {
-      for (size_t i = 0; i < len; i++) {
-        char *error = req->handle.errors[i];
+  js_receiver_t ctx;
+  err = js_get_reference_value(env, req->ctx, ctx);
+  assert(err == 0);
 
-        if (error) continue;
+  rocksdb_native_on_read_t cb;
+  err = js_get_reference_value(env, req->on_read, cb);
+  assert(err == 0);
 
-        rocksdb_slice_destroy(&req->reads[i].value);
-      }
-    }
+  req->on_read.reset();
+  req->ctx.reset();
 
-    req->on_read.reset();
-    req->ctx.reset();
-  } else {
-    js_handle_scope_t *scope;
-    err = js_open_handle_scope(env, &scope);
-    assert(err == 0);
+  js_array_t errors;
+  err = js_create_array(env, len, errors);
+  assert(err == 0);
 
-    js_array_t errors;
-    err = js_create_array(env, len, errors);
-    assert(err == 0);
+  js_array_t values;
+  err = js_create_array(env, len, values);
+  assert(err == 0);
 
-    js_array_t values;
-    err = js_create_array(env, len, values);
-    assert(err == 0);
+  for (size_t i = 0; i < len; i++) {
+    char *error = req->handle.errors[i];
 
-    for (size_t i = 0; i < len; i++) {
-      char *error = req->handle.errors[i];
+    if (error) {
+      js_string_t result;
 
-      if (error) {
-        js_string_t result;
+      err = js_create_string(env, error, result);
+      assert(err == 0);
 
-        err = js_create_string(env, error, result);
-        assert(err == 0);
+      err = js_set_element(env, errors, i, result);
+      assert(err == 0);
+    } else {
+      rocksdb_slice_t *value = &req->reads[i].value;
 
-        err = js_set_element(env, errors, i, result);
-        assert(err == 0);
-      } else {
+      if (db->exiting) rocksdb_slice_destroy(value);
+      else {
         js_arraybuffer_t result;
 
-        rocksdb_slice_t *slice = &req->reads[i].value;
-
-        if (slice->data == nullptr && slice->len == size_t(-1)) {
+        if (value->data == nullptr && value->len == size_t(-1)) {
           err = js_get_null(env, static_cast<js_value_t **>(result));
           assert(err == 0);
         } else {
-          err = rocksdb_native__try_create_external_arraybuffer(env, const_cast<char *>(slice->data), slice->len, result);
+          err = rocksdb_native__try_create_external_arraybuffer(env, const_cast<char *>(value->data), value->len, result);
           assert(err == 0);
         }
 
@@ -1231,23 +1228,15 @@ rocksdb_native__on_read(rocksdb_read_batch_t *handle, int status) {
         assert(err == 0);
       }
     }
+  }
 
-    js_receiver_t ctx;
-    err = js_get_reference_value(env, req->ctx, ctx);
-    assert(err == 0);
-
-    rocksdb_native_on_read_t cb;
-    err = js_get_reference_value(env, req->on_read, cb);
-    assert(err == 0);
-
-    req->on_read.reset();
-    req->ctx.reset();
-
-    js_call_function_with_checkpoint(env, cb, ctx, errors, values);
-
-    err = js_close_handle_scope(env, scope);
-    assert(err == 0);
+  if (!db->exiting) {
+    err = js_call_function_with_checkpoint(env, cb, ctx, errors, values);
+    (void) err;
   }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
 }
 
 static void
@@ -1256,7 +1245,7 @@ rocksdb_native_read(
   js_arraybuffer_span_of_t<rocksdb_native_t, 1> db,
   js_arraybuffer_span_of_t<rocksdb_native_read_batch_t, 1> req,
   js_array_t operations,
-  std::optional<js_arraybuffer_t> snapshot,
+  std::optional<js_arraybuffer_span_of_t<rocksdb_native_snapshot_t, 1>> snapshot,
   bool async_io,
   bool fill_cache,
   js_receiver_t ctx,
@@ -1311,10 +1300,7 @@ rocksdb_native_read(
     .fill_cache = fill_cache
   };
 
-  if (snapshot) {
-    err = js_get_arraybuffer_info(env, snapshot.value(), options.snapshot);
-    assert(err == 0);
-  }
+  if (snapshot) options.snapshot = &snapshot.value()->handle;
 
   err = rocksdb_read(&db->handle, &req->handle, req->reads, len, &options, rocksdb_native__on_read);
 
@@ -1380,37 +1366,35 @@ rocksdb_native__on_write(rocksdb_write_batch_t *handle, int status) {
 
   auto env = req->env;
 
-  if (db->exiting) {
-    req->on_write.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_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
 
-    js_receiver_t ctx;
-    err = js_get_reference_value(env, req->ctx, ctx);
-    assert(err == 0);
+  js_receiver_t ctx;
+  err = js_get_reference_value(env, req->ctx, ctx);
+  assert(err == 0);
 
-    rocksdb_native_on_write_t cb;
-    err = js_get_reference_value(env, req->on_write, cb);
-    assert(err == 0);
+  rocksdb_native_on_write_t cb;
+  err = js_get_reference_value(env, req->on_write, cb);
+  assert(err == 0);
 
-    req->on_write.reset();
-    req->ctx.reset();
+  req->on_write.reset();
+  req->ctx.reset();
 
-    js_call_function_with_checkpoint(env, cb, ctx, error);
+  std::optional<js_string_t> error;
 
-    err = js_close_handle_scope(env, scope);
+  if (req->handle.error) {
+    err = js_create_string(env, req->handle.error, error.emplace());
     assert(err == 0);
   }
+
+  if (!db->exiting) {
+    err = js_call_function_with_checkpoint(env, cb, ctx, error);
+    (void) err;
+  }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
 }
 
 static void
@@ -1531,37 +1515,35 @@ rocksdb_native__on_flush(rocksdb_flush_t *handle, int status) {
 
   auto env = req->env;
 
-  if (db->exiting) {
-    req->on_flush.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_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
 
-    js_receiver_t ctx;
-    err = js_get_reference_value(env, req->ctx, ctx);
-    assert(err == 0);
+  js_receiver_t ctx;
+  err = js_get_reference_value(env, req->ctx, ctx);
+  assert(err == 0);
 
-    rocksdb_native_on_flush_t cb;
-    err = js_get_reference_value(env, req->on_flush, cb);
-    assert(err == 0);
+  rocksdb_native_on_flush_t cb;
+  err = js_get_reference_value(env, req->on_flush, cb);
+  assert(err == 0);
 
-    req->on_flush.reset();
-    req->ctx.reset();
+  req->on_flush.reset();
+  req->ctx.reset();
 
-    js_call_function_with_checkpoint(env, cb, ctx, error);
+  std::optional<js_string_t> error;
 
-    err = js_close_handle_scope(env, scope);
+  if (req->handle.error) {
+    err = js_create_string(env, req->handle.error, error.emplace());
     assert(err == 0);
   }
+
+  if (!db->exiting) {
+    err = js_call_function_with_checkpoint(env, cb, ctx, error);
+    (void) err;
+  }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
 }
 
 static js_arraybuffer_t
@@ -1613,37 +1595,35 @@ rocksdb_native__on_compact_range(rocksdb_compact_range_t *handle, int status) {
 
   auto env = req->env;
 
-  if (db->exiting) {
-    req->on_compact_range.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_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
 
-    js_receiver_t ctx;
-    err = js_get_reference_value(env, req->ctx, ctx);
-    assert(err == 0);
+  js_receiver_t ctx;
+  err = js_get_reference_value(env, req->ctx, ctx);
+  assert(err == 0);
 
-    rocksdb_native_on_compact_range_t cb;
-    err = js_get_reference_value(env, req->on_compact_range, cb);
-    assert(err == 0);
+  rocksdb_native_on_compact_range_t cb;
+  err = js_get_reference_value(env, req->on_compact_range, cb);
+  assert(err == 0);
 
-    req->on_compact_range.reset();
-    req->ctx.reset();
+  req->on_compact_range.reset();
+  req->ctx.reset();
 
-    js_call_function_with_checkpoint(env, cb, ctx, error);
+  std::optional<js_string_t> error;
 
-    err = js_close_handle_scope(env, scope);
+  if (req->handle.error) {
+    err = js_create_string(env, req->handle.error, error.emplace());
     assert(err == 0);
   }
+
+  if (!db->exiting) {
+    err = js_call_function_with_checkpoint(env, cb, ctx, error);
+    (void) err;
+  }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
 }
 
 static js_arraybuffer_t
@@ -1711,37 +1691,35 @@ rocksdb_native__on_approximate_size(rocksdb_approximate_size_t *handle, int stat
 
   auto 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_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
 
-    js_receiver_t ctx;
-    err = js_get_reference_value(env, req->ctx, ctx);
-    assert(err == 0);
+  js_receiver_t ctx;
+  err = js_get_reference_value(env, req->ctx, ctx);
+  assert(err == 0);
 
-    rocksdb_native_on_approximate_size_t cb;
-    err = js_get_reference_value(env, req->on_approximate_size, cb);
-    assert(err == 0);
+  rocksdb_native_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();
+  req->on_approximate_size.reset();
+  req->ctx.reset();
 
-    js_call_function_with_checkpoint(env, cb, ctx, error, req->handle.result);
+  std::optional<js_string_t> error;
 
-    err = js_close_handle_scope(env, scope);
+  if (req->handle.error) {
+    err = js_create_string(env, req->handle.error, error.emplace());
     assert(err == 0);
   }
+
+  if (!db->exiting) {
+    err = js_call_function_with_checkpoint(env, cb, ctx, error, req->handle.result);
+    (void) err;
+  }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
 }
 
 static js_arraybuffer_t
@@ -1801,13 +1779,6 @@ rocksdb_native_approximate_size(
   return handle;
 }
 
-static void
-rocksdb_native__on_snapshot_teardown(void *data) {
-  auto snapshot = reinterpret_cast<rocksdb_native_snapshot_t *>(data);
-
-  rocksdb_snapshot_destroy(&snapshot->handle);
-}
-
 static js_arraybuffer_t
 rocksdb_native_snapshot_create(js_env_t *env, js_arraybuffer_span_of_t<rocksdb_native_t, 1> db) {
   int err;
@@ -1818,6 +1789,8 @@ rocksdb_native_snapshot_create(js_env_t *env, js_arraybuffer_span_of_t<rocksdb_n
   err = js_create_arraybuffer(env, snapshot, handle);
   assert(err == 0);
 
+  snapshot->db = db;
+
   err = rocksdb_snapshot_create(&db->handle, &snapshot->handle);
 
   if (err < 0) {
@@ -1827,9 +1800,11 @@ rocksdb_native_snapshot_create(js_env_t *env, js_arraybuffer_span_of_t<rocksdb_n
     throw js_pending_exception;
   }
 
-  err = js_add_teardown_callback(env, rocksdb_native__on_snapshot_teardown, snapshot);
+  err = js_create_reference(env, handle, snapshot->ctx);
   assert(err == 0);
 
+  db->snapshots.insert(snapshot);
+
   return handle;
 }
 
@@ -1839,8 +1814,9 @@ rocksdb_native_snapshot_destroy(js_env_t *env, js_arraybuffer_span_of_t<rocksdb_
 
   rocksdb_snapshot_destroy(&snapshot->handle);
 
-  err = js_remove_teardown_callback(env, rocksdb_native__on_snapshot_teardown, snapshot);
-  assert(err == 0);
+  snapshot->db->snapshots.erase(snapshot);
+
+  snapshot->ctx.reset();
 }
 
 static js_value_t *