17073077835

Committed 19 Aug 2025 02:40PM UTC coverage: 24.083%. First build

Build # 17073077835

Build Type

Pull #4177

github

Committed by

web-flow

Commit Message

Merge b42e5758f into 431a8f2b5

Pull Request Pull Request #4177: feat: ArrayOperations infallible, eager validation + new_unchecked

Run Details

197 of 1455 new or added lines in 154 files covered. (13.54%)

8646 of 35901 relevant lines covered (24.08%)

142.28 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/vortex-array/src/arrow/datum.rs

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright the Vortex contributors

use arrow_array::{Array as ArrowArray, ArrayRef as ArrowArrayRef, Datum as ArrowDatum};
use arrow_schema::DataType;
use vortex_error::{VortexResult, vortex_panic};

use crate::arrays::ConstantArray;
use crate::arrow::{FromArrowArray, IntoArrowArray};
use crate::{Array, ArrayRef, IntoArray};

/// A wrapper around a generic Arrow array that can be used as a Datum in Arrow compute.
#[derive(Debug)]
pub struct Datum {
    array: ArrowArrayRef,
    is_scalar: bool,
}

impl Datum {
    /// Create a new [`Datum`] from an [`ArrayRef`], which can then be passed to Arrow compute.
    pub fn try_new(array: &dyn Array) -> VortexResult<Self> {
        if array.is_constant() {
            Ok(Self {
                array: array.slice(0, 1).into_arrow_preferred()?,
                is_scalar: true,
            })
        } else {
            Ok(Self {
                array: array.to_array().into_arrow_preferred()?,
                is_scalar: false,
            })
        }
    }

    pub fn with_target_datatype(
        array: &dyn Array,
        target_datatype: &DataType,
    ) -> VortexResult<Self> {
        if array.is_constant() {
            Ok(Self {
                array: array.slice(0, 1).into_arrow(target_datatype)?,
                is_scalar: true,
            })
        } else {
            Ok(Self {
                array: array.to_array().into_arrow(target_datatype)?,
                is_scalar: false,
            })
        }
    }
}

impl ArrowDatum for Datum {
    fn get(&self) -> (&dyn ArrowArray, bool) {
        (&self.array, self.is_scalar)
    }
}

/// Convert an Arrow array to an Array with a specific length.
/// This is useful for compute functions that delegate to Arrow using [Datum],
/// which will return a scalar (length 1 Arrow array) if the input array is constant.
///
/// # Error
///
/// The provided array must have length
pub fn from_arrow_array_with_len<A>(array: A, len: usize, nullable: bool) -> ArrayRef
where
    ArrayRef: FromArrowArray<A>,
{
    let array = ArrayRef::from_arrow(array, nullable);
    if array.len() == len {
        return array;
    }

    if array.len() != 1 {
        vortex_panic!(
            "Array length mismatch, expected {} got {} for encoding {}",
            len,
            array.len(),
            array.encoding_id()
        );
    }

    ConstantArray::new(array.scalar_at(0), len).into_array()
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	use arrow_array::{Array as ArrowArray, ArrayRef as ArrowArrayRef, Datum as ArrowDatum};
5	use arrow_schema::DataType;
6	use vortex_error::{VortexResult, vortex_panic};
7
8	use crate::arrays::ConstantArray;
9	use crate::arrow::{FromArrowArray, IntoArrowArray};
10	use crate::{Array, ArrayRef, IntoArray};
11
12	/// A wrapper around a generic Arrow array that can be used as a Datum in Arrow compute.
13	#[derive(Debug)]
14	pub struct Datum {
15	array: ArrowArrayRef,
16	is_scalar: bool,
17	}
18
19	impl Datum {
20	/// Create a new [`Datum`] from an [`ArrayRef`], which can then be passed to Arrow compute.
21	pub fn try_new(array: &dyn Array) -> VortexResult<Self> {	×
22	if array.is_constant() {	×
23	Ok(Self {
NEW 24	array: array.slice(0, 1).into_arrow_preferred()?,	×
25	is_scalar: true,
26	})
27	} else {
28	Ok(Self {
29	array: array.to_array().into_arrow_preferred()?,	×
30	is_scalar: false,
31	})
32	}
33	}	×
34
35	pub fn with_target_datatype(	×
36	array: &dyn Array,	×
37	target_datatype: &DataType,	×
38	) -> VortexResult<Self> {	×
39	if array.is_constant() {	×
40	Ok(Self {
NEW 41	array: array.slice(0, 1).into_arrow(target_datatype)?,	×
42	is_scalar: true,
43	})
44	} else {
45	Ok(Self {
46	array: array.to_array().into_arrow(target_datatype)?,	×
47	is_scalar: false,
48	})
49	}
50	}	×
51	}
52
53	impl ArrowDatum for Datum {
54	fn get(&self) -> (&dyn ArrowArray, bool) {	×
55	(&self.array, self.is_scalar)	×
56	}	×
57	}
58
59	/// Convert an Arrow array to an Array with a specific length.
60	/// This is useful for compute functions that delegate to Arrow using [Datum],
61	/// which will return a scalar (length 1 Arrow array) if the input array is constant.
62	///
63	/// # Error
64	///
65	/// The provided array must have length
NEW 66	pub fn from_arrow_array_with_len<A>(array: A, len: usize, nullable: bool) -> ArrayRef	×
67	where	×
68	ArrayRef: FromArrowArray<A>,	×
69	{
70	let array = ArrayRef::from_arrow(array, nullable);	×
71	if array.len() == len {	×
NEW 72	return array;	×
73	}	×
74
75	if array.len() != 1 {	×
76	vortex_panic!(	×
77	"Array length mismatch, expected {} got {} for encoding {}",	×
78	len,
79	array.len(),	×
80	array.encoding_id()	×
81	);
82	}	×
83
NEW 84	ConstantArray::new(array.scalar_at(0), len).into_array()	×
85	}	×

vortex-data / vortex / 17073077835

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous