strings::contains() for multiple scalar search targets

cpp/benchmarks/string/find.cpp

@@ -71,8 +71,55 @@ static void bench_find_string(nvbench::state& state)
       cudf::strings::find_multiple(input, cudf::strings_column_view(targets));
     });
   } else if (api == "contains") {
-    state.exec(nvbench::exec_tag::sync,
-               [&](nvbench::launch& launch) { cudf::strings::contains(input, target); });
+    constexpr bool combine          = false;  // test true/false
+    bool has_same_target_first_char = false;  // test true/false
+    constexpr int iters             = 10;     // test 4/10
+    bool check_result               = false;
+
+    std::vector<std::string> match_targets({" abc",
+                                            "W43",
+                                            "0987 5W43",
+                                            "123 abc",
+                                            "23 abc",
+                                            "3 abc",
+                                            "é",
+                                            "7 5W43",
+                                            "87 5W43",
+                                            "987 5W43"});
+    auto multi_targets = std::vector<std::string>{};
+    for (int i = 0; i < iters; i++) {
+      // if has same first chars in targets, use duplicated targets.
+      int idx = has_same_target_first_char ? i / 2 : i;
+      multi_targets.emplace_back(match_targets[idx]);
+    }
+
+    if constexpr (not combine) {
+      state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
+        std::vector<std::unique_ptr<cudf::column>> contains_results;
+        std::vector<cudf::column_view> contains_cvs;
+        for (size_t i = 0; i < multi_targets.size(); i++) {
+          contains_results.emplace_back(
+            cudf::strings::contains(input, cudf::string_scalar(multi_targets[i])));
+          contains_cvs.emplace_back(contains_results.back()->view());
+        }
+
+        if (check_result) {
+          cudf::test::strings_column_wrapper multi_targets_column(multi_targets.begin(),
+                                                                  multi_targets.end());
+          auto tab =
+            cudf::strings::multi_contains(input, cudf::strings_column_view(multi_targets_column));
+          for (int i = 0; i < tab->num_columns(); i++) {
+            cudf::test::detail::expect_columns_equal(contains_cvs[i], tab->get_column(i).view());
+          }
+        }
+      });
+    } else {  // combine
+      state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
+        cudf::test::strings_column_wrapper multi_targets_column(multi_targets.begin(),
+                                                                multi_targets.end());
+        cudf::strings::multi_contains(input, cudf::strings_column_view(multi_targets_column));
+      });
+    }
   } else if (api == "starts_with") {
     state.exec(nvbench::exec_tag::sync,
                [&](nvbench::launch& launch) { cudf::strings::starts_with(input, target); });

cpp/include/cudf/strings/find.hpp

@@ -140,6 +140,36 @@ std::unique_ptr<column> contains(
   rmm::cuda_stream_view stream      = cudf::get_default_stream(),
   rmm::device_async_resource_ref mr = rmm::mr::get_current_device_resource());
 
+/**
+ * @brief Returns a table of columns of boolean values for each string where true indicates
+ * the target string was found within that string in the provided column.
+ *
+ * Each column in the result table corresponds to the result for the target string at the same
+ * ordinal. i.e. 0th column is the boolean-column result for the 0th target string, 1th for 1th,
+ * etc.
+ *
+ * If the target is not found for a string, false is returned for that entry in the output column.
+ * If the target is an empty string, true is returned for all non-null entries in the output column.
+ *
+ * Any null string entries return corresponding null entries in the output columns.
+ * e.g.:
+ *   input:   "a", "b", "c"
+ *   targets: "a", "c"
+ *   output is a table with two boolean columns:
+ *     column_0: true, false, false
+ *     column_1: false, false, true
+ * @param input Strings instance for this operation
+ * @param targets UTF-8 encoded strings to search for in each string in `input`
+ * @param stream CUDA stream used for device memory operations and kernel launches
+ * @param mr Device memory resource used to allocate the returned column's device memory
+ * @return New BOOL8 column
+ */
+std::unique_ptr<table> multi_contains(
+  strings_column_view const& input,
+  strings_column_view const& targets,
+  rmm::cuda_stream_view stream        = cudf::get_default_stream(),
+  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
 /**
  * @brief Returns a column of boolean values for each string where true indicates
  * the corresponding target string was found within that string in the provided column.