strings::contains() for multiple scalar search targets

cpp/benchmarks/string/find.cpp

@@ -73,6 +73,27 @@ static void bench_find_string(nvbench::state& state)
   } else if (api == "contains") {
     state.exec(nvbench::exec_tag::sync,
                [&](nvbench::launch& launch) { cudf::strings::contains(input, target); });
+  } else if (api == "multi-contains") {
+    constexpr int iters = 10;
+    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++) {
+      multi_targets.emplace_back(match_targets[i % match_targets.size()]);
+    }
+    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); });
@@ -84,7 +105,8 @@ static void bench_find_string(nvbench::state& state)
 
 NVBENCH_BENCH(bench_find_string)
   .set_name("find_string")
-  .add_string_axis("api", {"find", "find_multi", "contains", "starts_with", "ends_with"})
+  .add_string_axis("api",
+                   {"find", "find_multi", "contains", "starts_with", "ends_with", "multi-contains"})
   .add_int64_axis("row_width", {32, 64, 128, 256, 512, 1024})
   .add_int64_axis("num_rows", {260'000, 1'953'000, 16'777'216})
   .add_int64_axis("hit_rate", {20, 80});  // percentage

cpp/include/cudf/strings/find.hpp

@@ -138,6 +138,39 @@ std::unique_ptr<column> contains(
   rmm::cuda_stream_view stream      = cudf::get_default_stream(),
   rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
+/**
+ * @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.:
+ * @code
+ *   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
+ * @endcode
+ *
+ * @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.