From 3c9ee4975716921bbdc97b88ff51eb78ab800f61 Mon Sep 17 00:00:00 2001 From: Christopher Prohm Date: Wed, 19 Jun 2024 21:08:21 +0200 Subject: [PATCH 1/5] Remove deprecated API --- Changes.md | 6 ++ serde_arrow/src/arrow2_impl/api.rs | 89 +------------------ serde_arrow/src/arrow2_impl/schema.rs | 9 +- serde_arrow/src/arrow_impl/api.rs | 92 +------------------- serde_arrow/src/arrow_impl/schema.rs | 9 +- serde_arrow/src/internal/schema/data_type.rs | 9 +- serde_arrow/src/lib.rs | 12 --- 7 files changed, 15 insertions(+), 211 deletions(-) diff --git a/Changes.md b/Changes.md index a33b7bb2..9aabb455 100644 --- a/Changes.md +++ b/Changes.md @@ -1,5 +1,11 @@ # Change log +## 0.12 + +- Remove `serde_arrow::schema::Schema` +- Remove `serde_arrow::ArrowBuilder` and `serde_arrow::Arrow2Builder` +- Use `impl serde::Serialize` instead of `&(impl serde::Serialize + ?Sized)` + ## 0.11.6 - Add `arrow=52` support diff --git a/serde_arrow/src/arrow2_impl/api.rs b/serde_arrow/src/arrow2_impl/api.rs index cf95b246..bd997275 100644 --- a/serde_arrow/src/arrow2_impl/api.rs +++ b/serde_arrow/src/arrow2_impl/api.rs @@ -8,97 +8,10 @@ use crate::{ _impl::arrow2::{array::Array, datatypes::Field}, internal::{ array_builder::ArrayBuilder, deserializer::Deserializer, error::Result, - schema::SerdeArrowSchema, serializer::Serializer, + serializer::Serializer, }, }; -/// Build arrow2 arrays record by record (*requires one of the `arrow2-*` -/// features*) -/// -/// The given items should be records (e.g., structs). To serialize items -/// encoding single values consider the [`Items`][crate::utils::Items] and -/// [`Item`][crate::utils::Item] wrappers. -/// -/// Example: -/// -/// ```rust -/// # fn main() -> serde_arrow::Result<()> { -/// # use serde_arrow::_impl::arrow2 as arrow2; -/// use arrow2::datatypes::{DataType, Field}; -/// use serde::Serialize; -/// use serde_arrow::Arrow2Builder; -/// -/// ##[derive(Serialize)] -/// struct Record { -/// a: Option, -/// b: u64, -/// } -/// -/// let mut builder = Arrow2Builder::new(&[ -/// Field::new("a", DataType::Float32, true), -/// Field::new("b", DataType::UInt64, false), -/// ])?; -/// -/// builder.push(&Record { a: Some(1.0), b: 2})?; -/// builder.push(&Record { a: Some(3.0), b: 4})?; -/// builder.push(&Record { a: Some(5.0), b: 5})?; -/// -/// builder.extend(&[ -/// Record { a: Some(6.0), b: 7}, -/// Record { a: Some(8.0), b: 9}, -/// Record { a: Some(10.0), b: 11}, -/// ])?; -/// -/// let arrays = builder.build_arrays()?; -/// # -/// # assert_eq!(arrays.len(), 2); -/// # assert_eq!(arrays[0].len(), 6); -/// # Ok(()) -/// # } -/// ``` -#[deprecated = "`Arrow2Builder` is deprecated. Use `ArrayBuilder` instead"] -pub struct Arrow2Builder(ArrayBuilder); - -#[allow(deprecated)] -impl std::fmt::Debug for Arrow2Builder { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "Arrow2Builder<...>") - } -} - -#[allow(deprecated)] -impl Arrow2Builder { - /// Build a new Arrow2Builder for the given fields - /// - /// This method may fail when unsupported data types are encountered in the - /// given fields. - /// - pub fn new(fields: &[Field]) -> Result { - let schema = SerdeArrowSchema::from_arrow2_fields(fields)?; - Ok(Self(ArrayBuilder::new(schema)?)) - } - - /// Add a single record to the arrays - /// - pub fn push(&mut self, item: &T) -> Result<()> { - self.0.push(item) - } - - /// Add multiple records to the arrays - /// - pub fn extend(&mut self, items: &T) -> Result<()> { - self.0.extend(items) - } - - /// Build the arrays from the rows pushed to far. - /// - /// This operation will reset the underlying buffers and start a new batch. - /// - pub fn build_arrays(&mut self) -> Result>> { - self.0.to_arrow2() - } -} - /// Build arrow2 arrays from the given items (*requires one of the `arrow2-*` /// features*) /// diff --git a/serde_arrow/src/arrow2_impl/schema.rs b/serde_arrow/src/arrow2_impl/schema.rs index 7b730ad2..f5a156b5 100644 --- a/serde_arrow/src/arrow2_impl/schema.rs +++ b/serde_arrow/src/arrow2_impl/schema.rs @@ -18,8 +18,7 @@ impl SerdeArrowSchema { Self::try_from(fields) } - /// This method is deprecated. Use - /// [`to_arrow2_fields`][SerdeArrowSchema::to_arrow2_fields] instead: + /// Build a vec of fields from a Schema object /// /// ```rust /// # fn main() -> serde_arrow::_impl::PanicOnError<()> { @@ -33,12 +32,6 @@ impl SerdeArrowSchema { /// # Ok(()) /// # } /// ``` - #[deprecated = "The method `get_arrow2_fields` is deprecated. Use `to_arrow2_fields` instead"] - pub fn get_arrow2_fields(&self) -> Result> { - Vec::::try_from(self) - } - - /// Build a vec of fields from a Schema object pub fn to_arrow2_fields(&self) -> Result> { Vec::::try_from(self) } diff --git a/serde_arrow/src/arrow_impl/api.rs b/serde_arrow/src/arrow_impl/api.rs index 50f6cf2b..ad0815c4 100644 --- a/serde_arrow/src/arrow_impl/api.rs +++ b/serde_arrow/src/arrow_impl/api.rs @@ -14,94 +14,6 @@ use crate::{ }, }; -/// Build arrow arrays record by record (*requires one of the `arrow-*` -/// features*) -/// -/// The given items should be records (e.g., structs). To serialize items -/// encoding single values consider the [`Items`][crate::utils::Items] and -/// [`Item`][crate::utils::Item] wrappers. -/// -/// Example: -/// -/// ```rust -/// # fn main() -> serde_arrow::Result<()> { -/// # use serde_arrow::_impl::arrow as arrow; -/// use arrow::datatypes::{DataType, Field}; -/// use serde::Serialize; -/// use serde_arrow::ArrowBuilder; -/// -/// ##[derive(Serialize)] -/// struct Record { -/// a: Option, -/// b: u64, -/// } -/// -/// let mut builder = ArrowBuilder::new(&[ -/// Field::new("a", DataType::Float32, true), -/// Field::new("b", DataType::UInt64, false), -/// ])?; -/// -/// builder.push(&Record { a: Some(1.0), b: 2})?; -/// builder.push(&Record { a: Some(3.0), b: 4})?; -/// builder.push(&Record { a: Some(5.0), b: 5})?; -/// -/// builder.extend(&[ -/// Record { a: Some(6.0), b: 7}, -/// Record { a: Some(8.0), b: 9}, -/// Record { a: Some(10.0), b: 11}, -/// ])?; -/// -/// let arrays = builder.build_arrays()?; -/// # -/// # assert_eq!(arrays.len(), 2); -/// # assert_eq!(arrays[0].len(), 6); -/// # Ok(()) -/// # } -/// ``` -#[deprecated = "`ArrowBuilder` is deprecated. Use `ArrayBuilder` instead"] -pub struct ArrowBuilder(ArrayBuilder); - -#[allow(deprecated)] -impl std::fmt::Debug for ArrowBuilder { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "ArrowBuilder<...>") - } -} - -#[allow(deprecated)] -impl ArrowBuilder { - /// Build a new ArrowBuilder for the given fields - /// - /// This method may fail when unsupported data types are encountered in the - /// given fields. - /// - pub fn new(fields: &[Field]) -> Result { - Ok(Self(ArrayBuilder::new(SerdeArrowSchema::try_from( - fields, - )?)?)) - } - - /// Add a single record to the arrays - /// - pub fn push(&mut self, item: &T) -> Result<()> { - self.0.push(item) - } - - /// Add multiple records to the arrays - /// - pub fn extend(&mut self, items: &T) -> Result<()> { - self.0.extend(items) - } - - /// Build the arrays from the rows pushed to far. - /// - /// This operation will reset the underlying buffers and start a new batch. - /// - pub fn build_arrays(&mut self) -> Result> { - self.0.to_arrow() - } -} - /// Build arrow arrays from the given items (*requires one of the `arrow-*` /// features*) /// @@ -109,7 +21,7 @@ impl ArrowBuilder { /// structs). To serialize items encoding single values consider the /// [`Items`][crate::utils::Items] wrapper. /// -/// To build arrays record by record use [`ArrowBuilder`]. To construct a record +/// To build arrays record by record use [`ArrayBuilder`]. To construct a record /// batch, consider using [`to_record_batch`]. /// /// Example: @@ -193,7 +105,7 @@ where /// structs). To serialize items encoding single values consider the /// [`Items`][crate::utils::Items] wrapper. /// -/// To build arrays record by record use [`ArrowBuilder`]. +/// To build arrays record by record use [`ArrayBuilder`]. /// /// Example: /// diff --git a/serde_arrow/src/arrow_impl/schema.rs b/serde_arrow/src/arrow_impl/schema.rs index 16784a64..0f872e27 100644 --- a/serde_arrow/src/arrow_impl/schema.rs +++ b/serde_arrow/src/arrow_impl/schema.rs @@ -18,8 +18,7 @@ impl SerdeArrowSchema { Self::try_from(fields) } - /// This method is deprecated. Use - /// [`to_arrow_fields`][SerdeArrowSchema::to_arrow_fields] instead: + /// Build a vec of fields from a Schema object /// /// ```rust /// # fn main() -> serde_arrow::_impl::PanicOnError<()> { @@ -33,12 +32,6 @@ impl SerdeArrowSchema { /// # Ok(()) /// # } /// ``` - #[deprecated = "The method `get_arrow_fields` is deprecated. Use `to_arrow_fields` instead"] - pub fn get_arrow_fields(&self) -> Result> { - Vec::::try_from(self) - } - - /// Build a vec of fields from a Schema object pub fn to_arrow_fields(&self) -> Result> { Vec::::try_from(self) } diff --git a/serde_arrow/src/internal/schema/data_type.rs b/serde_arrow/src/internal/schema/data_type.rs index a384f6fb..bfd70025 100644 --- a/serde_arrow/src/internal/schema/data_type.rs +++ b/serde_arrow/src/internal/schema/data_type.rs @@ -194,11 +194,10 @@ impl std::str::FromStr for GenericTimeUnit { fn from_str(s: &str) -> Result { match s { - // TODO: remove plural forms (were incorrectly supported in 0.11.x) - "Second" | "Seconds" => Ok(Self::Second), - "Millisecond" | "Milliseconds" => Ok(Self::Millisecond), - "Microsecond" | "Microseconds" => Ok(Self::Microsecond), - "Nanosecond" | "Nanoseconds" => Ok(Self::Nanosecond), + "Second" => Ok(Self::Second), + "Millisecond" => Ok(Self::Millisecond), + "Microsecond" => Ok(Self::Microsecond), + "Nanosecond" => Ok(Self::Nanosecond), s => fail!("Invalid time unit {s}"), } } diff --git a/serde_arrow/src/lib.rs b/serde_arrow/src/lib.rs index 64f6f8a9..44be12f0 100644 --- a/serde_arrow/src/lib.rs +++ b/serde_arrow/src/lib.rs @@ -325,20 +325,12 @@ mod arrow_impl; #[cfg(has_arrow)] pub use arrow_impl::api::{from_arrow, from_record_batch, to_arrow, to_record_batch}; -#[cfg(has_arrow)] -#[allow(deprecated)] -pub use arrow_impl::api::ArrowBuilder; - #[cfg(has_arrow2)] mod arrow2_impl; #[cfg(has_arrow2)] pub use arrow2_impl::api::{from_arrow2, to_arrow2}; -#[cfg(has_arrow2)] -#[allow(deprecated)] -pub use arrow2_impl::api::Arrow2Builder; - #[deny(missing_docs)] /// Helpers that may be useful when using `serde_arrow` pub mod utils { @@ -395,10 +387,6 @@ pub mod schema { Overwrites, SchemaLike, SerdeArrowSchema, Strategy, TracingOptions, STRATEGY_KEY, }; - /// Renamed to [`SerdeArrowSchema`] - #[deprecated = "serde_arrow::schema::Schema is deprecated. Use serde_arrow::schema::SerdeArrowSchema instead"] - pub type Schema = SerdeArrowSchema; - /// Support for [canonical extension types][ext-docs]. This module is experimental without semver guarantees. /// /// [ext-docs]: https://arrow.apache.org/docs/format/CanonicalExtensions.html From 5f08a069fbb1c8ce283808f944b351ba121b7507 Mon Sep 17 00:00:00 2001 From: Christopher Prohm Date: Wed, 19 Jun 2024 21:38:50 +0200 Subject: [PATCH 2/5] Use &[FieldRef] instead of &[Field] in arrow API --- Changes.md | 1 + serde_arrow/benches/groups/impls.rs | 11 +-- serde_arrow/src/_impl/docs/defs.rs | 4 +- serde_arrow/src/_impl/docs/quickstart.rs | 17 ++-- serde_arrow/src/arrow2_impl/api.rs | 2 +- serde_arrow/src/arrow_impl/api.rs | 20 ++--- serde_arrow/src/arrow_impl/deserialization.rs | 5 +- serde_arrow/src/arrow_impl/serialization.rs | 6 +- .../src/test_with_arrow/impls/union.rs | 84 +++++-------------- .../src/test_with_arrow/impls/utils.rs | 13 +-- .../issue_90_top_level_nulls_in_structs.rs | 6 +- .../src/test_with_arrow/items_wrapper.rs | 11 +-- .../serializer_deserializer.rs | 12 +-- 13 files changed, 69 insertions(+), 123 deletions(-) diff --git a/Changes.md b/Changes.md index 9aabb455..606c01cd 100644 --- a/Changes.md +++ b/Changes.md @@ -5,6 +5,7 @@ - Remove `serde_arrow::schema::Schema` - Remove `serde_arrow::ArrowBuilder` and `serde_arrow::Arrow2Builder` - Use `impl serde::Serialize` instead of `&(impl serde::Serialize + ?Sized)` +- Use `&[FieldRef]` instead of `&[Field]` in arrow APIs ## 0.11.6 diff --git a/serde_arrow/benches/groups/impls.rs b/serde_arrow/benches/groups/impls.rs index d8a044f8..1d5e2a80 100644 --- a/serde_arrow/benches/groups/impls.rs +++ b/serde_arrow/benches/groups/impls.rs @@ -13,6 +13,7 @@ macro_rules! define_benchmark { ) => { pub fn benchmark_serialize(c: &mut criterion::Criterion) { use serde_arrow::schema::{SerdeArrowSchema, SchemaLike}; + use serde_arrow::_impl::arrow::datatypes::FieldRef; for n in [$($n),*] { let mut group = c.benchmark_group(format!("{}_serialize({})", stringify!($name), n)); @@ -33,7 +34,7 @@ macro_rules! define_benchmark { .map(|_| <$ty>::random(&mut rng)) .collect::>(); let schema = SerdeArrowSchema::from_samples(&items, Default::default()).unwrap(); - let arrow_fields = schema.to_arrow_fields().unwrap(); + let arrow_fields = Vec::::try_from(&schema).unwrap(); let arrow2_fields = schema.to_arrow2_fields().unwrap(); #[allow(unused)] @@ -93,10 +94,10 @@ pub mod serde_arrow_arrow { use serde::Serialize; use serde_arrow::{ Result, - _impl::arrow::{array::ArrayRef, datatypes::Field}, + _impl::arrow::{array::ArrayRef, datatypes::FieldRef}, }; - pub fn serialize(fields: &[Field], items: &T) -> Result> + pub fn serialize(fields: &[FieldRef], items: &T) -> Result> where T: Serialize + ?Sized, { @@ -132,10 +133,10 @@ pub mod arrow { use serde_arrow::{ Error, Result, - _impl::arrow::{array::ArrayRef, datatypes::Field}, + _impl::arrow::{array::ArrayRef, datatypes::FieldRef}, }; - pub fn serialize(fields: &[Field], items: &[T]) -> Result> + pub fn serialize(fields: &[FieldRef], items: &[T]) -> Result> where T: Serialize, { diff --git a/serde_arrow/src/_impl/docs/defs.rs b/serde_arrow/src/_impl/docs/defs.rs index 295ea335..3320c2fa 100644 --- a/serde_arrow/src/_impl/docs/defs.rs +++ b/serde_arrow/src/_impl/docs/defs.rs @@ -22,12 +22,12 @@ pub fn example_record_batch() -> crate::_impl::arrow::array::RecordBatch { } #[cfg(has_arrow)] -pub fn example_arrow_arrays() -> (Vec, Vec) { +pub fn example_arrow_arrays() -> (Vec, Vec) { use crate::schema::{SchemaLike, TracingOptions}; let items = example_records(); - let fields = Vec::::from_type::(TracingOptions::default()).unwrap(); + let fields = Vec::::from_type::(TracingOptions::default()).unwrap(); let arrays = crate::to_arrow(&fields, &items).unwrap(); (fields, arrays) diff --git a/serde_arrow/src/_impl/docs/quickstart.rs b/serde_arrow/src/_impl/docs/quickstart.rs index 08800dc5..280a9a8b 100644 --- a/serde_arrow/src/_impl/docs/quickstart.rs +++ b/serde_arrow/src/_impl/docs/quickstart.rs @@ -16,7 +16,7 @@ //! # #[cfg(has_arrow)] //! # fn main() { //! # use serde_arrow::_impl::arrow as arrow; -//! use arrow::datatypes::{DataType, Field}; +//! use arrow::datatypes::{DataType, FieldRef}; //! use serde_arrow::{ //! schema::{SchemaLike, Strategy, TracingOptions}, //! utils::{Item, Items}, @@ -37,7 +37,7 @@ //! ```rust //! # #[cfg(has_arrow)] //! # fn main() -> serde_arrow::_impl::PanicOnError<()> { -//! # use serde_arrow::_impl::arrow::datatypes::{DataType, Field}; +//! # use serde_arrow::_impl::arrow::datatypes::{DataType, FieldRef}; //! # use serde_arrow::{schema::{SchemaLike, TracingOptions}, utils::Item}; //! use chrono::NaiveDateTime; //! @@ -46,7 +46,7 @@ //! // ... //! ]; //! -//! let fields = Vec::::from_samples(items, TracingOptions::default())?; +//! let fields = Vec::::from_samples(items, TracingOptions::default())?; //! assert_eq!(fields[0].data_type(), &DataType::LargeUtf8); //! # Ok(()) //! # } @@ -74,6 +74,7 @@ //! ```rust //! # #[cfg(has_arrow)] //! # fn main() -> serde_arrow::_impl::PanicOnError<()> { +//! # use std::sync::Arc; //! # use serde_arrow::_impl::arrow::datatypes::{DataType, Field}; //! # use serde_arrow::utils::Item; //! let records: &[Item] = &[ @@ -81,7 +82,7 @@ //! Item(9 * 60 * 60 * 24 * 1000), //! ]; //! -//! let fields = vec![Field::new("item", DataType::Date64, false)]; +//! let fields = vec![Arc::new(Field::new("item", DataType::Date64, false))]; //! let arrays = serde_arrow::to_arrow(&fields, records)?; //! # Ok(()) //! # } @@ -95,7 +96,7 @@ //! ```rust //! # #[cfg(has_arrow)] //! # fn main() -> serde_arrow::_impl::PanicOnError<()> { -//! # use serde_arrow::_impl::arrow::datatypes::Field; +//! # use serde_arrow::_impl::arrow::datatypes::FieldRef; //! # use serde_arrow::{schema::SchemaLike, utils::Item}; //! use std::str::FromStr; //! @@ -107,7 +108,7 @@ //! Item(BigDecimal::from_str("4.56").unwrap()), //! ]; //! -//! let fields = Vec::::from_value(&json!([ +//! let fields = Vec::::from_value(&json!([ //! {"name": "item", "data_type": "Decimal128(5, 2)"}, //! ]))?; //! @@ -145,10 +146,10 @@ //! ```rust //! # #[cfg(has_arrow)] //! # fn main() -> serde_arrow::_impl::PanicOnError<()> { -//! # use serde_arrow::_impl::arrow::datatypes::Field; +//! # use serde_arrow::_impl::arrow::datatypes::FieldRef; //! # use serde_arrow::{schema::{SchemaLike, TracingOptions}, utils::Item}; //! let items = &[Item("foo"), Item("bar")]; -//! let fields = Vec::::from_samples( +//! let fields = Vec::::from_samples( //! items, //! TracingOptions::default().string_dictionary_encoding(true), //! )?; diff --git a/serde_arrow/src/arrow2_impl/api.rs b/serde_arrow/src/arrow2_impl/api.rs index bd997275..c0352f8e 100644 --- a/serde_arrow/src/arrow2_impl/api.rs +++ b/serde_arrow/src/arrow2_impl/api.rs @@ -19,7 +19,7 @@ use crate::{ /// structs). To serialize items encoding single values consider the /// [`Items`][crate::utils::Items] wrapper. /// -/// To build arrays record by record use [`Arrow2Builder`]. +/// To build arrays record by record use [`ArrayBuilder`]. /// /// ```rust /// # fn main() -> serde_arrow::Result<()> { diff --git a/serde_arrow/src/arrow_impl/api.rs b/serde_arrow/src/arrow_impl/api.rs index ad0815c4..c73e906c 100644 --- a/serde_arrow/src/arrow_impl/api.rs +++ b/serde_arrow/src/arrow_impl/api.rs @@ -1,12 +1,10 @@ #![deny(missing_docs)] -use std::borrow::Cow; - use serde::{Deserialize, Serialize}; use crate::{ _impl::arrow::{ array::{Array, ArrayRef, RecordBatch}, - datatypes::{Field, FieldRef}, + datatypes::FieldRef, }, internal::{ array_builder::ArrayBuilder, deserializer::Deserializer, error::Result, @@ -29,7 +27,7 @@ use crate::{ /// ```rust /// # fn main() -> serde_arrow::Result<()> { /// # use serde_arrow::_impl::arrow; -/// use arrow::datatypes::Field; +/// use arrow::datatypes::FieldRef; /// use serde::{Serialize, Deserialize}; /// use serde_arrow::schema::{SchemaLike, TracingOptions}; /// @@ -44,7 +42,7 @@ use crate::{ /// // ... /// ]; /// -/// let fields = Vec::::from_type::(TracingOptions::default())?; +/// let fields = Vec::::from_type::(TracingOptions::default())?; /// let arrays = serde_arrow::to_arrow(&fields, &items)?; /// # /// # assert_eq!(arrays.len(), 2); @@ -52,7 +50,7 @@ use crate::{ /// # } /// ``` /// -pub fn to_arrow(fields: &[Field], items: &T) -> Result> { +pub fn to_arrow(fields: &[FieldRef], items: &T) -> Result> { let builder = ArrayBuilder::new(SerdeArrowSchema::try_from(fields)?)?; items .serialize(Serializer::new(builder))? @@ -70,7 +68,7 @@ pub fn to_arrow(fields: &[Field], items: &T) -> Result serde_arrow::Result<()> { /// # use serde_arrow::_impl::arrow; -/// use arrow::datatypes::Field; +/// use arrow::datatypes::FieldRef; /// use serde::{Deserialize, Serialize}; /// use serde_arrow::schema::{SchemaLike, TracingOptions}; /// @@ -82,20 +80,18 @@ pub fn to_arrow(fields: &[Field], items: &T) -> Result::from_type::(TracingOptions::default())?; +/// let fields = Vec::::from_type::(TracingOptions::default())?; /// let items: Vec = serde_arrow::from_arrow(&fields, &arrays)?; /// # Ok(()) /// # } /// ``` /// -pub fn from_arrow<'de, T, A>(fields: &[Field], arrays: &'de [A]) -> Result +pub fn from_arrow<'de, T, A>(fields: &[FieldRef], arrays: &'de [A]) -> Result where T: Deserialize<'de>, A: AsRef, { - let fields = fields.iter().map(Cow::Borrowed).collect::>(); - let deserializer = Deserializer::from_arrow(&fields, arrays)?; - T::deserialize(deserializer) + T::deserialize(Deserializer::from_arrow(fields, arrays)?) } /// Build a record batch from the given items (*requires one of the `arrow-*` diff --git a/serde_arrow/src/arrow_impl/deserialization.rs b/serde_arrow/src/arrow_impl/deserialization.rs index 82dc6116..788d33ef 100644 --- a/serde_arrow/src/arrow_impl/deserialization.rs +++ b/serde_arrow/src/arrow_impl/deserialization.rs @@ -35,7 +35,7 @@ use crate::_impl::arrow::{ datatypes::{ ArrowDictionaryKeyType, ArrowPrimitiveType, DataType, Date32Type, Date64Type, Decimal128Type, DurationMicrosecondType, DurationMillisecondType, DurationNanosecondType, - DurationSecondType, Field, Float16Type, Float32Type, Float64Type, Int16Type, Int32Type, + DurationSecondType, FieldRef, Float16Type, Float32Type, Float64Type, Int16Type, Int32Type, Int64Type, Int8Type, Time32MillisecondType, Time32SecondType, Time64MicrosecondType, Time64NanosecondType, TimestampMicrosecondType, TimestampMillisecondType, TimestampNanosecondType, TimestampSecondType, UInt16Type, UInt32Type, UInt64Type, @@ -69,9 +69,8 @@ impl<'de> Deserializer<'de> { /// # Ok(()) /// # } /// ``` - pub fn from_arrow(fields: &[F], arrays: &'de [A]) -> Result + pub fn from_arrow(fields: &[FieldRef], arrays: &'de [A]) -> Result where - F: AsRef, A: AsRef, { let fields = fields diff --git a/serde_arrow/src/arrow_impl/serialization.rs b/serde_arrow/src/arrow_impl/serialization.rs index b149fddb..0ca01941 100644 --- a/serde_arrow/src/arrow_impl/serialization.rs +++ b/serde_arrow/src/arrow_impl/serialization.rs @@ -5,7 +5,9 @@ use crate::{ _impl::arrow::{ array::{make_array, Array, ArrayData, ArrayRef, NullArray, RecordBatch}, buffer::{Buffer, ScalarBuffer}, - datatypes::{ArrowNativeType, ArrowPrimitiveType, DataType, Field, Float16Type, Schema}, + datatypes::{ + ArrowNativeType, ArrowPrimitiveType, DataType, Field, FieldRef, Float16Type, Schema, + }, }, internal::{ error::{fail, Result}, @@ -22,7 +24,7 @@ use crate::{ impl crate::internal::array_builder::ArrayBuilder { /// Build an ArrayBuilder from `arrow` fields (*requires one of the /// `arrow-*` features*) - pub fn from_arrow>(fields: &[F]) -> Result { + pub fn from_arrow(fields: &[FieldRef]) -> Result { let fields = fields .iter() .map(|f| GenericField::try_from(f.as_ref())) diff --git a/serde_arrow/src/test_with_arrow/impls/union.rs b/serde_arrow/src/test_with_arrow/impls/union.rs index 46571d1b..c16b5f3b 100644 --- a/serde_arrow/src/test_with_arrow/impls/union.rs +++ b/serde_arrow/src/test_with_arrow/impls/union.rs @@ -3,8 +3,8 @@ use serde_json::json; use crate::{ internal::schema::{GenericDataType, GenericField}, - schema::{Strategy, TracingOptions}, - utils::Item, + schema::{SchemaLike, Strategy, TracingOptions}, + utils::{Item, Items}, }; use super::utils::Test; @@ -302,68 +302,28 @@ fn enums_union() { .deserialize(&values); } -macro_rules! test_generic { - ( - $(#[ignore = $ignore:literal])? - fn $name:ident() { - $($stmt:stmt)* - } - ) => { - #[allow(unused)] - mod $name { - use crate::{ - schema::{SchemaLike, TracingOptions}, - utils::{Items, Item} - }; - use crate::internal::schema::{GenericField, GenericDataType}; - - mod arrow { - use super::*; - use crate::{to_arrow, from_arrow}; - use crate::_impl::arrow::datatypes::Field; - - $(#[ignore = $ignore])? - #[test] - fn test() { - $($stmt)* - } - } - mod arrow2 { - use super::*; - use crate::{to_arrow2 as to_arrow, from_arrow2 as from_arrow}; - use crate::_impl::arrow2::datatypes::Field; - - $(#[ignore = $ignore])? - #[test] - fn test() { - $($stmt)* - } - } - } - }; -} +#[test] +fn missing_union_variants() { + use crate::_impl::arrow::datatypes::FieldRef; + + use crate::internal::testing::assert_error; + use crate::schema::TracingOptions; + use serde::{Deserialize, Serialize}; -test_generic!( - fn missing_union_variants() { - use crate::internal::testing::assert_error; - use crate::schema::TracingOptions; - use serde::{Deserialize, Serialize}; - - #[derive(Serialize, Deserialize, Debug, PartialEq)] - enum U { - A, - B, - C, - } - - let tracing_options = TracingOptions::default().allow_null_fields(true); - let fields = Vec::::from_samples(&Items(&[U::A, U::C]), tracing_options).unwrap(); - - // NOTE: variant B was never encountered during tracing - let res = to_arrow(&fields, &Items(&[U::A, U::B, U::C])); - assert_error(&res, "Serialization failed: an unknown variant"); + #[derive(Serialize, Deserialize, Debug, PartialEq)] + enum U { + A, + B, + C, } -); + + let tracing_options = TracingOptions::default().allow_null_fields(true); + let fields = Vec::::from_samples(&Items(&[U::A, U::C]), tracing_options).unwrap(); + + // NOTE: variant B was never encountered during tracing + let res = crate::to_arrow(&fields, &Items(&[U::A, U::B, U::C])); + assert_error(&res, "Serialization failed: an unknown variant"); +} #[test] fn fieldless_unions_as_dictionary() { diff --git a/serde_arrow/src/test_with_arrow/impls/utils.rs b/serde_arrow/src/test_with_arrow/impls/utils.rs index a48cd381..84f1aeb0 100644 --- a/serde_arrow/src/test_with_arrow/impls/utils.rs +++ b/serde_arrow/src/test_with_arrow/impls/utils.rs @@ -16,7 +16,7 @@ pub struct Arrays { #[derive(Default)] pub struct Fields { - pub arrow: Option>, + pub arrow: Option>, pub arrow2: Option>, } @@ -77,11 +77,10 @@ impl Test { } impl Test { - pub fn get_arrow_fields(&self) -> Cow<'_, Vec> { + pub fn get_arrow_fields(&self) -> Cow<'_, Vec> { match self.schema.as_ref() { Some(schema) => Cow::Owned( - schema - .to_arrow_fields() + Vec::::try_from(schema) .expect("Cannot covert schema to arrow fields"), ), None => Cow::Borrowed( @@ -146,10 +145,6 @@ impl Test { pub fn try_serialize_arrow(&mut self, items: &T) -> Result<()> { let fields = self.get_arrow_fields().to_vec(); - let field_refs = fields - .iter() - .map(|f| Arc::new(f.clone())) - .collect::>(); let arrays = crate::to_arrow(&fields, items)?; assert_eq!(fields.len(), arrays.len()); @@ -168,7 +163,7 @@ impl Test { self.arrays.arrow = Some(arrays); - let mut builder = crate::ArrayBuilder::from_arrow(&field_refs)?; + let mut builder = crate::ArrayBuilder::from_arrow(&fields)?; builder.extend(items)?; let arrays = builder.to_arrow()?; assert_eq!(self.arrays.arrow, Some(arrays)); diff --git a/serde_arrow/src/test_with_arrow/issue_90_top_level_nulls_in_structs.rs b/serde_arrow/src/test_with_arrow/issue_90_top_level_nulls_in_structs.rs index 6365ce5b..76030bf5 100644 --- a/serde_arrow/src/test_with_arrow/issue_90_top_level_nulls_in_structs.rs +++ b/serde_arrow/src/test_with_arrow/issue_90_top_level_nulls_in_structs.rs @@ -9,7 +9,7 @@ use crate::{ schema::{SchemaLike, TracingOptions}, }; -use crate::_impl::arrow::{_raw::schema::Schema, array::RecordBatch, datatypes::Field}; +use crate::_impl::arrow::{_raw::schema::Schema, array::RecordBatch, datatypes::FieldRef}; #[derive(Deserialize, Serialize, Debug, PartialEq, Clone)] pub struct Distribution { @@ -40,7 +40,7 @@ fn example() -> PanicOnError<()> { VectorMetric { distribution: None }, ]; - let fields = Vec::::from_type::(TracingOptions::default())?; + let fields = Vec::::from_type::(TracingOptions::default())?; let arrays = serde_arrow::to_arrow(&fields, &metrics)?; let batch = RecordBatch::try_new(Arc::new(Schema::new(fields.clone())), arrays.clone())?; @@ -55,7 +55,7 @@ fn example() -> PanicOnError<()> { #[test] fn example_top_level_none() -> PanicOnError<()> { // top-level options are not supported if fields are are extracted - let res = Vec::::from_type::>(TracingOptions::default()); + let res = Vec::::from_type::>(TracingOptions::default()); assert!(res.is_err()); Ok(()) } diff --git a/serde_arrow/src/test_with_arrow/items_wrapper.rs b/serde_arrow/src/test_with_arrow/items_wrapper.rs index 60d4b637..38835a6b 100644 --- a/serde_arrow/src/test_with_arrow/items_wrapper.rs +++ b/serde_arrow/src/test_with_arrow/items_wrapper.rs @@ -2,7 +2,7 @@ use std::sync::Arc; use crate::{ self as serde_arrow, - _impl::arrow::{_raw::schema::Schema, array::RecordBatch, datatypes::Field}, + _impl::arrow::{_raw::schema::Schema, array::RecordBatch, datatypes::FieldRef}, internal::error::PanicOnError, schema::{SchemaLike, TracingOptions}, utils::{Item, Items}, @@ -10,14 +10,11 @@ use crate::{ #[test] fn example() -> PanicOnError<()> { - use serde_arrow::schema::SerdeArrowSchema; - let items: Vec = vec![1, 2, 3, 4, 5]; - let fields_from_type: Vec = - SerdeArrowSchema::from_type::>(TracingOptions::default())?.try_into()?; - let fields_from_samples: Vec = - SerdeArrowSchema::from_samples(&Items(&items), TracingOptions::default())?.try_into()?; + let fields_from_type = Vec::::from_type::>(TracingOptions::default())?; + let fields_from_samples = + Vec::::from_samples(&Items(&items), TracingOptions::default())?; assert_eq!(fields_from_type, fields_from_samples); let fields = fields_from_type; diff --git a/serde_arrow/src/test_with_arrow/serializer_deserializer.rs b/serde_arrow/src/test_with_arrow/serializer_deserializer.rs index fe4b6af0..c6009738 100644 --- a/serde_arrow/src/test_with_arrow/serializer_deserializer.rs +++ b/serde_arrow/src/test_with_arrow/serializer_deserializer.rs @@ -1,10 +1,7 @@ use serde::{Deserialize, Serialize}; use crate::{ - _impl::arrow::{ - array::ArrayRef, - datatypes::{Field, FieldRef}, - }, + _impl::arrow::{array::ArrayRef, datatypes::FieldRef}, schema::{SchemaLike, TracingOptions}, ArrayBuilder, Deserializer, }; @@ -27,7 +24,7 @@ enum Enum<'a> { TupleVariant(Record, Record), } -fn serialize(fields: &[impl AsRef], items: &I) -> Vec { +fn serialize(fields: &[FieldRef], items: &I) -> Vec { let builder = ArrayBuilder::from_arrow(&fields).unwrap(); items .serialize(crate::Serializer::new(builder)) @@ -37,10 +34,7 @@ fn serialize(fields: &[impl AsRef], items: &I) -> .unwrap() } -fn deserialize<'de, I: Deserialize<'de>>( - fields: &[impl AsRef], - arrays: &'de [ArrayRef], -) -> I { +fn deserialize<'de, I: Deserialize<'de>>(fields: &[FieldRef], arrays: &'de [ArrayRef]) -> I { I::deserialize(Deserializer::<'de>::from_arrow(fields, arrays).unwrap()).unwrap() } From d797a697e08a814a8ad7ee59eb9a4eb08257da96 Mon Sep 17 00:00:00 2001 From: Christopher Prohm Date: Wed, 19 Jun 2024 21:57:32 +0200 Subject: [PATCH 3/5] Remove from_arrow_fields / to_arrow_fields in SerdeArrowSchema --- Changes.md | 2 + serde_arrow/benches/groups/impls.rs | 4 +- serde_arrow/src/arrow2_impl/schema.rs | 32 +--------- serde_arrow/src/arrow_impl/schema.rs | 60 +++++-------------- serde_arrow/src/arrow_impl/serialization.rs | 2 +- .../src/test_with_arrow/impls/utils.rs | 3 +- 6 files changed, 24 insertions(+), 79 deletions(-) diff --git a/Changes.md b/Changes.md index 606c01cd..5f866886 100644 --- a/Changes.md +++ b/Changes.md @@ -6,6 +6,8 @@ - Remove `serde_arrow::ArrowBuilder` and `serde_arrow::Arrow2Builder` - Use `impl serde::Serialize` instead of `&(impl serde::Serialize + ?Sized)` - Use `&[FieldRef]` instead of `&[Field]` in arrow APIs +- Remove `from_arrow_fields` / `to_arrow_fields` for `SerdeArrowSchema`, use the + `TryFrom` conversions to convert between fields and `SerdeArrowSchema` ## 0.11.6 diff --git a/serde_arrow/benches/groups/impls.rs b/serde_arrow/benches/groups/impls.rs index 1d5e2a80..c8210479 100644 --- a/serde_arrow/benches/groups/impls.rs +++ b/serde_arrow/benches/groups/impls.rs @@ -13,7 +13,7 @@ macro_rules! define_benchmark { ) => { pub fn benchmark_serialize(c: &mut criterion::Criterion) { use serde_arrow::schema::{SerdeArrowSchema, SchemaLike}; - use serde_arrow::_impl::arrow::datatypes::FieldRef; + use serde_arrow::_impl::{arrow::datatypes::FieldRef, arrow2::datatypes::Field as Arrow2Field}; for n in [$($n),*] { let mut group = c.benchmark_group(format!("{}_serialize({})", stringify!($name), n)); @@ -35,7 +35,7 @@ macro_rules! define_benchmark { .collect::>(); let schema = SerdeArrowSchema::from_samples(&items, Default::default()).unwrap(); let arrow_fields = Vec::::try_from(&schema).unwrap(); - let arrow2_fields = schema.to_arrow2_fields().unwrap(); + let arrow2_fields = Vec::::try_from(&schema).unwrap(); #[allow(unused)] let bench_serde_arrow = true; diff --git a/serde_arrow/src/arrow2_impl/schema.rs b/serde_arrow/src/arrow2_impl/schema.rs index f5a156b5..5f137994 100644 --- a/serde_arrow/src/arrow2_impl/schema.rs +++ b/serde_arrow/src/arrow2_impl/schema.rs @@ -11,32 +11,6 @@ use crate::{ }, }; -/// Support for arrow2 types (*requires one of the `arrow2-*` features*) -impl SerdeArrowSchema { - /// Build a new Schema object from fields - pub fn from_arrow2_fields(fields: &[Field]) -> Result { - Self::try_from(fields) - } - - /// Build a vec of fields from a Schema object - /// - /// ```rust - /// # fn main() -> serde_arrow::_impl::PanicOnError<()> { - /// # use serde_arrow::schema::{SerdeArrowSchema, SchemaLike, TracingOptions}; - /// # #[derive(serde::Deserialize)] - /// # struct Item { a: u32 } - /// # let schema = SerdeArrowSchema::from_type::(TracingOptions::default()).unwrap(); - /// # let fields = - /// schema.to_arrow2_fields()? - /// # ; - /// # Ok(()) - /// # } - /// ``` - pub fn to_arrow2_fields(&self) -> Result> { - Vec::::try_from(self) - } -} - impl TryFrom for Vec { type Error = Error; @@ -72,20 +46,20 @@ impl Sealed for Vec {} /// `arrow2-*` features*) impl SchemaLike for Vec { fn from_value(value: &T) -> Result { - SerdeArrowSchema::from_value(value)?.to_arrow2_fields() + SerdeArrowSchema::from_value(value)?.try_into() } fn from_type<'de, T: serde::Deserialize<'de> + ?Sized>( options: crate::schema::TracingOptions, ) -> Result { - SerdeArrowSchema::from_type::(options)?.to_arrow2_fields() + SerdeArrowSchema::from_type::(options)?.try_into() } fn from_samples( samples: &T, options: crate::schema::TracingOptions, ) -> Result { - SerdeArrowSchema::from_samples(samples, options)?.to_arrow2_fields() + SerdeArrowSchema::from_samples(samples, options)?.try_into() } } diff --git a/serde_arrow/src/arrow_impl/schema.rs b/serde_arrow/src/arrow_impl/schema.rs index 0f872e27..5d637400 100644 --- a/serde_arrow/src/arrow_impl/schema.rs +++ b/serde_arrow/src/arrow_impl/schema.rs @@ -11,37 +11,11 @@ use crate::{ }, }; -/// Support for arrow types (*requires one of the `arrow-*` features*) -impl SerdeArrowSchema { - /// Build a new Schema object from fields - pub fn from_arrow_fields(fields: &[Field]) -> Result { - Self::try_from(fields) - } - - /// Build a vec of fields from a Schema object - /// - /// ```rust - /// # fn main() -> serde_arrow::_impl::PanicOnError<()> { - /// # use serde_arrow::schema::{SerdeArrowSchema, SchemaLike, TracingOptions}; - /// # #[derive(serde::Deserialize)] - /// # struct Item { a: u32 } - /// # let schema = SerdeArrowSchema::from_type::(TracingOptions::default()).unwrap(); - /// # let fields = - /// schema.to_arrow_fields()? - /// # ; - /// # Ok(()) - /// # } - /// ``` - pub fn to_arrow_fields(&self) -> Result> { - Vec::::try_from(self) - } -} - impl TryFrom for Vec { type Error = Error; fn try_from(value: SerdeArrowSchema) -> Result { - value.fields.iter().map(Field::try_from).collect() + (&value).try_into() } } @@ -53,6 +27,14 @@ impl<'a> TryFrom<&'a SerdeArrowSchema> for Vec { } } +impl TryFrom for Vec { + type Error = Error; + + fn try_from(value: SerdeArrowSchema) -> Result { + (&value).try_into() + } +} + impl<'a> TryFrom<&'a SerdeArrowSchema> for Vec { type Error = Error; @@ -97,20 +79,20 @@ impl Sealed for Vec {} /// `arrow-*` features*) impl SchemaLike for Vec { fn from_value(value: &T) -> Result { - SerdeArrowSchema::from_value(value)?.to_arrow_fields() + SerdeArrowSchema::from_value(value)?.try_into() } fn from_type<'de, T: serde::Deserialize<'de> + ?Sized>( options: crate::schema::TracingOptions, ) -> Result { - SerdeArrowSchema::from_type::(options)?.to_arrow_fields() + SerdeArrowSchema::from_type::(options)?.try_into() } fn from_samples( samples: &T, options: crate::schema::TracingOptions, ) -> Result { - SerdeArrowSchema::from_samples(samples, options)?.to_arrow_fields() + SerdeArrowSchema::from_samples(samples, options)?.try_into() } } @@ -120,32 +102,20 @@ impl Sealed for Vec {} /// `arrow-*` features*) impl SchemaLike for Vec { fn from_value(value: &T) -> Result { - Ok(SerdeArrowSchema::from_value(value)? - .to_arrow_fields()? - .into_iter() - .map(Arc::new) - .collect()) + SerdeArrowSchema::from_value(value)?.try_into() } fn from_type<'de, T: serde::Deserialize<'de> + ?Sized>( options: crate::schema::TracingOptions, ) -> Result { - Ok(SerdeArrowSchema::from_type::(options)? - .to_arrow_fields()? - .into_iter() - .map(Arc::new) - .collect()) + SerdeArrowSchema::from_type::(options)?.try_into() } fn from_samples( samples: &T, options: crate::schema::TracingOptions, ) -> Result { - Ok(SerdeArrowSchema::from_samples(samples, options)? - .to_arrow_fields()? - .into_iter() - .map(Arc::new) - .collect()) + SerdeArrowSchema::from_samples(samples, options)?.try_into() } } diff --git a/serde_arrow/src/arrow_impl/serialization.rs b/serde_arrow/src/arrow_impl/serialization.rs index 0ca01941..e07fe32d 100644 --- a/serde_arrow/src/arrow_impl/serialization.rs +++ b/serde_arrow/src/arrow_impl/serialization.rs @@ -42,7 +42,7 @@ impl crate::internal::array_builder::ArrayBuilder { /// `arrow-*` features*) pub fn to_record_batch(&mut self) -> Result { let arrays = self.builder.build_arrow()?; - let fields = self.schema.to_arrow_fields()?; + let fields = Vec::::try_from(&self.schema)?; let schema = Schema::new(fields); Ok(RecordBatch::try_new(Arc::new(schema), arrays)?) } diff --git a/serde_arrow/src/test_with_arrow/impls/utils.rs b/serde_arrow/src/test_with_arrow/impls/utils.rs index 84f1aeb0..4721f8f2 100644 --- a/serde_arrow/src/test_with_arrow/impls/utils.rs +++ b/serde_arrow/src/test_with_arrow/impls/utils.rs @@ -95,8 +95,7 @@ impl Test { pub fn get_arrow2_fields(&self) -> Cow<'_, Vec> { match self.schema.as_ref() { Some(schema) => Cow::Owned( - schema - .to_arrow2_fields() + Vec::::try_from(schema) .expect("Cannot covert schema to arrow fields"), ), None => Cow::Borrowed( From 8525e5f295752cb990e48e900d14cdf2bfd47d14 Mon Sep 17 00:00:00 2001 From: Christopher Prohm Date: Wed, 19 Jun 2024 22:00:26 +0200 Subject: [PATCH 4/5] Update docs --- serde_arrow/src/internal/schema/mod.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/serde_arrow/src/internal/schema/mod.rs b/serde_arrow/src/internal/schema/mod.rs index 469e2224..10981ece 100644 --- a/serde_arrow/src/internal/schema/mod.rs +++ b/serde_arrow/src/internal/schema/mod.rs @@ -281,6 +281,9 @@ pub trait SchemaLike: Sized + Sealed { } /// A collection of fields as understood by `serde_arrow` +/// +/// It can be converted from / to arrow or arrow2 fields. +/// #[derive(Default, Debug, PartialEq, Clone, Serialize)] pub struct SerdeArrowSchema { pub(crate) fields: Vec, From 01b496f8ae9b9ca96a169dc6e17d252cf88991e9 Mon Sep 17 00:00:00 2001 From: Christopher Prohm Date: Wed, 19 Jun 2024 22:07:10 +0200 Subject: [PATCH 5/5] Remove SerdeArrowSchema::new(), Overwrites::new() --- Changes.md | 1 + serde_arrow/src/internal/schema/mod.rs | 7 ------- serde_arrow/src/internal/schema/test.rs | 10 +++++----- serde_arrow/src/internal/schema/tracing_options.rs | 7 ------- 4 files changed, 6 insertions(+), 19 deletions(-) diff --git a/Changes.md b/Changes.md index 5f866886..c4588156 100644 --- a/Changes.md +++ b/Changes.md @@ -8,6 +8,7 @@ - Use `&[FieldRef]` instead of `&[Field]` in arrow APIs - Remove `from_arrow_fields` / `to_arrow_fields` for `SerdeArrowSchema`, use the `TryFrom` conversions to convert between fields and `SerdeArrowSchema` +- Remove `SerdeArrowSchema::new()`, `Overwrites::new()` ## 0.11.6 diff --git a/serde_arrow/src/internal/schema/mod.rs b/serde_arrow/src/internal/schema/mod.rs index 10981ece..fdec33da 100644 --- a/serde_arrow/src/internal/schema/mod.rs +++ b/serde_arrow/src/internal/schema/mod.rs @@ -289,13 +289,6 @@ pub struct SerdeArrowSchema { pub(crate) fields: Vec, } -impl SerdeArrowSchema { - /// Return a new schema without any fields - pub fn new() -> Self { - Self::default() - } -} - impl Sealed for SerdeArrowSchema {} impl SchemaLike for SerdeArrowSchema { diff --git a/serde_arrow/src/internal/schema/test.rs b/serde_arrow/src/internal/schema/test.rs index a8e72bca..e976e567 100644 --- a/serde_arrow/src/internal/schema/test.rs +++ b/serde_arrow/src/internal/schema/test.rs @@ -14,7 +14,7 @@ impl SerdeArrowSchema { #[test] fn example() { - let schema = SerdeArrowSchema::new() + let schema = SerdeArrowSchema::default() .with_field(GenericField::new("foo", GenericDataType::U8, false)) .with_field(GenericField::new("bar", GenericDataType::Utf8, false)); @@ -30,7 +30,7 @@ fn example() { #[test] fn example_without_wrapper() { - let expected = SerdeArrowSchema::new() + let expected = SerdeArrowSchema::default() .with_field(GenericField::new("foo", GenericDataType::U8, false)) .with_field(GenericField::new("bar", GenericDataType::Utf8, false)); @@ -41,7 +41,7 @@ fn example_without_wrapper() { #[test] fn list() { - let schema = SerdeArrowSchema::new().with_field( + let schema = SerdeArrowSchema::default().with_field( GenericField::new("value", GenericDataType::List, false).with_child(GenericField::new( "element", GenericDataType::I32, @@ -69,7 +69,7 @@ fn doc_schema() { "#; let actual: SerdeArrowSchema = serde_json::from_str(&schema).unwrap(); - let expected = SerdeArrowSchema::new() + let expected = SerdeArrowSchema::default() .with_field(GenericField::new("foo", GenericDataType::U8, false)) .with_field(GenericField::new("bar", GenericDataType::Utf8, false)); @@ -78,7 +78,7 @@ fn doc_schema() { #[test] fn date64_with_strategy() { - let schema = SerdeArrowSchema::new().with_field( + let schema = SerdeArrowSchema::default().with_field( GenericField::new("item", GenericDataType::Date64, false) .with_strategy(Strategy::NaiveStrAsDate64), ); diff --git a/serde_arrow/src/internal/schema/tracing_options.rs b/serde_arrow/src/internal/schema/tracing_options.rs index a61797bb..1acad363 100644 --- a/serde_arrow/src/internal/schema/tracing_options.rs +++ b/serde_arrow/src/internal/schema/tracing_options.rs @@ -300,10 +300,3 @@ impl TracingOptions { /// An opaque mapping of field paths to field definitions #[derive(Debug, Clone, Default, PartialEq)] pub struct Overwrites(pub(crate) HashMap); - -impl Overwrites { - /// Create a new empty instance - pub fn new() -> Self { - Self::default() - } -}