16331938722

Committed 16 Jul 2025 10:49PM UTC coverage: 80.702% (-0.9%) from 81.557%

Build # 16331938722

Build Type

push

github

Committed by

web-flow

Commit Message

feat: build with stable rust (#3881)

Run Details

120 of 173 new or added lines in 28 files covered. (69.36%)

174 existing lines in 102 files now uncovered.

41861 of 51871 relevant lines covered (80.7%)

157487.71 hits per line

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

79.59

/vortex-array/src/arrow/compute/to_arrow/varbin.rs

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

use std::sync::Arc;

use arrow_array::{
    ArrayRef as ArrowArrayRef, GenericBinaryArray, GenericStringArray, OffsetSizeTrait,
};
use arrow_schema::DataType;
use vortex_dtype::{DType, NativePType, Nullability, PType};
use vortex_error::{VortexResult, vortex_bail};

use crate::arrays::{VarBinArray, VarBinVTable};
use crate::arrow::compute::{ToArrowKernel, ToArrowKernelAdapter};
use crate::compute::cast;
use crate::{Array, ToCanonical, register_kernel};

impl ToArrowKernel for VarBinVTable {
    fn to_arrow(
        &self,
        array: &VarBinArray,
        arrow_type: Option<&DataType>,
    ) -> VortexResult<Option<ArrowArrayRef>> {
        let offsets_ptype = PType::try_from(array.offsets().dtype())?;

        match arrow_type {
            // Emit out preferred Arrow VarBin array.
            None => match array.dtype() {
                DType::Binary(_) => match offsets_ptype {
                    PType::I64 | PType::U64 => to_arrow::<i64>(array),
                    _ => to_arrow::<i32>(array),
                },
                DType::Utf8(_) => match offsets_ptype {
                    PType::I64 | PType::U64 => to_arrow::<i64>(array),
                    _ => to_arrow::<i32>(array),
                },
                _ => unreachable!("Unsupported DType"),
            },
            // Emit the requested Arrow array.
            Some(DataType::Binary) if array.dtype().is_binary() => to_arrow::<i32>(array),
            Some(DataType::LargeBinary) if array.dtype().is_binary() => to_arrow::<i64>(array),
            Some(DataType::Utf8) if array.dtype().is_utf8() => to_arrow::<i32>(array),
            Some(DataType::LargeUtf8) if array.dtype().is_utf8() => to_arrow::<i64>(array),
            // Allow fallback to canonicalize to a VarBinView and try again.
            Some(DataType::BinaryView) | Some(DataType::Utf8View) => {
                return Ok(None);
            }
            // Any other type is not supported.
            Some(_) => {
                vortex_bail!("Cannot convert VarBin to Arrow type {arrow_type:?}");
            }
        }
        .map(Some)
    }
}

register_kernel!(ToArrowKernelAdapter(VarBinVTable).lift());

fn to_arrow<O: NativePType + OffsetSizeTrait>(array: &VarBinArray) -> VortexResult<ArrowArrayRef> {
    let offsets = cast(
        array.offsets(),
        &DType::Primitive(O::PTYPE, Nullability::NonNullable),
    )?
    .to_primitive()
    .map_err(|err| err.with_context("Failed to canonicalize offsets"))?;

    let nulls = array.validity_mask()?.to_null_buffer();
    let data = array.bytes().clone();

    // Switch on DType.
    Ok(match array.dtype() {
        DType::Binary(_) => Arc::new(unsafe {
            GenericBinaryArray::new_unchecked(
                offsets.buffer::<O>().into_arrow_offset_buffer(),
                data.into_arrow_buffer(),
                nulls,
            )
        }),
        DType::Utf8(_) => Arc::new(unsafe {
            GenericStringArray::new_unchecked(
                offsets.buffer::<O>().into_arrow_offset_buffer(),
                data.into_arrow_buffer(),
                nulls,
            )
        }),
        _ => unreachable!("expected utf8 or binary instead of {}", array.dtype()),
    })
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	use std::sync::Arc;
5
6	use arrow_array::{
7	ArrayRef as ArrowArrayRef, GenericBinaryArray, GenericStringArray, OffsetSizeTrait,
8	};
9	use arrow_schema::DataType;
10	use vortex_dtype::{DType, NativePType, Nullability, PType};
11	use vortex_error::{VortexResult, vortex_bail};
12
13	use crate::arrays::{VarBinArray, VarBinVTable};
14	use crate::arrow::compute::{ToArrowKernel, ToArrowKernelAdapter};
15	use crate::compute::cast;
16	use crate::{Array, ToCanonical, register_kernel};
17
18	impl ToArrowKernel for VarBinVTable {
19	fn to_arrow(	1,687✔
20	&self,	1,687✔
21	array: &VarBinArray,	1,687✔
22	arrow_type: Option<&DataType>,	1,687✔
23	) -> VortexResult<Option<ArrowArrayRef>> {	1,687✔
24	let offsets_ptype = PType::try_from(array.offsets().dtype())?;	1,687✔
25
26	match arrow_type {	×
27	// Emit out preferred Arrow VarBin array.
28	None => match array.dtype() {	1,614✔
29	DType::Binary(_) => match offsets_ptype {	205✔
30	PType::I64 \| PType::U64 => to_arrow::<i64>(array),	×
31	_ => to_arrow::<i32>(array),	205✔
32	},
33	DType::Utf8(_) => match offsets_ptype {	1,409✔
34	PType::I64 \| PType::U64 => to_arrow::<i64>(array),	×
35	_ => to_arrow::<i32>(array),	1,409✔
36	},
37	_ => unreachable!("Unsupported DType"),	×
38	},
39	// Emit the requested Arrow array.
40	Some(DataType::Binary) if array.dtype().is_binary() => to_arrow::<i32>(array),	×
41	Some(DataType::LargeBinary) if array.dtype().is_binary() => to_arrow::<i64>(array),	×
42	Some(DataType::Utf8) if array.dtype().is_utf8() => to_arrow::<i32>(array),	1✔
43	Some(DataType::LargeUtf8) if array.dtype().is_utf8() => to_arrow::<i64>(array),	×
44	// Allow fallback to canonicalize to a VarBinView and try again.
45	Some(DataType::BinaryView) \| Some(DataType::Utf8View) => {
46	return Ok(None);	72✔
47	}
48	// Any other type is not supported.
49	Some(_) => {
50	vortex_bail!("Cannot convert VarBin to Arrow type {arrow_type:?}");	×
51	}
52	}
53	.map(Some)	1,615✔
54	}	1,687✔
55	}
56
57	register_kernel!(ToArrowKernelAdapter(VarBinVTable).lift());
58
59	fn to_arrow<O: NativePType + OffsetSizeTrait>(array: &VarBinArray) -> VortexResult<ArrowArrayRef> {	1,615✔
60	let offsets = cast(	1,615✔
61	array.offsets(),	1,615✔
62	&DType::Primitive(O::PTYPE, Nullability::NonNullable),	1,615✔
UNCOV 63	)?	×
64	.to_primitive()	1,615✔
65	.map_err(\|err\| err.with_context("Failed to canonicalize offsets"))?;	1,615✔
66
67	let nulls = array.validity_mask()?.to_null_buffer();	1,615✔
68	let data = array.bytes().clone();	1,615✔
69
70	// Switch on DType.
71	Ok(match array.dtype() {	1,615✔
72	DType::Binary(_) => Arc::new(unsafe {	205✔
73	GenericBinaryArray::new_unchecked(	205✔
74	offsets.buffer::<O>().into_arrow_offset_buffer(),	205✔
75	data.into_arrow_buffer(),	205✔
76	nulls,	205✔
77	)	205✔
78	}),	205✔
79	DType::Utf8(_) => Arc::new(unsafe {	1,410✔
80	GenericStringArray::new_unchecked(	1,410✔
81	offsets.buffer::<O>().into_arrow_offset_buffer(),	1,410✔
82	data.into_arrow_buffer(),	1,410✔
83	nulls,	1,410✔
84	)	1,410✔
85	}),	1,410✔
86	_ => unreachable!("expected utf8 or binary instead of {}", array.dtype()),	×
87	})
88	}	1,615✔

vortex-data / vortex / 16331938722

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