slatedb 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e7afb38b40ead3216b671173af52bf1a30215979f8e850dbb1e4f7dabf823f3
-  data.tar.gz: '03923c7ffdd47ba2ea9d846e98af2f66ce8fc1287e3ed3e99d21e5c27db05a8b'
+  metadata.gz: dd1077018f7a8738545fc60b626a0e51d3240ae4141d9616787bf642489a22bc
+  data.tar.gz: 7aea1d1d0f9e1e3ee349d742246b7f89353ab8af39a6aca12d3167d7064d9023
 SHA512:
-  metadata.gz: d693ec11b74c8eea9722a270f48ccf8d209f21138a24dac54fbfa5d8242e23233982ea1f94aa31a667d4c0902c524213d20a9872fb6fb538685446d0efbb4fd1
-  data.tar.gz: 2e1b75894800650de82f8671bd07eefc678b6cfaaf6259245fbf854f8faaa0b8651f5c0ba1f07f4be5a8b0d85b2b54ca19177d2801a1f0f91400dde42202477a
+  metadata.gz: 2fcbdc5f116120c4d06bb857407047505a5ca5c526a9c8209cb06411635adc506b9a634024db9152c23f5b98f46d9600d2cf21d4826cf5a947b335cb72449eb2
+  data.tar.gz: e40b8fde694ca637e5ab80d529e161eefe8901cf478a768ebbc2ddd35b9cc16f42e8858feb4cd149333e7e3db6f4ee977770485390c56303ba8dba3fd88803ff

data/README.md

@@ -8,10 +8,6 @@ Ruby bindings for [SlateDB](https://slatedb.io), a cloud-native embedded key-val
 
 These bindings are still in early development, and while SlateDB itself is used in Production, these bindings have yet to be. Contributions are welcome!
 
-### TODO
-
-- [ ] Cross-compile native extensions
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -32,8 +28,7 @@ Or install it yourself as:
 gem install slatedb
 ```
 
-> [!IMPORTANT]
-> This gem currently requires a working Rust toolchain to install until the dependencies are cross-compiled.
+Precompiled native gems are published for common Linux and Darwin platforms. Building from source still requires a Rust toolchain.
 
 ## Usage
 
@@ -268,6 +263,27 @@ db.transaction do |txn|
 end
 ```
 
+You can narrow a prefix scan to a sub-range using the `from:` (inclusive) and
+`to:` (exclusive) options (SlateDB >= 0.14.0). Both are key *suffixes* that are
+appended to the prefix, so they let you paginate or resume within a prefix
+without building full-key ranges by hand. The scan never escapes the prefix.
+
+```ruby
+# Keys "user:100" (inclusive) up to "user:200" (exclusive)
+db.scan_prefix("user:", from: "100", to: "200").each do |key, value|
+  puts "#{key}: #{value}"
+end
+
+# Only a lower bound: from "user:500" to the end of the prefix
+db.scan_prefix("user:", from: "500")
+
+# Only an upper bound: from the start of the prefix up to (but not including) "user:100"
+db.scan_prefix("user:", to: "100")
+
+# Sub-ranges compose with order: and work on transactions, snapshots, and readers
+db.scan_prefix("user:", from: "100", to: "200", order: :desc)
+```
+
 ### Merge Operations
 
 Merge operations allow you to combine values without reading them first, useful for counters, append-only logs, and similar patterns:
@@ -487,13 +503,24 @@ SlateDb::Reader.open("/tmp/mydb", url: "s3://bucket/path") do |reader|
   end
 end
 
-# Open at a specific checkpoint
+# Open at a specific checkpoint (pins the reader to that checkpoint's state)
 SlateDb::Reader.open("/tmp/mydb", 
                      url: "s3://bucket/path",
                      checkpoint_id: "uuid-here") do |reader|
   reader.get("key")
 end
 
+# Follow the latest state without managing a checkpoint (SlateDB >= 0.15.0).
+# This performs no object-store writes but offers no protection from garbage
+# collection, so it suits read-only or mirrored databases. By default (neither
+# checkpoint_id nor follow_latest set) the reader creates and periodically
+# refreshes its own checkpoint instead.
+SlateDb::Reader.open("/tmp/mydb",
+                     url: "s3://bucket/path",
+                     follow_latest: true) do |reader|
+  reader.get("key")
+end
+
 # Enable the reader's on-disk cache and cap its open file handles
 # (max_open_file_handles, added in SlateDB 0.13.0, only takes effect when
 # cache_root is set, since that is what enables the cached object store).
@@ -534,8 +561,19 @@ admin.run_gc(min_age: 3600_000)                 # Set min age for all directorie
 admin.run_gc(manifest_min_age: 86400_000)       # Custom age for manifest (1 day)
 admin.run_gc(wal_min_age: 60_000)               # Custom age for WAL (1 minute)
 admin.run_gc(compacted_min_age: 60_000)         # Custom age for compacted (1 minute)
+
+# Delete a database (SlateDB >= 0.16.0)
+would_delete = admin.delete_db                  # Dry run: returns the object paths
+                                                # that *would* be deleted, deleting nothing
+deleted = admin.delete_db(confirm: true)        # Actually delete; returns the removed paths
 ```
 
+`delete_db` is idempotent, and a confirmed delete of a directory that is not a
+SlateDB database (no manifest and no in-progress deletion marker) is refused, so
+a mistyped path cannot wipe an unrelated directory. For a cloned database, any
+checkpoints it pinned in parent databases are stripped before its own objects
+are removed.
+
 ### Flushing
 
 Ensure all writes are persisted:
@@ -545,6 +583,26 @@ db.put("key", "value")
 db.flush
 ```
 
+By default, `flush` flushes the write-ahead log (WAL) if enabled, otherwise the
+memtable. You can choose explicitly with `flush_type:` (SlateDB >= 0.16.0):
+
+```ruby
+db.flush(flush_type: :wal)       # Flush the write-ahead log
+db.flush(flush_type: :memtable)  # Freeze and flush memtable entries to object storage
+```
+
+### Closing
+
+Closing flushes the active memtable first by default, so durable writes are not
+lost. You can control the final flush when closing (SlateDB >= 0.16.0):
+
+```ruby
+db.close                       # Flush the memtable, then close (default)
+db.close(flush_type: :wal)     # Flush the WAL before closing
+db.close(flush: false)         # Close without a final flush; writes that are not
+                               # yet durable may be lost
+```
+
 ## Thread Safety
 
 **SlateDB is fully thread-safe and optimized for concurrent access.**
@@ -604,6 +662,37 @@ Exception hierarchy:
 - Ruby 3.3+
 - Rust toolchain (for building from source)
 
+## Releasing
+
+Releases publish a generic `ruby` platform gem and **precompiled native gems**
+for six platforms (`x86_64-linux`, `aarch64-linux`, `x86_64-linux-musl`,
+`aarch64-linux-musl`, `arm64-darwin`, `x86_64-darwin`) to
+[rubygems.org](https://rubygems.org/gems/slatedb). The generic gem keeps
+RubyGems' latest-version metadata aligned; supported platforms should still
+resolve to their matching precompiled native gem.
+
+### Cutting a release
+
+The gem version comes from `lib/slatedb/version.rb`, not from the tag. Use the
+mise helper to bump, commit, tag, and push in one step (must be on `main` with a
+clean working tree):
+
+```bash
+mise run release:cut 0.4.3
+# or: mise run release:cut 0.4.3 --no-push
+```
+
+That updates `SlateDb::VERSION`, commits `Release v0.4.3`, creates tag `v0.4.3`,
+and pushes the commit + tag (unless `--no-push`). The tag triggers the release
+pipeline.
+
+The `release:verify-tag` step fails the build if the tag and
+`SlateDb::VERSION` disagree, so the tag (`v0.4.3`) must match `version.rb`
+(`0.4.3`).
+
+To exercise packaging without publishing, trigger a manual build on the
+`slatedb-rb-release` pipeline or set `DRY_RUN=true`.
+
 ## Development
 
 After checking out the repo, run:

data/ext/slatedb/Cargo.toml

@@ -11,7 +11,7 @@ name = "slatedb"
 crate-type = ["cdylib"]
 
 [dependencies]
-slatedb = "0.13.1"
+slatedb = "0.16.0"
 magnus = { version = "0.8.2", features = ["rb-sys"] }
 rb-sys = { version = "0.9.128", features = ["stable-api-compiled-fallback"] }
 tokio = { version = "1.52.3", features = ["rt-multi-thread", "sync"] }

data/ext/slatedb/src/admin.rs

@@ -230,6 +230,7 @@ impl Admin {
                         Some(GarbageCollectorDirectoryOptions {
                             interval: default_opts.as_ref().and_then(|o| o.interval),
                             min_age: std::time::Duration::from_millis(ms),
+                            dry_run: default_opts.as_ref().map(|o| o.dry_run).unwrap_or(false),
                         })
                     } else {
                         default_opts
@@ -243,6 +244,7 @@ impl Admin {
                     default_opts.manifest_options,
                 ),
                 wal_options: make_dir_opts(wal_min_age, min_age, default_opts.wal_options),
+                wal_fence_options: default_opts.wal_fence_options,
                 compacted_options: make_dir_opts(
                     compacted_min_age,
                     min_age,
@@ -250,6 +252,9 @@ impl Admin {
                 ),
                 compactions_options: default_opts.compactions_options,
                 detach_options: default_opts.detach_options,
+                metric_level: default_opts.metric_level,
+                boundary_files_enabled: default_opts.boundary_files_enabled,
+                object_store_max_retries: default_opts.object_store_max_retries,
             }
         };
 
@@ -260,6 +265,26 @@ impl Admin {
 
         Ok(())
     }
+
+    /// Delete a database, stripping any checkpoints it pinned in parent
+    /// databases (for clones) before removing its own objects (SlateDB >= 0.16.0).
+    ///
+    /// # Arguments
+    /// * `confirm` - When `false` (the default), performs a dry run and returns
+    ///   the list of object paths that *would* be deleted without touching
+    ///   anything. When `true`, actually deletes and returns the object paths
+    ///   that were removed.
+    ///
+    /// A `confirm` delete of a directory with neither a manifest nor a leftover
+    /// `.deleting` marker is refused, so an incorrect path cannot wipe an
+    /// unrelated directory. The operation is idempotent.
+    ///
+    /// # Returns
+    /// An array of object paths (deleted, or that would be deleted for a dry run).
+    pub fn delete_db(&self, confirm: bool) -> Result<Vec<String>, Error> {
+        let deleted = block_on_result(async { self.inner.delete_db(confirm).await })?;
+        Ok(deleted)
+    }
 }
 
 /// Define the Admin class on the SlateDb module.
@@ -277,6 +302,7 @@ pub fn define_admin_class(ruby: &Ruby, module: &magnus::RModule) -> Result<(), E
     class.define_method("_refresh_checkpoint", method!(Admin::refresh_checkpoint, 2))?;
     class.define_method("_delete_checkpoint", method!(Admin::delete_checkpoint, 1))?;
     class.define_method("_run_gc", method!(Admin::run_gc, 1))?;
+    class.define_method("_delete_db", method!(Admin::delete_db, 1))?;
 
     Ok(())
 }

data/ext/slatedb/src/database.rs

@@ -4,7 +4,8 @@ use std::sync::{Arc, Mutex};
 use magnus::prelude::*;
 use magnus::{function, method, Error, RHash, Ruby};
 use slatedb::config::{
-    DurabilityLevel, MergeOptions, PutOptions, ReadOptions, ScanOptions, Ttl, WriteOptions,
+    CloseOptions, DurabilityLevel, FlushOptions, FlushType, MergeOptions, PutOptions, ReadOptions,
+    ScanOptions, Ttl, WriteOptions,
 };
 use slatedb::object_store::memory::InMemory;
 use slatedb::{Db, IsolationLevel, IterationOrder, KeyValue};
@@ -16,7 +17,7 @@ use crate::metrics::Metrics;
 use crate::runtime::block_on_result;
 use crate::snapshot::Snapshot;
 use crate::transaction::Transaction;
-use crate::utils::{get_optional, resolve_object_store};
+use crate::utils::{get_optional, prefix_subrange_from_kwargs, resolve_object_store};
 use crate::write_batch::WriteBatch;
 
 /// Ruby wrapper for SlateDB database.
@@ -79,13 +80,32 @@ impl Database {
     }
 
     fn write_options_from_kwargs(kwargs: &RHash) -> Result<WriteOptions, Error> {
-        let await_durable = get_optional::<bool>(kwargs, "await_durable")?.unwrap_or(true);
         let seqnum = get_optional::<u64>(kwargs, "seqnum")?.unwrap_or(0);
 
-        Ok(WriteOptions {
-            await_durable,
-            seqnum,
-        })
+        Ok(WriteOptions { seqnum })
+    }
+
+    /// Parse the `await_durable` keyword argument (defaults to `true`).
+    ///
+    /// As of SlateDB 0.16.0, `await_durable` is no longer a `WriteOptions`
+    /// field. Write methods return immediately after updating the in-memory
+    /// WAL/MemTable and hand back a `WriteHandle`; blocking until the write is
+    /// durable in object storage is done by awaiting that handle. This helper
+    /// preserves the previous ergonomic `await_durable:` behavior for callers.
+    fn await_durable_from_kwargs(kwargs: &RHash) -> Result<bool, Error> {
+        Ok(get_optional::<bool>(kwargs, "await_durable")?.unwrap_or(true))
+    }
+
+    /// Parse a `flush_type` name into a SlateDB `FlushType` (SlateDB >= 0.16.0).
+    fn parse_flush_type(name: &str) -> Result<FlushType, Error> {
+        match name {
+            "wal" => Ok(FlushType::Wal),
+            "memtable" | "mem_table" => Ok(FlushType::MemTable),
+            other => Err(invalid_argument_error(&format!(
+                "invalid flush_type: {} (expected 'wal' or 'memtable')",
+                other
+            ))),
+        }
     }
 
     /// Open a database at the given path.
@@ -249,16 +269,14 @@ impl Database {
         }
 
         let put_opts = PutOptions { ttl: Ttl::Default };
-
-        let write_opts = WriteOptions {
-            await_durable: true,
-            seqnum: 0,
-        };
+        let write_opts = WriteOptions::default();
 
         block_on_result(async {
-            self.inner
+            let handle = self
+                .inner
                 .put_with_options(key.as_bytes(), value.as_bytes(), &put_opts, &write_opts)
-                .await
+                .await?;
+            handle.await_durable().await
         })?;
         self.increment_metric("db.put.count");
 
@@ -280,18 +298,23 @@ impl Database {
         let ttl = get_optional::<u64>(&kwargs, "ttl")?;
         let put_opts = PutOptions {
             ttl: match ttl {
-                Some(ms) => Ttl::ExpireAfter(ms),
+                Some(ms) => Ttl::ExpireAfterMillis(ms),
                 None => Ttl::Default,
             },
         };
 
-        // Parse await_durable
         let write_opts = Self::write_options_from_kwargs(&kwargs)?;
+        let await_durable = Self::await_durable_from_kwargs(&kwargs)?;
 
         block_on_result(async {
-            self.inner
+            let handle = self
+                .inner
                 .put_with_options(key.as_bytes(), value.as_bytes(), &put_opts, &write_opts)
-                .await
+                .await?;
+            if await_durable {
+                handle.await_durable().await?;
+            }
+            Ok(())
         })?;
         self.increment_metric("db.put_with_options.count");
 
@@ -307,15 +330,14 @@ impl Database {
             return Err(invalid_argument_error("key cannot be empty"));
         }
 
-        let write_opts = WriteOptions {
-            await_durable: true,
-            seqnum: 0,
-        };
+        let write_opts = WriteOptions::default();
 
         block_on_result(async {
-            self.inner
+            let handle = self
+                .inner
                 .delete_with_options(key.as_bytes(), &write_opts)
-                .await
+                .await?;
+            handle.await_durable().await
         })?;
         self.increment_metric("db.delete.count");
 
@@ -333,11 +355,17 @@ impl Database {
         }
 
         let write_opts = Self::write_options_from_kwargs(&kwargs)?;
+        let await_durable = Self::await_durable_from_kwargs(&kwargs)?;
 
         block_on_result(async {
-            self.inner
+            let handle = self
+                .inner
                 .delete_with_options(key.as_bytes(), &write_opts)
-                .await
+                .await?;
+            if await_durable {
+                handle.await_durable().await?;
+            }
+            Ok(())
         })?;
         self.increment_metric("db.delete_with_options.count");
 
@@ -467,7 +495,7 @@ impl Database {
         let opts = ScanOptions::default();
         let iter = block_on_result(async {
             self.inner
-                .scan_prefix_with_options(prefix.as_bytes(), &opts)
+                .scan_prefix_with_options(prefix.as_bytes(), .., &opts)
                 .await
         })?;
 
@@ -534,9 +562,10 @@ impl Database {
             };
         }
 
+        let subrange = prefix_subrange_from_kwargs(&kwargs)?;
         let iter = block_on_result(async {
             self.inner
-                .scan_prefix_with_options(prefix.as_bytes(), &opts)
+                .scan_prefix_with_options(prefix.as_bytes(), subrange, &opts)
                 .await
         })?;
 
@@ -549,7 +578,10 @@ impl Database {
     /// * `batch` - The WriteBatch to write
     pub fn write(&self, batch: &WriteBatch) -> Result<(), Error> {
         let batch_inner = batch.take()?;
-        block_on_result(async { self.inner.write(batch_inner).await })?;
+        block_on_result(async {
+            let handle = self.inner.write(batch_inner).await?;
+            handle.await_durable().await
+        })?;
         Ok(())
     }
 
@@ -560,13 +592,19 @@ impl Database {
     /// * `kwargs` - Keyword arguments (await_durable, seqnum)
     pub fn write_with_options(&self, batch: &WriteBatch, kwargs: RHash) -> Result<(), Error> {
         let write_opts = Self::write_options_from_kwargs(&kwargs)?;
+        let await_durable = Self::await_durable_from_kwargs(&kwargs)?;
 
         let batch_inner = batch.take()?;
 
         block_on_result(async {
-            self.inner
+            let handle = self
+                .inner
                 .write_with_options(batch_inner, &write_opts)
-                .await
+                .await?;
+            if await_durable {
+                handle.await_durable().await?;
+            }
+            Ok(())
         })?;
 
         Ok(())
@@ -583,16 +621,14 @@ impl Database {
         }
 
         let merge_opts = MergeOptions { ttl: Ttl::Default };
-
-        let write_opts = WriteOptions {
-            await_durable: true,
-            seqnum: 0,
-        };
+        let write_opts = WriteOptions::default();
 
         block_on_result(async {
-            self.inner
+            let handle = self
+                .inner
                 .merge_with_options(key.as_bytes(), value.as_bytes(), &merge_opts, &write_opts)
-                .await
+                .await?;
+            handle.await_durable().await
         })?;
 
         Ok(())
@@ -617,17 +653,23 @@ impl Database {
         let ttl = get_optional::<u64>(&kwargs, "ttl")?;
         let merge_opts = MergeOptions {
             ttl: match ttl {
-                Some(ms) => Ttl::ExpireAfter(ms),
+                Some(ms) => Ttl::ExpireAfterMillis(ms),
                 None => Ttl::Default,
             },
         };
 
         let write_opts = Self::write_options_from_kwargs(&kwargs)?;
+        let await_durable = Self::await_durable_from_kwargs(&kwargs)?;
 
         block_on_result(async {
-            self.inner
+            let handle = self
+                .inner
                 .merge_with_options(key.as_bytes(), value.as_bytes(), &merge_opts, &write_opts)
-                .await
+                .await?;
+            if await_durable {
+                handle.await_durable().await?;
+            }
+            Ok(())
         })?;
 
         Ok(())
@@ -707,6 +749,19 @@ impl Database {
         Ok(())
     }
 
+    /// Flush the database, choosing the flush type (SlateDB >= 0.16.0).
+    ///
+    /// # Arguments
+    /// * `flush_type` - "wal" to flush the WAL, or "memtable" to freeze and
+    ///   flush memtable entries to object storage.
+    pub fn flush_with_options(&self, flush_type: String) -> Result<(), Error> {
+        let options = FlushOptions {
+            flush_type: Self::parse_flush_type(&flush_type)?,
+        };
+        block_on_result(async { self.inner.flush_with_options(options).await })?;
+        Ok(())
+    }
+
     /// Return the database metrics registry.
     pub fn metrics(&self) -> Result<Metrics, Error> {
         Ok(Metrics::new(self.metrics.clone()))
@@ -717,6 +772,22 @@ impl Database {
         block_on_result(async { self.inner.close().await })?;
         Ok(())
     }
+
+    /// Close the database, controlling the final flush (SlateDB >= 0.16.0).
+    ///
+    /// # Arguments
+    /// * `flush_type` - `Some("wal"|"memtable")` to flush before closing, or
+    ///   `None` to close without a final flush (writes that are not yet durable
+    ///   may be lost).
+    pub fn close_with_options(&self, flush_type: Option<String>) -> Result<(), Error> {
+        let flush_type = match flush_type {
+            Some(name) => Some(Self::parse_flush_type(&name)?),
+            None => None,
+        };
+        let options = CloseOptions { flush_type };
+        block_on_result(async { self.inner.close_with_options(options).await })?;
+        Ok(())
+    }
 }
 
 /// Define the Database class on the SlateDb module.
@@ -771,9 +842,17 @@ pub fn define_database_class(ruby: &Ruby, module: &magnus::RModule) -> Result<()
         "_create_checkpoint",
         method!(Database::create_checkpoint, 1),
     )?;
-    class.define_method("flush", method!(Database::flush, 0))?;
+    class.define_method("_flush", method!(Database::flush, 0))?;
+    class.define_method(
+        "_flush_with_options",
+        method!(Database::flush_with_options, 1),
+    )?;
     class.define_method("_metrics", method!(Database::metrics, 0))?;
-    class.define_method("close", method!(Database::close, 0))?;
+    class.define_method("_close", method!(Database::close, 0))?;
+    class.define_method(
+        "_close_with_options",
+        method!(Database::close_with_options, 1),
+    )?;
 
     Ok(())
 }

data/ext/slatedb/src/reader.rs

@@ -4,12 +4,13 @@ use magnus::prelude::*;
 use magnus::{function, method, Error, RHash, Ruby};
 use slatedb::config::{DbReaderOptions, DurabilityLevel, ReadOptions, ScanOptions};
 use slatedb::DbReader;
+use slatedb::DbReaderMode;
 use slatedb::IterationOrder;
 
 use crate::errors::invalid_argument_error;
 use crate::iterator::Iterator;
 use crate::runtime::block_on_result;
-use crate::utils::{get_optional, resolve_object_store};
+use crate::utils::{get_optional, prefix_subrange_from_kwargs, resolve_object_store};
 
 /// Ruby wrapper for SlateDB Reader.
 ///
@@ -26,11 +27,20 @@ impl Reader {
     /// # Arguments
     /// * `path` - The path identifier for the database
     /// * `url` - Optional object store URL
-    /// * `checkpoint_id` - Optional checkpoint UUID to read at
+    /// * `checkpoint_id` - Optional checkpoint UUID to read at. When set, the reader
+    ///   is pinned to that checkpoint ([`DbReaderMode::Checkpoint`]).
     /// * `kwargs` - Additional options (manifest_poll_interval, checkpoint_lifetime,
-    ///   max_memtable_bytes, skip_wal_replay, cache_root, max_open_file_handles).
+    ///   max_memtable_bytes, skip_wal_replay, cache_root, max_open_file_handles,
+    ///   follow_latest).
     ///   The local disk cache (and therefore `max_open_file_handles`) is only active
     ///   when `cache_root` is set.
+    ///
+    ///   When neither `checkpoint_id` nor `follow_latest` is given the reader defaults
+    ///   to [`DbReaderMode::ManagedCheckpoint`], creating and periodically refreshing
+    ///   its own checkpoint so garbage collection cannot delete objects out from under
+    ///   it. Setting `follow_latest: true` selects [`DbReaderMode::FollowLatest`], which
+    ///   tails the latest manifest without writing any checkpoint — useful for read-only
+    ///   or mirrored databases, at the cost of no protection from garbage collection.
     pub fn open(
         path: String,
         url: Option<String>,
@@ -46,16 +56,24 @@ impl Reader {
         let skip_wal_replay = get_optional::<bool>(&kwargs, "skip_wal_replay")?;
         let max_open_file_handles = get_optional::<usize>(&kwargs, "max_open_file_handles")?;
         let cache_root = get_optional::<String>(&kwargs, "cache_root")?;
-
-        // Parse checkpoint_id as UUID
-        let checkpoint_uuid =
-            if let Some(id_str) = checkpoint_id {
-                Some(uuid::Uuid::parse_str(&id_str).map_err(|e| {
+        let follow_latest = get_optional::<bool>(&kwargs, "follow_latest")?.unwrap_or(false);
+
+        // Resolve the reader mode from checkpoint_id / follow_latest.
+        let mode = match checkpoint_id {
+            Some(id_str) => {
+                if follow_latest {
+                    return Err(invalid_argument_error(
+                        "checkpoint_id and follow_latest are mutually exclusive",
+                    ));
+                }
+                let uuid = uuid::Uuid::parse_str(&id_str).map_err(|e| {
                     invalid_argument_error(&format!("invalid checkpoint_id: {}", e))
-                })?)
-            } else {
-                None
-            };
+                })?;
+                DbReaderMode::Checkpoint(uuid)
+            }
+            None if follow_latest => DbReaderMode::FollowLatest,
+            None => DbReaderMode::ManagedCheckpoint,
+        };
 
         let reader = block_on_result(async {
             let object_store: Arc<dyn slatedb::object_store::ObjectStore> =
@@ -85,7 +103,7 @@ impl Reader {
             if let Some(max_handles) = max_open_file_handles {
                 options.object_store_cache_options.max_open_file_handles = max_handles;
             }
-            DbReader::open(path, object_store, checkpoint_uuid, options).await
+            DbReader::open(path, object_store, mode, options).await
         })?;
 
         Ok(Self {
@@ -239,7 +257,8 @@ impl Reader {
             return Err(invalid_argument_error("prefix cannot be empty"));
         }
 
-        let iter = block_on_result(async { self.inner.scan_prefix(prefix.as_bytes()).await })?;
+        let iter =
+            block_on_result(async { self.inner.scan_prefix(prefix.as_bytes(), ..).await })?;
 
         Ok(Iterator::new(iter))
     }
@@ -297,9 +316,10 @@ impl Reader {
             };
         }
 
+        let subrange = prefix_subrange_from_kwargs(&kwargs)?;
         let iter = block_on_result(async {
             self.inner
-                .scan_prefix_with_options(prefix.as_bytes(), &opts)
+                .scan_prefix_with_options(prefix.as_bytes(), subrange, &opts)
                 .await
         })?;
 

data/ext/slatedb/src/snapshot.rs

@@ -10,7 +10,7 @@ use slatedb::IterationOrder;
 use crate::errors::{closed_error, invalid_argument_error};
 use crate::iterator::Iterator;
 use crate::runtime::block_on_result;
-use crate::utils::get_optional;
+use crate::utils::{get_optional, prefix_subrange_from_kwargs};
 
 /// Ruby wrapper for SlateDB Snapshot.
 ///
@@ -190,7 +190,7 @@ impl Snapshot {
             .as_ref()
             .ok_or_else(|| closed_error("snapshot is closed"))?;
 
-        let iter = block_on_result(async { snapshot.scan_prefix(prefix.as_bytes()).await })?;
+        let iter = block_on_result(async { snapshot.scan_prefix(prefix.as_bytes(), ..).await })?;
 
         Ok(Iterator::new(iter))
     }
@@ -248,6 +248,8 @@ impl Snapshot {
             };
         }
 
+        let subrange = prefix_subrange_from_kwargs(&kwargs)?;
+
         let guard = self.inner.borrow();
         let snapshot = guard
             .as_ref()
@@ -255,7 +257,7 @@ impl Snapshot {
 
         let iter = block_on_result(async {
             snapshot
-                .scan_prefix_with_options(prefix.as_bytes(), &opts)
+                .scan_prefix_with_options(prefix.as_bytes(), subrange, &opts)
                 .await
         })?;
 

data/ext/slatedb/src/transaction.rs

@@ -11,7 +11,7 @@ use slatedb::IterationOrder;
 use crate::errors::{closed_error, invalid_argument_error, map_error};
 use crate::iterator::Iterator;
 use crate::runtime::block_on_result;
-use crate::utils::get_optional;
+use crate::utils::{get_optional, prefix_subrange_from_kwargs};
 
 /// Ruby wrapper for SlateDB Transaction.
 ///
@@ -109,7 +109,7 @@ impl Transaction {
         let ttl = get_optional::<u64>(&kwargs, "ttl")?;
         let put_opts = PutOptions {
             ttl: match ttl {
-                Some(ms) => Ttl::ExpireAfter(ms),
+                Some(ms) => Ttl::ExpireAfterMillis(ms),
                 None => Ttl::Default,
             },
         };
@@ -172,7 +172,7 @@ impl Transaction {
         let ttl = get_optional::<u64>(&kwargs, "ttl")?;
         let merge_opts = MergeOptions {
             ttl: match ttl {
-                Some(ms) => Ttl::ExpireAfter(ms),
+                Some(ms) => Ttl::ExpireAfterMillis(ms),
                 None => Ttl::Default,
             },
         };
@@ -295,7 +295,7 @@ impl Transaction {
             .as_ref()
             .ok_or_else(|| closed_error("transaction is closed"))?;
 
-        let iter = block_on_result(async { txn.scan_prefix(prefix.as_bytes()).await })?;
+        let iter = block_on_result(async { txn.scan_prefix(prefix.as_bytes(), ..).await })?;
 
         Ok(Iterator::new(iter))
     }
@@ -353,13 +353,16 @@ impl Transaction {
             };
         }
 
+        let subrange = prefix_subrange_from_kwargs(&kwargs)?;
+
         let guard = self.inner.borrow();
         let txn = guard
             .as_ref()
             .ok_or_else(|| closed_error("transaction is closed"))?;
 
         let iter = block_on_result(async {
-            txn.scan_prefix_with_options(prefix.as_bytes(), &opts).await
+            txn.scan_prefix_with_options(prefix.as_bytes(), subrange, &opts)
+                .await
         })?;
 
         Ok(Iterator::new(iter))
@@ -392,7 +395,16 @@ impl Transaction {
             .take()
             .ok_or_else(|| closed_error("transaction is closed"))?;
 
-        block_on_result(async { txn.commit().await })?;
+        block_on_result(async {
+            // As of SlateDB 0.16.0, commit returns as soon as the write is in
+            // memory and hands back an optional WriteHandle (None for an empty
+            // or read-only transaction). Await durability to preserve the
+            // previous blocking-commit behavior.
+            if let Some(handle) = txn.commit().await? {
+                handle.await_durable().await?;
+            }
+            Ok(())
+        })?;
         Ok(())
     }
 
@@ -400,10 +412,7 @@ impl Transaction {
     pub fn commit_with_options(&self, kwargs: RHash) -> Result<(), Error> {
         let await_durable = get_optional::<bool>(&kwargs, "await_durable")?.unwrap_or(true);
         let seqnum = get_optional::<u64>(&kwargs, "seqnum")?.unwrap_or(0);
-        let write_opts = WriteOptions {
-            await_durable,
-            seqnum,
-        };
+        let write_opts = WriteOptions { seqnum };
 
         let txn = self
             .inner
@@ -411,7 +420,14 @@ impl Transaction {
             .take()
             .ok_or_else(|| closed_error("transaction is closed"))?;
 
-        block_on_result(async { txn.commit_with_options(&write_opts).await })?;
+        block_on_result(async {
+            if let Some(handle) = txn.commit_with_options(&write_opts).await? {
+                if await_durable {
+                    handle.await_durable().await?;
+                }
+            }
+            Ok(())
+        })?;
         Ok(())
     }
 

data/ext/slatedb/src/utils.rs

@@ -1,10 +1,14 @@
+use std::ops::Bound;
 use std::sync::Arc;
 
 use magnus::value::ReprValue;
 use magnus::{Error, RHash, Ruby, TryConvert};
 use slatedb::object_store::aws::AmazonS3Builder;
-use slatedb::object_store::{Error as ObjectStoreError, ObjectStore, ObjectStoreScheme};
-use slatedb::{Db, Error as SlateError};
+use slatedb::object_store::prefix::PrefixStore;
+use slatedb::object_store::{
+    parse_url_opts, Error as ObjectStoreError, ObjectStore, ObjectStoreScheme,
+};
+use slatedb::Error as SlateError;
 use url::Url;
 
 /// Helper to extract an optional value from an RHash
@@ -23,6 +27,30 @@ pub fn get_optional<T: TryConvert>(hash: &RHash, key: &str) -> Result<Option<T>,
     }
 }
 
+/// A key sub-range for a prefix scan, expressed as owned byte bounds. This
+/// implements `slatedb::bytes_range::ByteRangeBounds`, so it can be passed
+/// straight to `scan_prefix`/`scan_prefix_with_options`.
+pub type PrefixSubrange = (Bound<Vec<u8>>, Bound<Vec<u8>>);
+
+/// Build a suffix sub-range (relative to a scan prefix) from optional
+/// `subrange_from` / `subrange_to` keyword arguments.
+///
+/// The bounds are key *suffixes* appended to the prefix: `subrange_from` is an
+/// inclusive lower bound and `subrange_to` is an exclusive upper bound. A
+/// missing bound is unbounded, so an empty hash yields a full-prefix scan
+/// (equivalent to `..`).
+pub fn prefix_subrange_from_kwargs(hash: &RHash) -> Result<PrefixSubrange, Error> {
+    let start = match get_optional::<String>(hash, "subrange_from")? {
+        Some(s) => Bound::Included(s.into_bytes()),
+        None => Bound::Unbounded,
+    };
+    let end = match get_optional::<String>(hash, "subrange_to")? {
+        Some(s) => Bound::Excluded(s.into_bytes()),
+        None => Bound::Unbounded,
+    };
+    Ok((start, end))
+}
+
 /// Convert an object_store error to a SlateDB error
 fn to_slate_error(e: ObjectStoreError) -> SlateError {
     SlateError::unavailable(e.to_string())
@@ -52,8 +80,22 @@ pub fn resolve_object_store(url: &str) -> Result<Arc<dyn ObjectStore>, SlateErro
             Ok(Arc::new(store))
         }
         _ => {
-            // Fall back to slatedb's default resolver for other schemes
-            Db::resolve_object_store(url)
+            // SlateDB 0.14 changed `Db::resolve_object_store` to reject any URL
+            // that carries a path component (returning `InvalidObjectStorePath`),
+            // whereas 0.13 transparently wrapped it in a `PrefixStore`. Preserve
+            // the old, more forgiving behavior here so callers can keep passing a
+            // full location such as "file:///data/mydb" or "gs://bucket/prefix".
+            //
+            // Env keys are lowercased because `parse_url_opts` only recognizes
+            // lower-case option keys.
+            let env_vars = std::env::vars().map(|(k, v)| (k.to_ascii_lowercase(), v));
+            let (store, path) = parse_url_opts(&parsed_url, env_vars).map_err(to_slate_error)?;
+            let store: Arc<dyn ObjectStore> = Arc::from(store);
+            if path.as_ref().is_empty() {
+                Ok(store)
+            } else {
+                Ok(Arc::new(PrefixStore::new(store, path)))
+            }
         }
     }
 }

data/ext/slatedb/src/write_batch.rs

@@ -49,7 +49,7 @@ impl WriteBatch {
         let ttl = get_optional::<u64>(&kwargs, "ttl")?;
         let put_opts = PutOptions {
             ttl: match ttl {
-                Some(ms) => Ttl::ExpireAfter(ms),
+                Some(ms) => Ttl::ExpireAfterMillis(ms),
                 None => Ttl::Default,
             },
         };
@@ -102,7 +102,7 @@ impl WriteBatch {
         let ttl = get_optional::<u64>(&kwargs, "ttl")?;
         let merge_opts = MergeOptions {
             ttl: match ttl {
-                Some(ms) => Ttl::ExpireAfter(ms),
+                Some(ms) => Ttl::ExpireAfterMillis(ms),
                 None => Ttl::Default,
             },
         };

data/lib/slatedb/admin.rb

@@ -118,5 +118,33 @@ module SlateDb
       opts[:min_age] = min_age if min_age
       _run_gc(opts)
     end
+
+    # Delete a database, removing its objects from the object store
+    # (SlateDB >= 0.16.0).
+    #
+    # For a cloned database, any checkpoints it pinned in parent databases are
+    # stripped before its own objects are removed.
+    #
+    # By default this performs a dry run: it returns the object paths that
+    # *would* be deleted without removing anything. Pass +confirm: true+ to
+    # actually delete. A confirmed delete of a directory that is not a SlateDB
+    # database (no manifest and no in-progress deletion marker) is refused, so a
+    # mistyped path cannot wipe an unrelated directory. The operation is
+    # idempotent.
+    #
+    # @param confirm [Boolean] When false (the default), performs a dry run and
+    #   returns the paths that would be deleted. When true, deletes and returns
+    #   the paths that were removed.
+    # @return [Array<String>] Object paths deleted (or that would be deleted)
+    #
+    # @example Preview what would be deleted
+    #   admin.delete_db.each { |path| puts path }
+    #
+    # @example Actually delete the database
+    #   deleted = admin.delete_db(confirm: true)
+    #
+    def delete_db(confirm: false)
+      _delete_db(confirm)
+    end
   end
 end

data/lib/slatedb/database.rb

@@ -246,6 +246,11 @@ module SlateDb
     # @param cache_blocks [Boolean, nil] Whether to cache blocks
     # @param max_fetch_tasks [Integer, nil] Maximum number of fetch tasks
     # @param order [Symbol, String, nil] Iteration order (:asc/:ascending or :desc/:descending)
+    # @param from [String, nil] Inclusive lower bound suffix, appended to the
+    #   prefix, to start scanning from (e.g. prefix "user:" with from "100"
+    #   starts at "user:100"). Defaults to the start of the prefix.
+    # @param to [String, nil] Exclusive upper bound suffix, appended to the
+    #   prefix, to stop scanning at. Defaults to the end of the prefix.
     # @return [Iterator] An iterator over key-value pairs
     #
     # @example Scan all user keys
@@ -253,8 +258,13 @@ module SlateDb
     #     puts "#{key}: #{value}"
     #   end
     #
+    # @example Scan a sub-range within a prefix
+    #   # keys "user:100" (inclusive) up to "user:200" (exclusive)
+    #   db.scan_prefix("user:", from: "100", to: "200")
+    #
     def scan_prefix(prefix, durability_filter: nil, dirty: nil,
-                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil, order: nil, &)
+                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil, order: nil,
+                    from: nil, to: nil, &)
       opts = scan_options(
         durability_filter: durability_filter,
         dirty: dirty,
@@ -263,6 +273,8 @@ module SlateDb
         max_fetch_tasks: max_fetch_tasks,
         order: order
       )
+      opts[:subrange_from] = from if from
+      opts[:subrange_to] = to if to
 
       iter = if opts.empty?
                _scan_prefix(prefix)
@@ -494,5 +506,63 @@ module SlateDb
     def metrics
       _metrics
     end
+
+    # Flush in-memory writes to object storage.
+    #
+    # With no arguments this flushes pending writes durably, matching the
+    # previous behavior. Pass +flush_type+ to control what is flushed
+    # (SlateDB >= 0.16.0).
+    #
+    # @param flush_type [Symbol, String, nil] Which data to flush: :wal to flush
+    #   the write-ahead log, or :memtable to freeze and flush memtable entries
+    #   to object storage. When nil (the default), SlateDB flushes the WAL if
+    #   enabled, otherwise the memtable.
+    # @return [void]
+    #
+    # @example Flush pending writes
+    #   db.flush
+    #
+    # @example Explicitly flush the WAL
+    #   db.flush(flush_type: :wal)
+    #
+    def flush(flush_type: nil)
+      if flush_type.nil?
+        _flush
+      else
+        _flush_with_options(flush_type.to_s)
+      end
+    end
+
+    # Close the database.
+    #
+    # By default the active memtable is flushed before closing (matching the
+    # previous behavior). Pass +flush: false+ to close without a final flush,
+    # in which case writes that are not yet durable may be lost
+    # (SlateDB >= 0.16.0).
+    #
+    # @param flush [Boolean] Whether to flush before closing (default: true)
+    # @param flush_type [Symbol, String, nil] When flushing, which data to
+    #   flush: :wal or :memtable. Defaults to :memtable. Ignored when
+    #   +flush: false+.
+    # @return [void]
+    #
+    # @example Close (flushing the memtable first)
+    #   db.close
+    #
+    # @example Close without flushing
+    #   db.close(flush: false)
+    #
+    # @example Flush the WAL before closing
+    #   db.close(flush_type: :wal)
+    #
+    def close(flush: true, flush_type: nil)
+      if !flush
+        _close_with_options(nil)
+      elsif flush_type.nil?
+        _close
+      else
+        _close_with_options(flush_type.to_s)
+      end
+    end
   end
 end

data/lib/slatedb/reader.rb

@@ -7,7 +7,14 @@ module SlateDb
       #
       # @param path [String] The path identifier for the database
       # @param url [String, nil] Optional object store URL
-      # @param checkpoint_id [String, nil] Optional checkpoint UUID to read at
+      # @param checkpoint_id [String, nil] Optional checkpoint UUID to read at. When
+      #   given, the reader is pinned to that checkpoint and does not follow new writes.
+      # @param follow_latest [Boolean, nil] When true, the reader tails the latest
+      #   manifest without creating or maintaining its own checkpoint. This performs no
+      #   object-store writes but provides no protection from garbage collection, so it
+      #   is best suited to read-only or mirrored databases. Mutually exclusive with
+      #   +checkpoint_id+. When neither is set (the default), the reader manages its own
+      #   checkpoint and refreshes it periodically. (Requires SlateDB >= 0.15.0)
       # @param manifest_poll_interval [Integer, nil] Poll interval in milliseconds
       # @param checkpoint_lifetime [Integer, nil] Checkpoint lifetime in milliseconds
       # @param max_memtable_bytes [Integer, nil] Maximum memtable size in bytes
@@ -35,16 +42,20 @@ module SlateDb
       # @example Open at a specific checkpoint
       #   reader = SlateDb::Reader.open("/tmp/mydb", checkpoint_id: "uuid-here")
       #
+      # @example Follow the latest state without managing a checkpoint
+      #   reader = SlateDb::Reader.open("/tmp/mydb", follow_latest: true)
+      #
       # @example Enable the on-disk cache and cap its open file handles
       #   reader = SlateDb::Reader.open("/tmp/mydb",
       #                                 cache_root: "/var/cache/slatedb",
       #                                 max_open_file_handles: 256)
       #
-      def open(path, url: nil, checkpoint_id: nil,
+      def open(path, url: nil, checkpoint_id: nil, follow_latest: nil,
                manifest_poll_interval: nil, checkpoint_lifetime: nil,
                max_memtable_bytes: nil, cache_root: nil, max_open_file_handles: nil,
                merge_operator: nil)
         opts = {}
+        opts[:follow_latest] = follow_latest unless follow_latest.nil?
         opts[:manifest_poll_interval] = manifest_poll_interval if manifest_poll_interval
         opts[:checkpoint_lifetime] = checkpoint_lifetime if checkpoint_lifetime
         opts[:max_memtable_bytes] = max_memtable_bytes if max_memtable_bytes
@@ -127,16 +138,25 @@ module SlateDb
     # @param read_ahead_bytes [Integer, nil] Number of bytes to read ahead
     # @param cache_blocks [Boolean, nil] Whether to cache blocks
     # @param max_fetch_tasks [Integer, nil] Maximum number of fetch tasks
+    # @param from [String, nil] Inclusive lower bound suffix, appended to the
+    #   prefix, to start scanning from (e.g. prefix "user:" with from "100"
+    #   starts at "user:100"). Defaults to the start of the prefix.
+    # @param to [String, nil] Exclusive upper bound suffix, appended to the
+    #   prefix, to stop scanning at. Defaults to the end of the prefix.
     # @return [Iterator] An iterator over key-value pairs
     #
     def scan_prefix(prefix, durability_filter: nil, dirty: nil,
-                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil, &)
-      opts = {}
-      opts[:durability_filter] = durability_filter.to_s if durability_filter
-      opts[:dirty] = dirty unless dirty.nil?
-      opts[:read_ahead_bytes] = read_ahead_bytes if read_ahead_bytes
-      opts[:cache_blocks] = cache_blocks unless cache_blocks.nil?
-      opts[:max_fetch_tasks] = max_fetch_tasks if max_fetch_tasks
+                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil,
+                    from: nil, to: nil, &)
+      opts = {
+        durability_filter: durability_filter&.to_s,
+        dirty: dirty,
+        read_ahead_bytes: read_ahead_bytes,
+        cache_blocks: cache_blocks,
+        max_fetch_tasks: max_fetch_tasks,
+        subrange_from: from,
+        subrange_to: to
+      }.compact
 
       iter = if opts.empty?
                _scan_prefix(prefix)

data/lib/slatedb/snapshot.rb

@@ -59,16 +59,24 @@ module SlateDb
     # @param read_ahead_bytes [Integer, nil] Number of bytes to read ahead
     # @param cache_blocks [Boolean, nil] Whether to cache blocks
     # @param max_fetch_tasks [Integer, nil] Maximum number of fetch tasks
+    # @param from [String, nil] Inclusive lower bound suffix, appended to the
+    #   prefix, to start scanning from. Defaults to the start of the prefix.
+    # @param to [String, nil] Exclusive upper bound suffix, appended to the
+    #   prefix, to stop scanning at. Defaults to the end of the prefix.
     # @return [Iterator] An iterator over key-value pairs
     #
     def scan_prefix(prefix, durability_filter: nil, dirty: nil,
-                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil, &)
-      opts = {}
-      opts[:durability_filter] = durability_filter.to_s if durability_filter
-      opts[:dirty] = dirty unless dirty.nil?
-      opts[:read_ahead_bytes] = read_ahead_bytes if read_ahead_bytes
-      opts[:cache_blocks] = cache_blocks unless cache_blocks.nil?
-      opts[:max_fetch_tasks] = max_fetch_tasks if max_fetch_tasks
+                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil,
+                    from: nil, to: nil, &)
+      opts = {
+        durability_filter: durability_filter&.to_s,
+        dirty: dirty,
+        read_ahead_bytes: read_ahead_bytes,
+        cache_blocks: cache_blocks,
+        max_fetch_tasks: max_fetch_tasks,
+        subrange_from: from,
+        subrange_to: to
+      }.compact
 
       iter = if opts.empty?
                _scan_prefix(prefix)

data/lib/slatedb/transaction.rb

@@ -98,16 +98,24 @@ module SlateDb
     # @param read_ahead_bytes [Integer, nil] Number of bytes to read ahead
     # @param cache_blocks [Boolean, nil] Whether to cache blocks
     # @param max_fetch_tasks [Integer, nil] Maximum number of fetch tasks
+    # @param from [String, nil] Inclusive lower bound suffix, appended to the
+    #   prefix, to start scanning from. Defaults to the start of the prefix.
+    # @param to [String, nil] Exclusive upper bound suffix, appended to the
+    #   prefix, to stop scanning at. Defaults to the end of the prefix.
     # @return [Iterator] An iterator over key-value pairs
     #
     def scan_prefix(prefix, durability_filter: nil, dirty: nil,
-                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil, &)
-      opts = {}
-      opts[:durability_filter] = durability_filter.to_s if durability_filter
-      opts[:dirty] = dirty unless dirty.nil?
-      opts[:read_ahead_bytes] = read_ahead_bytes if read_ahead_bytes
-      opts[:cache_blocks] = cache_blocks unless cache_blocks.nil?
-      opts[:max_fetch_tasks] = max_fetch_tasks if max_fetch_tasks
+                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil,
+                    from: nil, to: nil, &)
+      opts = {
+        durability_filter: durability_filter&.to_s,
+        dirty: dirty,
+        read_ahead_bytes: read_ahead_bytes,
+        cache_blocks: cache_blocks,
+        max_fetch_tasks: max_fetch_tasks,
+        subrange_from: from,
+        subrange_to: to
+      }.compact
 
       iter = if opts.empty?
                _scan_prefix(prefix)

data/lib/slatedb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SlateDb
-  VERSION = "0.3.1"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slatedb
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - SlateDB Contributors
@@ -137,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Ruby bindings for SlateDB
 test_files: []