slatedb 0.3.1 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e7afb38b40ead3216b671173af52bf1a30215979f8e850dbb1e4f7dabf823f3
-  data.tar.gz: '03923c7ffdd47ba2ea9d846e98af2f66ce8fc1287e3ed3e99d21e5c27db05a8b'
+  metadata.gz: 5ea58f5cc108fef4066004dce3db7641d979589c6afa56023845b4e568198630
+  data.tar.gz: c5e52bded1c840e6d51ba420b673c5f03e3f9450dd78476dc129a45cab02b11b
 SHA512:
-  metadata.gz: d693ec11b74c8eea9722a270f48ccf8d209f21138a24dac54fbfa5d8242e23233982ea1f94aa31a667d4c0902c524213d20a9872fb6fb538685446d0efbb4fd1
-  data.tar.gz: 2e1b75894800650de82f8671bd07eefc678b6cfaaf6259245fbf854f8faaa0b8651f5c0ba1f07f4be5a8b0d85b2b54ca19177d2801a1f0f91400dde42202477a
+  metadata.gz: 715e35df65d25a1487f648718ec72e593fed5e22289f47c2017aa8eac24ccda5d5df00151ec618b1d732550be2f8b6ac5d8136b9358d18c197ae11b5e437e8a9
+  data.tar.gz: 92780ae93284906f92a4e4550d885c281af32f7cd1f91642e6ca9ebbe1f114d574d20a17be3f0605b5caaaafe64e27e70f12a96b5fcc6255fd8f0e210f0fa9b1

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).
@@ -604,6 +631,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.15.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,
             }
         };
 

data/ext/slatedb/src/database.rs

@@ -16,7 +16,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.
@@ -467,7 +467,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 +534,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
         })?;
 

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.
 ///
@@ -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))

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/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)

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.4.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slatedb
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.4
 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.16
 specification_version: 4
 summary: Ruby bindings for SlateDB
 test_files: []