slatedb 0.3.2.beta.3-aarch64-linux → 0.4.2-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e76279bb9bc5aa478e7e23ac4511c207e91c8b14cdf607cb14d6de4bb313294d
-  data.tar.gz: b445f20056d97a6bde1db9a015c8dde2882a51b34a63dc5e30ee83f3584b73f7
+  metadata.gz: a048a2dc5967cf32c55414f25edd93b101f37e473d9f4852641d4b10b6da4b9c
+  data.tar.gz: 6ba87318128ed507047bc9abf0ded29d1d2c8774f4b55f63d161b5feae2cabdc
 SHA512:
-  metadata.gz: ae4a654eadc4731ef29d64d6623a827cf200f554935659e4daf0b603f97ede90abf3122611b8d559c7b26dd11b1d870a0f48777376f1175478eb11bc835961e7
-  data.tar.gz: 2705167ceefbaa4c7deac2a1562c4e383f55a69a8cca4be1372f64ee7ff826b5a7e25acf43cf2a1678829d049b68d0e2e9447973d88caac3fade97782b3ece62
+  metadata.gz: f1639d74b9dc65c95966bd2cca5835c091096a5af2603b8769a208c866529ba5f48bbff44127b39dd6f1f08fa86b7457735ef21616517ed2f96792f4c05d7bd4
+  data.tar.gz: 05a547c559a58bdc6ff64223f685621f2363525e08cdbb5b80a263e5a415d621bbd0454f480a92eaacaf10e44f407e8fec1810dc5cf2cec64f5f1ea387a1e005

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/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.2.beta.3"
+  VERSION = "0.4.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slatedb
 version: !ruby/object:Gem::Version
-  version: 0.3.2.beta.3
+  version: 0.4.2
 platform: aarch64-linux
 authors:
 - SlateDB Contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-16 00:00:00.000000000 Z
+date: 2026-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake