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

Coverage Stats

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/compute/like.rs

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

use std::any::Any;
use std::sync::LazyLock;

use arcref::ArcRef;
use vortex_dtype::DType;
use vortex_error::{VortexError, VortexExpect, VortexResult, vortex_bail, vortex_err};

use crate::arrow::{Datum, from_arrow_array_with_len};
use crate::compute::{ComputeFn, ComputeFnVTable, InvocationArgs, Kernel, Options, Output};
use crate::vtable::VTable;
use crate::{Array, ArrayRef};

static LIKE_FN: LazyLock<ComputeFn> = LazyLock::new(|| {
    let compute = ComputeFn::new("like".into(), ArcRef::new_ref(&Like));
    for kernel in inventory::iter::<LikeKernelRef> {
        compute.register_kernel(kernel.0.clone());
    }
    compute
});

/// Perform SQL left LIKE right
///
/// There are two wildcards supported with the LIKE operator:
/// - %: matches zero or more characters
/// - _: matches exactly one character
pub fn like(
    array: &dyn Array,
    pattern: &dyn Array,
    options: LikeOptions,
) -> VortexResult<ArrayRef> {
    LIKE_FN
        .invoke(&InvocationArgs {
            inputs: &[array.into(), pattern.into()],
            options: &options,
        })?
        .unwrap_array()
}

pub struct LikeKernelRef(ArcRef<dyn Kernel>);
inventory::collect!(LikeKernelRef);

pub trait LikeKernel: VTable {
    fn like(
        &self,
        array: &Self::Array,
        pattern: &dyn Array,
        options: LikeOptions,
    ) -> VortexResult<Option<ArrayRef>>;
}

#[derive(Debug)]
pub struct LikeKernelAdapter<V: VTable>(pub V);

impl<V: VTable + LikeKernel> LikeKernelAdapter<V> {
    pub const fn lift(&'static self) -> LikeKernelRef {
        LikeKernelRef(ArcRef::new_ref(self))
    }
}

impl<V: VTable + LikeKernel> Kernel for LikeKernelAdapter<V> {
    fn invoke(&self, args: &InvocationArgs) -> VortexResult<Option<Output>> {
        let inputs = LikeArgs::try_from(args)?;
        let Some(array) = inputs.array.as_opt::<V>() else {
            return Ok(None);
        };
        Ok(V::like(&self.0, array, inputs.pattern, inputs.options)?.map(|array| array.into()))
    }
}

struct Like;

impl ComputeFnVTable for Like {
    fn invoke(
        &self,
        args: &InvocationArgs,
        kernels: &[ArcRef<dyn Kernel>],
    ) -> VortexResult<Output> {
        let LikeArgs {
            array,
            pattern,
            options,
        } = LikeArgs::try_from(args)?;

        for kernel in kernels {
            if let Some(output) = kernel.invoke(args)? {
                return Ok(output);
            }
        }
        if let Some(output) = array.invoke(&LIKE_FN, args)? {
            return Ok(output);
        }

        // Otherwise, we fall back to the Arrow implementation
        Ok(arrow_like(array, pattern, options)?.into())
    }

    fn return_dtype(&self, args: &InvocationArgs) -> VortexResult<DType> {
        let LikeArgs { array, pattern, .. } = LikeArgs::try_from(args)?;
        if !matches!(array.dtype(), DType::Utf8(..)) {
            vortex_bail!("Expected utf8 array, got {}", array.dtype());
        }
        if !matches!(pattern.dtype(), DType::Utf8(..)) {
            vortex_bail!("Expected utf8 pattern, got {}", array.dtype());
        }
        let nullability = array.dtype().is_nullable() || pattern.dtype().is_nullable();
        Ok(DType::Bool(nullability.into()))
    }

    fn return_len(&self, args: &InvocationArgs) -> VortexResult<usize> {
        let LikeArgs { array, pattern, .. } = LikeArgs::try_from(args)?;
        if array.len() != pattern.len() {
            vortex_bail!(
                "Length mismatch lhs len {} ({}) != rhs len {} ({})",
                array.len(),
                array.encoding_id(),
                pattern.len(),
                pattern.encoding_id()
            );
        }
        Ok(array.len())
    }

    fn is_elementwise(&self) -> bool {
        true
    }
}

/// Options for SQL LIKE function
#[derive(Default, Debug, Clone, Copy)]
pub struct LikeOptions {
    pub negated: bool,
    pub case_insensitive: bool,
}

impl Options for LikeOptions {
    fn as_any(&self) -> &dyn Any {
        self
    }
}

struct LikeArgs<'a> {
    array: &'a dyn Array,
    pattern: &'a dyn Array,
    options: LikeOptions,
}

impl<'a> TryFrom<&InvocationArgs<'a>> for LikeArgs<'a> {
    type Error = VortexError;

    fn try_from(value: &InvocationArgs<'a>) -> Result<Self, Self::Error> {
        if value.inputs.len() != 2 {
            vortex_bail!("Expected 2 inputs, found {}", value.inputs.len());
        }
        let array = value.inputs[0]
            .array()
            .ok_or_else(|| vortex_err!("Expected first input to be an array"))?;
        let pattern = value.inputs[1]
            .array()
            .ok_or_else(|| vortex_err!("Expected second input to be an array"))?;
        let options = *value
            .options
            .as_any()
            .downcast_ref::<LikeOptions>()
            .vortex_expect("Expected options to be LikeOptions");

        Ok(LikeArgs {
            array,
            pattern,
            options,
        })
    }
}

/// Implementation of `LikeFn` using the Arrow crate.
pub(crate) fn arrow_like(
    array: &dyn Array,
    pattern: &dyn Array,
    options: LikeOptions,
) -> VortexResult<ArrayRef> {
    let nullable = array.dtype().is_nullable() | pattern.dtype().is_nullable();
    let len = array.len();
    assert_eq!(
        array.len(),
        pattern.len(),
        "Arrow Like: length mismatch for {}",
        array.encoding_id()
    );
    let lhs = Datum::try_new(array)?;
    let rhs = Datum::try_new(pattern)?;

    let result = match (options.negated, options.case_insensitive) {
        (false, false) => arrow_string::like::like(&lhs, &rhs)?,
        (true, false) => arrow_string::like::nlike(&lhs, &rhs)?,
        (false, true) => arrow_string::like::ilike(&lhs, &rhs)?,
        (true, true) => arrow_string::like::nilike(&lhs, &rhs)?,
    };

    Ok(from_arrow_array_with_len(&result, len, nullable))
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	use std::any::Any;
5	use std::sync::LazyLock;
6
7	use arcref::ArcRef;
8	use vortex_dtype::DType;
9	use vortex_error::{VortexError, VortexExpect, VortexResult, vortex_bail, vortex_err};
10
11	use crate::arrow::{Datum, from_arrow_array_with_len};
12	use crate::compute::{ComputeFn, ComputeFnVTable, InvocationArgs, Kernel, Options, Output};
13	use crate::vtable::VTable;
14	use crate::{Array, ArrayRef};
15
16	static LIKE_FN: LazyLock<ComputeFn> = LazyLock::new(\|\| {	×
17	let compute = ComputeFn::new("like".into(), ArcRef::new_ref(&Like));	×
18	for kernel in inventory::iter::<LikeKernelRef> {	×
19	compute.register_kernel(kernel.0.clone());	×
20	}	×
21	compute	×
22	});	×
23
24	/// Perform SQL left LIKE right
25	///
26	/// There are two wildcards supported with the LIKE operator:
27	/// - %: matches zero or more characters
28	/// - _: matches exactly one character
29	pub fn like(	×
30	array: &dyn Array,	×
31	pattern: &dyn Array,	×
32	options: LikeOptions,	×
33	) -> VortexResult<ArrayRef> {	×
34	LIKE_FN	×
35	.invoke(&InvocationArgs {	×
36	inputs: &[array.into(), pattern.into()],	×
37	options: &options,	×
38	})?	×
39	.unwrap_array()	×
40	}	×
41
42	pub struct LikeKernelRef(ArcRef<dyn Kernel>);
43	inventory::collect!(LikeKernelRef);
44
45	pub trait LikeKernel: VTable {
46	fn like(
47	&self,
48	array: &Self::Array,
49	pattern: &dyn Array,
50	options: LikeOptions,
51	) -> VortexResult<Option<ArrayRef>>;
52	}
53
54	#[derive(Debug)]
55	pub struct LikeKernelAdapter<V: VTable>(pub V);
56
57	impl<V: VTable + LikeKernel> LikeKernelAdapter<V> {
58	pub const fn lift(&'static self) -> LikeKernelRef {	×
59	LikeKernelRef(ArcRef::new_ref(self))	×
60	}	×
61	}
62
63	impl<V: VTable + LikeKernel> Kernel for LikeKernelAdapter<V> {
64	fn invoke(&self, args: &InvocationArgs) -> VortexResult<Option<Output>> {	×
65	let inputs = LikeArgs::try_from(args)?;	×
66	let Some(array) = inputs.array.as_opt::<V>() else {	×
67	return Ok(None);	×
68	};
69	Ok(V::like(&self.0, array, inputs.pattern, inputs.options)?.map(\|array\| array.into()))	×
70	}	×
71	}
72
73	struct Like;
74
75	impl ComputeFnVTable for Like {
76	fn invoke(	×
77	&self,	×
78	args: &InvocationArgs,	×
79	kernels: &[ArcRef<dyn Kernel>],	×
80	) -> VortexResult<Output> {	×
81	let LikeArgs {
82	array,	×
83	pattern,	×
84	options,	×
85	} = LikeArgs::try_from(args)?;	×
86
87	for kernel in kernels {	×
88	if let Some(output) = kernel.invoke(args)? {	×
89	return Ok(output);	×
90	}	×
91	}
92	if let Some(output) = array.invoke(&LIKE_FN, args)? {	×
93	return Ok(output);	×
94	}	×
95
96	// Otherwise, we fall back to the Arrow implementation
97	Ok(arrow_like(array, pattern, options)?.into())	×
98	}	×
99
100	fn return_dtype(&self, args: &InvocationArgs) -> VortexResult<DType> {	×
101	let LikeArgs { array, pattern, .. } = LikeArgs::try_from(args)?;	×
102	if !matches!(array.dtype(), DType::Utf8(..)) {	×
103	vortex_bail!("Expected utf8 array, got {}", array.dtype());	×
104	}	×
105	if !matches!(pattern.dtype(), DType::Utf8(..)) {	×
106	vortex_bail!("Expected utf8 pattern, got {}", array.dtype());	×
107	}	×
108	let nullability = array.dtype().is_nullable() \|\| pattern.dtype().is_nullable();	×
109	Ok(DType::Bool(nullability.into()))	×
110	}	×
111
112	fn return_len(&self, args: &InvocationArgs) -> VortexResult<usize> {	×
113	let LikeArgs { array, pattern, .. } = LikeArgs::try_from(args)?;	×
114	if array.len() != pattern.len() {	×
115	vortex_bail!(	×
116	"Length mismatch lhs len {} ({}) != rhs len {} ({})",	×
117	array.len(),	×
118	array.encoding_id(),	×
119	pattern.len(),	×
120	pattern.encoding_id()	×
121	);
122	}	×
123	Ok(array.len())	×
124	}	×
125
126	fn is_elementwise(&self) -> bool {	×
127	true	×
128	}	×
129	}
130
131	/// Options for SQL LIKE function
132	#[derive(Default, Debug, Clone, Copy)]
133	pub struct LikeOptions {
134	pub negated: bool,
135	pub case_insensitive: bool,
136	}
137
138	impl Options for LikeOptions {
139	fn as_any(&self) -> &dyn Any {	×
140	self	×
141	}	×
142	}
143
144	struct LikeArgs<'a> {
145	array: &'a dyn Array,
146	pattern: &'a dyn Array,
147	options: LikeOptions,
148	}
149
150	impl<'a> TryFrom<&InvocationArgs<'a>> for LikeArgs<'a> {
151	type Error = VortexError;
152
153	fn try_from(value: &InvocationArgs<'a>) -> Result<Self, Self::Error> {	×
154	if value.inputs.len() != 2 {	×
155	vortex_bail!("Expected 2 inputs, found {}", value.inputs.len());	×
156	}	×
157	let array = value.inputs[0]	×
158	.array()	×
159	.ok_or_else(\|\| vortex_err!("Expected first input to be an array"))?;	×
160	let pattern = value.inputs[1]	×
161	.array()	×
162	.ok_or_else(\|\| vortex_err!("Expected second input to be an array"))?;	×
163	let options = *value	×
164	.options	×
165	.as_any()	×
166	.downcast_ref::<LikeOptions>()	×
167	.vortex_expect("Expected options to be LikeOptions");	×
168
169	Ok(LikeArgs {	×
170	array,	×
171	pattern,	×
172	options,	×
173	})	×
174	}	×
175	}
176
177	/// Implementation of `LikeFn` using the Arrow crate.
178	pub(crate) fn arrow_like(	×
179	array: &dyn Array,	×
180	pattern: &dyn Array,	×
181	options: LikeOptions,	×
182	) -> VortexResult<ArrayRef> {	×
183	let nullable = array.dtype().is_nullable() \| pattern.dtype().is_nullable();	×
184	let len = array.len();	×
185	assert_eq!(	×
186	array.len(),	×
187	pattern.len(),	×
188	"Arrow Like: length mismatch for {}",	×
189	array.encoding_id()	×
190	);
191	let lhs = Datum::try_new(array)?;	×
192	let rhs = Datum::try_new(pattern)?;	×
193
194	let result = match (options.negated, options.case_insensitive) {	×
195	(false, false) => arrow_string::like::like(&lhs, &rhs)?,	×
196	(true, false) => arrow_string::like::nlike(&lhs, &rhs)?,	×
197	(false, true) => arrow_string::like::ilike(&lhs, &rhs)?,	×
198	(true, true) => arrow_string::like::nilike(&lhs, &rhs)?,	×
199	};
200
NEW 201	Ok(from_arrow_array_with_len(&result, len, nullable))	×
202	}	×

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