16473770414

Committed 23 Jul 2025 02:38PM UTC coverage: 80.988% (-0.07%) from 81.055%

Build # 16473770414

Build Type

push

github

Committed by

web-flow

Commit Message

chore[duckdb]: scan log info -> trace (#3989)

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

35 existing lines in 7 files now uncovered.

42052 of 51924 relevant lines covered (80.99%)

173623.22 hits per line

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

83.82

/vortex-expr/src/exprs/list_contains.rs

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

use std::fmt::{Debug, Display, Formatter};
use std::hash::Hash;

use vortex_array::compute::list_contains as compute_list_contains;
use vortex_array::{ArrayRef, DeserializeMetadata, EmptyMetadata};
use vortex_dtype::DType;
use vortex_error::{VortexResult, vortex_bail};

use crate::{
    AnalysisExpr, ExprEncodingRef, ExprId, ExprRef, IntoExpr, LiteralVTable, Scope, StatsCatalog,
    VTable, and, gt, lit, lt, or, vtable,
};

vtable!(ListContains);

#[allow(clippy::derived_hash_with_manual_eq)]
#[derive(Debug, Clone, Hash)]
pub struct ListContainsExpr {
    list: ExprRef,
    value: ExprRef,
}

impl PartialEq for ListContainsExpr {
    fn eq(&self, other: &Self) -> bool {
        self.list.eq(&other.list) && self.value.eq(&other.value)
    }
}

pub struct ListContainsExprEncoding;

impl VTable for ListContainsVTable {
    type Expr = ListContainsExpr;
    type Encoding = ListContainsExprEncoding;
    type Metadata = EmptyMetadata;

    fn id(_encoding: &Self::Encoding) -> ExprId {
        ExprId::new_ref("list_contains")
    }

    fn encoding(_expr: &Self::Expr) -> ExprEncodingRef {
        ExprEncodingRef::new_ref(ListContainsExprEncoding.as_ref())
    }

    fn metadata(_expr: &Self::Expr) -> Option<Self::Metadata> {
        Some(EmptyMetadata)
    }

    fn children(expr: &Self::Expr) -> Vec<&ExprRef> {
        vec![&expr.list, &expr.value]
    }

    fn with_children(_expr: &Self::Expr, children: Vec<ExprRef>) -> VortexResult<Self::Expr> {
        Ok(ListContainsExpr::new(
            children[0].clone(),
            children[1].clone(),
        ))
    }

    fn build(
        _encoding: &Self::Encoding,
        _metadata: &<Self::Metadata as DeserializeMetadata>::Output,
        children: Vec<ExprRef>,
    ) -> VortexResult<Self::Expr> {
        if children.len() != 2 {
            vortex_bail!(
                "ListContains expression must have exactly 2 children, got {}",
                children.len()
            );
        }
        Ok(ListContainsExpr::new(
            children[0].clone(),
            children[1].clone(),
        ))
    }

    fn evaluate(expr: &Self::Expr, scope: &Scope) -> VortexResult<ArrayRef> {
        compute_list_contains(
            expr.list.evaluate(scope)?.as_ref(),
            expr.value.evaluate(scope)?.as_ref(),
        )
    }

    fn return_dtype(expr: &Self::Expr, scope: &DType) -> VortexResult<DType> {
        Ok(DType::Bool(
            expr.list.return_dtype(scope)?.nullability()
                | expr.value.return_dtype(scope)?.nullability(),
        ))
    }
}

impl ListContainsExpr {
    pub fn new(list: ExprRef, value: ExprRef) -> Self {
        Self { list, value }
    }

    pub fn new_expr(list: ExprRef, value: ExprRef) -> ExprRef {
        Self::new(list, value).into_expr()
    }

    pub fn value(&self) -> &ExprRef {
        &self.value
    }
}

pub fn list_contains(list: ExprRef, value: ExprRef) -> ExprRef {
    ListContainsExpr::new(list, value).into_expr()
}

impl Display for ListContainsExpr {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "contains({}, {})", &self.list, &self.value)
    }
}

impl AnalysisExpr for ListContainsExpr {
    // falsification(contains([1,2,5], x)) =>
    //   falsification(x != 1) and falsification(x != 2) and falsification(x != 5)

    fn stat_falsification(&self, catalog: &mut dyn StatsCatalog) -> Option<ExprRef> {
        let min = self.list.min(catalog)?;
        let max = self.list.max(catalog)?;
        // If the list is constant when we can compare each element to the value
        if min == max {
            let list_ = min
                .as_opt::<LiteralVTable>()
                .and_then(|l| l.value().as_list_opt())
                .and_then(|l| l.elements())?;
            if list_.is_empty() {
                // contains([], x) is always false.
                return Some(lit(true));
            }
            let value_max = self.value.max(catalog)?;
            let value_min = self.value.min(catalog)?;

            return list_
                .iter()
                .map(move |v| {
                    or(
                        lt(value_max.clone(), lit(v.clone())),
                        gt(value_min.clone(), lit(v.clone())),
                    )
                })
                .reduce(and);
        }

        None
    }
}

#[cfg(test)]
mod tests {
    use vortex_array::arrays::{BoolArray, BooleanBuffer, ListArray, PrimitiveArray};
    use vortex_array::stats::Stat;
    use vortex_array::validity::Validity;
    use vortex_array::{Array, ArrayRef, IntoArray};
    use vortex_dtype::PType::I32;
    use vortex_dtype::{DType, Field, FieldPath, FieldPathSet, Nullability, StructFields};
    use vortex_scalar::Scalar;
    use vortex_utils::aliases::hash_map::HashMap;

    use crate::list_contains::list_contains;
    use crate::pruning::checked_pruning_expr;
    use crate::{Arc, HashSet, Scope, and, col, get_item, gt, lit, lt, or, root};

    fn test_array() -> ArrayRef {
        ListArray::try_new(
            PrimitiveArray::from_iter(vec![1, 1, 2, 2, 2, 2, 2, 3, 3, 3]).into_array(),
            PrimitiveArray::from_iter(vec![0, 5, 10]).into_array(),
            Validity::AllValid,
        )
        .unwrap()
        .into_array()
    }

    #[test]
    pub fn test_one() {
        let arr = test_array();

        let expr = list_contains(root(), lit(1));
        let item = expr.evaluate(&Scope::new(arr)).unwrap();

        assert_eq!(
            item.scalar_at(0).unwrap(),
            Scalar::bool(true, Nullability::Nullable)
        );
        assert_eq!(
            item.scalar_at(1).unwrap(),
            Scalar::bool(false, Nullability::Nullable)
        );
    }

    #[test]
    pub fn test_all() {
        let arr = test_array();

        let expr = list_contains(root(), lit(2));
        let item = expr.evaluate(&Scope::new(arr)).unwrap();

        assert_eq!(
            item.scalar_at(0).unwrap(),
            Scalar::bool(true, Nullability::Nullable)
        );
        assert_eq!(
            item.scalar_at(1).unwrap(),
            Scalar::bool(true, Nullability::Nullable)
        );
    }

    #[test]
    pub fn test_none() {
        let arr = test_array();

        let expr = list_contains(root(), lit(4));
        let item = expr.evaluate(&Scope::new(arr)).unwrap();

        assert_eq!(
            item.scalar_at(0).unwrap(),
            Scalar::bool(false, Nullability::Nullable)
        );
        assert_eq!(
            item.scalar_at(1).unwrap(),
            Scalar::bool(false, Nullability::Nullable)
        );
    }

    #[test]
    pub fn test_empty() {
        let arr = ListArray::try_new(
            PrimitiveArray::from_iter(vec![1, 1, 2, 2, 2]).into_array(),
            PrimitiveArray::from_iter(vec![0, 5, 5]).into_array(),
            Validity::AllValid,
        )
        .unwrap()
        .into_array();

        let expr = list_contains(root(), lit(2));
        let item = expr.evaluate(&Scope::new(arr)).unwrap();

        assert_eq!(
            item.scalar_at(0).unwrap(),
            Scalar::bool(true, Nullability::Nullable)
        );
        assert_eq!(
            item.scalar_at(1).unwrap(),
            Scalar::bool(false, Nullability::Nullable)
        );
    }

    #[test]
    pub fn test_nullable() {
        let arr = ListArray::try_new(
            PrimitiveArray::from_iter(vec![1, 1, 2, 2, 2]).into_array(),
            PrimitiveArray::from_iter(vec![0, 5, 5]).into_array(),
            Validity::Array(BoolArray::from(BooleanBuffer::from(vec![true, false])).into_array()),
        )
        .unwrap()
        .into_array();

        let expr = list_contains(root(), lit(2));
        let item = expr.evaluate(&Scope::new(arr)).unwrap();

        assert_eq!(
            item.scalar_at(0).unwrap(),
            Scalar::bool(true, Nullability::Nullable)
        );
        assert!(!item.is_valid(1).unwrap());
    }

    #[test]
    pub fn test_return_type() {
        let scope = DType::Struct(
            StructFields::new(
                ["array"].into(),
                vec![DType::List(
                    Arc::new(DType::Primitive(I32, Nullability::NonNullable)),
                    Nullability::Nullable,
                )],
            ),
            Nullability::NonNullable,
        );

        let expr = list_contains(get_item("array", root()), lit(2));

        // Expect nullable, although scope is non-nullable
        assert_eq!(
            expr.return_dtype(&scope).unwrap(),
            DType::Bool(Nullability::Nullable)
        );
    }

    #[test]
    pub fn list_falsification() {
        let expr = list_contains(
            lit(Scalar::list(
                Arc::new(DType::Primitive(I32, Nullability::NonNullable)),
                vec![1.into(), 2.into(), 3.into()],
                Nullability::NonNullable,
            )),
            col("a"),
        );

        let (expr, st) = checked_pruning_expr(
            &expr,
            &FieldPathSet::from_iter([
                FieldPath::from_iter([Field::Name("a".into()), Field::Name("max".into())]),
                FieldPath::from_iter([Field::Name("a".into()), Field::Name("min".into())]),
            ]),
        )
        .unwrap();

        assert_eq!(
            &expr,
            &and(
                and(
                    or(lt(col("a_max"), lit(1i32)), gt(col("a_min"), lit(1i32)),),
                    or(lt(col("a_max"), lit(2i32)), gt(col("a_min"), lit(2i32)),)
                ),
                or(lt(col("a_max"), lit(3i32)), gt(col("a_min"), lit(3i32)),)
            )
        );

        assert_eq!(
            st.map(),
            &HashMap::from_iter([(
                FieldPath::from_name("a"),
                HashSet::from([Stat::Min, Stat::Max])
            )])
        );
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	use std::fmt::{Debug, Display, Formatter};
5	use std::hash::Hash;
6
7	use vortex_array::compute::list_contains as compute_list_contains;
8	use vortex_array::{ArrayRef, DeserializeMetadata, EmptyMetadata};
9	use vortex_dtype::DType;
10	use vortex_error::{VortexResult, vortex_bail};
11
12	use crate::{
13	AnalysisExpr, ExprEncodingRef, ExprId, ExprRef, IntoExpr, LiteralVTable, Scope, StatsCatalog,
14	VTable, and, gt, lit, lt, or, vtable,
15	};
16
17	vtable!(ListContains);
18
19	#[allow(clippy::derived_hash_with_manual_eq)]
20	#[derive(Debug, Clone, Hash)]
21	pub struct ListContainsExpr {
22	list: ExprRef,
23	value: ExprRef,
24	}
25
26	impl PartialEq for ListContainsExpr {
27	fn eq(&self, other: &Self) -> bool {	663✔
28	self.list.eq(&other.list) && self.value.eq(&other.value)	663✔
29	}	663✔
30	}
31
32	pub struct ListContainsExprEncoding;
33
34	impl VTable for ListContainsVTable {
35	type Expr = ListContainsExpr;
36	type Encoding = ListContainsExprEncoding;
37	type Metadata = EmptyMetadata;
38
39	fn id(_encoding: &Self::Encoding) -> ExprId {	128✔
40	ExprId::new_ref("list_contains")	128✔
41	}	128✔
42
43	fn encoding(_expr: &Self::Expr) -> ExprEncodingRef {	×
44	ExprEncodingRef::new_ref(ListContainsExprEncoding.as_ref())	×
45	}	×
46
47	fn metadata(_expr: &Self::Expr) -> Option<Self::Metadata> {	×
48	Some(EmptyMetadata)	×
49	}	×
50
51	fn children(expr: &Self::Expr) -> Vec<&ExprRef> {	1,739✔
52	vec![&expr.list, &expr.value]	1,739✔
53	}	1,739✔
54
55	fn with_children(_expr: &Self::Expr, children: Vec<ExprRef>) -> VortexResult<Self::Expr> {	141✔
56	Ok(ListContainsExpr::new(	141✔
57	children[0].clone(),	141✔
58	children[1].clone(),	141✔
59	))	141✔
60	}	141✔
61
62	fn build(	×
63	_encoding: &Self::Encoding,	×
64	_metadata: &<Self::Metadata as DeserializeMetadata>::Output,	×
65	children: Vec<ExprRef>,	×
66	) -> VortexResult<Self::Expr> {	×
67	if children.len() != 2 {	×
68	vortex_bail!(	×
69	"ListContains expression must have exactly 2 children, got {}",	×
70	children.len()	×
71	);
72	}	×
73	Ok(ListContainsExpr::new(	×
74	children[0].clone(),	×
75	children[1].clone(),	×
76	))	×
77	}	×
78
79	fn evaluate(expr: &Self::Expr, scope: &Scope) -> VortexResult<ArrayRef> {	84✔
80	compute_list_contains(	84✔
81	expr.list.evaluate(scope)?.as_ref(),	84✔
82	expr.value.evaluate(scope)?.as_ref(),	84✔
83	)
84	}	84✔
85
86	fn return_dtype(expr: &Self::Expr, scope: &DType) -> VortexResult<DType> {	179✔
87	Ok(DType::Bool(
88	expr.list.return_dtype(scope)?.nullability()	179✔
89	\| expr.value.return_dtype(scope)?.nullability(),	179✔
90	))
91	}	179✔
92	}
93
94	impl ListContainsExpr {
95	pub fn new(list: ExprRef, value: ExprRef) -> Self {	195✔
96	Self { list, value }	195✔
97	}	195✔
98
99	pub fn new_expr(list: ExprRef, value: ExprRef) -> ExprRef {	×
100	Self::new(list, value).into_expr()	×
101	}	×
102
103	pub fn value(&self) -> &ExprRef {	×
104	&self.value	×
105	}	×
106	}
107
108	pub fn list_contains(list: ExprRef, value: ExprRef) -> ExprRef {	54✔
109	ListContainsExpr::new(list, value).into_expr()	54✔
110	}	54✔
111
112	impl Display for ListContainsExpr {
UNCOV 113	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {	×
UNCOV 114	write!(f, "contains({}, {})", &self.list, &self.value)	×
UNCOV 115	}	×
116	}
117
118	impl AnalysisExpr for ListContainsExpr {
119	// falsification(contains([1,2,5], x)) =>
120	// falsification(x != 1) and falsification(x != 2) and falsification(x != 5)
121
122	fn stat_falsification(&self, catalog: &mut dyn StatsCatalog) -> Option<ExprRef> {	48✔
123	let min = self.list.min(catalog)?;	48✔
124	let max = self.list.max(catalog)?;	48✔
125	// If the list is constant when we can compare each element to the value
126	if min == max {	48✔
127	let list_ = min	48✔
128	.as_opt::<LiteralVTable>()	48✔
129	.and_then(\|l\| l.value().as_list_opt())	48✔
130	.and_then(\|l\| l.elements())?;	48✔
131	if list_.is_empty() {	48✔
132	// contains([], x) is always false.
133	return Some(lit(true));	×
134	}	48✔
135	let value_max = self.value.max(catalog)?;	48✔
136	let value_min = self.value.min(catalog)?;	48✔
137
138	return list_	48✔
139	.iter()	48✔
140	.map(move \|v\| {	474✔
141	or(	474✔
142	lt(value_max.clone(), lit(v.clone())),	474✔
143	gt(value_min.clone(), lit(v.clone())),	474✔
144	)	474✔
145	})	474✔
146	.reduce(and);	48✔
147	}	×
148
149	None	×
150	}	48✔
151	}
152
153	#[cfg(test)]
154	mod tests {
155	use vortex_array::arrays::{BoolArray, BooleanBuffer, ListArray, PrimitiveArray};
156	use vortex_array::stats::Stat;
157	use vortex_array::validity::Validity;
158	use vortex_array::{Array, ArrayRef, IntoArray};
159	use vortex_dtype::PType::I32;
160	use vortex_dtype::{DType, Field, FieldPath, FieldPathSet, Nullability, StructFields};
161	use vortex_scalar::Scalar;
162	use vortex_utils::aliases::hash_map::HashMap;
163
164	use crate::list_contains::list_contains;
165	use crate::pruning::checked_pruning_expr;
166	use crate::{Arc, HashSet, Scope, and, col, get_item, gt, lit, lt, or, root};
167
168	fn test_array() -> ArrayRef {	3✔
169	ListArray::try_new(	3✔
170	PrimitiveArray::from_iter(vec![1, 1, 2, 2, 2, 2, 2, 3, 3, 3]).into_array(),	3✔
171	PrimitiveArray::from_iter(vec![0, 5, 10]).into_array(),	3✔
172	Validity::AllValid,	3✔
173	)	3✔
174	.unwrap()	3✔
175	.into_array()	3✔
176	}	3✔
177
178	#[test]
179	pub fn test_one() {	1✔
180	let arr = test_array();	1✔
181
182	let expr = list_contains(root(), lit(1));	1✔
183	let item = expr.evaluate(&Scope::new(arr)).unwrap();	1✔
184
185	assert_eq!(	1✔
186	item.scalar_at(0).unwrap(),	1✔
187	Scalar::bool(true, Nullability::Nullable)	1✔
188	);
189	assert_eq!(	1✔
190	item.scalar_at(1).unwrap(),	1✔
191	Scalar::bool(false, Nullability::Nullable)	1✔
192	);
193	}	1✔
194
195	#[test]
196	pub fn test_all() {	1✔
197	let arr = test_array();	1✔
198
199	let expr = list_contains(root(), lit(2));	1✔
200	let item = expr.evaluate(&Scope::new(arr)).unwrap();	1✔
201
202	assert_eq!(	1✔
203	item.scalar_at(0).unwrap(),	1✔
204	Scalar::bool(true, Nullability::Nullable)	1✔
205	);
206	assert_eq!(	1✔
207	item.scalar_at(1).unwrap(),	1✔
208	Scalar::bool(true, Nullability::Nullable)	1✔
209	);
210	}	1✔
211
212	#[test]
213	pub fn test_none() {	1✔
214	let arr = test_array();	1✔
215
216	let expr = list_contains(root(), lit(4));	1✔
217	let item = expr.evaluate(&Scope::new(arr)).unwrap();	1✔
218
219	assert_eq!(	1✔
220	item.scalar_at(0).unwrap(),	1✔
221	Scalar::bool(false, Nullability::Nullable)	1✔
222	);
223	assert_eq!(	1✔
224	item.scalar_at(1).unwrap(),	1✔
225	Scalar::bool(false, Nullability::Nullable)	1✔
226	);
227	}	1✔
228
229	#[test]
230	pub fn test_empty() {	1✔
231	let arr = ListArray::try_new(	1✔
232	PrimitiveArray::from_iter(vec![1, 1, 2, 2, 2]).into_array(),	1✔
233	PrimitiveArray::from_iter(vec![0, 5, 5]).into_array(),	1✔
234	Validity::AllValid,	1✔
235	)
236	.unwrap()	1✔
237	.into_array();	1✔
238
239	let expr = list_contains(root(), lit(2));	1✔
240	let item = expr.evaluate(&Scope::new(arr)).unwrap();	1✔
241
242	assert_eq!(	1✔
243	item.scalar_at(0).unwrap(),	1✔
244	Scalar::bool(true, Nullability::Nullable)	1✔
245	);
246	assert_eq!(	1✔
247	item.scalar_at(1).unwrap(),	1✔
248	Scalar::bool(false, Nullability::Nullable)	1✔
249	);
250	}	1✔
251
252	#[test]
253	pub fn test_nullable() {	1✔
254	let arr = ListArray::try_new(	1✔
255	PrimitiveArray::from_iter(vec![1, 1, 2, 2, 2]).into_array(),	1✔
256	PrimitiveArray::from_iter(vec![0, 5, 5]).into_array(),	1✔
257	Validity::Array(BoolArray::from(BooleanBuffer::from(vec![true, false])).into_array()),	1✔
258	)
259	.unwrap()	1✔
260	.into_array();	1✔
261
262	let expr = list_contains(root(), lit(2));	1✔
263	let item = expr.evaluate(&Scope::new(arr)).unwrap();	1✔
264
265	assert_eq!(	1✔
266	item.scalar_at(0).unwrap(),	1✔
267	Scalar::bool(true, Nullability::Nullable)	1✔
268	);
269	assert!(!item.is_valid(1).unwrap());	1✔
270	}	1✔
271
272	#[test]
273	pub fn test_return_type() {	1✔
274	let scope = DType::Struct(	1✔
275	StructFields::new(	1✔
276	["array"].into(),	1✔
277	vec![DType::List(	1✔
278	Arc::new(DType::Primitive(I32, Nullability::NonNullable)),	1✔
279	Nullability::Nullable,	1✔
280	)],	1✔
281	),	1✔
282	Nullability::NonNullable,	1✔
283	);	1✔
284
285	let expr = list_contains(get_item("array", root()), lit(2));	1✔
286
287	// Expect nullable, although scope is non-nullable
288	assert_eq!(	1✔
289	expr.return_dtype(&scope).unwrap(),	1✔
290	DType::Bool(Nullability::Nullable)
291	);
292	}	1✔
293
294	#[test]
295	pub fn list_falsification() {	1✔
296	let expr = list_contains(	1✔
297	lit(Scalar::list(	1✔
298	Arc::new(DType::Primitive(I32, Nullability::NonNullable)),	1✔
299	vec![1.into(), 2.into(), 3.into()],	1✔
300	Nullability::NonNullable,	1✔
301	)),	1✔
302	col("a"),	1✔
303	);
304
305	let (expr, st) = checked_pruning_expr(	1✔
306	&expr,	1✔
307	&FieldPathSet::from_iter([	1✔
308	FieldPath::from_iter([Field::Name("a".into()), Field::Name("max".into())]),	1✔
309	FieldPath::from_iter([Field::Name("a".into()), Field::Name("min".into())]),	1✔
310	]),	1✔
311	)	1✔
312	.unwrap();	1✔
313
314	assert_eq!(	1✔
315	&expr,	1✔
316	&and(	1✔
317	and(	1✔
318	or(lt(col("a_max"), lit(1i32)), gt(col("a_min"), lit(1i32)),),	1✔
319	or(lt(col("a_max"), lit(2i32)), gt(col("a_min"), lit(2i32)),)	1✔
320	),	1✔
321	or(lt(col("a_max"), lit(3i32)), gt(col("a_min"), lit(3i32)),)	1✔
322	)	1✔
323	);
324
325	assert_eq!(	1✔
326	st.map(),	1✔
327	&HashMap::from_iter([(	1✔
328	FieldPath::from_name("a"),	1✔
329	HashSet::from([Stat::Min, Stat::Max])	1✔
330	)])	1✔
331	);
332	}	1✔
333	}

vortex-data / vortex / 16473770414

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