slatedb 0.1.1 → 0.2.0

data/ext/slatedb/src/transaction.rs

@@ -2,8 +2,10 @@ use std::cell::RefCell;
 
 use magnus::prelude::*;
 use magnus::{method, Error, RHash, Ruby};
-use slatedb::config::{DurabilityLevel, PutOptions, ReadOptions, ScanOptions, Ttl, WriteOptions};
-use slatedb::DBTransaction;
+use slatedb::config::{
+    DurabilityLevel, MergeOptions, PutOptions, ReadOptions, ScanOptions, Ttl, WriteOptions,
+};
+use slatedb::DbTransaction;
 
 use crate::errors::{closed_error, invalid_argument_error, map_error};
 use crate::iterator::Iterator;
@@ -16,12 +18,12 @@ use crate::utils::get_optional;
 /// After commit or rollback, the transaction is closed.
 #[magnus::wrap(class = "SlateDb::Transaction", free_immediately, size)]
 pub struct Transaction {
-    inner: RefCell<Option<DBTransaction>>,
+    inner: RefCell<Option<DbTransaction>>,
 }
 
 impl Transaction {
-    /// Create a new Transaction from a DBTransaction.
-    pub fn new(txn: DBTransaction) -> Self {
+    /// Create a new Transaction from a DbTransaction.
+    pub fn new(txn: DbTransaction) -> Self {
         Self {
             inner: RefCell::new(Some(txn)),
         }
@@ -135,6 +137,48 @@ impl Transaction {
         Ok(())
     }
 
+    /// Merge a value within the transaction.
+    pub fn merge(&self, key: String, value: String) -> Result<(), Error> {
+        if key.is_empty() {
+            return Err(invalid_argument_error("key cannot be empty"));
+        }
+
+        let guard = self.inner.borrow();
+        let txn = guard
+            .as_ref()
+            .ok_or_else(|| closed_error("transaction is closed"))?;
+
+        txn.merge(key.as_bytes(), value.as_bytes())
+            .map_err(map_error)?;
+
+        Ok(())
+    }
+
+    /// Merge a value with options within the transaction.
+    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"));
+        }
+
+        let ttl = get_optional::<u64>(&kwargs, "ttl")?;
+        let merge_opts = MergeOptions {
+            ttl: match ttl {
+                Some(ms) => Ttl::ExpireAfter(ms),
+                None => Ttl::Default,
+            },
+        };
+
+        let guard = self.inner.borrow();
+        let txn = guard
+            .as_ref()
+            .ok_or_else(|| closed_error("transaction is closed"))?;
+
+        txn.merge_with_options(key.as_bytes(), value.as_bytes(), &merge_opts)
+            .map_err(map_error)?;
+
+        Ok(())
+    }
+
     /// Scan a range of keys within the transaction.
     pub fn scan(&self, start: String, end_key: Option<String>) -> Result<Iterator, Error> {
         if start.is_empty() {
@@ -219,6 +263,93 @@ impl Transaction {
         Ok(Iterator::new(iter))
     }
 
+    /// Scan all keys with a given prefix within the transaction.
+    pub fn scan_prefix(&self, prefix: String) -> Result<Iterator, Error> {
+        if prefix.is_empty() {
+            return Err(invalid_argument_error("prefix cannot be empty"));
+        }
+
+        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(prefix.as_bytes()).await })?;
+
+        Ok(Iterator::new(iter))
+    }
+
+    /// Scan all keys with a given prefix with options within the transaction.
+    pub fn scan_prefix_with_options(
+        &self,
+        prefix: String,
+        kwargs: RHash,
+    ) -> Result<Iterator, Error> {
+        if prefix.is_empty() {
+            return Err(invalid_argument_error("prefix cannot be empty"));
+        }
+
+        let mut opts = ScanOptions::default();
+
+        if let Some(df) = get_optional::<String>(&kwargs, "durability_filter")? {
+            opts.durability_filter = match df.as_str() {
+                "remote" => DurabilityLevel::Remote,
+                "memory" => DurabilityLevel::Memory,
+                other => {
+                    return Err(invalid_argument_error(&format!(
+                        "invalid durability_filter: {} (expected 'remote' or 'memory')",
+                        other
+                    )))
+                }
+            };
+        }
+
+        if let Some(dirty) = get_optional::<bool>(&kwargs, "dirty")? {
+            opts.dirty = dirty;
+        }
+
+        if let Some(rab) = get_optional::<usize>(&kwargs, "read_ahead_bytes")? {
+            opts.read_ahead_bytes = rab;
+        }
+
+        if let Some(cb) = get_optional::<bool>(&kwargs, "cache_blocks")? {
+            opts.cache_blocks = cb;
+        }
+
+        if let Some(mft) = get_optional::<usize>(&kwargs, "max_fetch_tasks")? {
+            opts.max_fetch_tasks = mft;
+        }
+
+        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 })?;
+
+        Ok(Iterator::new(iter))
+    }
+
+    /// Mark keys as read for conflict detection.
+    ///
+    /// This explicitly tracks reads for conflict checking in serializable isolation,
+    /// even when the keys weren't actually read via get().
+    ///
+    /// # Arguments
+    /// * `keys` - Array of keys to mark as read
+    pub fn mark_read(&self, keys: Vec<String>) -> Result<(), Error> {
+        let guard = self.inner.borrow();
+        let txn = guard
+            .as_ref()
+            .ok_or_else(|| closed_error("transaction is closed"))?;
+
+        let key_bytes: Vec<&[u8]> = keys.iter().map(|k| k.as_bytes()).collect();
+        txn.mark_read(&key_bytes).map_err(map_error)?;
+
+        Ok(())
+    }
+
     /// Commit the transaction.
     pub fn commit(&self) -> Result<(), Error> {
         let txn = self
@@ -275,11 +406,22 @@ pub fn define_transaction_class(ruby: &Ruby, module: &magnus::RModule) -> Result
         method!(Transaction::put_with_options, 3),
     )?;
     class.define_method("_delete", method!(Transaction::delete, 1))?;
+    class.define_method("_merge", method!(Transaction::merge, 2))?;
+    class.define_method(
+        "_merge_with_options",
+        method!(Transaction::merge_with_options, 3),
+    )?;
     class.define_method("_scan", method!(Transaction::scan, 2))?;
     class.define_method(
         "_scan_with_options",
         method!(Transaction::scan_with_options, 3),
     )?;
+    class.define_method("_scan_prefix", method!(Transaction::scan_prefix, 1))?;
+    class.define_method(
+        "_scan_prefix_with_options",
+        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_with_options",

data/ext/slatedb/src/utils.rs

@@ -2,8 +2,8 @@ use std::sync::Arc;
 
 use magnus::value::ReprValue;
 use magnus::{Error, RHash, Ruby, TryConvert};
-use object_store::aws::AmazonS3Builder;
-use object_store::ObjectStoreScheme;
+use slatedb::object_store::aws::AmazonS3Builder;
+use slatedb::object_store::{Error as ObjectStoreError, ObjectStore, ObjectStoreScheme};
 use slatedb::{Db, Error as SlateError};
 use url::Url;
 
@@ -24,7 +24,7 @@ pub fn get_optional<T: TryConvert>(hash: &RHash, key: &str) -> Result<Option<T>,
 }
 
 /// Convert an object_store error to a SlateDB error
-fn to_slate_error(e: object_store::Error) -> SlateError {
+fn to_slate_error(e: ObjectStoreError) -> SlateError {
     SlateError::unavailable(e.to_string())
 }
 
@@ -33,7 +33,7 @@ fn to_slate_error(e: object_store::Error) -> SlateError {
 /// This function handles S3 URLs specially to ensure environment variables
 /// like AWS_ACCESS_KEY_ID are properly recognized (the default object_store
 /// registry only recognizes lowercase variants like aws_access_key_id).
-pub fn resolve_object_store(url: &str) -> Result<Arc<dyn object_store::ObjectStore>, SlateError> {
+pub fn resolve_object_store(url: &str) -> Result<Arc<dyn ObjectStore>, SlateError> {
     let parsed_url: Url = url
         .try_into()
         .map_err(|e: url::ParseError| SlateError::invalid(format!("invalid URL: {}", e)))?;
@@ -44,6 +44,7 @@ pub fn resolve_object_store(url: &str) -> Result<Arc<dyn object_store::ObjectSto
     match scheme {
         ObjectStoreScheme::AmazonS3 => {
             // Use from_env() to properly handle uppercase AWS_* environment variables
+            // (the default object_store registry only recognizes lowercase variants)
             let store = AmazonS3Builder::from_env()
                 .with_url(url)
                 .build()

data/ext/slatedb/src/write_batch.rs

@@ -2,7 +2,7 @@ use std::cell::RefCell;
 
 use magnus::prelude::*;
 use magnus::{function, method, Error, RHash, Ruby};
-use slatedb::config::{PutOptions, Ttl};
+use slatedb::config::{MergeOptions, PutOptions, Ttl};
 use slatedb::WriteBatch as SlateWriteBatch;
 
 use crate::errors::invalid_argument_error;
@@ -72,6 +72,43 @@ impl WriteBatch {
         Ok(())
     }
 
+    /// Add a merge operation to the batch.
+    pub fn merge(&self, key: String, value: String) -> Result<(), Error> {
+        if key.is_empty() {
+            return Err(invalid_argument_error("key cannot be empty"));
+        }
+
+        self.inner
+            .borrow_mut()
+            .merge(key.as_bytes(), value.as_bytes());
+
+        Ok(())
+    }
+
+    /// Add a merge operation with options to the batch.
+    ///
+    /// Options:
+    /// - ttl: Time-to-live in milliseconds
+    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"));
+        }
+
+        let ttl = get_optional::<u64>(&kwargs, "ttl")?;
+        let merge_opts = MergeOptions {
+            ttl: match ttl {
+                Some(ms) => Ttl::ExpireAfter(ms),
+                None => Ttl::Default,
+            },
+        };
+
+        self.inner
+            .borrow_mut()
+            .merge_with_options(key.as_bytes(), value.as_bytes(), &merge_opts);
+
+        Ok(())
+    }
+
     /// Take ownership of the inner WriteBatch (consumes it).
     /// Used internally when writing the batch to the database.
     pub fn take(&self) -> Result<SlateWriteBatch, Error> {
@@ -93,6 +130,11 @@ pub fn define_write_batch_class(ruby: &Ruby, module: &magnus::RModule) -> Result
         method!(WriteBatch::put_with_options, 3),
     )?;
     class.define_method("_delete", method!(WriteBatch::delete, 1))?;
+    class.define_method("_merge", method!(WriteBatch::merge, 2))?;
+    class.define_method(
+        "_merge_with_options",
+        method!(WriteBatch::merge_with_options, 3),
+    )?;
 
     Ok(())
 }

data/lib/slatedb/database.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module SlateDb
-  class Database
+  class Database # rubocop:disable Metrics/ClassLength
     private_class_method :new
 
     class << self
@@ -9,6 +9,9 @@ module SlateDb
       #
       # @param path [String] The path identifier for the database
       # @param url [String, nil] Optional object store URL (e.g., "s3://bucket/path")
+      # @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.
       # @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)
       #
@@ -25,8 +28,29 @@ module SlateDb
       # @example Open with S3 backend
       #   db = SlateDb::Database.open("/tmp/mydb", url: "s3://mybucket/path")
       #
-      def open(path, url: nil)
-        db = _open(path, url)
+      # @example Open with a custom merge operator (Proc)
+      #   # Custom merge that adds numbers
+      #   db = SlateDb::Database.open("/tmp/mydb", merge_operator: ->(key, existing, new_val) {
+      #     existing_num = existing ? existing.to_i : 0
+      #     (existing_num + new_val.to_i).to_s
+      #   })
+      #   db.merge("counter", "5")
+      #   db.merge("counter", "3")
+      #   db.get("counter") # => "8"
+      #
+      def open(path, url: nil, merge_operator: nil)
+        opts = {}
+
+        case merge_operator
+        when Symbol, String
+          opts[:merge_operator] = merge_operator.to_s
+        when Proc
+          # Store the proc to prevent GC and pass to Rust
+          @_merge_operator_proc = merge_operator
+          opts[:merge_operator_proc] = merge_operator
+        end
+
+        db = _open(path, url, opts)
 
         if block_given?
           begin
@@ -168,6 +192,43 @@ module SlateDb
       end
     end
 
+    # Scan all keys with a given prefix.
+    #
+    # @param prefix [String] The key prefix to scan
+    # @param durability_filter [String, nil] Filter by durability level ("remote" or "memory")
+    # @param dirty [Boolean, nil] Whether to include uncommitted data
+    # @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
+    # @return [Iterator] An iterator over key-value pairs
+    #
+    # @example Scan all user keys
+    #   db.scan_prefix("user:") do |key, value|
+    #     puts "#{key}: #{value}"
+    #   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
+
+      iter = if opts.empty?
+               _scan_prefix(prefix)
+             else
+               _scan_prefix_with_options(prefix, opts)
+             end
+
+      if block_given?
+        iter.each(&)
+      else
+        iter
+      end
+    end
+
     # Write a batch of operations atomically.
     #
     # @param batch [WriteBatch] The batch to write
@@ -195,6 +256,31 @@ module SlateDb
       end
     end
 
+    # Merge a value into the database.
+    #
+    # @param key [String] The key to merge into
+    # @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)
+    # @return [void]
+    #
+    # @example Merge with string concatenation operator
+    #   db = SlateDb::Database.open("/tmp/mydb", merge_operator: :string_concat)
+    #   db.merge("key", "part1")
+    #   db.merge("key", "part2")
+    #
+    def merge(key, value, ttl: nil, await_durable: nil)
+      opts = {}
+      opts[:ttl] = ttl if ttl
+      opts[:await_durable] = await_durable unless await_durable.nil?
+
+      if opts.empty?
+        _merge(key, value)
+      else
+        _merge_with_options(key, value, opts)
+      end
+    end
+
     # Create and write a batch using a block.
     #
     # @param await_durable [Boolean] Whether to wait for durability (default: true)
@@ -308,5 +394,25 @@ module SlateDb
         snap
       end
     end
+
+    # Create a checkpoint of the database.
+    #
+    # @param lifetime [Integer, nil] Checkpoint lifetime in milliseconds
+    # @param name [String, nil] Optional name for the checkpoint
+    # @return [Hash] Hash with :id (UUID string) and :manifest_id (integer)
+    #
+    # @example Create a named checkpoint
+    #   checkpoint = db.create_checkpoint(name: "before-migration")
+    #   puts "Checkpoint ID: #{checkpoint[:id]}"
+    #
+    # @example Create a checkpoint with lifetime
+    #   checkpoint = db.create_checkpoint(lifetime: 3600_000) # 1 hour
+    #
+    def create_checkpoint(lifetime: nil, name: nil)
+      opts = {}
+      opts[:lifetime] = lifetime if lifetime
+      opts[:name] = name if name
+      _create_checkpoint(opts)
+    end
   end
 end

data/lib/slatedb/reader.rb

@@ -11,6 +11,7 @@ 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 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)
       #
@@ -29,11 +30,12 @@ module SlateDb
       #
       def open(path, url: nil, checkpoint_id: nil,
                manifest_poll_interval: nil, checkpoint_lifetime: nil,
-               max_memtable_bytes: nil)
+               max_memtable_bytes: 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[:merge_operator] = merge_operator.to_s if merge_operator
 
         reader = _open(path, url, checkpoint_id, opts)
 
@@ -101,5 +103,37 @@ module SlateDb
         iter
       end
     end
+
+    # Scan all keys with a given prefix.
+    #
+    # @param prefix [String] The key prefix to scan
+    # @param durability_filter [String, nil] Filter by durability level
+    # @param dirty [Boolean, nil] Whether to include uncommitted data
+    # @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
+    # @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
+
+      iter = if opts.empty?
+               _scan_prefix(prefix)
+             else
+               _scan_prefix_with_options(prefix, opts)
+             end
+
+      if block_given?
+        iter.each(&)
+      else
+        iter
+      end
+    end
   end
 end

data/lib/slatedb/snapshot.rb

@@ -50,5 +50,37 @@ module SlateDb
         iter
       end
     end
+
+    # Scan all keys with a given prefix from the snapshot.
+    #
+    # @param prefix [String] The key prefix to scan
+    # @param durability_filter [String, nil] Filter by durability level
+    # @param dirty [Boolean, nil] Whether to include uncommitted data
+    # @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
+    # @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
+
+      iter = if opts.empty?
+               _scan_prefix(prefix)
+             else
+               _scan_prefix_with_options(prefix, opts)
+             end
+
+      if block_given?
+        iter.each(&)
+      else
+        iter
+      end
+    end
   end
 end

data/lib/slatedb/transaction.rb

@@ -47,6 +47,21 @@ module SlateDb
       _delete(key)
     end
 
+    # Merge a value within the transaction.
+    #
+    # @param key [String] The key to merge into
+    # @param value [String] The merge operand to apply
+    # @param ttl [Integer, nil] Time-to-live in milliseconds
+    # @return [void]
+    #
+    def merge(key, value, ttl: nil)
+      if ttl
+        _merge_with_options(key, value, { ttl: ttl })
+      else
+        _merge(key, value)
+      end
+    end
+
     # Scan a range of keys within the transaction.
     #
     # @param start_key [String] The start key (inclusive)
@@ -74,5 +89,57 @@ module SlateDb
         iter
       end
     end
+
+    # Scan all keys with a given prefix within the transaction.
+    #
+    # @param prefix [String] The key prefix to scan
+    # @param durability_filter [String, nil] Filter by durability level
+    # @param dirty [Boolean, nil] Whether to include uncommitted data
+    # @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
+    # @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
+
+      iter = if opts.empty?
+               _scan_prefix(prefix)
+             else
+               _scan_prefix_with_options(prefix, opts)
+             end
+
+      if block_given?
+        iter.each(&)
+      else
+        iter
+      end
+    end
+
+    # Mark keys as read for conflict detection.
+    #
+    # This explicitly tracks reads for conflict checking in serializable isolation,
+    # allowing selective read-write conflict detection even when keys weren't
+    # actually read via get().
+    #
+    # @param keys [Array<String>] The keys to mark as read
+    # @return [void]
+    #
+    # @example Mark keys for conflict detection
+    #   db.transaction(isolation: :serializable) do |txn|
+    #     txn.mark_read(["key1", "key2"])
+    #     # These keys will now be checked for conflicts on commit
+    #     txn.put("key3", "value")
+    #   end
+    #
+    def mark_read(keys)
+      _mark_read(Array(keys))
+    end
   end
 end

data/lib/slatedb/version.rb

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

data/lib/slatedb/write_batch.rb

@@ -34,5 +34,25 @@ module SlateDb
       _delete(key)
       self
     end
+
+    # Add a merge operation to the batch.
+    #
+    # @param key [String] The key to merge into
+    # @param value [String] The merge operand to apply
+    # @param ttl [Integer, nil] Time-to-live in milliseconds
+    # @return [self] Returns self for method chaining
+    #
+    # @example
+    #   batch.merge("key", "part1")
+    #   batch.merge("key", "part2", ttl: 30_000)
+    #
+    def merge(key, value, ttl: nil)
+      if ttl
+        _merge_with_options(key, value, { ttl: ttl })
+      else
+        _merge(key, value)
+      end
+      self
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slatedb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - SlateDB Contributors
@@ -97,6 +97,7 @@ files:
 - ext/slatedb/src/errors.rs
 - ext/slatedb/src/iterator.rs
 - ext/slatedb/src/lib.rs
+- ext/slatedb/src/merge_ops.rs
 - ext/slatedb/src/reader.rs
 - ext/slatedb/src/runtime.rs
 - ext/slatedb/src/snapshot.rs
@@ -134,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.2
 specification_version: 4
 summary: Ruby bindings for SlateDB
 test_files: []