slatedb 0.4.2-aarch64-linux → 0.5.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a048a2dc5967cf32c55414f25edd93b101f37e473d9f4852641d4b10b6da4b9c
-  data.tar.gz: 6ba87318128ed507047bc9abf0ded29d1d2c8774f4b55f63d161b5feae2cabdc
+  metadata.gz: ed29074506d3ec0998e585cf316ce03e2518aab3e42ec26704e2f41cb2df6f25
+  data.tar.gz: 18a4c04c383ea51511db610953a055d4416ae41a1acb21ad44cd743a6d617ee2
 SHA512:
-  metadata.gz: f1639d74b9dc65c95966bd2cca5835c091096a5af2603b8769a208c866529ba5f48bbff44127b39dd6f1f08fa86b7457735ef21616517ed2f96792f4c05d7bd4
-  data.tar.gz: 05a547c559a58bdc6ff64223f685621f2363525e08cdbb5b80a263e5a415d621bbd0454f480a92eaacaf10e44f407e8fec1810dc5cf2cec64f5f1ea387a1e005
+  metadata.gz: 7d54388635318353eaf700ef410c1aed4fd2c2a2ff434ad5e6cba98d5046ec6e6e1c8968f62be9e44b35336b64364972ad8336c54a248496425533caf82d1fe4
+  data.tar.gz: f4e74b56361d0b76f395704554ed50c180a05629ef9329599b1e938ed562a74a65a3ca33273481fb6976ccae2e0f10076fae150e980728ae9b786067eb99b74d

data/README.md

@@ -561,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:
@@ -572,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.**

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

@@ -506,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/version.rb

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

metadata

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