feat: Speed up starts_with for small prefixes

crates/polars-arrow/src/array/binview/view.rs

@@ -136,6 +136,28 @@ impl View {
         }
     }
 
+    /// Checks if the string starts with the prefix
+    /// When the prefix is smaller than View::MAX_INLINE_SIZE then this will be very fast
+    pub fn starts_with(&self, prefix: &str, buffers: &[Buffer<u8>]) -> bool {
+        unsafe {
+            if self.length <= View::MAX_INLINE_SIZE {
+                self.get_inlined_slice_unchecked()
+                    .starts_with(prefix.as_bytes())
+            } else {
+                let starts = self
+                    .prefix
+                    .to_le_bytes()
+                    .starts_with(&prefix.as_bytes()[0..4]);
+                if starts {
+                    return self
+                        .get_slice_unchecked(buffers)
+                        .starts_with(prefix.as_bytes());
+                }
+                false
+            }
+        }
+    }
+
     /// Constructs a byteslice from this view.
     ///
     /// # Safety

crates/polars-ops/src/chunked_array/strings/namespace.rs

@@ -1,4 +1,4 @@
-use arrow::array::ValueSize;
+use arrow::array::{Array, ValueSize};
 use arrow::legacy::kernels::string::*;
 #[cfg(feature = "string_encoding")]
 use base64::engine::general_purpose;
@@ -216,6 +216,35 @@ pub trait StringNameSpaceImpl: AsString {
         }
     }
 
+    /// Check if strings starts with a substring
+    fn starts_with(&self, sub: &str) -> BooleanChunked {
+        let ca = self.as_string();
+
+        let iter = ca.downcast_iter().map(|arr| {
+            let out: <BooleanType as PolarsDataType>::Array = arr
+                .views()
+                .iter()
+                .map(|view| view.starts_with(sub, arr.data_buffers()))
+                .collect_arr_with_dtype(DataType::Boolean.to_arrow(CompatLevel::newest()));
+            out.with_validity_typed(arr.validity().cloned())
+        });
+
+        ChunkedArray::from_chunk_iter(ca.name().clone(), iter)
+    }
+
+    /// This is more performant than the BinaryChunked version because we use the inline prefix
+    /// Use the BinaryChunked::ends_with as there is no specialization here for that
+    fn starts_with_chunked(&self, prefix: &StringChunked) -> BooleanChunked {
+        let ca = self.as_string();
+        match prefix.len() {
+            1 => match prefix.get(0) {
+                Some(s) => self.starts_with(s),
+                None => BooleanChunked::full_null(ca.name().clone(), ca.len()),
+            },
+            _ => broadcast_binary_elementwise_values(ca, prefix, |s, sub| s.starts_with(sub)),
+        }
+    }
+
     /// Get the length of the string values as number of chars.
     fn str_len_chars(&self) -> UInt32Chunked {
         let ca = self.as_string();

crates/polars-plan/src/dsl/function_expr/strings.rs

@@ -502,9 +502,8 @@ pub(super) fn ends_with(s: &[Column]) -> PolarsResult<Column> {
 }
 
 pub(super) fn starts_with(s: &[Column]) -> PolarsResult<Column> {
-    let ca = &s[0].str()?.as_binary();
-    let prefix = &s[1].str()?.as_binary();
-
+    let ca = s[0].str()?;
+    let prefix = s[1].str()?;
     Ok(ca.starts_with_chunked(prefix).into_column())
 }