Remove deprecated Arrow functions (#7830)

# Which issue does this PR close?

- Closes #7810.

# Rationale for this change

Removes the last batch of functions that can be removed in 56.0.0.

Some deprecated functions remain (esp in arrow-schema and arrow-ipc),
but those will be dealt with elsewhere (#7467)

# What changes are included in this PR?

# Are these changes tested?

Covered by existing tests

# Are there any user-facing changes?

Yes, public functions are removed

Author: etseidl

arrow-array/src/builder/generic_bytes_view_builder.rs

@@ -134,13 +134,6 @@ impl<T: ByteViewType + ?Sized> GenericByteViewBuilder<T> {
         }
     }
 
-    /// Override the size of buffers to allocate for holding string data
-    /// Use `with_fixed_block_size` instead.
-    #[deprecated(since = "53.0.0", note = "Use `with_fixed_block_size` instead")]
-    pub fn with_block_size(self, block_size: u32) -> Self {
-        self.with_fixed_block_size(block_size)
-    }
-
     /// Deduplicate strings while building the array
     ///
     /// This will potentially decrease the memory usage if the array have repeated strings

arrow-array/src/builder/null_builder.rs

@@ -59,18 +59,6 @@ impl NullBuilder {
         Self { len: 0 }
     }
 
-    /// Creates a new null builder with space for `capacity` elements without re-allocating
-    #[deprecated = "there is no actual notion of capacity in the NullBuilder, so emulating it makes little sense"]
-    pub fn with_capacity(_capacity: usize) -> Self {
-        Self::new()
-    }
-
-    /// Returns the capacity of this builder measured in slots of type `T`
-    #[deprecated = "there is no actual notion of capacity in the NullBuilder, so emulating it makes little sense"]
-    pub fn capacity(&self) -> usize {
-        self.len
-    }
-
     /// Appends a null slot into the builder
     #[inline]
     pub fn append_null(&mut self) {

arrow-array/src/types.rs

@@ -71,12 +71,6 @@ pub trait ArrowPrimitiveType: primitive::PrimitiveTypeSealed + 'static {
     /// the corresponding Arrow data type of this primitive type.
     const DATA_TYPE: DataType;
 
-    /// Returns the byte width of this primitive type.
-    #[deprecated(since = "52.0.0", note = "Use ArrowNativeType::get_byte_width")]
-    fn get_byte_width() -> usize {
-        std::mem::size_of::<Self::Native>()
-    }
-
     /// Returns a default value of this primitive type.
     ///
     /// This is useful for aggregate array ops like `sum()`, `mean()`.
@@ -1034,10 +1028,10 @@ impl Date64Type {
     /// # Arguments
     ///
     /// * `i` - The Date64Type to convert
-    #[deprecated]
+    #[deprecated(since = "56.0.0", note = "Use to_naive_date_opt instead.")]
     pub fn to_naive_date(i: <Date64Type as ArrowPrimitiveType>::Native) -> NaiveDate {
-        let epoch = NaiveDate::from_ymd_opt(1970, 1, 1).unwrap();
-        epoch.add(Duration::try_milliseconds(i).unwrap())
+        Self::to_naive_date_opt(i)
+            .unwrap_or_else(|| panic!("Date64Type::to_naive_date overflowed for date: {i}",))
     }
 
     /// Converts an arrow Date64Type into a chrono::NaiveDateTime if it fits in the range that chrono::NaiveDateTime can represent.

arrow-flight/src/decode.rs

@@ -138,12 +138,6 @@ impl FlightRecordBatchStream {
         self.trailers.as_ref().and_then(|trailers| trailers.get())
     }
 
-    /// Has a message defining the schema been received yet?
-    #[deprecated = "use schema().is_some() instead"]
-    pub fn got_schema(&self) -> bool {
-        self.schema().is_some()
-    }
-
     /// Return schema for the stream, if it has been received
     pub fn schema(&self) -> Option<&SchemaRef> {
         self.inner.schema()

arrow-ord/src/cmp.rs

@@ -655,70 +655,6 @@ pub fn compare_byte_view<T: ByteViewType>(
     unsafe { GenericByteViewArray::compare_unchecked(left, left_idx, right, right_idx) }
 }
 
-/// Comparing two [`GenericByteViewArray`] at index `left_idx` and `right_idx`
-///
-/// Comparing two ByteView types are non-trivial.
-/// It takes a bit of patience to understand why we don't just compare two &[u8] directly.
-///
-/// ByteView types give us the following two advantages, and we need to be careful not to lose them:
-/// (1) For string/byte smaller than 12 bytes, the entire data is inlined in the view.
-///     Meaning that reading one array element requires only one memory access
-///     (two memory access required for StringArray, one for offset buffer, the other for value buffer).
-///
-/// (2) For string/byte larger than 12 bytes, we can still be faster than (for certain operations) StringArray/ByteArray,
-///     thanks to the inlined 4 bytes.
-///     Consider equality check:
-///     If the first four bytes of the two strings are different, we can return false immediately (with just one memory access).
-///
-/// If we directly compare two &[u8], we materialize the entire string (i.e., make multiple memory accesses), which might be unnecessary.
-/// - Most of the time (eq, ord), we only need to look at the first 4 bytes to know the answer,
-///   e.g., if the inlined 4 bytes are different, we can directly return unequal without looking at the full string.
-///
-/// # Order check flow
-/// (1) if both string are smaller than 12 bytes, we can directly compare the data inlined to the view.
-/// (2) if any of the string is larger than 12 bytes, we need to compare the full string.
-///     (2.1) if the inlined 4 bytes are different, we can return the result immediately.
-///     (2.2) o.w., we need to compare the full string.
-///
-/// # Safety
-/// The left/right_idx must within range of each array
-#[deprecated(
-    since = "52.2.0",
-    note = "Use `GenericByteViewArray::compare_unchecked` instead"
-)]
-pub unsafe fn compare_byte_view_unchecked<T: ByteViewType>(
-    left: &GenericByteViewArray<T>,
-    left_idx: usize,
-    right: &GenericByteViewArray<T>,
-    right_idx: usize,
-) -> std::cmp::Ordering {
-    let l_view = left.views().get_unchecked(left_idx);
-    let l_len = *l_view as u32;
-
-    let r_view = right.views().get_unchecked(right_idx);
-    let r_len = *r_view as u32;
-
-    if l_len <= 12 && r_len <= 12 {
-        let l_data = unsafe { GenericByteViewArray::<T>::inline_value(l_view, l_len as usize) };
-        let r_data = unsafe { GenericByteViewArray::<T>::inline_value(r_view, r_len as usize) };
-        return l_data.cmp(r_data);
-    }
-
-    // one of the string is larger than 12 bytes,
-    // we then try to compare the inlined data first
-    let l_inlined_data = unsafe { GenericByteViewArray::<T>::inline_value(l_view, 4) };
-    let r_inlined_data = unsafe { GenericByteViewArray::<T>::inline_value(r_view, 4) };
-    if r_inlined_data != l_inlined_data {
-        return l_inlined_data.cmp(r_inlined_data);
-    }
-
-    // unfortunately, we need to compare the full data
-    let l_full_data: &[u8] = unsafe { left.value_unchecked(left_idx).as_ref() };
-    let r_full_data: &[u8] = unsafe { right.value_unchecked(right_idx).as_ref() };
-
-    l_full_data.cmp(r_full_data)
-}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;

arrow-ord/src/ord.rs

@@ -265,12 +265,6 @@ fn compare_struct(
     Ok(f)
 }
 
-#[deprecated(since = "52.0.0", note = "Use make_comparator")]
-#[doc(hidden)]
-pub fn build_compare(left: &dyn Array, right: &dyn Array) -> Result<DynComparator, ArrowError> {
-    make_comparator(left, right, SortOptions::default())
-}
-
 /// Returns a comparison function that compares two values at two different positions
 /// between the two arrays.
 ///

arrow-schema/src/schema.rs

@@ -365,13 +365,6 @@ impl Schema {
         self.fields.iter().flat_map(|f| f.fields()).collect()
     }
 
-    /// Returns a vector with references to all fields (including nested fields)
-    #[deprecated(since = "52.2.0", note = "Use `flattened_fields` instead")]
-    #[inline]
-    pub fn all_fields(&self) -> Vec<&Field> {
-        self.flattened_fields()
-    }
-
     /// Returns an immutable reference of a specific [`Field`] instance selected using an
     /// offset within the internal `fields` vector.
     ///

arrow-string/src/regexp.rs

@@ -33,22 +33,6 @@ use regex::Regex;
 use std::collections::HashMap;
 use std::sync::Arc;
 
-/// Perform SQL `array ~ regex_array` operation on [`StringArray`] / [`LargeStringArray`].
-/// If `regex_array` element has an empty value, the corresponding result value is always true.
-///
-/// `flags_array` are optional [`StringArray`] / [`LargeStringArray`] flag, which allow
-/// special search modes, such as case insensitive and multi-line mode.
-/// See the documentation [here](https://docs.rs/regex/1.5.4/regex/#grouping-and-flags)
-/// for more information.
-#[deprecated(since = "54.0.0", note = "please use `regexp_is_match` instead")]
-pub fn regexp_is_match_utf8<OffsetSize: OffsetSizeTrait>(
-    array: &GenericStringArray<OffsetSize>,
-    regex_array: &GenericStringArray<OffsetSize>,
-    flags_array: Option<&GenericStringArray<OffsetSize>>,
-) -> Result<BooleanArray, ArrowError> {
-    regexp_is_match(array, regex_array, flags_array)
-}
-
 /// Return BooleanArray indicating which strings in an array match an array of
 /// regular expressions.
 ///
@@ -164,19 +148,6 @@ where
     Ok(BooleanArray::from(data))
 }
 
-/// Perform SQL `array ~ regex_array` operation on [`StringArray`] /
-/// [`LargeStringArray`] and a scalar.
-///
-/// See the documentation on [`regexp_is_match_utf8`] for more details.
-#[deprecated(since = "54.0.0", note = "please use `regexp_is_match_scalar` instead")]
-pub fn regexp_is_match_utf8_scalar<OffsetSize: OffsetSizeTrait>(
-    array: &GenericStringArray<OffsetSize>,
-    regex: &str,
-    flag: Option<&str>,
-) -> Result<BooleanArray, ArrowError> {
-    regexp_is_match_scalar(array, regex, flag)
-}
-
 /// Return BooleanArray indicating which strings in an array match a single regular expression.
 ///
 /// This is equivalent to the SQL `array ~ regex_array`, supporting

arrow/src/array/mod.rs

@@ -35,6 +35,4 @@ pub use arrow_data::transform::{Capacities, MutableArrayData};
 pub use arrow_array::ffi::export_array_into_raw;
 
 // --------------------- Array's values comparison ---------------------
-
-#[allow(deprecated)]
-pub use arrow_ord::ord::{build_compare, make_comparator, DynComparator};
+pub use arrow_ord::ord::{make_comparator, DynComparator};

arrow/src/compute/kernels.rs

@@ -30,8 +30,5 @@ pub use arrow_string::{concat_elements, length, regexp, substring};
 pub mod comparison {
     pub use arrow_ord::comparison::*;
     pub use arrow_string::like::*;
-    // continue to export deprecated methods until they are removed
     pub use arrow_string::regexp::{regexp_is_match, regexp_is_match_scalar};
-    #[allow(deprecated)]
-    pub use arrow_string::regexp::{regexp_is_match_utf8, regexp_is_match_utf8_scalar};
 }