16842450156

Committed 08 Aug 2025 11:22PM UTC coverage: 86.303% (+0.07%) from 86.234%

Build # 16842450156

Build Type

Pull #4177

github

Committed by

web-flow

Commit Message

Merge d774e31ff into de5f71d7b

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

Run Details

619 of 689 new or added lines in 105 files covered. (89.84%)

13 existing lines in 8 files now uncovered.

53559 of 62059 relevant lines covered (86.3%)

542885.51 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.
///
/// Panics if the length of the array is not 1 and also not equal to the expected length.
pub fn from_arrow_array_with_len<A>(array: A, len: usize, nullable: bool) -> VortexResult<ArrayRef>
where
    ArrayRef: FromArrowArray<A>,
{
    let array = ArrayRef::from_arrow(array, nullable);
    if array.len() == len {
        return Ok(array);
    }

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

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

vortex-data / vortex / 16842450156

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