deltalake-rb 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5cf17adf5a39ed09d967a1ea9dd0fa5c4164bfcb4ec8011e04d103860d00363
-  data.tar.gz: 9ef1fb9a89ef79635f96e3de774082d38941fe10467daec466bb29653c5a1950
+  metadata.gz: 16f0dd7fef3c4d05ba4f20bfb9b3580e7fd0b970c29df1e09f8c6419751fec76
+  data.tar.gz: 5c283e45ba6bfc0e329c84e04cc289a9e9093a4587de02a64fb9309dfdfb441d
 SHA512:
-  metadata.gz: 48d134fff281ad684da618f77a132e657b033b745bef5bb4459929d49a826f6023ef1a0a79c8bcb7c94f22dc90df7062b79b9fa0b93390e8d8847c987ba7582c
-  data.tar.gz: df3f375da00a57a2b50d9b2b335cc8a2c1164ce958df3e87d02a224b9e7cce34fcfdce046aaad59ede603e642dfd1b0396bc412e30405ebe09c30c2b7f10130b
+  metadata.gz: 47f7b19281515b0289de294165d02fe26d931f0d8b7fee59666772688acbe99effa3465a43605a72686d6c3f42d8403957954ee66cf3d62966265db8781d19cb
+  data.tar.gz: 938ca39e060cd9c1815b63510b3238d9da5afedcda3e3ab4adce177d0d89fffea29172a867fbef2786daf9c7c4cdf3992d7c7bd9a90f549e111222e70264f2fd

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.3.2 (2026-06-08)
+
+- Updated `deltalake` to 0.32.4
+
+## 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",
@@ -902,9 +902,9 @@ checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
 [[package]]
 name = "buoyant_kernel"
-version = "0.21.103"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "091ea1cbe1aa4ccda750be5267761d1508b94e98f3c004f08264ac9630ae5da5"
+checksum = "0d3ca37afa82755db7b4fd51a4eab9e53eeb0aa1898fae15d373bd6df4bdf0f8"
 dependencies = [
  "arrow",
  "buoyant_kernel_derive",
@@ -916,6 +916,7 @@ dependencies = [
  "itertools 0.14.0",
  "object_store",
  "parquet",
+ "percent-encoding",
  "rand 0.9.4",
  "reqwest 0.13.2",
  "roaring",
@@ -926,6 +927,7 @@ dependencies = [
  "thiserror 2.0.12",
  "tokio",
  "tracing",
+ "tracing-subscriber",
  "url",
  "uuid",
  "z85",
@@ -1101,9 +1103,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 +1118,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 +2063,9 @@ dependencies = [
 
 [[package]]
 name = "deltalake"
-version = "0.32.0"
+version = "0.32.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fa1982d9e81550676c64169e8e9feaaf8aafb218c88418a1e50642eecd2508e"
+checksum = "2695b91fd02afd5b4726a190fd58019674492d824e30598391390b0307644da8"
 dependencies = [
  "buoyant_kernel",
  "ctor",
@@ -2116,9 +2118,9 @@ dependencies = [
 
 [[package]]
 name = "deltalake-core"
-version = "0.32.0"
+version = "0.32.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fe744c5c69db390db74a114f7d5e412f1b5d8cc3dcef50bf19599035ad8fff6"
+checksum = "4588e95ff3b2ccdba56d9ec262bd3467c0593000f729402528706f62be8be1ca"
 dependencies = [
  "arrow",
  "arrow-arith",
@@ -2201,7 +2203,7 @@ dependencies = [
 
 [[package]]
 name = "deltalake-ruby"
-version = "0.3.0"
+version = "0.3.2"
 dependencies = [
  "arrow",
  "arrow-schema",
@@ -3183,9 +3185,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"
@@ -3312,6 +3314,15 @@ dependencies = [
  "minimal-lexical",
 ]
 
+[[package]]
+name = "nu-ansi-term"
+version = "0.50.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "num-bigint"
 version = "0.4.6"
@@ -4097,9 +4108,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",
@@ -4254,6 +4265,15 @@ dependencies = [
  "digest 0.11.2",
 ]
 
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
 [[package]]
 name = "shell-words"
 version = "1.1.0"
@@ -4536,6 +4556,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "thread_local"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "thrift"
 version = "0.17.0"
@@ -4749,6 +4778,32 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
 dependencies = [
  "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
+dependencies = [
+ "nu-ansi-term",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing-core",
+ "tracing-log",
 ]
 
 [[package]]
@@ -4886,6 +4941,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+
 [[package]]
 name = "version_check"
 version = "0.9.5"

data/ext/deltalake/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltalake-ruby"
-version = "0.3.0"
+version = "0.3.2"
 license = "Apache-2.0"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2021"
@@ -15,7 +15,7 @@ crate-type = ["cdylib"]
 arrow = { version = "58", features = ["ffi"] }
 arrow-schema = { version = "58", features = ["serde"] }
 chrono = "0.4"
-delta_kernel = { package = "buoyant_kernel", version = "0.21", features = ["arrow-58", "default-engine-rustls"] }
+delta_kernel = { package = "buoyant_kernel", version = "0.22", features = ["arrow-58", "default-engine-rustls"] }
 futures = "0.3"
 magnus = "0.8"
 num_cpus = "1"
@@ -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.4"
 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};
@@ -191,13 +193,13 @@ impl RawDeltaTable {
                 .with_io_runtime(IORuntime::default());
 
             if let Some(storage_options) = storage_options {
-                builder = builder.with_storage_options(storage_options)
+                builder = builder.with_storage_options(storage_options);
             }
             if let Some(version) = version {
-                builder = builder.with_version(version)
+                builder = builder.with_version(version);
             }
             if without_files {
-                builder = builder.without_files()
+                builder = builder.without_files();
             }
             if let Some(buf_size) = log_buffer_size {
                 builder = builder
@@ -222,7 +224,7 @@ impl RawDeltaTable {
         let mut builder = deltalake::DeltaTableBuilder::from_url(table_url)
             .map_err(|_| RbValueError::new_err("Failed to create table builder"))?;
         if let Some(storage_options) = storage_options {
-            builder = builder.with_storage_options(storage_options)
+            builder = builder.with_storage_options(storage_options);
         }
         Ok(rt()
             .block_on(async {
@@ -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)]
@@ -776,7 +832,7 @@ impl RawDeltaTable {
         let mut cmd = table.restore();
         if let Some(val) = target {
             if let Some(version) = Integer::from_value(val) {
-                cmd = cmd.with_version_to_restore(version.to_u64()?)
+                cmd = cmd.with_version_to_restore(version.to_u64()?);
             }
             if let Ok(ds) = String::try_convert(val) {
                 let datetime = DateTime::<Utc>::from(
@@ -784,7 +840,7 @@ impl RawDeltaTable {
                         RbValueError::new_err(format!("Failed to parse datetime string: {err}"))
                     })?,
                 );
-                cmd = cmd.with_datetime_to_restore(datetime)
+                cmd = cmd.with_datetime_to_restore(datetime);
             }
         }
         cmd = cmd.with_ignore_missing_files(ignore_missing_files);
@@ -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,
@@ -1077,32 +1243,32 @@ impl RawDeltaTable {
 
             if let Some(name) = &name {
                 builder = builder.with_table_name(name);
-            };
+            }
 
             if let Some(description) = &description {
                 builder = builder.with_description(description);
-            };
+            }
 
             if let Some(predicate) = predicate {
                 builder = builder.with_replace_where(predicate);
-            };
+            }
 
             if let Some(target_file_size) = target_file_size {
                 let target_file_size = NonZeroU64::new(target_file_size).ok_or_else(|| {
                     RubyError::ValueError("target_file_size must be greater than 0".to_string())
                 })?;
-                builder = builder.with_target_file_size(Some(target_file_size))
-            };
+                builder = builder.with_target_file_size(Some(target_file_size));
+            }
 
             if let Some(config) = configuration {
                 builder = builder.with_configuration(config);
-            };
+            }
 
             if let Some(commit_properties) =
                 maybe_create_commit_properties(commit_properties, post_commithook_properties)
             {
                 builder = builder.with_commit_properties(commit_properties);
-            };
+            }
 
             rt().block_on(builder.into_future())
                 .map_err(RubyError::from)
@@ -1249,11 +1415,11 @@ fn maybe_create_commit_properties(
             let json_metadata: Map<String, serde_json::Value> =
                 metadata.into_iter().map(|(k, v)| (k, v.into())).collect();
             commit_properties = commit_properties.with_metadata(json_metadata);
-        };
+        }
 
         if let Some(max_retries) = commit_props.max_commit_retries {
             commit_properties = commit_properties.with_max_retries(max_retries);
-        };
+        }
 
         if let Some(app_transactions) = commit_props.app_transactions {
             let app_transactions = app_transactions.iter().map(Transaction::from).collect();
@@ -1263,7 +1429,7 @@ fn maybe_create_commit_properties(
 
     if let Some(post_commit_hook_props) = post_commithook_properties {
         commit_properties =
-            set_post_commithook_properties(commit_properties, post_commit_hook_props)
+            set_post_commithook_properties(commit_properties, post_commit_hook_props);
     }
     Some(commit_properties)
 }
@@ -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/ext/deltalake/src/merge.rs

@@ -108,11 +108,11 @@ impl RbMergeBuilder {
             Some(cmd) => Some(
                 cmd.when_matched_update(|mut update| {
                     for (column, expression) in updates {
-                        update = update.update(column, expression)
+                        update = update.update(column, expression);
                     }
                     if let Some(predicate) = predicate {
-                        update = update.predicate(predicate)
-                    };
+                        update = update.predicate(predicate);
+                    }
                     update
                 })
                 .map_err(RubyError::from)?,
@@ -128,8 +128,8 @@ impl RbMergeBuilder {
             Some(cmd) => Some(
                 cmd.when_matched_delete(|mut delete| {
                     if let Some(predicate) = predicate {
-                        delete = delete.predicate(predicate)
-                    };
+                        delete = delete.predicate(predicate);
+                    }
                     delete
                 })
                 .map_err(RubyError::from)?,
@@ -149,11 +149,11 @@ impl RbMergeBuilder {
             Some(cmd) => Some(
                 cmd.when_not_matched_insert(|mut insert| {
                     for (column, expression) in updates {
-                        insert = insert.set(column, expression)
+                        insert = insert.set(column, expression);
                     }
                     if let Some(predicate) = predicate {
-                        insert = insert.predicate(predicate)
-                    };
+                        insert = insert.predicate(predicate);
+                    }
                     insert
                 })
                 .map_err(RubyError::from)?,
@@ -173,11 +173,11 @@ impl RbMergeBuilder {
             Some(cmd) => Some(
                 cmd.when_not_matched_by_source_update(|mut update| {
                     for (column, expression) in updates {
-                        update = update.update(column, expression)
+                        update = update.update(column, expression);
                     }
                     if let Some(predicate) = predicate {
-                        update = update.predicate(predicate)
-                    };
+                        update = update.predicate(predicate);
+                    }
                     update
                 })
                 .map_err(RubyError::from)?,
@@ -193,8 +193,8 @@ impl RbMergeBuilder {
             Some(cmd) => Some(
                 cmd.when_not_matched_by_source_delete(|mut delete| {
                     if let Some(predicate) = predicate {
-                        delete = delete.predicate(predicate)
-                    };
+                        delete = delete.predicate(predicate);
+                    }
                     delete
                 })
                 .map_err(RubyError::from)?,

data/lib/deltalake/version.rb

@@ -1,3 +1,3 @@
 module DeltaLake
-  VERSION = "0.3.0"
+  VERSION = "0.3.2"
 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.2
 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: []