slatedb 0.4.4-aarch64-linux → 0.6.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68154d73d7a14d2f9a123f14934a9eb8078309925de1f729dabc8b235db90d00
-  data.tar.gz: 876a2e026b98ec3a712acf9c8398fbfd551fde2b610e5b2a2ac76140a0c2f4a0
+  metadata.gz: f94b5f32f05b9d21536aa9441c17e42539db489eae97aa46556f35dfa699b7dd
+  data.tar.gz: 1620d5a46e797daf8de95d821415be96a5fc6c80e4f97a278b07a1032ae1c240
 SHA512:
-  metadata.gz: 1d71b6e1c6192789e7f66bb532c5b34706fe57a23cc34de57d8f4c0df4a9cc8a6653260fe82f9c8817ead19ffec9c531af8d3284cbc3a4c5ca7932c6de7f6bf1
-  data.tar.gz: fe43746af4e69f5336948a8196bba3f5fc07a9338dfba5f643aabf93cd71e972d054a66471cb4bd58fdf1ac93437c4a12624365c5c67ba2ac25ebb92577059a1
+  metadata.gz: ce0bef97705696cf225053c27f088e5c3dabe30f0d05f358e7a71d405e39fe2b7f864c5d0d29e57f74636e6d7eb1319ed05b9d12eed107dfc8410c86e4c4cafa
+  data.tar.gz: cf8eaa8427cdd8d9346635fe7c1463cf5be0a05256da13e3679105e371d5cc7c82e383c357c7c0dd092f0f745581ac4e0b4ef1404967a07631ec1d95542e00cf

data/README.md

@@ -64,6 +64,34 @@ SlateDb::Database.open("/tmp/mydb") do |db|
 end  # automatically closed
 ```
 
+### Compaction Controls
+
+SlateDB 0.17 adds controls for how long compaction inputs remain protected from
+garbage collection and when to consolidate sorted runs:
+
+```ruby
+SlateDb::Database.open("mydb",
+                       url: "s3://mybucket/path",
+                       compactor_checkpoint_lifetime: 30 * 60_000,
+                       sorted_run_consolidation_threshold: 8) do |db|
+  db.put("key", "value")
+end
+```
+
+`compactor_checkpoint_lifetime` is in milliseconds and defaults to 15 minutes.
+Reads, scans, snapshots, and transactions using old compaction inputs must finish
+within that time; after it expires, garbage collection can remove those inputs.
+
+`sorted_run_consolidation_threshold` starts fallback consolidation when the
+projected sorted-run count exceeds the threshold. It is not a hard limit.
+Zero disables it (the default); use at least two to enable it. SlateDB warns and
+disables the trigger for one. Low thresholds can increase storage reads and writes.
+
+### Key Size
+
+Keys can now exceed the previous 65,535-byte limit, up to SlateDB's new
+4,294,967,295-byte limit. Very large keys still require enough memory to process.
+
 ### Persistent Storage
 
 For persistent storage, provide an object store URL:
@@ -501,6 +529,14 @@ SlateDb::Reader.open("/tmp/mydb", url: "s3://bucket/path") do |reader|
   reader.scan("prefix:").each do |k, v|
     puts "#{k}: #{v}"
   end
+
+  # Range and prefix scans accept :asc/:ascending or :desc/:descending.
+  reader.scan("user:100", "user:200", order: :desc).each do |k, v|
+    puts "#{k}: #{v}"
+  end
+  reader.scan_prefix("user:", from: "100", to: "200", order: :desc).each do |k, v|
+    puts "#{k}: #{v}"
+  end
 end
 
 # Open at a specific checkpoint (pins the reader to that checkpoint's state)
@@ -561,8 +597,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:
@@ -572,6 +619,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.**

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

@@ -12,6 +12,12 @@ module SlateDb
       # @param merge_operator [Symbol, String, Proc, nil] Optional merge operator.
       #   Can be a symbol/string ("string_concat" or "concat") or a Proc/lambda
       #   that takes (key, existing_value, new_value) and returns the merged value.
+      # @param compactor_checkpoint_lifetime [Integer, nil] How long compaction inputs
+      #   are protected from garbage collection, in milliseconds (default: 15 minutes).
+      #   Reads using those inputs must finish within this time.
+      # @param sorted_run_consolidation_threshold [Integer, nil] Sorted-run count above
+      #   which fallback consolidation starts. Zero disables it (default); use at least
+      #   two to enable it. One is disabled by SlateDB with a warning. This is not a hard limit.
       # @yield [db] If a block is given, yields the database and ensures it's closed
       # @return [Database] The opened database (or block result if block given)
       #
@@ -38,8 +44,12 @@ module SlateDb
       #   db.merge("counter", "3")
       #   db.get("counter") # => "8"
       #
-      def open(path, url: nil, merge_operator: nil)
-        opts = {}
+      def open(path, url: nil, merge_operator: nil,
+               compactor_checkpoint_lifetime: nil, sorted_run_consolidation_threshold: nil)
+        opts = {
+          compactor_checkpoint_lifetime: compactor_checkpoint_lifetime,
+          sorted_run_consolidation_threshold: sorted_run_consolidation_threshold
+        }.compact
 
         case merge_operator
         when Symbol, String
@@ -506,5 +516,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

@@ -106,16 +106,19 @@ module SlateDb
     #
     # @param start_key [String] The start key (inclusive)
     # @param end_key [String, nil] The end key (exclusive)
+    # @param order [Symbol, String, nil] Iteration order (:asc/:ascending or :desc/:descending)
     # @return [Iterator] An iterator over key-value pairs
     #
     def scan(start_key, end_key = nil, 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, order: 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,
+        order: order&.to_s
+      }.compact
 
       iter = if opts.empty?
                _scan(start_key, end_key)
@@ -138,6 +141,7 @@ 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 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.
@@ -146,7 +150,7 @@ module SlateDb
     # @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,
+                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil, order: nil,
                     from: nil, to: nil, &)
       opts = {
         durability_filter: durability_filter&.to_s,
@@ -154,6 +158,7 @@ module SlateDb
         read_ahead_bytes: read_ahead_bytes,
         cache_blocks: cache_blocks,
         max_fetch_tasks: max_fetch_tasks,
+        order: order&.to_s,
         subrange_from: from,
         subrange_to: to
       }.compact

data/lib/slatedb/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slatedb
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.6.1
 platform: aarch64-linux
 authors:
 - SlateDB Contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-08-03 00:00:00.000000000 Z
+date: 2026-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.86'
+        version: '1.92'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.86'
+        version: '1.92'
 description: A cloud-native embedded key-value store built on object storage
 email:
 - slatedb@example.com