Merge pull request #7459 from b41sh/feat-func-v2-regexp

feat(query): migrate regexp func to func-v2

Author: mergify[bot]

Cargo.lock

@@ -221,9 +221,9 @@ where F: Fn(&[ValueRef<AnyType>], &GenericMap) -> Result<Value<AnyType>, String>
                 }
             }
         }
-        let nonull_results = f(&nonull_args, generics)?;
+        let results = f(&nonull_args, generics)?;
         let bitmap = bitmap.unwrap_or_else(|| constant_bitmap(true, len));
-        match nonull_results {
+        match results {
             Value::Scalar(s) => {
                 if bitmap.get(0) {
                     Ok(Value::Scalar(Result::upcast_scalar(s)))
@@ -232,10 +232,21 @@ where F: Fn(&[ValueRef<AnyType>], &GenericMap) -> Result<Value<AnyType>, String>
                 }
             }
             Value::Column(column) => {
-                let result = Column::Nullable(Box::new(NullableColumn {
-                    column,
-                    validity: bitmap.into(),
-                }));
+                let result = match column {
+                    Column::Nullable(box nullable_column) => {
+                        let validity = bitmap.into();
+                        let validity =
+                            common_arrow::arrow::bitmap::and(&nullable_column.validity, &validity);
+                        Column::Nullable(Box::new(NullableColumn {
+                            column: nullable_column.column,
+                            validity,
+                        }))
+                    }
+                    _ => Column::Nullable(Box::new(NullableColumn {
+                        column,
+                        validity: bitmap.into(),
+                    })),
+                };
                 Ok(Value::Column(Result::upcast_column(result)))
             }
         }

src/query/expression/src/function.rs

@@ -232,11 +232,14 @@ impl<'a, T: ValueType> Iterator for NullableIterator<'a, T> {
     type Item = Option<T::ScalarRef<'a>>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next().zip(self.validity.next()).map(
-            |(scalar, is_null)| {
-                if is_null { None } else { Some(scalar) }
-            },
-        )
+        self.iter
+            .next()
+            .zip(self.validity.next())
+            .map(
+                |(scalar, is_not_null)| {
+                    if is_not_null { Some(scalar) } else { None }
+                },
+            )
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {

src/query/expression/src/types/nullable.rs

@@ -36,8 +36,10 @@ ordered-float = { git = "https://github.com/andylokandy/rust-ordered-float.git",
     "rand",
 ] }
 rand = { version = "0.8.5", features = ["small_rng"] }
+regex = "1.5.6"
 serde = { version = "1.0.137", features = ["derive"] }
 serde_json = "1.0"
+simdutf8 = "0.1.4"
 strength_reduce = "0.2.3"
 
 [dev-dependencies]