slatedb 0.2.0 → 0.3.1

data/ext/slatedb/src/metrics.rs

@@ -0,0 +1,47 @@
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
+use magnus::prelude::*;
+use magnus::{method, Error, Ruby};
+/// Ruby wrapper for SlateDB metrics registry.
+///
+/// This struct is exposed to Ruby as `SlateDb::Metrics`.
+#[magnus::wrap(class = "SlateDb::Metrics", free_immediately, size)]
+pub struct Metrics {
+    inner: Arc<Mutex<HashMap<String, i64>>>,
+}
+
+impl Metrics {
+    pub fn new(inner: Arc<Mutex<HashMap<String, i64>>>) -> Self {
+        Self { inner }
+    }
+
+    /// Return a list of metric names.
+    pub fn names(&self) -> Result<magnus::RArray, Error> {
+        let metrics = self.inner.lock().expect("metrics mutex poisoned");
+        let ruby = Ruby::get().expect("Ruby runtime not available");
+        let result = ruby.ary_new_capa(metrics.len());
+
+        for name in metrics.keys() {
+            result.push(ruby.str_new(name))?;
+        }
+
+        Ok(result)
+    }
+
+    /// Get the current value of a metric by name.
+    pub fn get(&self, name: String) -> Result<Option<i64>, Error> {
+        let metrics = self.inner.lock().expect("metrics mutex poisoned");
+        Ok(metrics.get(&name).copied())
+    }
+}
+
+/// Define the Metrics class on the SlateDb module.
+pub fn define_metrics_class(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    let class = module.define_class("Metrics", ruby.class_object())?;
+
+    class.define_method("names", method!(Metrics::names, 0))?;
+    class.define_method("get", method!(Metrics::get, 1))?;
+
+    Ok(())
+}

data/ext/slatedb/src/reader.rs

@@ -4,10 +4,10 @@ use magnus::prelude::*;
 use magnus::{function, method, Error, RHash, Ruby};
 use slatedb::config::{DbReaderOptions, DurabilityLevel, ReadOptions, ScanOptions};
 use slatedb::DbReader;
+use slatedb::IterationOrder;
 
 use crate::errors::invalid_argument_error;
 use crate::iterator::Iterator;
-use crate::merge_ops::parse_merge_operator;
 use crate::runtime::block_on_result;
 use crate::utils::{get_optional, resolve_object_store};
 
@@ -27,7 +27,10 @@ impl Reader {
     /// * `path` - The path identifier for the database
     /// * `url` - Optional object store URL
     /// * `checkpoint_id` - Optional checkpoint UUID to read at
-    /// * `kwargs` - Additional options (manifest_poll_interval, checkpoint_lifetime, max_memtable_bytes, merge_operator)
+    /// * `kwargs` - Additional options (manifest_poll_interval, checkpoint_lifetime,
+    ///   max_memtable_bytes, skip_wal_replay, cache_root, max_open_file_handles).
+    ///   The local disk cache (and therefore `max_open_file_handles`) is only active
+    ///   when `cache_root` is set.
     pub fn open(
         path: String,
         url: Option<String>,
@@ -40,7 +43,9 @@ impl Reader {
         let checkpoint_lifetime = get_optional::<u64>(&kwargs, "checkpoint_lifetime")?
             .map(std::time::Duration::from_millis);
         let max_memtable_bytes = get_optional::<u64>(&kwargs, "max_memtable_bytes")?;
-        let merge_operator = parse_merge_operator(&kwargs)?;
+        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 =
@@ -53,11 +58,12 @@ impl Reader {
             };
 
         let reader = block_on_result(async {
-            let object_store: Arc<dyn slatedb::object_store::ObjectStore> = if let Some(ref url) = url {
-                resolve_object_store(url)?
-            } else {
-                Arc::new(slatedb::object_store::memory::InMemory::new())
-            };
+            let object_store: Arc<dyn slatedb::object_store::ObjectStore> =
+                if let Some(ref url) = url {
+                    resolve_object_store(url)?
+                } else {
+                    Arc::new(slatedb::object_store::memory::InMemory::new())
+                };
 
             let mut options = DbReaderOptions::default();
             if let Some(interval) = manifest_poll_interval {
@@ -69,10 +75,16 @@ impl Reader {
             if let Some(max_bytes) = max_memtable_bytes {
                 options.max_memtable_bytes = max_bytes;
             }
-            if let Some(merge_operator) = merge_operator {
-                options.merge_operator = Some(merge_operator);
+            if let Some(skip_replay) = skip_wal_replay {
+                options.skip_wal_replay = skip_replay;
+            }
+            if let Some(ref root) = cache_root {
+                options.object_store_cache_options.root_folder =
+                    Some(std::path::PathBuf::from(root));
+            }
+            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
         })?;
 
@@ -116,6 +128,10 @@ impl Reader {
             opts.dirty = dirty;
         }
 
+        if let Some(cb) = get_optional::<bool>(&kwargs, "cache_blocks")? {
+            opts.cache_blocks = cb;
+        }
+
         let result =
             block_on_result(async { self.inner.get_with_options(key.as_bytes(), &opts).await })?;
         Ok(result.map(|b| String::from_utf8_lossy(&b).to_string()))
@@ -191,6 +207,18 @@ impl Reader {
         if let Some(mft) = get_optional::<usize>(&kwargs, "max_fetch_tasks")? {
             opts.max_fetch_tasks = mft;
         }
+        if let Some(order) = get_optional::<String>(&kwargs, "order")? {
+            opts.order = match order.as_str() {
+                "ascending" | "asc" => IterationOrder::Ascending,
+                "descending" | "desc" => IterationOrder::Descending,
+                other => {
+                    return Err(invalid_argument_error(&format!(
+                        "invalid order: {} (expected 'asc' or 'desc')",
+                        other
+                    )))
+                }
+            };
+        }
 
         let start_bytes = start.into_bytes();
         let end_bytes = end_key.map(|e| e.into_bytes());
@@ -256,6 +284,18 @@ impl Reader {
         if let Some(mft) = get_optional::<usize>(&kwargs, "max_fetch_tasks")? {
             opts.max_fetch_tasks = mft;
         }
+        if let Some(order) = get_optional::<String>(&kwargs, "order")? {
+            opts.order = match order.as_str() {
+                "ascending" | "asc" => IterationOrder::Ascending,
+                "descending" | "desc" => IterationOrder::Descending,
+                other => {
+                    return Err(invalid_argument_error(&format!(
+                        "invalid order: {} (expected 'asc' or 'desc')",
+                        other
+                    )))
+                }
+            };
+        }
 
         let iter = block_on_result(async {
             self.inner

data/ext/slatedb/src/snapshot.rs

@@ -5,6 +5,7 @@ use magnus::prelude::*;
 use magnus::{method, Error, RHash, Ruby};
 use slatedb::config::{DurabilityLevel, ReadOptions, ScanOptions};
 use slatedb::DbSnapshot;
+use slatedb::IterationOrder;
 
 use crate::errors::{closed_error, invalid_argument_error};
 use crate::iterator::Iterator;
@@ -68,6 +69,10 @@ impl Snapshot {
             opts.dirty = dirty;
         }
 
+        if let Some(cb) = get_optional::<bool>(&kwargs, "cache_blocks")? {
+            opts.cache_blocks = cb;
+        }
+
         let guard = self.inner.borrow();
         let snapshot = guard
             .as_ref()
@@ -143,6 +148,18 @@ impl Snapshot {
         if let Some(mft) = get_optional::<usize>(&kwargs, "max_fetch_tasks")? {
             opts.max_fetch_tasks = mft;
         }
+        if let Some(order) = get_optional::<String>(&kwargs, "order")? {
+            opts.order = match order.as_str() {
+                "ascending" | "asc" => IterationOrder::Ascending,
+                "descending" | "desc" => IterationOrder::Descending,
+                other => {
+                    return Err(invalid_argument_error(&format!(
+                        "invalid order: {} (expected 'asc' or 'desc')",
+                        other
+                    )))
+                }
+            };
+        }
 
         let guard = self.inner.borrow();
         let snapshot = guard
@@ -218,6 +235,18 @@ impl Snapshot {
         if let Some(mft) = get_optional::<usize>(&kwargs, "max_fetch_tasks")? {
             opts.max_fetch_tasks = mft;
         }
+        if let Some(order) = get_optional::<String>(&kwargs, "order")? {
+            opts.order = match order.as_str() {
+                "ascending" | "asc" => IterationOrder::Ascending,
+                "descending" | "desc" => IterationOrder::Descending,
+                other => {
+                    return Err(invalid_argument_error(&format!(
+                        "invalid order: {} (expected 'asc' or 'desc')",
+                        other
+                    )))
+                }
+            };
+        }
 
         let guard = self.inner.borrow();
         let snapshot = guard

data/ext/slatedb/src/transaction.rs

@@ -6,6 +6,7 @@ use slatedb::config::{
     DurabilityLevel, MergeOptions, PutOptions, ReadOptions, ScanOptions, Ttl, WriteOptions,
 };
 use slatedb::DbTransaction;
+use slatedb::IterationOrder;
 
 use crate::errors::{closed_error, invalid_argument_error, map_error};
 use crate::iterator::Iterator;
@@ -69,13 +70,16 @@ impl Transaction {
             opts.dirty = dirty;
         }
 
+        if let Some(cb) = get_optional::<bool>(&kwargs, "cache_blocks")? {
+            opts.cache_blocks = cb;
+        }
+
         let guard = self.inner.borrow();
         let txn = guard
             .as_ref()
             .ok_or_else(|| closed_error("transaction is closed"))?;
 
-        let result =
-            block_on_result(async { txn.get_with_options(key.as_bytes(), &opts).await })?;
+        let result = block_on_result(async { txn.get_with_options(key.as_bytes(), &opts).await })?;
         Ok(result.map(|b| String::from_utf8_lossy(&b).to_string()))
     }
 
@@ -155,7 +159,12 @@ impl Transaction {
     }
 
     /// Merge a value with options within the transaction.
-    pub fn merge_with_options(&self, key: String, value: String, kwargs: RHash) -> Result<(), Error> {
+    pub fn merge_with_options(
+        &self,
+        key: String,
+        value: String,
+        kwargs: RHash,
+    ) -> Result<(), Error> {
         if key.is_empty() {
             return Err(invalid_argument_error("key cannot be empty"));
         }
@@ -244,6 +253,18 @@ impl Transaction {
         if let Some(mft) = get_optional::<usize>(&kwargs, "max_fetch_tasks")? {
             opts.max_fetch_tasks = mft;
         }
+        if let Some(order) = get_optional::<String>(&kwargs, "order")? {
+            opts.order = match order.as_str() {
+                "ascending" | "asc" => IterationOrder::Ascending,
+                "descending" | "desc" => IterationOrder::Descending,
+                other => {
+                    return Err(invalid_argument_error(&format!(
+                        "invalid order: {} (expected 'asc' or 'desc')",
+                        other
+                    )))
+                }
+            };
+        }
 
         let guard = self.inner.borrow();
         let txn = guard
@@ -319,14 +340,27 @@ impl Transaction {
         if let Some(mft) = get_optional::<usize>(&kwargs, "max_fetch_tasks")? {
             opts.max_fetch_tasks = mft;
         }
+        if let Some(order) = get_optional::<String>(&kwargs, "order")? {
+            opts.order = match order.as_str() {
+                "ascending" | "asc" => IterationOrder::Ascending,
+                "descending" | "desc" => IterationOrder::Descending,
+                other => {
+                    return Err(invalid_argument_error(&format!(
+                        "invalid order: {} (expected 'asc' or 'desc')",
+                        other
+                    )))
+                }
+            };
+        }
 
         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 })?;
+        let iter = block_on_result(async {
+            txn.scan_prefix_with_options(prefix.as_bytes(), &opts).await
+        })?;
 
         Ok(Iterator::new(iter))
     }
@@ -365,7 +399,11 @@ impl Transaction {
     /// Commit the transaction with options.
     pub fn commit_with_options(&self, kwargs: RHash) -> Result<(), Error> {
         let await_durable = get_optional::<bool>(&kwargs, "await_durable")?.unwrap_or(true);
-        let write_opts = WriteOptions { await_durable };
+        let seqnum = get_optional::<u64>(&kwargs, "seqnum")?.unwrap_or(0);
+        let write_opts = WriteOptions {
+            await_durable,
+            seqnum,
+        };
 
         let txn = self
             .inner
@@ -422,7 +460,7 @@ pub fn define_transaction_class(ruby: &Ruby, module: &magnus::RModule) -> Result
         method!(Transaction::scan_prefix_with_options, 2),
     )?;
     class.define_method("_mark_read", method!(Transaction::mark_read, 1))?;
-    class.define_method("commit", method!(Transaction::commit, 0))?;
+    class.define_method("_commit", method!(Transaction::commit, 0))?;
     class.define_method(
         "_commit_with_options",
         method!(Transaction::commit_with_options, 1),

data/ext/slatedb/src/write_batch.rs

@@ -89,7 +89,12 @@ impl WriteBatch {
     ///
     /// Options:
     /// - ttl: Time-to-live in milliseconds
-    pub fn merge_with_options(&self, key: String, value: String, kwargs: RHash) -> Result<(), Error> {
+    pub fn merge_with_options(
+        &self,
+        key: String,
+        value: String,
+        kwargs: RHash,
+    ) -> Result<(), Error> {
         if key.is_empty() {
             return Err(invalid_argument_error("key cannot be empty"));
         }

data/lib/slatedb/database.rb

@@ -95,12 +95,44 @@ module SlateDb
       end
     end
 
+    # Get a key-value pair with SlateDB metadata.
+    #
+    # @param key [String] The key to look up
+    # @param durability_filter [String, nil] Filter by durability level ("remote" or "memory")
+    # @param dirty [Boolean, nil] Whether to include uncommitted data
+    # @param cache_blocks [Boolean, nil] Whether to cache blocks
+    # @return [Hash, nil] A hash with :key, :value, :seq, :create_ts, and :expire_ts, or nil if not found
+    #
+    # @example Inspect metadata
+    #   entry = db.get_key_value("mykey")
+    #   entry[:value] # => "myvalue"
+    #   entry[:seq]   # => sequence number
+    #
+    def get_key_value(key, durability_filter: nil, dirty: nil, cache_blocks: nil)
+      opts = {}
+      opts[:durability_filter] = durability_filter.to_s if durability_filter
+      opts[:dirty] = dirty unless dirty.nil?
+      opts[:cache_blocks] = cache_blocks unless cache_blocks.nil?
+
+      if opts.empty?
+        _get_key_value(key)
+      else
+        _get_key_value_with_options(key, opts)
+      end
+    end
+
+    alias get_entry get_key_value
+
     # Store a key-value pair.
     #
     # @param key [String] The key to store
     # @param value [String] The value to store
     # @param ttl [Integer, nil] Time-to-live in milliseconds
     # @param await_durable [Boolean] Whether to wait for durability (default: true)
+    # @param seqnum [Integer, nil] User-supplied sequence number for this write.
+    #   When provided (and non-zero), it is used instead of the internally
+    #   generated sequence number. It must be strictly greater than the current
+    #   maximum sequence number or the write fails. (Requires SlateDB >= 0.13.0)
     # @return [void]
     #
     # @example Basic put
@@ -112,10 +144,14 @@ module SlateDb
     # @example Put without waiting for durability
     #   db.put("mykey", "myvalue", await_durable: false)
     #
-    def put(key, value, ttl: nil, await_durable: nil)
+    # @example Put with an explicit sequence number
+    #   db.put("mykey", "myvalue", seqnum: 42)
+    #
+    def put(key, value, ttl: nil, await_durable: nil, seqnum: nil)
       opts = {}
       opts[:ttl] = ttl if ttl
       opts[:await_durable] = await_durable unless await_durable.nil?
+      opts[:seqnum] = seqnum if seqnum
 
       if opts.empty?
         _put(key, value)
@@ -128,6 +164,8 @@ module SlateDb
     #
     # @param key [String] The key to delete
     # @param await_durable [Boolean] Whether to wait for durability (default: true)
+    # @param seqnum [Integer, nil] User-supplied sequence number for this write.
+    #   See {#put} for semantics. (Requires SlateDB >= 0.13.0)
     # @return [void]
     #
     # @example Basic delete
@@ -136,11 +174,15 @@ module SlateDb
     # @example Delete without waiting for durability
     #   db.delete("mykey", await_durable: false)
     #
-    def delete(key, await_durable: nil)
-      if await_durable.nil?
+    def delete(key, await_durable: nil, seqnum: nil)
+      opts = {}
+      opts[:await_durable] = await_durable unless await_durable.nil?
+      opts[:seqnum] = seqnum if seqnum
+
+      if opts.empty?
         _delete(key)
       else
-        _delete_with_options(key, { await_durable: await_durable })
+        _delete_with_options(key, opts)
       end
     end
 
@@ -153,6 +195,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)
     # @return [Iterator] An iterator over key-value pairs
     #
     # @example Basic scan
@@ -171,13 +214,15 @@ module SlateDb
     #   end
     #
     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 = scan_options(
+        durability_filter: durability_filter,
+        dirty: dirty,
+        read_ahead_bytes: read_ahead_bytes,
+        cache_blocks: cache_blocks,
+        max_fetch_tasks: max_fetch_tasks,
+        order: order
+      )
 
       iter = if opts.empty?
                _scan(start_key, end_key)
@@ -200,6 +245,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)
     # @return [Iterator] An iterator over key-value pairs
     #
     # @example Scan all user keys
@@ -208,13 +254,15 @@ module SlateDb
     #   end
     #
     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, order: nil, &)
+      opts = scan_options(
+        durability_filter: durability_filter,
+        dirty: dirty,
+        read_ahead_bytes: read_ahead_bytes,
+        cache_blocks: cache_blocks,
+        max_fetch_tasks: max_fetch_tasks,
+        order: order
+      )
 
       iter = if opts.empty?
                _scan_prefix(prefix)
@@ -229,10 +277,26 @@ module SlateDb
       end
     end
 
+    def scan_options(durability_filter:, dirty:, read_ahead_bytes:, cache_blocks:,
+                     max_fetch_tasks:, order:)
+      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
+      opts[:order] = order.to_s if order
+      opts
+    end
+
+    private :scan_options
+
     # Write a batch of operations atomically.
     #
     # @param batch [WriteBatch] The batch to write
     # @param await_durable [Boolean] Whether to wait for durability (default: true)
+    # @param seqnum [Integer, nil] User-supplied sequence number applied to the
+    #   batch. See {#put} for semantics. (Requires SlateDB >= 0.13.0)
     # @return [void]
     #
     # @example Write a batch
@@ -248,11 +312,15 @@ module SlateDb
     #     b.put("key2", "value2")
     #   end
     #
-    def write(batch, await_durable: nil)
-      if await_durable.nil?
+    def write(batch, await_durable: nil, seqnum: nil)
+      opts = {}
+      opts[:await_durable] = await_durable unless await_durable.nil?
+      opts[:seqnum] = seqnum if seqnum
+
+      if opts.empty?
         _write(batch)
       else
-        _write_with_options(batch, { await_durable: await_durable })
+        _write_with_options(batch, opts)
       end
     end
 
@@ -262,6 +330,8 @@ module SlateDb
     # @param value [String] The merge operand to apply
     # @param ttl [Integer, nil] Time-to-live in milliseconds
     # @param await_durable [Boolean] Whether to wait for durability (default: true)
+    # @param seqnum [Integer, nil] User-supplied sequence number for this write.
+    #   See {#put} for semantics. (Requires SlateDB >= 0.13.0)
     # @return [void]
     #
     # @example Merge with string concatenation operator
@@ -269,10 +339,11 @@ module SlateDb
     #   db.merge("key", "part1")
     #   db.merge("key", "part2")
     #
-    def merge(key, value, ttl: nil, await_durable: nil)
+    def merge(key, value, ttl: nil, await_durable: nil, seqnum: nil)
       opts = {}
       opts[:ttl] = ttl if ttl
       opts[:await_durable] = await_durable unless await_durable.nil?
+      opts[:seqnum] = seqnum if seqnum
 
       if opts.empty?
         _merge(key, value)
@@ -284,6 +355,8 @@ module SlateDb
     # Create and write a batch using a block.
     #
     # @param await_durable [Boolean] Whether to wait for durability (default: true)
+    # @param seqnum [Integer, nil] User-supplied sequence number applied to the
+    #   batch. See {#put} for semantics. (Requires SlateDB >= 0.13.0)
     # @yield [batch] Yields a WriteBatch to the block
     # @return [void]
     #
@@ -294,10 +367,10 @@ module SlateDb
     #     b.delete("old_key")
     #   end
     #
-    def batch(await_durable: nil)
+    def batch(await_durable: nil, seqnum: nil)
       b = WriteBatch.new
       yield b
-      write(b, await_durable: await_durable)
+      write(b, await_durable: await_durable, seqnum: seqnum)
     end
 
     # Begin a new transaction.
@@ -414,5 +487,12 @@ module SlateDb
       opts[:name] = name if name
       _create_checkpoint(opts)
     end
+
+    # Get database metrics registry.
+    #
+    # @return [Metrics] Metrics registry
+    def metrics
+      _metrics
+    end
   end
 end

data/lib/slatedb/metrics.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SlateDb
+  class Metrics
+    # Get a metric value by name.
+    #
+    # @param name [String] Metric name
+    # @return [Integer, nil] Current value or nil if not found
+    def [](name)
+      get(name)
+    end
+
+    # Convert all metrics to a hash.
+    #
+    # @return [Hash] Map of metric name to value
+    def to_h
+      names.to_h { |metric_name| [metric_name, get(metric_name)] }
+    end
+  end
+end

data/lib/slatedb/reader.rb

@@ -11,6 +11,13 @@ module SlateDb
       # @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
+      # @param cache_root [String, nil] Root folder for the reader's local on-disk
+      #   object-store cache. Setting this enables the cached object store; when it is
+      #   not set the cache (and `max_open_file_handles`) has no effect.
+      # @param max_open_file_handles [Integer, nil] Maximum number of file handles to keep
+      #   open in the reader's file-handle cache. When the limit is reached, the least
+      #   recently used handle is closed (default: 1000). Only takes effect when
+      #   `cache_root` is set. (Requires SlateDB >= 0.13.0)
       # @param merge_operator [Symbol, String, nil] Optional merge operator ("string_concat" or "concat")
       # @yield [reader] If a block is given, yields the reader and ensures it's closed
       # @return [Reader] The opened reader (or block result if block given)
@@ -28,13 +35,21 @@ module SlateDb
       # @example Open at a specific checkpoint
       #   reader = SlateDb::Reader.open("/tmp/mydb", checkpoint_id: "uuid-here")
       #
+      # @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,
                manifest_poll_interval: nil, checkpoint_lifetime: nil,
-               max_memtable_bytes: nil, merge_operator: nil)
+               max_memtable_bytes: nil, cache_root: nil, max_open_file_handles: nil,
+               merge_operator: nil)
         opts = {}
         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
+        opts[:cache_root] = cache_root if cache_root
+        opts[:max_open_file_handles] = max_open_file_handles if max_open_file_handles
         opts[:merge_operator] = merge_operator.to_s if merge_operator
 
         reader = _open(path, url, checkpoint_id, opts)