deltalake-rb 0.2.9 → 0.3.1

data/ext/deltalake/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "deltalake-ruby"
-version = "0.2.9"
+version = "0.3.1"
 license = "Apache-2.0"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2021"
-rust-version = "1.82"
+rust-version = "1.91.1"
 publish = false
 
 [lib]
@@ -12,20 +12,21 @@ name = "deltalake"
 crate-type = ["cdylib"]
 
 [dependencies]
-arrow = { version = "57", features = ["ffi"] }
-arrow-schema = { version = "57", features = ["serde"] }
+arrow = { version = "58", features = ["ffi"] }
+arrow-schema = { version = "58", features = ["serde"] }
 chrono = "0.4"
-delta_kernel = { version = "0.19", features = ["arrow-57", "default-engine-rustls"] }
+delta_kernel = { package = "buoyant_kernel", version = "0.21", features = ["arrow-58", "default-engine-rustls"] }
 futures = "0.3"
 magnus = "0.8"
 num_cpus = "1"
+rb-sys = "0.9"
 serde = "1"
 serde_json = "1"
 tokio = { version = "1", features = ["rt-multi-thread"] }
 uuid = { version = "1", features = ["serde", "v4"] }
 
 [dependencies.deltalake]
-version = "=0.31.1"
+version = "=0.32.1"
 features = [
     "azure",
     "datafusion",

data/ext/deltalake/src/error.rs

@@ -4,6 +4,8 @@ use deltalake::{errors::DeltaTableError, ObjectStoreError};
 use magnus::{Error as RbErr, Module, RModule, Ruby};
 use std::borrow::Cow;
 
+use crate::ruby::{RbException, RbIOError, RbNotImplementedError, RbRuntimeError, RbValueError};
+
 macro_rules! create_exception {
     ($type:ident, $name:expr) => {
         pub struct $type {}
@@ -36,6 +38,10 @@ pub(crate) fn to_rt_err(msg: impl ToString) -> RbErr {
     RbRuntimeError::new_err(msg.to_string())
 }
 
+pub(crate) fn to_rt_err2(msg: impl ToString) -> RubyError {
+    RubyError::RuntimeError(msg.to_string())
+}
+
 fn inner_to_rb_err(err: DeltaTableError) -> RbErr {
     match err {
         DeltaTableError::NotATable(msg) => TableNotFoundError::new_err(msg),
@@ -89,6 +95,9 @@ fn datafusion_to_rb(err: DataFusionError) -> RbErr {
 pub enum RubyError {
     DeltaTable(DeltaTableError),
     DataFusion(DataFusionError),
+    // Ruby-specific errors for when GVL released
+    RuntimeError(String),
+    ValueError(String),
 }
 
 impl From<DeltaTableError> for RubyError {
@@ -108,28 +117,8 @@ impl From<RubyError> for RbErr {
         match value {
             RubyError::DeltaTable(err) => inner_to_rb_err(err),
             RubyError::DataFusion(err) => datafusion_to_rb(err),
+            RubyError::RuntimeError(err) => RbRuntimeError::new_err(err),
+            RubyError::ValueError(err) => RbValueError::new_err(err),
         }
     }
 }
-
-macro_rules! create_builtin_exception {
-    ($type:ident, $method:ident) => {
-        pub struct $type {}
-
-        impl $type {
-            pub fn new_err<T>(message: T) -> RbErr
-            where
-                T: Into<Cow<'static, str>>,
-            {
-                let ruby = Ruby::get().unwrap();
-                RbErr::new(ruby.$method(), message)
-            }
-        }
-    };
-}
-
-create_builtin_exception!(RbException, exception_runtime_error);
-create_builtin_exception!(RbIOError, exception_io_error);
-create_builtin_exception!(RbNotImplementedError, exception_not_imp_error);
-create_builtin_exception!(RbRuntimeError, exception_runtime_error);
-create_builtin_exception!(RbValueError, exception_arg_error);