dont use deprecated fn

Signed-off-by: Baris Palaska <barispalaska@gmail.com>

Author: palaska

encodings/parquet-variant/src/array.rs

@@ -14,6 +14,7 @@ use vortex_array::ArrayParts;
 use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
+use vortex_array::LEGACY_SESSION;
 use vortex_array::TypedArrayRef;
 use vortex_array::arrays::VariantArray;
 use vortex_array::arrow::ArrowArrayExecutor;
@@ -183,17 +184,32 @@ impl ParquetVariantData {
                 }
             })
             .unwrap_or(Validity::NonNullable);
-        let metadata =
-            ArrayRef::from_arrow(arrow_variant.metadata_field() as &dyn ArrowArray, false)?;
+        let metadata = ArrayRef::from_arrow_with_session(
+            arrow_variant.metadata_field() as &dyn ArrowArray,
+            false,
+            &LEGACY_SESSION,
+        )?;
 
         let value = arrow_variant
             .value_field()
-            .map(|v| ArrayRef::from_arrow(v as &dyn ArrowArray, value_nullable))
+            .map(|v| {
+                ArrayRef::from_arrow_with_session(
+                    v as &dyn ArrowArray,
+                    value_nullable,
+                    &LEGACY_SESSION,
+                )
+            })
             .transpose()?;
 
         let typed_value = arrow_variant
             .typed_value_field()
-            .map(|tv| ArrayRef::from_arrow(tv.as_ref(), typed_value_nullable))
+            .map(|tv| {
+                ArrayRef::from_arrow_with_session(
+                    tv.as_ref(),
+                    typed_value_nullable,
+                    &LEGACY_SESSION,
+                )
+            })
             .transpose()?;
 
         let pv = ParquetVariant::try_new(validity, metadata, value, typed_value)?;

encodings/runend/src/arrow.rs

@@ -69,7 +69,6 @@ where
 }
 
 #[cfg(test)]
-#[allow(deprecated)]
 mod tests {
     use std::sync::Arc;
     use std::sync::LazyLock;
@@ -131,7 +130,8 @@ mod tests {
             Buffer::<R::Native>::from_arrow_scalar_buffer(array.run_ends().inner().clone());
         let ends = PrimitiveArray::new(ends_buf, Validity::NonNullable)
             .reinterpret_cast(R::Native::PTYPE.to_unsigned());
-        let values = ArrayRef::from_arrow(array.values().as_ref(), nullable)?;
+        let values =
+            ArrayRef::from_arrow_with_session(array.values().as_ref(), nullable, &SESSION)?;
 
         let ends_array = PrimitiveArray::from_buffer_handle(
             ends.buffer_handle().clone(),

vortex-array/src/arrays/filter/execute/varbinview.rs

@@ -37,7 +37,11 @@ fn arrow_filter_fn(array: &ArrayRef, mask: &Mask) -> vortex_error::VortexResult<
     let mask_array = BooleanArray::new(values.bit_buffer().clone().into(), None);
     let filtered = arrow_select::filter::filter(array_ref.as_ref(), &mask_array)?;
 
-    ArrayRef::from_arrow(filtered.as_ref(), array.dtype().is_nullable())
+    ArrayRef::from_arrow_with_session(
+        filtered.as_ref(),
+        array.dtype().is_nullable(),
+        &LEGACY_SESSION,
+    )
 }
 
 #[cfg(test)]

vortex-array/src/arrow/convert.rs

@@ -93,7 +93,7 @@ pub fn from_arrow_array_with_len<A>(array: A, len: usize, nullable: bool) -> Vor
 where
     ArrayRef: FromArrowArray<A>,
 {
-    let array = ArrayRef::from_arrow(array, nullable)?;
+    let array = ArrayRef::from_arrow_with_session(array, nullable, &LEGACY_SESSION)?;
     if array.len() == len {
         return Ok(array);
     }

vortex-array/src/arrow/datum.rs

@@ -71,7 +71,10 @@ pub(super) fn to_arrow_byte_view<T: ByteViewType>(
     // We do this in case the vortex array is Utf8, and we want Binary or vice versa. By casting
     // first, we may push this down through the Vortex array tree. We choose nullable to be most
     // flexible since there's no prescribed nullability in Arrow types.
-    let array = array.cast(DType::from_arrow((&T::DATA_TYPE, Nullability::Nullable)))?;
+    let array = array.cast(DType::from_arrow_with_session(
+        (&T::DATA_TYPE, Nullability::Nullable),
+        ctx.session(),
+    ))?;
 
     let varbinview = array.execute::<VarBinViewArray>(ctx)?;
     canonical_varbinview_to_arrow::<T>(&varbinview, ctx)

vortex-array/src/arrow/executor/byte_view.rs

@@ -86,7 +86,7 @@ pub(super) fn to_arrow_struct(
 
     // Otherwise, we fall back to executing to a StructArray.
     let array = if let Some(fields) = target_fields {
-        let vx_fields = StructFields::from_arrow(fields);
+        let vx_fields = StructFields::from_arrow_with_session(fields, ctx.session());
         // We apply a cast to ensure we push down casting where possible into the struct fields.
         array.cast(DType::Struct(
             vx_fields,
@@ -351,7 +351,8 @@ mod tests {
         )?;
         let orig_dtype = array.dtype().clone();
         let arrow_array = array.into_array().execute_arrow(None, &mut ctx)?;
-        let from_arrow = array::ArrayRef::from_arrow(arrow_array.as_ref(), false)?;
+        let from_arrow =
+            array::ArrayRef::from_arrow_with_session(arrow_array.as_ref(), false, ctx.session())?;
         assert_eq!(&orig_dtype, from_arrow.dtype());
         Ok(())
     }

vortex-array/src/arrow/executor/struct_.rs

@@ -6,6 +6,7 @@ use vortex_error::VortexError;
 use vortex_error::VortexResult;
 
 use crate::ArrayRef;
+use crate::LEGACY_SESSION;
 use crate::arrow::FromArrowArray;
 use crate::dtype::DType;
 use crate::dtype::arrow::FromArrowType;
@@ -36,8 +37,11 @@ impl Iterator for ArrowArrayStreamAdapter {
         let batch = self.stream.next()?;
 
         Some(batch.map_err(VortexError::from).and_then(|b| {
-            debug_assert_eq!(&self.dtype, &DType::from_arrow(b.schema()));
-            ArrayRef::from_arrow(b, false)
+            debug_assert_eq!(
+                &self.dtype,
+                &DType::from_arrow_with_session(b.schema(), &LEGACY_SESSION)
+            );
+            ArrayRef::from_arrow_with_session(b, false, &LEGACY_SESSION)
         }))
     }
 }

vortex-array/src/arrow/iter.rs

@@ -47,6 +47,7 @@ mod tests {
     use arrow_schema::FieldRef;
     use arrow_schema::Schema;
 
+    use crate::LEGACY_SESSION;
     use crate::arrow::record_batch::StructArray;
     use crate::builders::ArrayBuilder;
     use crate::builders::ListBuilder;
@@ -81,8 +82,9 @@ mod tests {
             DataType::LargeListView(FieldRef::new(Field::new_list_field(DataType::Int32, false))),
             true,
         )]));
-        #[allow(deprecated)]
-        let rb = array.into_record_batch_with_schema(arrow_schema).unwrap();
+        let rb = array
+            .into_record_batch_with_schema_with_session(arrow_schema, &LEGACY_SESSION)
+            .unwrap();
 
         let xs = rb.column(0);
         assert_eq!(

vortex-array/src/arrow/record_batch.rs

@@ -1165,7 +1165,8 @@ mod test {
             nulls.finish(),
         );
 
-        let vortex_struct = ArrayRef::from_arrow(&arrow_struct, true).unwrap();
+        let vortex_struct =
+            ArrayRef::from_arrow_with_session(&arrow_struct, true, ctx.session()).unwrap();
 
         assert_eq!(
             &arrow_struct,
@@ -1193,7 +1194,8 @@ mod test {
         );
         let list_data_type = arrow_list.data_type();
 
-        let vortex_list = ArrayRef::from_arrow(&arrow_list, true).unwrap();
+        let vortex_list =
+            ArrayRef::from_arrow_with_session(&arrow_list, true, ctx.session()).unwrap();
 
         let rt_arrow_list = vortex_list
             .execute_arrow(Some(list_data_type), &mut ctx)