Implement LIKE in vortex instead of falling back to arrow

Replace the arrow-string backed LIKE executor with a native implementation
over canonical VarBinView arrays, dropping the arrow-string dependency from
vortex-array.

Patterns compile once into a LikePattern: wildcard-free patterns and
prefix/suffix/substring shapes use direct byte comparisons (memchr's SIMD
substring search for contains, ASCII case-insensitive variants for ILIKE
over ASCII data), everything else translates the SQL pattern to an anchored
regex over the value bytes, using the same translation as arrow-string so
semantics are unchanged. Non-constant pattern children reuse the previous
row's compiled pattern while the pattern bytes repeat.

Evaluation exploits the view layout: equality is a single masked 16-byte
compare for needles that fit inline, the prefix path rejects lanes with a
branch-free masked compare of the view's inline 4-byte prefix without
touching the data buffers, the suffix path slices exactly the trailing
needle bytes out of the view or its buffer, and contains/equality reject
on the view length before dereferencing.

Benchmarked against the previous arrow implementation (benches/like.rs,
64Ki strings, median): exact 100us -> 18us, prefix 144us -> 48us,
suffix 171us -> 105us, contains 876us -> 732us, regex 924us -> 744us,
ilike contains 2.52ms -> 2.03ms, per-row patterns 824us -> 565us.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Signed-off-by: Robert Kruszewski <github@robertk.io>

Author: robert3005

Cargo.lock

@@ -225,6 +225,7 @@ rand_distr = "0.6"
 ratatui = { version = "0.30", default-features = false }
 regex = "1.11.0"
 regex-automata = "0.4"
+regex-syntax = "0.8"
 reqwest = { version = "0.13.0", features = [
     "blocking",
     "charset",

Cargo.toml

@@ -31,7 +31,6 @@ arrow-data = { workspace = true }
 arrow-ord = { workspace = true }
 arrow-schema = { workspace = true, features = ["canonical_extension_types"] }
 arrow-select = { workspace = true }
-arrow-string = { workspace = true }
 async-lock = { workspace = true }
 bytes = { workspace = true }
 cfg-if = { workspace = true }
@@ -45,6 +44,7 @@ humansize = { workspace = true }
 inventory = { workspace = true }
 itertools = { workspace = true }
 jiff = { workspace = true }
+memchr = { workspace = true }
 num-traits = { workspace = true }
 num_enum = { workspace = true }
 parking_lot = { workspace = true }
@@ -55,6 +55,8 @@ primitive-types = { workspace = true, optional = true, features = [
 ] }
 prost = { workspace = true }
 rand = { workspace = true }
+regex = { workspace = true }
+regex-syntax = { workspace = true }
 rstest = { workspace = true, optional = true }
 rstest_reuse = { workspace = true, optional = true }
 rustc-hash = { workspace = true }
@@ -138,6 +140,10 @@ harness = false
 name = "kleene_bool"
 harness = false
 
+[[bench]]
+name = "like"
+harness = false
+
 [[bench]]
 name = "interleave"
 harness = false

vortex-array/Cargo.toml

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![expect(clippy::unwrap_used)]
+
+use divan::Bencher;
+use rand::RngExt;
+use rand::SeedableRng;
+use rand::distr::Uniform;
+use rand::prelude::StdRng;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::VarBinViewArray;
+use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
+use vortex_array::scalar_fn::fns::like::Like;
+use vortex_array::scalar_fn::fns::like::LikeOptions;
+
+fn main() {
+    divan::main();
+}
+
+const ARRAY_SIZE: usize = 65_536;
+
+/// Random lowercase strings of 4..=24 bytes, some with a `hello` infix.
+fn strings() -> ArrayRef {
+    let mut rng = StdRng::seed_from_u64(0);
+    let len_dist = Uniform::new_inclusive(4usize, 24).unwrap();
+    VarBinViewArray::from_iter_str((0..ARRAY_SIZE).map(|i| {
+        let len = rng.sample(len_dist);
+        let mut s: String = (0..len)
+            .map(|_| char::from(rng.random_range(b'a'..=b'z')))
+            .collect();
+        if i % 7 == 0 {
+            s.insert_str(len / 2, "hello");
+        }
+        s
+    }))
+    .into_array()
+}
+
+fn bench_like(bencher: Bencher, pattern: &str, options: LikeOptions) {
+    let session = vortex_array::array_session();
+    let array = strings();
+    bencher
+        .with_inputs(|| {
+            (
+                Like.try_new_array(
+                    ARRAY_SIZE,
+                    options,
+                    [
+                        array.clone(),
+                        ConstantArray::new(pattern, ARRAY_SIZE).into_array(),
+                    ],
+                )
+                .unwrap(),
+                session.create_execution_ctx(),
+            )
+        })
+        .bench_values(|(array, mut ctx)| array.execute::<BoolArray>(&mut ctx).unwrap());
+}
+
+#[divan::bench]
+fn like_exact(bencher: Bencher) {
+    bench_like(bencher, "hello", LikeOptions::default());
+}
+
+#[divan::bench]
+fn like_prefix(bencher: Bencher) {
+    bench_like(bencher, "hello%", LikeOptions::default());
+}
+
+#[divan::bench]
+fn like_suffix(bencher: Bencher) {
+    bench_like(bencher, "%hello", LikeOptions::default());
+}
+
+#[divan::bench]
+fn like_contains(bencher: Bencher) {
+    bench_like(bencher, "%hello%", LikeOptions::default());
+}
+
+#[divan::bench]
+fn like_regex(bencher: Bencher) {
+    bench_like(bencher, "h_llo%w%d", LikeOptions::default());
+}
+
+#[divan::bench]
+fn like_per_row_patterns(bencher: Bencher) {
+    let session = vortex_array::array_session();
+    let array = strings();
+    // A non-constant pattern child takes the per-row path; repeated patterns hit the
+    // compile cache.
+    let patterns = VarBinViewArray::from_iter_str((0..ARRAY_SIZE).map(|_| "hello%")).into_array();
+    bencher
+        .with_inputs(|| {
+            (
+                Like.try_new_array(
+                    ARRAY_SIZE,
+                    LikeOptions::default(),
+                    [array.clone(), patterns.clone()],
+                )
+                .unwrap(),
+                session.create_execution_ctx(),
+            )
+        })
+        .bench_values(|(array, mut ctx)| array.execute::<BoolArray>(&mut ctx).unwrap());
+}
+
+#[divan::bench]
+fn ilike_contains(bencher: Bencher) {
+    bench_like(
+        bencher,
+        "%HELLO%",
+        LikeOptions {
+            negated: false,
+            case_insensitive: true,
+        },
+    );
+}