16888979360

Committed 11 Aug 2025 06:38PM UTC coverage: 86.448% (+0.1%) from 86.315%

Build # 16888979360

Build Type

Pull #4177

github

Committed by

web-flow

Commit Message

Merge be9bafd2c into 448374543

Pull Request Pull Request #4177: (WIP) feat: ArrayOperations infallible

Run Details

1178 of 1266 new or added lines in 146 files covered. (93.05%)

18 existing lines in 13 files now uncovered.

53531 of 61923 relevant lines covered (86.45%)

539129.92 hits per line

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

61.29

/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> {	263,683✔
22	if array.is_constant() {	263,683✔
23	Ok(Self {
24	array: array.slice(0, 1).into_arrow_preferred()?,	131,034✔
25	is_scalar: true,
26	})
27	} else {
28	Ok(Self {
29	array: array.to_array().into_arrow_preferred()?,	132,649✔
30	is_scalar: false,
31	})
32	}
33	}	263,683✔
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) {	263,683✔
55	(&self.array, self.is_scalar)	263,683✔
56	}	263,683✔
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
66	pub fn from_arrow_array_with_len<A>(array: A, len: usize, nullable: bool) -> ArrayRef	122,763✔
67	where	122,763✔
68	ArrayRef: FromArrowArray<A>,	122,763✔
69	{
70	let array = ArrayRef::from_arrow(array, nullable);	122,763✔
71	if array.len() == len {	122,763✔
72	return array;	122,762✔
73	}	1✔
74
75	if array.len() != 1 {	1✔
76	vortex_panic!(	×
77	"Array length mismatch, expected {} got {} for encoding {}",	×
78	len,
79	array.len(),	×
80	array.encoding_id()	×
81	);
82	}	1✔
83
84	ConstantArray::new(array.scalar_at(0), len).into_array()	1✔
85	}	122,763✔

vortex-data / vortex / 16888979360

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