16935267080

Committed 13 Aug 2025 11:00AM UTC coverage: 24.312% (-63.3%) from 87.658%

Build # 16935267080

Build Type

Pull #4226

github

Committed by

web-flow

Commit Message

Merge 81b48c7fb into baa6ea202

Pull Request Pull Request #4226: Support converting TimestampTZ to and from duckdb

Run Details

0 of 2 new or added lines in 1 file covered. (0.0%)

20666 existing lines in 469 files now uncovered.

8726 of 35892 relevant lines covered (24.31%)

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

vortex-data / vortex / 16935267080

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