deltalake-rb 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5cf17adf5a39ed09d967a1ea9dd0fa5c4164bfcb4ec8011e04d103860d00363
-  data.tar.gz: 9ef1fb9a89ef79635f96e3de774082d38941fe10467daec466bb29653c5a1950
+  metadata.gz: ea5a918bf03fd3ebe4068b9a8b57d789ac6df2d302612f69782ad3b456f46cce
+  data.tar.gz: 40ae881f94ea68aa01f4a34eec07f343ea2689254e695714a177c262ee337e11
 SHA512:
-  metadata.gz: 48d134fff281ad684da618f77a132e657b033b745bef5bb4459929d49a826f6023ef1a0a79c8bcb7c94f22dc90df7062b79b9fa0b93390e8d8847c987ba7582c
-  data.tar.gz: df3f375da00a57a2b50d9b2b335cc8a2c1164ce958df3e87d02a224b9e7cce34fcfdce046aaad59ede603e642dfd1b0396bc412e30405ebe09c30c2b7f10130b
+  metadata.gz: 8c8c4c92f8dddb8650bf97a46f8729525cdfadcad3768e6b791ed88a7531a6f78028afbd6cf7aaf0a1b089003849fe365435d556606953469e60ec17233156a6
+  data.tar.gz: 1acdfab5067d69bf657c1acac3cf103424734c5cde928c1ef15fb4825df359bd78c5051688f68e1fe4755ba452ba2c0b5ef57375921497051b9756aa58ad4191

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.3.1 (2026-05-14)
+
+- Updated `deltalake` to 0.32.1
+
 ## 0.3.0 (2026-04-22)
 
 - Updated `deltalake` to 0.32.0

data/Cargo.lock

@@ -306,9 +306,9 @@ dependencies = [
 
 [[package]]
 name = "async-compression"
-version = "0.4.41"
+version = "0.4.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0f9ee0f6e02ffd7ad5816e9464499fba7b3effd01123b515c41d1697c43dad1"
+checksum = "e79b3f8a79cccc2898f31920fc69f304859b3bd567490f75ebf51ae1c792a9ac"
 dependencies = [
  "compression-codecs",
  "compression-core",
@@ -1101,9 +1101,9 @@ dependencies = [
 
 [[package]]
 name = "compression-codecs"
-version = "0.4.37"
+version = "0.4.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb7b51a7d9c967fc26773061ba86150f19c50c0d65c887cb1fbe295fd16619b7"
+checksum = "ce2548391e9c1929c21bf6aa2680af86fe4c1b33e6cea9ac1cfeec0bd11218cf"
 dependencies = [
  "bzip2",
  "compression-core",
@@ -1116,9 +1116,9 @@ dependencies = [
 
 [[package]]
 name = "compression-core"
-version = "0.4.31"
+version = "0.4.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d"
+checksum = "cc14f565cf027a105f7a44ccf9e5b424348421a1d8952a8fc9d499d313107789"
 
 [[package]]
 name = "const-oid"
@@ -2061,9 +2061,9 @@ dependencies = [
 
 [[package]]
 name = "deltalake"
-version = "0.32.0"
+version = "0.32.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fa1982d9e81550676c64169e8e9feaaf8aafb218c88418a1e50642eecd2508e"
+checksum = "8268de472e1692b47d4a3016d3443fa7aa1f24d5a92337ee867204951959c293"
 dependencies = [
  "buoyant_kernel",
  "ctor",
@@ -2116,9 +2116,9 @@ dependencies = [
 
 [[package]]
 name = "deltalake-core"
-version = "0.32.0"
+version = "0.32.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fe744c5c69db390db74a114f7d5e412f1b5d8cc3dcef50bf19599035ad8fff6"
+checksum = "4b6f1d41164959efaaae6d77fc00f9609ec59159ad4d0278924e79a0738f61b0"
 dependencies = [
  "arrow",
  "arrow-arith",
@@ -2201,7 +2201,7 @@ dependencies = [
 
 [[package]]
 name = "deltalake-ruby"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "arrow",
  "arrow-schema",
@@ -2268,7 +2268,7 @@ dependencies = [
  "libc",
  "option-ext",
  "redox_users",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -2768,7 +2768,7 @@ dependencies = [
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.6.0",
+ "socket2 0.5.10",
  "system-configuration",
  "tokio",
  "tower-service",
@@ -3183,9 +3183,9 @@ dependencies = [
 
 [[package]]
 name = "link-section"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "468808413fa8bdf0edbe61c2bbc182dfc59885b94f496cf3fb42c9c96b1e0149"
+checksum = "b685d66585d646efe09fec763d796c291049c8b6bf84e04954bffc8748341f0d"
 
 [[package]]
 name = "linux-raw-sys"
@@ -3724,7 +3724,7 @@ dependencies = [
  "once_cell",
  "socket2 0.5.10",
  "tracing",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4028,7 +4028,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4086,7 +4086,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4097,9 +4097,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.12"
+version = "0.103.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8279bb85272c9f10811ae6a6c547ff594d6a7f3c6c6b02ee9726d1d0dcfcdd06"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
 dependencies = [
  "aws-lc-rs",
  "ring",
@@ -4369,7 +4369,7 @@ dependencies = [
  "cfg-if",
  "libc",
  "psm",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4493,7 +4493,7 @@ dependencies = [
  "getrandom 0.3.3",
  "once_cell",
  "rustix",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -5103,7 +5103,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]

data/ext/deltalake/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltalake-ruby"
-version = "0.3.0"
+version = "0.3.1"
 license = "Apache-2.0"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2021"
@@ -26,7 +26,7 @@ tokio = { version = "1", features = ["rt-multi-thread"] }
 uuid = { version = "1", features = ["serde", "v4"] }
 
 [dependencies.deltalake]
-version = "=0.32.0"
+version = "=0.32.1"
 features = [
     "azure",
     "datafusion",

data/ext/deltalake/src/lib.rs

@@ -6,7 +6,7 @@ mod schema;
 mod utils;
 
 use chrono::{DateTime, Duration, FixedOffset, Utc};
-use delta_kernel::schema::StructField;
+use delta_kernel::schema::{MetadataValue, StructField};
 use delta_kernel::table_properties::DataSkippingNumIndexedCols;
 use deltalake::arrow::ffi_stream::{ArrowArrayStreamReader, FFI_ArrowArrayStream};
 use deltalake::arrow::record_batch::RecordBatchIterator;
@@ -22,10 +22,12 @@ use deltalake::logstore::IORuntime;
 use deltalake::logstore::LogStoreRef;
 use deltalake::operations::collect_sendable_stream;
 use deltalake::operations::optimize::OptimizeType;
+use deltalake::operations::update_table_metadata::TableMetadataUpdate;
 use deltalake::parquet::basic::Compression;
 use deltalake::parquet::errors::ParquetError;
 use deltalake::parquet::file::properties::WriterProperties;
 use deltalake::partitions::PartitionFilter;
+use deltalake::protocol::log_compaction::compact_logs;
 use deltalake::table::config::TablePropertiesExt;
 use deltalake::table::state::DeltaTableState;
 use deltalake::{DeltaResult, DeltaTable};
@@ -470,6 +472,49 @@ impl RawDeltaTable {
         Ok(metrics.files_deleted)
     }
 
+    #[allow(clippy::too_many_arguments)]
+    pub fn update(
+        rb: &Ruby,
+        self_: &Self,
+        updates: HashMap<String, String>,
+        predicate: Option<String>,
+        writer_properties: Option<RbWriterProperties>,
+        safe_cast: bool,
+        commit_properties: Option<RbCommitProperties>,
+        post_commithook_properties: Option<RbPostCommitHookProperties>,
+    ) -> RbResult<String> {
+        let (table, metrics) = rb
+            .detach(|| {
+                let table = self_._table.lock().map_err(to_rt_err2)?.clone();
+                let mut cmd = table.update().with_safe_cast(safe_cast);
+
+                if let Some(writer_props) = writer_properties {
+                    cmd = cmd.with_writer_properties(
+                        set_writer_properties(writer_props).map_err(RubyError::from)?,
+                    );
+                }
+
+                for (col_name, expression) in updates {
+                    cmd = cmd.with_update(col_name.clone(), expression.clone());
+                }
+
+                if let Some(update_predicate) = predicate {
+                    cmd = cmd.with_predicate(update_predicate);
+                }
+
+                if let Some(commit_properties) =
+                    maybe_create_commit_properties(commit_properties, post_commithook_properties)
+                {
+                    cmd = cmd.with_commit_properties(commit_properties);
+                }
+
+                rt().block_on(cmd.into_future()).map_err(RubyError::from)
+            })
+            .map_err(RbErr::from)?;
+        self_.set_state(table.state)?;
+        Ok(serde_json::to_string(&metrics).unwrap())
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub fn compact_optimize(
         rb: &Ruby,
@@ -664,8 +709,16 @@ impl RawDeltaTable {
         Ok(())
     }
 
+    pub fn generate(&self) -> RbResult<()> {
+        let table = self._table.lock().map_err(to_rt_err)?.clone();
+        rt().block_on(async { table.generate().await })
+            .map_err(RubyError::from)?;
+        Ok(())
+    }
+
     pub fn load_cdf(
-        &self,
+        rb: &Ruby,
+        self_: &Self,
         starting_version: Option<Version>,
         ending_version: Option<Version>,
         starting_timestamp: Option<String>,
@@ -673,7 +726,7 @@ impl RawDeltaTable {
         columns: Option<Vec<String>>,
     ) -> RbResult<ArrowArrayStream> {
         let ctx = SessionContext::new();
-        let table = self._table.lock().map_err(to_rt_err)?.clone();
+        let table = self_._table.lock().map_err(to_rt_err)?.clone();
         let mut cmd = table.scan_cdf();
 
         if let Some(sv) = starting_version {
@@ -698,38 +751,41 @@ impl RawDeltaTable {
         let table_provider: Arc<dyn TableProvider> =
             Arc::new(DeltaCdfTableProvider::try_new(cmd).map_err(RubyError::from)?);
 
-        let plan = rt()
-            .block_on(async {
-                let mut df = ctx.read_table(table_provider)?;
-                if let Some(columns) = columns {
-                    let cols: Vec<_> = columns.iter().map(|c| c.as_ref()).collect();
-                    df = df.select_columns(&cols)?;
-                }
-                df.create_physical_plan().await
-            })
-            .map_err(RubyError::from)?;
+        rb.detach(|| {
+            let plan = rt()
+                .block_on(async {
+                    let mut df = ctx.read_table(table_provider)?;
+                    if let Some(columns) = columns {
+                        let cols: Vec<_> = columns.iter().map(|c| c.as_ref()).collect();
+                        df = df.select_columns(&cols)?;
+                    }
+                    df.create_physical_plan().await
+                })
+                .map_err(RubyError::from)?;
 
-        let mut tasks = vec![];
-        for p in 0..plan.properties().output_partitioning().partition_count() {
-            let inner_plan = plan.clone();
-            let partition_batch = inner_plan.execute(p, ctx.task_ctx()).unwrap();
-            let handle = rt().spawn(collect_sendable_stream(partition_batch));
-            tasks.push(handle);
-        }
+            let mut tasks = vec![];
+            for p in 0..plan.properties().output_partitioning().partition_count() {
+                let inner_plan = plan.clone();
+                let partition_batch = inner_plan.execute(p, ctx.task_ctx()).unwrap();
+                let handle = rt().spawn(collect_sendable_stream(partition_batch));
+                tasks.push(handle);
+            }
 
-        // This is unfortunate.
-        let batches = rt()
-            .block_on(join_all(tasks))
-            .into_iter()
-            .flatten()
-            .collect::<Result<Vec<Vec<_>>, _>>()
-            .unwrap()
-            .into_iter()
-            .flatten()
-            .map(Ok);
-        let batch_iter = RecordBatchIterator::new(batches, plan.schema());
-        let ffi_stream = FFI_ArrowArrayStream::new(Box::new(batch_iter));
-        Ok(ArrowArrayStream { stream: ffi_stream })
+            // This is unfortunate.
+            let batches = rt()
+                .block_on(join_all(tasks))
+                .into_iter()
+                .flatten()
+                .collect::<Result<Vec<Vec<_>>, _>>()
+                .unwrap()
+                .into_iter()
+                .flatten()
+                .map(Ok);
+            let batch_iter = RecordBatchIterator::new(batches, plan.schema());
+            let ffi_stream = FFI_ArrowArrayStream::new(Box::new(batch_iter));
+            Ok::<_, RubyError>(ArrowArrayStream { stream: ffi_stream })
+        })
+        .map_err(RbErr::from)
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -903,6 +959,34 @@ impl RawDeltaTable {
         .map_err(RbErr::from)
     }
 
+    pub fn compact_logs(
+        rb: &Ruby,
+        self_: &Self,
+        starting_version: u64,
+        ending_version: u64,
+    ) -> RbResult<()> {
+        rb.detach(|| {
+            let operation_id = Uuid::new_v4();
+
+            #[allow(clippy::await_holding_lock)]
+            let result = rt().block_on(async {
+                match self_._table.lock() {
+                    Ok(table) => {
+                        compact_logs(&table, starting_version, ending_version, Some(operation_id))
+                            .await
+                            .map_err(RubyError::from)
+                    }
+                    Err(e) => Err(RubyError::RuntimeError(e.to_string())),
+                }
+            });
+
+            result
+        })
+        .map_err(RbErr::from)?;
+
+        Ok(())
+    }
+
     pub fn cleanup_metadata(rb: &Ruby, self_: &Self) -> RbResult<()> {
         let (_result, new_state) = rb.detach(|| {
             let operation_id = Uuid::new_v4();
@@ -1009,6 +1093,54 @@ impl RawDeltaTable {
         Ok(())
     }
 
+    pub fn set_table_name(
+        &self,
+        name: String,
+        commit_properties: Option<RbCommitProperties>,
+        post_commithook_properties: Option<RbPostCommitHookProperties>,
+    ) -> RbResult<()> {
+        let update = TableMetadataUpdate {
+            name: Some(name),
+            description: None,
+        };
+        let table = self._table.lock().map_err(to_rt_err)?.clone();
+        let mut cmd = table.update_table_metadata().with_update(update);
+
+        if let Some(commit_properties) =
+            maybe_create_commit_properties(commit_properties, post_commithook_properties)
+        {
+            cmd = cmd.with_commit_properties(commit_properties);
+        }
+
+        let table = rt().block_on(cmd.into_future()).map_err(RubyError::from)?;
+        self.set_state(table.state)?;
+        Ok(())
+    }
+
+    pub fn set_table_description(
+        &self,
+        description: String,
+        commit_properties: Option<RbCommitProperties>,
+        post_commithook_properties: Option<RbPostCommitHookProperties>,
+    ) -> RbResult<()> {
+        let update = TableMetadataUpdate {
+            name: None,
+            description: Some(description),
+        };
+        let table = self._table.lock().map_err(to_rt_err)?.clone();
+        let mut cmd = table.update_table_metadata().with_update(update);
+
+        if let Some(commit_properties) =
+            maybe_create_commit_properties(commit_properties, post_commithook_properties)
+        {
+            cmd = cmd.with_commit_properties(commit_properties);
+        }
+
+        let table = rt().block_on(cmd.into_future()).map_err(RubyError::from)?;
+        self.set_state(table.state)?;
+        Ok(())
+    }
+
     pub fn repair(
         &self,
         dry_run: bool,
@@ -1038,6 +1170,40 @@ impl RawDeltaTable {
             .map_err(RubyError::from)?)
     }
 
+    pub fn set_column_metadata(
+        rb: &Ruby,
+        self_: &Self,
+        field_name: String,
+        metadata: HashMap<String, String>,
+        commit_properties: Option<RbCommitProperties>,
+        post_commithook_properties: Option<RbPostCommitHookProperties>,
+    ) -> RbResult<()> {
+        let table = rb
+            .detach(|| {
+                let table = self_._table.lock().map_err(to_rt_err2)?.clone();
+                let mut cmd = table
+                    .update_field_metadata()
+                    .with_field_name(&field_name)
+                    .with_metadata(
+                        metadata
+                            .iter()
+                            .map(|(k, v)| (k.clone(), MetadataValue::String(v.clone())))
+                            .collect(),
+                    );
+
+                if let Some(commit_properties) =
+                    maybe_create_commit_properties(commit_properties, post_commithook_properties)
+                {
+                    cmd = cmd.with_commit_properties(commit_properties)
+                }
+
+                rt().block_on(cmd.into_future()).map_err(RubyError::from)
+            })
+            .map_err(RbErr::from)?;
+        self_.set_state(table.state)?;
+        Ok(())
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub fn write(
         rb: &Ruby,
@@ -1511,6 +1677,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("file_uris", method!(RawDeltaTable::file_uris, 1))?;
     class.define_method("schema", method!(RawDeltaTable::schema, 0))?;
     class.define_method("vacuum", method!(RawDeltaTable::vacuum, 5))?;
+    class.define_method("update", method!(RawDeltaTable::update, 6))?;
     class.define_method(
         "compact_optimize",
         method!(RawDeltaTable::compact_optimize, 7),
@@ -1529,6 +1696,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "drop_constraints",
         method!(RawDeltaTable::drop_constraints, 2),
     )?;
+    class.define_method("generate", method!(RawDeltaTable::generate, 0))?;
     class.define_method("load_cdf", method!(RawDeltaTable::load_cdf, 5))?;
     class.define_method(
         "create_merge_builder",
@@ -1549,6 +1717,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "create_checkpoint",
         method!(RawDeltaTable::create_checkpoint, 0),
     )?;
+    class.define_method("compact_logs", method!(RawDeltaTable::compact_logs, 2))?;
     class.define_method(
         "cleanup_metadata",
         method!(RawDeltaTable::cleanup_metadata, 0),
@@ -1562,11 +1731,20 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "set_table_properties",
         method!(RawDeltaTable::set_table_properties, 2),
     )?;
+    class.define_method("set_table_name", method!(RawDeltaTable::set_table_name, 3))?;
+    class.define_method(
+        "set_table_description",
+        method!(RawDeltaTable::set_table_description, 3),
+    )?;
     class.define_method("repair", method!(RawDeltaTable::repair, 3))?;
     class.define_method(
         "transaction_version",
         method!(RawDeltaTable::transaction_version, 1),
     )?;
+    class.define_method(
+        "set_column_metadata",
+        method!(RawDeltaTable::set_column_metadata, 4),
+    )?;
     class.define_method("write", method!(RawDeltaTable::write, 12))?;
 
     let class = module.define_class("RawDeltaTableMetaData", ruby.class_object())?;

data/lib/deltalake/version.rb

@@ -1,3 +1,3 @@
 module DeltaLake
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deltalake-rb
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Andrew Kane
@@ -72,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Delta Lake for Ruby
 test_files: []