Skip to content

Commit d2d9b12

Browse files
IN LIST: clean up generic static filtering (#21927)
## Which issue does this PR close? - Part of #19241. - This PR was originally proposed as the first commit in the broader `IN LIST` optimization series in #19390. - This PR builds on the refactor extracted in #21649. ## Rationale for this change After #21649, non-primitive constant `IN LIST` evaluation still uses the extracted `ArrayStaticFilter` fallback path. That path relies on comparator checks for each input row. This PR replaces that fallback lookup with a precomputed hash table and shared result construction so generic constant-list evaluation is cheaper before the later specialized primitive and string optimizations from #19390. ## What changes are included in this PR? The PR is split so reviewers can separate mechanical cleanup from the behavior/performance changes: 1. `Refactor generic InList static filter helpers` Pure refactoring. This moves the existing generic static-filter construction and probe loop into helper methods inside `ArrayStaticFilter`, without changing the lookup data structure or result semantics. 2. `Build InList results from bitmaps` Changes how the generic path materializes `BooleanArray` results after membership has been computed. Instead of mixing membership checks and SQL three-valued null handling in the row loop, this builds a contains bitmap first and applies the null/negation rules with bitmap operations. This keeps the same `IN` / `NOT IN` semantics, including the `NULL` cases. 3. `Optimize generic InList static filtering` Replaces the fallback lookup storage from a unit-valued raw-entry `HashMap` to `hashbrown::HashTable<usize>`. The table still stores indices into the constant list and still uses Arrow hashing plus `make_comparator` for equality, but avoids the extra map value bookkeeping. The existing specialized primitive filters and dictionary handling are intentionally left out of scope. ## Are these changes tested? Yes. ## Are there any user-facing changes? No. This is an internal performance optimization only. <!-- codex-benchmark-start --> ## Local benchmark snapshot Benchmark command: ```bash cargo bench -p datafusion-physical-expr --profile release-nonlto --bench in_list_strategy -- --save-baseline <name> ``` Method: compare adjacent saved baselines using raw Criterion sample minima (`min(time / iters)`). Lower is better; changes within +/-5% are treated as noise. Compared baselines: merge-base -> [#21927](#21927) Relevant scope: generic fallback string/view/binary rows. Summary: 62 relevant rows, 61 faster, 0 slower, 1 within +/-5%. Largest relevant deltas: | Benchmark | Before | After | Change | |---|---:|---:|---:| | `utf8view/short_8b/list=64/match=0%` | 45.55 us | 21.85 us | -52.0% (2.08x faster) | | `utf8view/short_8b/list=256/match=0%` | 44.34 us | 21.71 us | -51.0% (2.04x faster) | | `utf8view/short_8b/list=16/match=0%` | 44.03 us | 21.60 us | -50.9% (2.04x faster) | | `utf8view/short_8b/list=4/match=0%` | 41.54 us | 20.52 us | -50.6% (2.02x faster) | | `utf8view/len_12b/list=16/match=0%` | 41.43 us | 20.55 us | -50.4% (2.02x faster) | | `utf8view/len_12b/list=64/match=0%` | 41.59 us | 21.00 us | -49.5% (1.98x faster) | | `fixed_size_binary/fsb16/list=10000/match=0%` | 58.11 us | 29.36 us | -49.5% (1.98x faster) | | `fixed_size_binary/fsb16/list=256/match=0%` | 55.49 us | 28.57 us | -48.5% (1.94x faster) | | `utf8view/shared_prefix/pfx=8/list=16/match=0%` | 57.54 us | 32.07 us | -44.3% (1.79x faster) | | `utf8view/mixed_len/list=16/match=0%` | 62.86 us | 35.25 us | -43.9% (1.78x faster) | | `fixed_size_binary/fsb16/list=4/match=0%` | 47.62 us | 27.20 us | -42.9% (1.75x faster) | | `fixed_size_binary/fsb16/list=64/match=0%` | 47.85 us | 27.45 us | -42.6% (1.74x faster) | | `utf8view/mixed_len/list=64/match=0%` | 66.09 us | 38.00 us | -42.5% (1.74x faster) | | `utf8/short_8b/list=256/match=0%` | 52.09 us | 30.49 us | -41.5% (1.71x faster) | | `utf8view/shared_prefix/pfx=12/list=32/match=0%` | 70.61 us | 42.33 us | -40.1% (1.67x faster) | <details> <summary>Full relevant table (62 rows)</summary> | Benchmark | Before | After | Change | |---|---:|---:|---:| | `fixed_size_binary/fsb16/list=10000/match=0%` | 58.11 us | 29.36 us | -49.5% (1.98x faster) | | `fixed_size_binary/fsb16/list=10000/match=50%` | 98.77 us | 81.20 us | -17.8% (1.22x faster) | | `fixed_size_binary/fsb16/list=256/match=0%` | 55.49 us | 28.57 us | -48.5% (1.94x faster) | | `fixed_size_binary/fsb16/list=256/match=50%` | 96.40 us | 79.32 us | -17.7% (1.22x faster) | | `fixed_size_binary/fsb16/list=4/match=0%` | 47.62 us | 27.20 us | -42.9% (1.75x faster) | | `fixed_size_binary/fsb16/list=4/match=50%` | 93.08 us | 75.58 us | -18.8% (1.23x faster) | | `fixed_size_binary/fsb16/list=64/match=0%` | 47.85 us | 27.45 us | -42.6% (1.74x faster) | | `fixed_size_binary/fsb16/list=64/match=50%` | 95.20 us | 74.96 us | -21.3% (1.27x faster) | | `nulls/utf8/long_24b/list=16/match=50%/nulls=20%` | 85.74 us | 74.79 us | -12.8% (1.15x faster) | | `nulls/utf8/short_8b/list=16/match=50%/nulls=20%` | 80.01 us | 77.30 us | -3.4% (within +/-5%) | | `nulls/utf8view/long_24b/list=16/match=50%/nulls=20%` | 110.19 us | 96.52 us | -12.4% (1.14x faster) | | `nulls/utf8view/short_8b/list=16/match=50%/nulls=20%` | 74.78 us | 62.92 us | -15.9% (1.19x faster) | | `nulls/utf8view/short_8b/list=16/match=50%/nulls=20%/NOT_IN` | 71.24 us | 63.51 us | -10.9% (1.12x faster) | | `nulls/utf8view/short_8b/list=16/match=50%/nulls=50%` | 83.84 us | 62.11 us | -25.9% (1.35x faster) | | `utf8/long_24b/list=256/match=0%` | 58.79 us | 37.57 us | -36.1% (1.56x faster) | | `utf8/long_24b/list=256/match=50%` | 107.85 us | 74.62 us | -30.8% (1.45x faster) | | `utf8/long_24b/list=4/match=0%` | 56.68 us | 37.64 us | -33.6% (1.51x faster) | | `utf8/long_24b/list=4/match=50%` | 100.40 us | 79.11 us | -21.2% (1.27x faster) | | `utf8/long_24b/list=64/match=0%` | 59.39 us | 35.95 us | -39.5% (1.65x faster) | | `utf8/long_24b/list=64/match=50%` | 101.26 us | 79.59 us | -21.4% (1.27x faster) | | `utf8/mixed_len/list=16/match=0%` | 60.51 us | 49.06 us | -18.9% (1.23x faster) | | `utf8/mixed_len/list=16/match=50%` | 154.00 us | 139.13 us | -9.7% (1.11x faster) | | `utf8/mixed_len/list=64/match=0%` | 63.46 us | 49.87 us | -21.4% (1.27x faster) | | `utf8/mixed_len/list=64/match=50%` | 154.01 us | 134.01 us | -13.0% (1.15x faster) | | `utf8/shared_prefix/pfx=12/list=32/match=50%` | 98.73 us | 76.64 us | -22.4% (1.29x faster) | | `utf8/short_8b/list=16/match=50%/NOT_IN` | 96.18 us | 72.15 us | -25.0% (1.33x faster) | | `utf8/short_8b/list=256/match=0%` | 52.09 us | 30.49 us | -41.5% (1.71x faster) | | `utf8/short_8b/list=256/match=50%` | 94.56 us | 74.39 us | -21.3% (1.27x faster) | | `utf8/short_8b/list=4/match=0%` | 51.95 us | 32.27 us | -37.9% (1.61x faster) | | `utf8/short_8b/list=4/match=50%` | 95.05 us | 78.47 us | -17.4% (1.21x faster) | | `utf8/short_8b/list=64/match=0%` | 53.60 us | 33.34 us | -37.8% (1.61x faster) | | `utf8/short_8b/list=64/match=50%` | 96.35 us | 80.95 us | -16.0% (1.19x faster) | | `utf8view/len_12b/list=16/match=0%` | 41.43 us | 20.55 us | -50.4% (2.02x faster) | | `utf8view/len_12b/list=16/match=50%` | 73.07 us | 50.49 us | -30.9% (1.45x faster) | | `utf8view/len_12b/list=64/match=0%` | 41.59 us | 21.00 us | -49.5% (1.98x faster) | | `utf8view/len_12b/list=64/match=50%` | 75.23 us | 50.25 us | -33.2% (1.50x faster) | | `utf8view/long_24b/list=16/match=0%` | 58.48 us | 38.22 us | -34.7% (1.53x faster) | | `utf8view/long_24b/list=16/match=50%` | 109.63 us | 87.32 us | -20.4% (1.26x faster) | | `utf8view/long_24b/list=256/match=0%` | 61.12 us | 38.40 us | -37.2% (1.59x faster) | | `utf8view/long_24b/list=256/match=50%` | 113.25 us | 91.61 us | -19.1% (1.24x faster) | | `utf8view/long_24b/list=4/match=0%` | 58.43 us | 39.48 us | -32.4% (1.48x faster) | | `utf8view/long_24b/list=4/match=50%` | 112.73 us | 90.14 us | -20.0% (1.25x faster) | | `utf8view/long_24b/list=64/match=0%` | 62.17 us | 38.48 us | -38.1% (1.62x faster) | | `utf8view/long_24b/list=64/match=50%` | 109.35 us | 87.64 us | -19.8% (1.25x faster) | | `utf8view/mixed_len/list=16/match=0%` | 62.86 us | 35.25 us | -43.9% (1.78x faster) | | `utf8view/mixed_len/list=16/match=50%` | 126.60 us | 103.97 us | -17.9% (1.22x faster) | | `utf8view/mixed_len/list=64/match=0%` | 66.09 us | 38.00 us | -42.5% (1.74x faster) | | `utf8view/mixed_len/list=64/match=50%` | 137.76 us | 112.23 us | -18.5% (1.23x faster) | | `utf8view/shared_prefix/pfx=12/list=32/match=0%` | 70.61 us | 42.33 us | -40.1% (1.67x faster) | | `utf8view/shared_prefix/pfx=12/list=32/match=50%` | 115.15 us | 94.27 us | -18.1% (1.22x faster) | | `utf8view/shared_prefix/pfx=16/list=64/match=0%` | 63.47 us | 40.67 us | -35.9% (1.56x faster) | | `utf8view/shared_prefix/pfx=16/list=64/match=50%` | 112.27 us | 91.32 us | -18.7% (1.23x faster) | | `utf8view/shared_prefix/pfx=8/list=16/match=0%` | 57.54 us | 32.07 us | -44.3% (1.79x faster) | | `utf8view/shared_prefix/pfx=8/list=16/match=50%` | 100.47 us | 82.69 us | -17.7% (1.21x faster) | | `utf8view/short_8b/list=16/match=0%` | 44.03 us | 21.60 us | -50.9% (2.04x faster) | | `utf8view/short_8b/list=16/match=50%` | 72.92 us | 49.10 us | -32.7% (1.49x faster) | | `utf8view/short_8b/list=256/match=0%` | 44.34 us | 21.71 us | -51.0% (2.04x faster) | | `utf8view/short_8b/list=256/match=50%` | 72.43 us | 51.58 us | -28.8% (1.40x faster) | | `utf8view/short_8b/list=4/match=0%` | 41.54 us | 20.52 us | -50.6% (2.02x faster) | | `utf8view/short_8b/list=4/match=50%` | 72.50 us | 48.46 us | -33.2% (1.50x faster) | | `utf8view/short_8b/list=64/match=0%` | 45.55 us | 21.85 us | -52.0% (2.08x faster) | | `utf8view/short_8b/list=64/match=50%` | 73.14 us | 50.92 us | -30.4% (1.44x faster) | </details> <!-- codex-benchmark-end -->
1 parent 421890e commit d2d9b12

3 files changed

Lines changed: 194 additions & 86 deletions

File tree

‎datafusion/physical-expr/src/expressions/in_list.rs‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,7 @@ use datafusion_expr::{ColumnarValue, expr_vec_fmt};
3838

3939
mod array_static_filter;
4040
mod primitive_filter;
41+
mod result;
4142
mod static_filter;
4243
mod strategy;
4344

‎datafusion/physical-expr/src/expressions/in_list/array_static_filter.rs‎

Lines changed: 88 additions & 86 deletions
Original file line numberDiff line numberDiff line change
@@ -23,23 +23,104 @@ use arrow::buffer::{BooleanBuffer, NullBuffer};
2323
use arrow::compute::{SortOptions, take};
2424
use arrow::datatypes::DataType;
2525
use arrow::util::bit_iterator::BitIndexIterator;
26-
use datafusion_common::HashMap;
2726
use datafusion_common::Result;
2827
use datafusion_common::hash_utils::{RandomState, with_hashes};
29-
use hashbrown::hash_map::RawEntryMut;
28+
use hashbrown::HashTable;
3029

30+
use super::result::build_in_list_result;
3131
use super::static_filter::StaticFilter;
3232

3333
/// Static filter for InList that stores the array and hash set for O(1) lookups
3434
#[derive(Debug, Clone)]
3535
pub(super) struct ArrayStaticFilter {
3636
in_array: ArrayRef,
3737
state: RandomState,
38-
/// Used to provide a lookup from value to in list index
38+
/// Stores indices into `in_array` for O(1) lookups.
39+
table: HashTable<usize>,
40+
}
41+
42+
impl ArrayStaticFilter {
43+
/// Computes a [`StaticFilter`] for the provided [`Array`] if there
44+
/// are nulls present or there are more than the configured number of
45+
/// elements.
3946
///
40-
/// Note: usize::hash is not used, instead the raw entry
41-
/// API is used to store entries w.r.t their value
42-
map: HashMap<usize, (), ()>,
47+
/// Note: This is split into a separate function as higher-rank trait bounds currently
48+
/// cause type inference to misbehave
49+
pub(super) fn try_new(in_array: ArrayRef) -> Result<ArrayStaticFilter> {
50+
// Null type has no natural order - return empty hash set
51+
if in_array.data_type() == &DataType::Null {
52+
return Ok(ArrayStaticFilter {
53+
in_array,
54+
state: RandomState::default(),
55+
table: HashTable::new(),
56+
});
57+
}
58+
59+
let state = RandomState::default();
60+
let table = Self::build_haystack_table(&in_array, &state)?;
61+
62+
Ok(Self {
63+
in_array,
64+
state,
65+
table,
66+
})
67+
}
68+
69+
fn build_haystack_table(
70+
haystack: &ArrayRef,
71+
state: &RandomState,
72+
) -> Result<HashTable<usize>> {
73+
let mut table = HashTable::new();
74+
75+
with_hashes([haystack.as_ref()], state, |hashes| -> Result<()> {
76+
let cmp = make_comparator(haystack, haystack, SortOptions::default())?;
77+
78+
let insert_value = |idx| {
79+
let hash = hashes[idx];
80+
// Only insert if not already present (deduplication)
81+
if table.find(hash, |&x| cmp(x, idx).is_eq()).is_none() {
82+
table.insert_unique(hash, idx, |&x| hashes[x]);
83+
}
84+
};
85+
86+
match haystack.nulls() {
87+
Some(nulls) => {
88+
BitIndexIterator::new(nulls.validity(), nulls.offset(), nulls.len())
89+
.for_each(insert_value)
90+
}
91+
None => (0..haystack.len()).for_each(insert_value),
92+
}
93+
94+
Ok(())
95+
})?;
96+
97+
Ok(table)
98+
}
99+
100+
fn find_needles_in_haystack(
101+
&self,
102+
needles: &dyn Array,
103+
negated: bool,
104+
) -> Result<BooleanArray> {
105+
let needle_nulls = needles.logical_nulls();
106+
let haystack_has_nulls = self.in_array.null_count() != 0;
107+
108+
with_hashes([needles], &self.state, |needle_hashes| {
109+
let cmp = make_comparator(needles, &self.in_array, SortOptions::default())?;
110+
111+
Ok(build_in_list_result(
112+
needles.len(),
113+
needle_nulls.as_ref(),
114+
haystack_has_nulls,
115+
negated,
116+
#[inline(always)]
117+
|i| {
118+
let hash = needle_hashes[i];
119+
self.table.find(hash, |&idx| cmp(i, idx).is_eq()).is_some()
120+
},
121+
))
122+
})
123+
}
43124
}
44125

45126
impl StaticFilter for ArrayStaticFilter {
@@ -76,85 +157,6 @@ impl StaticFilter for ArrayStaticFilter {
76157
_ => {}
77158
}
78159

79-
let needle_nulls = v.logical_nulls();
80-
let needle_nulls = needle_nulls.as_ref();
81-
let haystack_has_nulls = self.in_array.null_count() != 0;
82-
83-
with_hashes([v], &self.state, |hashes| {
84-
let cmp = make_comparator(v, &self.in_array, SortOptions::default())?;
85-
Ok((0..v.len())
86-
.map(|i| {
87-
// SQL three-valued logic: null IN (...) is always null
88-
if needle_nulls.is_some_and(|nulls| nulls.is_null(i)) {
89-
return None;
90-
}
91-
92-
let hash = hashes[i];
93-
let contains = self
94-
.map
95-
.raw_entry()
96-
.from_hash(hash, |idx| cmp(i, *idx).is_eq())
97-
.is_some();
98-
99-
match contains {
100-
true => Some(!negated),
101-
false if haystack_has_nulls => None,
102-
false => Some(negated),
103-
}
104-
})
105-
.collect())
106-
})
107-
}
108-
}
109-
110-
impl ArrayStaticFilter {
111-
/// Computes a [`StaticFilter`] for the provided [`Array`] if there
112-
/// are nulls present or there are more than the configured number of
113-
/// elements.
114-
///
115-
/// Note: This is split into a separate function as higher-rank trait bounds currently
116-
/// cause type inference to misbehave
117-
pub(super) fn try_new(in_array: ArrayRef) -> Result<ArrayStaticFilter> {
118-
// Null type has no natural order - return empty hash set
119-
if in_array.data_type() == &DataType::Null {
120-
return Ok(ArrayStaticFilter {
121-
in_array,
122-
state: RandomState::default(),
123-
map: HashMap::with_hasher(()),
124-
});
125-
}
126-
127-
let state = RandomState::default();
128-
let mut map: HashMap<usize, (), ()> = HashMap::with_hasher(());
129-
130-
with_hashes([&in_array], &state, |hashes| -> Result<()> {
131-
let cmp = make_comparator(&in_array, &in_array, SortOptions::default())?;
132-
133-
let insert_value = |idx| {
134-
let hash = hashes[idx];
135-
if let RawEntryMut::Vacant(v) = map
136-
.raw_entry_mut()
137-
.from_hash(hash, |x| cmp(*x, idx).is_eq())
138-
{
139-
v.insert_with_hasher(hash, idx, (), |x| hashes[*x]);
140-
}
141-
};
142-
143-
match in_array.nulls() {
144-
Some(nulls) => {
145-
BitIndexIterator::new(nulls.validity(), nulls.offset(), nulls.len())
146-
.for_each(insert_value)
147-
}
148-
None => (0..in_array.len()).for_each(insert_value),
149-
}
150-
151-
Ok(())
152-
})?;
153-
154-
Ok(Self {
155-
in_array,
156-
state,
157-
map,
158-
})
160+
self.find_needles_in_haystack(v, negated)
159161
}
160162
}
Lines changed: 105 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,105 @@
1+
// Licensed to the Apache Software Foundation (ASF) under one
2+
// or more contributor license agreements. See the NOTICE file
3+
// distributed with this work for additional information
4+
// regarding copyright ownership. The ASF licenses this file
5+
// to you under the Apache License, Version 2.0 (the
6+
// "License"); you may not use this file except in compliance
7+
// with the License. You may obtain a copy of the License at
8+
//
9+
// http://www.apache.org/licenses/LICENSE-2.0
10+
//
11+
// Unless required by applicable law or agreed to in writing,
12+
// software distributed under the License is distributed on an
13+
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14+
// KIND, either express or implied. See the License for the
15+
// specific language governing permissions and limitations
16+
// under the License.
17+
18+
//! Result building helpers for InList operations.
19+
//!
20+
//! This module provides unified logic for building BooleanArray results
21+
//! from IN list membership tests, handling null propagation correctly
22+
//! according to SQL three-valued logic.
23+
24+
use arrow::array::BooleanArray;
25+
use arrow::buffer::{BooleanBuffer, NullBuffer};
26+
27+
// Truth table for (needle_nulls, haystack_has_nulls, negated):
28+
// (Some, true, false) => values: valid & contains, nulls: valid & contains
29+
// (None, true, false) => values: contains, nulls: contains
30+
// (Some, true, true) => values: valid & !contains, nulls: valid & contains
31+
// (None, true, true) => values: !contains, nulls: contains
32+
// (Some, false, false) => values: valid & contains, nulls: valid
33+
// (Some, false, true) => values: valid & !contains, nulls: valid
34+
// (None, false, false) => values: contains, nulls: none
35+
// (None, false, true) => values: !contains, nulls: none
36+
37+
/// Builds a BooleanArray result for IN list operations.
38+
///
39+
/// This function handles the null propagation logic for SQL IN lists:
40+
/// - If the needle value is null, the result is null
41+
/// - If the needle is not in the set and the haystack has nulls, the result is null
42+
/// - Otherwise, the result is true/false based on membership and negation
43+
///
44+
/// This version computes contains for all positions, including nulls, then applies
45+
/// null masking via bitmap operations.
46+
#[inline]
47+
pub(crate) fn build_in_list_result<C>(
48+
len: usize,
49+
needle_nulls: Option<&NullBuffer>,
50+
haystack_has_nulls: bool,
51+
negated: bool,
52+
contains: C,
53+
) -> BooleanArray
54+
where
55+
C: FnMut(usize) -> bool,
56+
{
57+
let contains_buf = BooleanBuffer::collect_bool(len, contains);
58+
build_result_from_contains(needle_nulls, haystack_has_nulls, negated, contains_buf)
59+
}
60+
61+
/// Builds a BooleanArray result from a pre-computed contains buffer.
62+
///
63+
/// This version does not assume contains_buf is pre-masked at null positions.
64+
/// It handles nulls using bitmap operations.
65+
#[inline]
66+
pub(crate) fn build_result_from_contains(
67+
needle_nulls: Option<&NullBuffer>,
68+
haystack_has_nulls: bool,
69+
negated: bool,
70+
contains_buf: BooleanBuffer,
71+
) -> BooleanArray {
72+
match (needle_nulls, haystack_has_nulls, negated) {
73+
// Haystack has nulls: result is null unless value is found.
74+
(Some(v), true, false) => {
75+
// values: valid & contains, nulls: valid & contains
76+
let values = v.inner() & &contains_buf;
77+
BooleanArray::new(values.clone(), Some(NullBuffer::new(values)))
78+
}
79+
(None, true, false) => {
80+
BooleanArray::new(contains_buf.clone(), Some(NullBuffer::new(contains_buf)))
81+
}
82+
(Some(v), true, true) => {
83+
// NOT IN with nulls: false if found, null if not found or needle null.
84+
// values: valid & !contains, nulls: valid & contains
85+
let valid = v.inner();
86+
let values = valid & &(!&contains_buf);
87+
let nulls = valid & &contains_buf;
88+
BooleanArray::new(values, Some(NullBuffer::new(nulls)))
89+
}
90+
(None, true, true) => {
91+
BooleanArray::new(!&contains_buf, Some(NullBuffer::new(contains_buf)))
92+
}
93+
// Haystack has no nulls: result validity follows needle validity.
94+
(Some(v), false, false) => {
95+
// values: valid & contains, nulls: valid
96+
BooleanArray::new(v.inner() & &contains_buf, Some(v.clone()))
97+
}
98+
(Some(v), false, true) => {
99+
// values: valid & !contains, nulls: valid
100+
BooleanArray::new(v.inner() & &(!&contains_buf), Some(v.clone()))
101+
}
102+
(None, false, false) => BooleanArray::new(contains_buf, None),
103+
(None, false, true) => BooleanArray::new(!&contains_buf, None),
104+
}
105+
}

0 commit comments

Comments
 (0)