deltalake-rb 0.1.7 → 0.2.1

data/ext/deltalake/Cargo.toml

@@ -1,24 +1,32 @@
 [package]
 name = "deltalake"
-version = "0.1.7"
+version = "0.2.1"
 license = "Apache-2.0"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2021"
-rust-version = "1.82.0"
+rust-version = "1.82"
 publish = false
 
 [lib]
 crate-type = ["cdylib"]
 
 [dependencies]
-arrow = { version = "55", features = ["ffi"] }
-arrow-schema = { version = "55", features = ["serde"] }
+arrow = { version = "55.2", features = ["ffi"] }
+arrow-schema = { version = "55.2", features = ["serde"] }
 chrono = "0.4"
-delta_kernel = "=0.10.0"
-deltalake = { version = "=0.26.0", features = ["azure", "datafusion", "gcs", "s3"] }
+delta_kernel = { version = "0.14", features = ["arrow-55", "default-engine-rustls"] }
 futures = "0.3"
-magnus = "0.7"
+magnus = "0.8"
 num_cpus = "1"
 serde = "1"
 serde_json = "1"
 tokio = { version = "1", features = ["rt-multi-thread"] }
+
+[dependencies.deltalake]
+version = "=0.28.0"
+features = [
+    "azure",
+    "datafusion",
+    "gcs",
+    "s3"
+]

data/ext/deltalake/src/error.rs

@@ -1,8 +1,7 @@
 use arrow_schema::ArrowError;
 use deltalake::datafusion::error::DataFusionError;
-use deltalake::protocol::ProtocolError;
 use deltalake::{errors::DeltaTableError, ObjectStoreError};
-use magnus::{exception, Error as RbErr, Module, RModule, Ruby};
+use magnus::{Error as RbErr, Module, RModule, Ruby};
 use std::borrow::Cow;
 
 macro_rules! create_exception {
@@ -42,7 +41,7 @@ fn inner_to_rb_err(err: DeltaTableError) -> RbErr {
         DeltaTableError::InvalidJsonLog { .. } => DeltaProtocolError::new_err(err.to_string()),
         DeltaTableError::InvalidStatsJson { .. } => DeltaProtocolError::new_err(err.to_string()),
         DeltaTableError::InvalidData { violations } => {
-            DeltaProtocolError::new_err(format!("Invariant violations: {:?}", violations))
+            DeltaProtocolError::new_err(format!("Invariant violations: {violations:?}"))
         }
 
         // commit errors
@@ -81,31 +80,12 @@ fn arrow_to_rb(err: ArrowError) -> RbErr {
     }
 }
 
-fn checkpoint_to_rb(err: ProtocolError) -> RbErr {
-    match err {
-        ProtocolError::Arrow { source } => arrow_to_rb(source),
-        ProtocolError::ObjectStore { source } => object_store_to_rb(source),
-        ProtocolError::EndOfLog => DeltaProtocolError::new_err("End of log"),
-        ProtocolError::NoMetaData => DeltaProtocolError::new_err("Table metadata missing"),
-        ProtocolError::CheckpointNotFound => DeltaProtocolError::new_err(err.to_string()),
-        ProtocolError::InvalidField(err) => RbValueError::new_err(err),
-        ProtocolError::InvalidRow(err) => RbValueError::new_err(err),
-        ProtocolError::InvalidDeletionVectorStorageType(err) => RbValueError::new_err(err),
-        ProtocolError::SerializeOperation { source } => RbValueError::new_err(source.to_string()),
-        ProtocolError::ParquetParseError { source } => RbIOError::new_err(source.to_string()),
-        ProtocolError::IO { source } => RbIOError::new_err(source.to_string()),
-        ProtocolError::Generic(msg) => DeltaError::new_err(msg),
-        ProtocolError::Kernel { source } => DeltaError::new_err(source.to_string()),
-    }
-}
-
 fn datafusion_to_rb(err: DataFusionError) -> RbErr {
     DeltaError::new_err(err.to_string())
 }
 
 pub enum RubyError {
     DeltaTable(DeltaTableError),
-    Protocol(ProtocolError),
     DataFusion(DataFusionError),
 }
 
@@ -115,12 +95,6 @@ impl From<DeltaTableError> for RubyError {
     }
 }
 
-impl From<ProtocolError> for RubyError {
-    fn from(err: ProtocolError) -> Self {
-        RubyError::Protocol(err)
-    }
-}
-
 impl From<DataFusionError> for RubyError {
     fn from(err: DataFusionError) -> Self {
         RubyError::DataFusion(err)
@@ -131,14 +105,13 @@ impl From<RubyError> for RbErr {
     fn from(value: RubyError) -> Self {
         match value {
             RubyError::DeltaTable(err) => inner_to_rb_err(err),
-            RubyError::Protocol(err) => checkpoint_to_rb(err),
             RubyError::DataFusion(err) => datafusion_to_rb(err),
         }
     }
 }
 
 macro_rules! create_builtin_exception {
-    ($type:ident, $class:expr) => {
+    ($type:ident, $method:ident) => {
         pub struct $type {}
 
         impl $type {
@@ -146,13 +119,14 @@ macro_rules! create_builtin_exception {
             where
                 T: Into<Cow<'static, str>>,
             {
-                RbErr::new($class, message)
+                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!(RbValueError, exception::arg_error());
+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!(RbValueError, exception_arg_error);

data/ext/deltalake/src/lib.rs

@@ -13,6 +13,7 @@ use std::time;
 
 use chrono::{DateTime, Duration, FixedOffset, Utc};
 use delta_kernel::schema::StructField;
+use delta_kernel::table_properties::DataSkippingNumIndexedCols;
 use deltalake::arrow::ffi_stream::{ArrowArrayStreamReader, FFI_ArrowArrayStream};
 use deltalake::arrow::record_batch::RecordBatchIterator;
 use deltalake::checkpoints::{cleanup_metadata, create_checkpoint};
@@ -21,8 +22,10 @@ use deltalake::datafusion::prelude::SessionContext;
 use deltalake::delta_datafusion::DeltaCdfTableProvider;
 use deltalake::errors::DeltaTableError;
 use deltalake::kernel::transaction::{CommitProperties, TableReference};
+use deltalake::kernel::StructDataExt;
 use deltalake::kernel::{scalars::ScalarExt, StructType, Transaction};
 use deltalake::logstore::IORuntime;
+use deltalake::logstore::LogStoreRef;
 use deltalake::operations::add_column::AddColumnBuilder;
 use deltalake::operations::add_feature::AddTableFeatureBuilder;
 use deltalake::operations::collect_sendable_stream;
@@ -39,25 +42,26 @@ use deltalake::parquet::basic::Compression;
 use deltalake::parquet::errors::ParquetError;
 use deltalake::parquet::file::properties::WriterProperties;
 use deltalake::partitions::PartitionFilter;
+use deltalake::table::config::TablePropertiesExt;
+use deltalake::table::state::DeltaTableState;
 use deltalake::{DeltaOps, DeltaResult};
 use error::DeltaError;
 use futures::future::join_all;
+use futures::TryStreamExt;
 
 use magnus::{
-    function, method, prelude::*, typed_data::Obj, Error, Integer, Module, RArray, RHash, Ruby,
-    TryConvert, Value,
+    function, method, prelude::*, try_convert::TryConvertOwned, typed_data::Obj, Error as RbErr,
+    Integer, Module, RArray, Ruby, TryConvert, Value,
 };
 use serde_json::Map;
 
-use crate::error::DeltaProtocolError;
-use crate::error::RbValueError;
-use crate::error::RubyError;
+use crate::error::{RbValueError, RubyError};
 use crate::features::TableFeatures;
 use crate::merge::RbMergeBuilder;
 use crate::schema::{schema_to_rbobject, Field};
 use crate::utils::rt;
 
-type RbResult<T> = Result<T, Error>;
+type RbResult<T> = Result<T, RbErr>;
 
 enum PartitionFilterValue {
     Single(String),
@@ -74,6 +78,8 @@ impl TryConvert for PartitionFilterValue {
     }
 }
 
+unsafe impl TryConvertOwned for PartitionFilterValue {}
+
 #[magnus::wrap(class = "DeltaLake::RawDeltaTable")]
 struct RawDeltaTable {
     _table: RefCell<deltalake::DeltaTable>,
@@ -86,7 +92,7 @@ struct RawDeltaTableMetaData {
     description: Option<String>,
     partition_columns: Vec<String>,
     created_time: Option<i64>,
-    configuration: HashMap<String, Option<String>>,
+    configuration: HashMap<String, String>,
 }
 
 impl RawDeltaTableMetaData {
@@ -110,13 +116,32 @@ impl RawDeltaTableMetaData {
         self.created_time
     }
 
-    fn configuration(&self) -> HashMap<String, Option<String>> {
+    fn configuration(&self) -> HashMap<String, String> {
         self.configuration.clone()
     }
 }
 
 type StringVec = Vec<String>;
 
+impl RawDeltaTable {
+    fn with_table<T>(&self, func: impl Fn(&deltalake::DeltaTable) -> RbResult<T>) -> RbResult<T> {
+        func(&self._table.borrow())
+    }
+
+    fn cloned_state(&self) -> RbResult<DeltaTableState> {
+        self.with_table(|t| {
+            t.snapshot()
+                .cloned()
+                .map_err(RubyError::from)
+                .map_err(RbErr::from)
+        })
+    }
+
+    fn log_store(&self) -> RbResult<LogStoreRef> {
+        self.with_table(|t| Ok(t.log_store().clone()))
+    }
+}
+
 impl RawDeltaTable {
     pub fn new(
         table_uri: String,
@@ -168,60 +193,58 @@ impl RawDeltaTable {
     }
 
     pub fn table_uri(&self) -> RbResult<String> {
-        Ok(self._table.borrow().table_uri())
+        self.with_table(|t| Ok(t.table_uri()))
     }
 
-    pub fn version(&self) -> RbResult<i64> {
-        Ok(self._table.borrow().version())
+    pub fn version(&self) -> RbResult<Option<i64>> {
+        self.with_table(|t| Ok(t.version()))
     }
 
     pub fn has_files(&self) -> RbResult<bool> {
-        Ok(self._table.borrow().config.require_files)
+        self.with_table(|t| Ok(t.config.require_files))
     }
 
     pub fn metadata(&self) -> RbResult<RawDeltaTableMetaData> {
-        let binding = self._table.borrow();
-        let metadata = binding.metadata().map_err(RubyError::from)?;
+        let metadata = self.with_table(|t| {
+            let snapshot = t.snapshot().map_err(RubyError::from).map_err(RbErr::from)?;
+            Ok(snapshot.metadata().clone())
+        })?;
         Ok(RawDeltaTableMetaData {
-            id: metadata.id.clone(),
-            name: metadata.name.clone(),
-            description: metadata.description.clone(),
-            partition_columns: metadata.partition_columns.clone(),
-            created_time: metadata.created_time,
-            configuration: metadata.configuration.clone(),
+            id: metadata.id().to_string(),
+            name: metadata.name().map(String::from),
+            description: metadata.description().map(String::from),
+            partition_columns: metadata.partition_columns().clone(),
+            created_time: metadata.created_time(),
+            configuration: metadata.configuration().clone(),
         })
     }
 
     pub fn protocol_versions(&self) -> RbResult<(i32, i32, Option<StringVec>, Option<StringVec>)> {
-        let binding = self._table.borrow();
-        let table_protocol = binding.protocol().map_err(RubyError::from)?;
+        let table_protocol = self.with_table(|t| {
+            let snapshot = t.snapshot().map_err(RubyError::from).map_err(RbErr::from)?;
+            Ok(snapshot.protocol().clone())
+        })?;
         Ok((
-            table_protocol.min_reader_version,
-            table_protocol.min_writer_version,
-            table_protocol
-                .writer_features
-                .as_ref()
-                .and_then(|features| {
-                    let empty_set = !features.is_empty();
-                    empty_set.then(|| {
-                        features
-                            .iter()
-                            .map(|v| v.to_string())
-                            .collect::<Vec<String>>()
-                    })
-                }),
-            table_protocol
-                .reader_features
-                .as_ref()
-                .and_then(|features| {
-                    let empty_set = !features.is_empty();
-                    empty_set.then(|| {
-                        features
-                            .iter()
-                            .map(|v| v.to_string())
-                            .collect::<Vec<String>>()
-                    })
-                }),
+            table_protocol.min_reader_version(),
+            table_protocol.min_writer_version(),
+            table_protocol.writer_features().and_then(|features| {
+                let empty_set = !features.is_empty();
+                empty_set.then(|| {
+                    features
+                        .iter()
+                        .map(|v| v.to_string())
+                        .collect::<Vec<String>>()
+                })
+            }),
+            table_protocol.reader_features().and_then(|features| {
+                let empty_set = !features.is_empty();
+                empty_set.then(|| {
+                    features
+                        .iter()
+                        .map(|v| v.to_string())
+                        .collect::<Vec<String>>()
+                })
+            }),
         ))
     }
 
@@ -237,31 +260,29 @@ impl RawDeltaTable {
             .map_err(RubyError::from)?)
     }
 
-    pub fn get_earliest_version(&self) -> RbResult<i64> {
-        Ok(rt()
-            .block_on(self._table.borrow().get_earliest_version())
-            .map_err(RubyError::from)?)
-    }
-
     pub fn get_num_index_cols(&self) -> RbResult<i32> {
-        Ok(self
-            ._table
-            .borrow()
-            .snapshot()
-            .map_err(RubyError::from)?
-            .config()
-            .num_indexed_cols())
+        self.with_table(|t| {
+            let n_cols = t
+                .snapshot()
+                .map_err(RubyError::from)?
+                .config()
+                .num_indexed_cols();
+            Ok(match n_cols {
+                DataSkippingNumIndexedCols::NumColumns(n_cols) => n_cols as i32,
+                DataSkippingNumIndexedCols::AllColumns => -1,
+            })
+        })
     }
 
     pub fn get_stats_columns(&self) -> RbResult<Option<Vec<String>>> {
-        Ok(self
-            ._table
-            .borrow()
-            .snapshot()
-            .map_err(RubyError::from)?
-            .config()
-            .stats_columns()
-            .map(|v| v.iter().map(|v| v.to_string()).collect::<Vec<String>>()))
+        self.with_table(|t| {
+            Ok(t.snapshot()
+                .map_err(RubyError::from)?
+                .config()
+                .data_skipping_stats_columns
+                .as_ref()
+                .map(|v| v.iter().map(|s| s.to_string()).collect::<Vec<String>>()))
+        })
     }
 
     pub fn load_with_datetime(&self, ds: String) -> RbResult<()> {
@@ -285,10 +306,14 @@ impl RawDeltaTable {
         if let Some(filters) = partition_filters {
             let filters = convert_partition_filters(filters).map_err(RubyError::from)?;
             Ok(self
-                ._table
-                .borrow()
-                .get_files_by_partitions(&filters)
-                .map_err(RubyError::from)?
+                .with_table(|t| {
+                    rt().block_on(async {
+                        t.get_files_by_partitions(&filters)
+                            .await
+                            .map_err(RubyError::from)
+                            .map_err(RbErr::from)
+                    })
+                })?
                 .into_iter()
                 .map(|p| p.to_string())
                 .collect())
@@ -296,8 +321,9 @@ impl RawDeltaTable {
             Ok(self
                 ._table
                 .borrow()
-                .get_files_iter()
+                .snapshot()
                 .map_err(RubyError::from)?
+                .file_paths_iter()
                 .map(|f| f.to_string())
                 .collect())
         }
@@ -307,31 +333,36 @@ impl RawDeltaTable {
         &self,
         partition_filters: Option<Vec<(String, String, PartitionFilterValue)>>,
     ) -> RbResult<Vec<String>> {
-        if !self._table.borrow().config.require_files {
+        if !self.with_table(|t| Ok(t.config.require_files))? {
             return Err(DeltaError::new_err("Table is initiated without files."));
         }
 
         if let Some(filters) = partition_filters {
             let filters = convert_partition_filters(filters).map_err(RubyError::from)?;
-            Ok(self
-                ._table
-                .borrow()
-                .get_file_uris_by_partitions(&filters)
-                .map_err(RubyError::from)?)
+            self.with_table(|t| {
+                rt().block_on(async {
+                    t.get_file_uris_by_partitions(&filters)
+                        .await
+                        .map_err(RubyError::from)
+                        .map_err(RbErr::from)
+                })
+            })
         } else {
-            Ok(self
-                ._table
-                .borrow()
-                .get_file_uris()
-                .map_err(RubyError::from)?
-                .collect())
+            self.with_table(|t| {
+                Ok(t.get_file_uris()
+                    .map_err(RubyError::from)
+                    .map_err(RbErr::from)?
+                    .collect::<Vec<String>>())
+            })
         }
     }
 
-    pub fn schema(&self) -> RbResult<Value> {
-        let binding = self._table.borrow();
-        let schema: &StructType = binding.get_schema().map_err(RubyError::from)?;
-        schema_to_rbobject(schema.to_owned())
+    pub fn schema(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
+        let schema: StructType = rb_self.with_table(|t| {
+            let snapshot = t.snapshot().map_err(RubyError::from).map_err(RbErr::from)?;
+            Ok(snapshot.schema().clone())
+        })?;
+        schema_to_rbobject(schema.to_owned(), ruby)
     }
 
     pub fn vacuum(
@@ -370,7 +401,7 @@ impl RawDeltaTable {
     pub fn compact_optimize(
         &self,
         partition_filters: Option<Vec<(String, String, PartitionFilterValue)>>,
-        target_size: Option<i64>,
+        target_size: Option<u64>,
         max_concurrent_tasks: Option<usize>,
         min_commit_interval: Option<u64>,
         writer_properties: Option<RbWriterProperties>,
@@ -419,7 +450,7 @@ impl RawDeltaTable {
         &self,
         z_order_columns: Vec<String>,
         partition_filters: Option<Vec<(String, String, PartitionFilterValue)>>,
-        target_size: Option<i64>,
+        target_size: Option<u64>,
         max_concurrent_tasks: Option<usize>,
         max_spill_size: usize,
         min_commit_interval: Option<u64>,
@@ -716,18 +747,19 @@ impl RawDeltaTable {
             .map_err(RubyError::from)?)
     }
 
-    fn get_active_partitions(&self) -> RbResult<RArray> {
-        let binding = self._table.borrow();
-        let _column_names: HashSet<&str> = binding
-            .get_schema()
-            .map_err(|_| DeltaProtocolError::new_err("table does not yet have a schema"))?
-            .fields()
-            .map(|field| field.name().as_str())
-            .collect();
-        let partition_columns: HashSet<&str> = binding
-            .metadata()
-            .map_err(RubyError::from)?
-            .partition_columns
+    fn get_active_partitions(ruby: &Ruby, rb_self: &Self) -> RbResult<RArray> {
+        let schema = rb_self.with_table(|t| {
+            let snapshot = t.snapshot().map_err(RubyError::from).map_err(RbErr::from)?;
+            Ok(snapshot.schema().clone())
+        })?;
+        let metadata = rb_self.with_table(|t| {
+            let snapshot = t.snapshot().map_err(RubyError::from).map_err(RbErr::from)?;
+            Ok(snapshot.metadata().clone())
+        })?;
+        let _column_names: HashSet<&str> =
+            schema.fields().map(|field| field.name().as_str()).collect();
+        let partition_columns: HashSet<&str> = metadata
+            .partition_columns()
             .iter()
             .map(|col| col.as_str())
             .collect();
@@ -736,12 +768,15 @@ impl RawDeltaTable {
 
         let partition_columns: Vec<&str> = partition_columns.into_iter().collect();
 
-        let adds = binding
-            .snapshot()
-            .map_err(RubyError::from)?
-            .get_active_add_actions_by_partitions(&converted_filters)
-            .map_err(RubyError::from)?
-            .collect::<Result<Vec<_>, _>>()
+        let state = rb_self.cloned_state()?;
+        let log_store = rb_self.log_store()?;
+        let adds: Vec<_> = rt()
+            .block_on(async {
+                state
+                    .get_active_add_actions_by_partitions(&log_store, &converted_filters)
+                    .try_collect()
+                    .await
+            })
             .map_err(RubyError::from)?;
         let active_partitions: HashSet<Vec<(&str, Option<String>)>> = adds
             .iter()
@@ -749,21 +784,22 @@ impl RawDeltaTable {
                 Ok::<_, RubyError>(
                     partition_columns
                         .iter()
-                        .flat_map(|col| {
-                            Ok::<_, RubyError>((
+                        .map(|col| {
+                            (
                                 *col,
                                 add.partition_values()
-                                    .map_err(RubyError::from)?
-                                    .get(*col)
+                                    .and_then(|v| {
+                                        v.index_of(col).and_then(|idx| v.value(idx).cloned())
+                                    })
                                     .map(|v| v.serialize()),
-                            ))
+                            )
                         })
                         .collect(),
                 )
             })
             .collect();
 
-        Ok(RArray::from_iter(active_partitions))
+        Ok(ruby.ary_from_iter(active_partitions))
     }
 
     pub fn create_checkpoint(&self) -> RbResult<()> {
@@ -781,15 +817,20 @@ impl RawDeltaTable {
     }
 
     pub fn get_add_file_sizes(&self) -> RbResult<HashMap<String, i64>> {
-        Ok(self
-            ._table
-            .borrow()
-            .snapshot()
-            .map_err(RubyError::from)?
-            .eager_snapshot()
-            .files()
-            .map(|f| (f.path().to_string(), f.size()))
-            .collect::<HashMap<String, i64>>())
+        self.with_table(|t| {
+            let log_store = t.log_store();
+            let sizes: HashMap<String, i64> = rt()
+                .block_on(async {
+                    t.snapshot()?
+                        .snapshot()
+                        .files(&log_store, None)
+                        .map_ok(|f| (f.path().to_string(), f.size()))
+                        .try_collect()
+                        .await
+                })
+                .map_err(RubyError::from)?;
+            Ok(sizes)
+        })
     }
 
     pub fn delete(
@@ -874,14 +915,13 @@ impl RawDeltaTable {
         Ok(serde_json::to_string(&metrics).unwrap())
     }
 
-    pub fn transaction_versions(&self) -> RHash {
-        RHash::from_iter(
-            self._table
-                .borrow()
-                .get_app_transaction_version()
-                .into_iter()
-                .map(|(app_id, transaction)| (app_id, RbTransaction::from(transaction))),
-        )
+    pub fn transaction_version(&self, app_id: String) -> RbResult<Option<i64>> {
+        // NOTE: this will simplify once we have moved logstore onto state.
+        let log_store = self.log_store()?;
+        let snapshot = self.with_table(|t| Ok(t.snapshot().map_err(RubyError::from)?.clone()))?;
+        Ok(rt()
+            .block_on(snapshot.transaction_version(log_store.as_ref(), app_id))
+            .map_err(RubyError::from)?)
     }
 }
 
@@ -1293,10 +1333,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "get_latest_version",
         method!(RawDeltaTable::get_latest_version, 0),
     )?;
-    class.define_method(
-        "get_earliest_version",
-        method!(RawDeltaTable::get_earliest_version, 0),
-    )?;
     class.define_method(
         "get_num_index_cols",
         method!(RawDeltaTable::get_num_index_cols, 0),
@@ -1366,8 +1402,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_method("repair", method!(RawDeltaTable::repair, 3))?;
     class.define_method(
-        "transaction_versions",
-        method!(RawDeltaTable::transaction_versions, 0),
+        "transaction_version",
+        method!(RawDeltaTable::transaction_version, 1),
     )?;
 
     let class = module.define_class("RawDeltaTableMetaData", ruby.class_object())?;
@@ -1394,6 +1430,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("to_i", method!(ArrowArrayStream::to_i, 0))?;
 
     let class = module.define_class("Field", ruby.class_object())?;
+    class.define_singleton_method("new", function!(Field::new, 2))?;
     class.define_method("name", method!(Field::name, 0))?;
     class.define_method("type", method!(Field::get_type, 0))?;
     class.define_method("nullable", method!(Field::nullable, 0))?;