feat(function): Add varbinary variants for strpos and contains (#15809)

Summary:

Adds `strpos`, `strrpos` and `contains` for varbinary columns which will allow for efficient string searching in encoded text data where we don't want to pay the charset decoding price (i.e. we don't have to convert the column to utf-8 and just do byte matches as an approximation).

Reviewed By: kaikalur

Differential Revision: D89479354

Author: laurencer

velox/expression/fuzzer/ExpressionFuzzerTest.cpp

@@ -191,6 +191,14 @@ std::unordered_set<std::string> skipFunctions = {
     // https://github.com/facebookincubator/velox/issues/13047
     "inverse_poisson_cdf",
     "map_subset", // https://github.com/facebookincubator/velox/issues/12654
+    // Presto doesn't support varbinary variants of strpos, strrpos and
+    // contains. Presto only has contains(array(T), T), not contains(varbinary,
+    // varbinary).
+    "strpos(varbinary,varbinary) -> bigint",
+    "strpos(varbinary,varbinary,bigint) -> bigint",
+    "strrpos(varbinary,varbinary) -> bigint",
+    "strrpos(varbinary,varbinary,bigint) -> bigint",
+    "contains(varbinary,varbinary) -> boolean",
     // JSON not supported, Real doesn't match exactly, etc.
     "array_join(array(json),varchar) -> varchar",
     "array_join(array(json),varchar,varchar) -> varchar",

velox/functions/prestosql/VarbinaryFunctions.h

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "velox/functions/Macros.h"
+#include "velox/functions/lib/string/StringCore.h"
+
+namespace facebook::velox::functions {
+
+/// strpos and strrpos functions for varbinary
+/// strpos(varbinary, varbinary) → bigint
+///     Returns the starting byte position of the first instance of the pattern
+///     in the binary data. Positions start with 1. If not found, 0 is returned.
+/// strpos(varbinary, varbinary, instance) → bigint
+///     Returns the byte position of the N-th instance of the pattern.
+///     instance must be a positive number. Positions start with 1. If not
+///     found, 0 is returned.
+/// strrpos(varbinary, varbinary) → bigint
+///     Returns the starting byte position of the first instance of the pattern
+///     in the binary data counting from the end. Positions start with 1. If not
+///     found, 0 is returned.
+/// strrpos(varbinary, varbinary, instance) → bigint
+///     Returns the byte position of the N-th instance of the pattern
+///     counting from the end. Instance must be a positive number. Positions
+///     start with 1. If not found, 0 is returned.
+template <typename T, bool lpos>
+struct StrPosVarbinaryFunctionBase {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<int64_t>& result,
+      const arg_type<Varbinary>& haystack,
+      const arg_type<Varbinary>& needle,
+      const arg_type<int64_t>& instance = 1) {
+    VELOX_USER_CHECK_GT(instance, 0, "'instance' must be a positive number");
+    if (needle.size() == 0) {
+      result = 1;
+      return;
+    }
+
+    int64_t byteIndex = -1;
+    if constexpr (lpos) {
+      byteIndex = stringCore::findNthInstanceByteIndexFromStart(
+          std::string_view(haystack.data(), haystack.size()),
+          std::string_view(needle.data(), needle.size()),
+          instance);
+    } else {
+      byteIndex = stringCore::findNthInstanceByteIndexFromEnd(
+          std::string_view(haystack.data(), haystack.size()),
+          std::string_view(needle.data(), needle.size()),
+          instance);
+    }
+
+    // Return 1-based byte position, or 0 if not found.
+    result = byteIndex == -1 ? 0 : byteIndex + 1;
+  }
+};
+
+template <typename T>
+struct StrLPosVarbinaryFunction : public StrPosVarbinaryFunctionBase<T, true> {
+};
+
+template <typename T>
+struct StrRPosVarbinaryFunction : public StrPosVarbinaryFunctionBase<T, false> {
+};
+
+/// contains for varbinary - returns true if the pattern exists in the binary
+/// data contains(varbinary, varbinary) → boolean
+template <typename T>
+struct ContainsVarbinaryFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<bool>& result,
+      const arg_type<Varbinary>& haystack,
+      const arg_type<Varbinary>& needle) {
+    if (needle.size() == 0) {
+      result = true;
+      return;
+    }
+    auto pos = std::string_view(haystack.data(), haystack.size())
+                   .find(std::string_view(needle.data(), needle.size()));
+    result = pos != std::string_view::npos;
+  }
+};
+
+} // namespace facebook::velox::functions

velox/functions/prestosql/registration/CMakeLists.txt

@@ -42,6 +42,7 @@ velox_add_library(
   TDigestFunctionsRegistration.cpp
   QDigestFunctionsRegistration.cpp
   URLFunctionsRegistration.cpp
+  VarbinaryFunctionsRegistration.cpp
 )
 
 if(VELOX_ENABLE_GEO)

velox/functions/prestosql/registration/RegistrationFunctions.cpp

@@ -41,6 +41,7 @@ extern void registerFloatingPointFunctions(const std::string& prefix);
 extern void registerJsonFunctions(const std::string& prefix);
 extern void registerMapFunctions(const std::string& prefix);
 extern void registerStringFunctions(const std::string& prefix);
+extern void registerVarbinaryFunctions(const std::string& prefix);
 extern void registerBinaryFunctions(const std::string& prefix);
 extern void registerURLFunctions(const std::string& prefix);
 extern void registerDataSizeFunctions(const std::string& prefix);
@@ -139,6 +140,10 @@ void registerStringFunctions(const std::string& prefix) {
   functions::registerStringFunctions(prefix);
 }
 
+void registerVarbinaryFunctions(const std::string& prefix) {
+  functions::registerVarbinaryFunctions(prefix);
+}
+
 void registerBinaryFunctions(const std::string& prefix) {
   functions::registerBinaryFunctions(prefix);
 }
@@ -173,6 +178,7 @@ void registerAllScalarFunctions(const std::string& prefix) {
   registerDateTimeFunctions(prefix);
   registerURLFunctions(prefix);
   registerStringFunctions(prefix);
+  registerVarbinaryFunctions(prefix);
   registerBinaryFunctions(prefix);
   registerBitwiseFunctions(prefix);
   registerUuidFunctions(prefix);

velox/functions/prestosql/registration/RegistrationFunctions.h

@@ -53,6 +53,8 @@ void registerURLFunctions(const std::string& prefix = "");
 
 void registerStringFunctions(const std::string& prefix = "");
 
+void registerVarbinaryFunctions(const std::string& prefix = "");
+
 void registerBinaryFunctions(const std::string& prefix = "");
 
 void registerBitwiseFunctions(const std::string& prefix = "");

velox/functions/prestosql/registration/VarbinaryFunctionsRegistration.cpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/functions/Registerer.h"
+#include "velox/functions/prestosql/StringFunctions.h"
+#include "velox/functions/prestosql/VarbinaryFunctions.h"
+
+namespace facebook::velox::functions {
+
+void registerVarbinaryFunctions(const std::string& prefix) {
+  // Length for varbinary
+  registerFunction<LengthVarbinaryFunction, int64_t, Varbinary>(
+      {prefix + "length"});
+
+  // substr for varbinary
+  registerFunction<SubstrVarbinaryFunction, Varbinary, Varbinary, int64_t>(
+      {prefix + "substr"});
+  registerFunction<
+      SubstrVarbinaryFunction,
+      Varbinary,
+      Varbinary,
+      int64_t,
+      int64_t>({prefix + "substr"});
+
+  // strpos/strrpos for varbinary
+  registerFunction<StrLPosVarbinaryFunction, int64_t, Varbinary, Varbinary>(
+      {prefix + "strpos"});
+  registerFunction<
+      StrLPosVarbinaryFunction,
+      int64_t,
+      Varbinary,
+      Varbinary,
+      int64_t>({prefix + "strpos"});
+  registerFunction<StrRPosVarbinaryFunction, int64_t, Varbinary, Varbinary>(
+      {prefix + "strrpos"});
+  registerFunction<
+      StrRPosVarbinaryFunction,
+      int64_t,
+      Varbinary,
+      Varbinary,
+      int64_t>({prefix + "strrpos"});
+
+  // contains for varbinary
+  registerFunction<ContainsVarbinaryFunction, bool, Varbinary, Varbinary>(
+      {prefix + "contains"});
+}
+} // namespace facebook::velox::functions