diff --git a/cpp/include/cudf/column/column_factories.hpp b/cpp/include/cudf/column/column_factories.hpp
index ebd7f5bbef0..c2cddf02789 100644
--- a/cpp/include/cudf/column/column_factories.hpp
+++ b/cpp/include/cudf/column/column_factories.hpp
@@ -420,27 +420,21 @@ std::unique_ptr<column> make_strings_column(
  *
  * The columns and mask are moved into the resulting strings column.
  *
- * @param[in] num_strings The number of strings the column represents.
- * @param[in] offsets_column The column of offset values for this column. The number of elements is
+ * @param num_strings The number of strings the column represents.
+ * @param offsets_column The column of offset values for this column. The number of elements is
  *  one more than the total number of strings so the `offset[last] - offset[0]` is the total number
  *  of bytes in the strings vector.
- * @param[in] chars_column The column of char bytes for all the strings for this column. Individual
+ * @param chars_column The column of char bytes for all the strings for this column. Individual
  *  strings are identified by the offsets and the nullmask.
- * @param[in] null_count The number of null string entries.
- * @param[in] null_mask The bits specifying the null strings in device memory. Arrow format for
+ * @param null_count The number of null string entries.
+ * @param null_mask The bits specifying the null strings in device memory. Arrow format for
  *  nulls is used for interpreting this bitmask.
- * @param[in] stream CUDA stream used for device memory operations and kernel launches.
- * @param[in] mr Device memory resource used for allocation of the column's `null_mask` and children
- * columns' device memory.
  */
-std::unique_ptr<column> make_strings_column(
-  size_type num_strings,
-  std::unique_ptr<column> offsets_column,
-  std::unique_ptr<column> chars_column,
-  size_type null_count,
-  rmm::device_buffer&& null_mask,
-  rmm::cuda_stream_view stream        = rmm::cuda_stream_default,
-  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+std::unique_ptr<column> make_strings_column(size_type num_strings,
+                                            std::unique_ptr<column> offsets_column,
+                                            std::unique_ptr<column> chars_column,
+                                            size_type null_count,
+                                            rmm::device_buffer&& null_mask);
 
 /**
  * @brief Construct a STRING type column given offsets, columns, and optional null count and null
diff --git a/cpp/include/cudf/strings/detail/copy_if_else.cuh b/cpp/include/cudf/strings/detail/copy_if_else.cuh
index 1f0f09125e6..72f9ac11ceb 100644
--- a/cpp/include/cudf/strings/detail/copy_if_else.cuh
+++ b/cpp/include/cudf/strings/detail/copy_if_else.cuh
@@ -111,9 +111,7 @@ std::unique_ptr<cudf::column> copy_if_else(
                              std::move(offsets_column),
                              std::move(chars_column),
                              null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/include/cudf/strings/detail/copy_range.cuh b/cpp/include/cudf/strings/detail/copy_range.cuh
index adf9d3c6525..7e8ab6a0b68 100644
--- a/cpp/include/cudf/strings/detail/copy_range.cuh
+++ b/cpp/include/cudf/strings/detail/copy_range.cuh
@@ -210,9 +210,7 @@ std::unique_ptr<column> copy_range(
                                std::move(p_offsets_column),
                                std::move(p_chars_column),
                                null_count,
-                               std::move(null_mask),
-                               stream,
-                               mr);
+                               std::move(null_mask));
   }
 }
 
diff --git a/cpp/include/cudf/strings/detail/gather.cuh b/cpp/include/cudf/strings/detail/gather.cuh
index 718c1737890..faae9a50be2 100644
--- a/cpp/include/cudf/strings/detail/gather.cuh
+++ b/cpp/include/cudf/strings/detail/gather.cuh
@@ -339,9 +339,7 @@ std::unique_ptr<cudf::column> gather(
                              std::move(out_offsets_column),
                              std::move(out_chars_column),
                              0,
-                             rmm::device_buffer{0, stream, mr},
-                             stream,
-                             mr);
+                             rmm::device_buffer{});
 }
 
 /**
diff --git a/cpp/include/cudf/strings/detail/merge.cuh b/cpp/include/cudf/strings/detail/merge.cuh
index e5ed03f34d6..d632e6c24cb 100644
--- a/cpp/include/cudf/strings/detail/merge.cuh
+++ b/cpp/include/cudf/strings/detail/merge.cuh
@@ -103,9 +103,7 @@ std::unique_ptr<column> merge(strings_column_view const& lhs,
                              std::move(offsets_column),
                              std::move(chars_column),
                              null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/include/cudf/strings/detail/scatter.cuh b/cpp/include/cudf/strings/detail/scatter.cuh
index 0522ceace1a..eb7493f4895 100644
--- a/cpp/include/cudf/strings/detail/scatter.cuh
+++ b/cpp/include/cudf/strings/detail/scatter.cuh
@@ -79,9 +79,7 @@ std::unique_ptr<column> scatter(
                              std::move(offsets_column),
                              std::move(chars_column),
                              UNKNOWN_NULL_COUNT,
-                             cudf::detail::copy_bitmask(target.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(target.parent(), stream, mr));
 }
 
 }  // namespace detail
diff --git a/cpp/include/cudf/strings/detail/strings_column_factories.cuh b/cpp/include/cudf/strings/detail/strings_column_factories.cuh
index 1831034231e..bb5e2787a14 100644
--- a/cpp/include/cudf/strings/detail/strings_column_factories.cuh
+++ b/cpp/include/cudf/strings/detail/strings_column_factories.cuh
@@ -131,9 +131,7 @@ std::unique_ptr<column> make_strings_column(IndexPairIterator begin,
                              std::move(offsets_column),
                              std::move(chars_column),
                              null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 /**
@@ -189,9 +187,7 @@ std::unique_ptr<column> make_strings_column(CharIterator chars_begin,
                              std::move(offsets_column),
                              std::move(chars_column),
                              null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/hash/md5_hash.cu b/cpp/src/hash/md5_hash.cu
index 80348ae7b51..973f3204c37 100644
--- a/cpp/src/hash/md5_hash.cu
+++ b/cpp/src/hash/md5_hash.cu
@@ -92,13 +92,8 @@ std::unique_ptr<column> md5_hash(table_view const& input,
                      hasher.finalize(&hash_state, d_chars + (row_index * 32));
                    });
 
-  return make_strings_column(input.num_rows(),
-                             std::move(offsets_column),
-                             std::move(chars_column),
-                             0,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+  return make_strings_column(
+    input.num_rows(), std::move(offsets_column), std::move(chars_column), 0, std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/interop/from_arrow.cu b/cpp/src/interop/from_arrow.cu
index 917a5b1ac9c..db55c82f109 100644
--- a/cpp/src/interop/from_arrow.cu
+++ b/cpp/src/interop/from_arrow.cu
@@ -285,9 +285,7 @@ std::unique_ptr<column> dispatch_to_cudf_column::operator()<cudf::string_view>(
                                      std::move(offsets_column),
                                      std::move(chars_column),
                                      UNKNOWN_NULL_COUNT,
-                                     std::move(*get_mask_buffer(array, stream, mr)),
-                                     stream,
-                                     mr);
+                                     std::move(*get_mask_buffer(array, stream, mr)));
 
   return num_rows == array.length() ? std::move(out_col)
                                     : std::make_unique<column>(cudf::detail::slice(
diff --git a/cpp/src/io/csv/durations.cu b/cpp/src/io/csv/durations.cu
index f607e2cd8a0..219d5759353 100644
--- a/cpp/src/io/csv/durations.cu
+++ b/cpp/src/io/csv/durations.cu
@@ -204,9 +204,7 @@ struct dispatch_from_durations_fn {
                                std::move(offsets_column),
                                std::move(chars_column),
                                durations.null_count(),
-                               std::move(null_mask),
-                               stream,
-                               mr);
+                               std::move(null_mask));
   }
 
   // non-duration types throw an exception
diff --git a/cpp/src/io/csv/writer_impl.cu b/cpp/src/io/csv/writer_impl.cu
index f50aae72418..de75ea6a51d 100644
--- a/cpp/src/io/csv/writer_impl.cu
+++ b/cpp/src/io/csv/writer_impl.cu
@@ -166,9 +166,7 @@ struct column_to_strings_fn {
                                std::move(children.first),
                                std::move(children.second),
                                column_v.null_count(),
-                               cudf::detail::copy_bitmask(column_v, stream_, mr_),
-                               stream_,
-                               mr_);
+                               cudf::detail::copy_bitmask(column_v, stream_, mr_));
   }
 
   // ints:
diff --git a/cpp/src/lists/copying/scatter_helper.cu b/cpp/src/lists/copying/scatter_helper.cu
index 53317fcf4aa..3cd8a23d0fc 100644
--- a/cpp/src/lists/copying/scatter_helper.cu
+++ b/cpp/src/lists/copying/scatter_helper.cu
@@ -279,10 +279,8 @@ struct list_child_constructor {
     return cudf::make_strings_column(num_child_rows,
                                      std::move(string_offsets),
                                      std::move(string_chars),
-                                     child_null_mask.second,            // Null count.
-                                     std::move(child_null_mask.first),  // Null mask.
-                                     stream,
-                                     mr);
+                                     child_null_mask.second,  // Null count.
+                                     std::move(child_null_mask.first));
   }
 
   /**
diff --git a/cpp/src/lists/interleave_columns.cu b/cpp/src/lists/interleave_columns.cu
index 4e69baef6ed..f0a2dabdc99 100644
--- a/cpp/src/lists/interleave_columns.cu
+++ b/cpp/src/lists/interleave_columns.cu
@@ -189,9 +189,7 @@ struct interleave_list_entries_fn {
                                std::move(offsets_column),
                                std::move(chars_column),
                                null_count,
-                               std::move(null_mask),
-                               stream,
-                               mr);
+                               std::move(null_mask));
   }
 
   template <class T>
diff --git a/cpp/src/replace/clamp.cu b/cpp/src/replace/clamp.cu
index 067d9fff077..4da1b27fa69 100644
--- a/cpp/src/replace/clamp.cu
+++ b/cpp/src/replace/clamp.cu
@@ -140,9 +140,7 @@ std::unique_ptr<cudf::column> clamp_string_column(strings_column_view const& inp
                              std::move(offsets_column),
                              std::move(chars_column),
                              input.null_count(),
-                             std::move(copy_bitmask(input.parent())),
-                             stream,
-                             mr);
+                             std::move(copy_bitmask(input.parent())));
 }
 
 template <typename T, typename OptionalScalarIterator, typename ReplaceScalarIterator>
diff --git a/cpp/src/replace/nulls.cu b/cpp/src/replace/nulls.cu
index 87e850e6676..4fa42021bd2 100644
--- a/cpp/src/replace/nulls.cu
+++ b/cpp/src/replace/nulls.cu
@@ -270,9 +270,7 @@ std::unique_ptr<cudf::column> replace_nulls_column_kernel_forwarder::operator()<
                                    std::move(offsets),
                                    std::move(output_chars),
                                    input.size() - valid_counter.value(stream),
-                                   std::move(valid_bits),
-                                   stream,
-                                   mr);
+                                   std::move(valid_bits));
 }
 
 template <>
diff --git a/cpp/src/replace/replace.cu b/cpp/src/replace/replace.cu
index 290e25a8181..a1d38ebe2e3 100644
--- a/cpp/src/replace/replace.cu
+++ b/cpp/src/replace/replace.cu
@@ -431,9 +431,7 @@ std::unique_ptr<cudf::column> replace_kernel_forwarder::operator()<cudf::string_
                                    std::move(offsets),
                                    std::move(output_chars),
                                    null_count,
-                                   std::move(valid_bits),
-                                   stream,
-                                   mr);
+                                   std::move(valid_bits));
 }
 
 template <>
diff --git a/cpp/src/reshape/interleave_columns.cu b/cpp/src/reshape/interleave_columns.cu
index b15708c5cf8..30ff7b0549e 100644
--- a/cpp/src/reshape/interleave_columns.cu
+++ b/cpp/src/reshape/interleave_columns.cu
@@ -207,9 +207,7 @@ struct interleave_columns_impl<T, typename std::enable_if_t<std::is_same_v<T, cu
                                std::move(offsets_column),
                                std::move(chars_column),
                                null_count,
-                               std::move(valid_mask.first),
-                               stream,
-                               mr);
+                               std::move(valid_mask.first));
   }
 };
 
diff --git a/cpp/src/strings/capitalize.cu b/cpp/src/strings/capitalize.cu
index 29ff7b242e6..023e82dfe24 100644
--- a/cpp/src/strings/capitalize.cu
+++ b/cpp/src/strings/capitalize.cu
@@ -199,9 +199,7 @@ std::unique_ptr<column> capitalizer(CapitalFn cfn,
                              std::move(children.first),
                              std::move(children.second),
                              input.null_count(),
-                             cudf::detail::copy_bitmask(input.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(input.parent(), stream, mr));
 }
 
 }  // namespace
diff --git a/cpp/src/strings/case.cu b/cpp/src/strings/case.cu
index cc0edb49a33..de7b6b2b560 100644
--- a/cpp/src/strings/case.cu
+++ b/cpp/src/strings/case.cu
@@ -144,9 +144,7 @@ std::unique_ptr<column> convert_case(strings_column_view const& strings,
                              std::move(children.first),
                              std::move(children.second),
                              strings.null_count(),
-                             cudf::detail::copy_bitmask(strings.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(strings.parent(), stream, mr));
 }
 
 }  // namespace
diff --git a/cpp/src/strings/char_types/char_types.cu b/cpp/src/strings/char_types/char_types.cu
index 1479062d1de..f61e1c1241b 100644
--- a/cpp/src/strings/char_types/char_types.cu
+++ b/cpp/src/strings/char_types/char_types.cu
@@ -182,9 +182,7 @@ std::unique_ptr<column> filter_characters_of_type(strings_column_view const& str
                              std::move(children.first),
                              std::move(children.second),
                              strings.null_count(),
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/combine/concatenate.cu b/cpp/src/strings/combine/concatenate.cu
index b2db61942d2..58a41277794 100644
--- a/cpp/src/strings/combine/concatenate.cu
+++ b/cpp/src/strings/combine/concatenate.cu
@@ -156,9 +156,7 @@ std::unique_ptr<column> concatenate(table_view const& strings_columns,
                              std::move(children.first),
                              std::move(children.second),
                              null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 namespace {
@@ -254,9 +252,7 @@ std::unique_ptr<column> concatenate(table_view const& strings_columns,
                              std::move(children.first),
                              std::move(children.second),
                              null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/combine/join.cu b/cpp/src/strings/combine/join.cu
index ccbedf99bc2..f7f3e63d213 100644
--- a/cpp/src/strings/combine/join.cu
+++ b/cpp/src/strings/combine/join.cu
@@ -117,13 +117,8 @@ std::unique_ptr<column> join_strings(strings_column_view const& strings,
       if ((idx + 1) < d_strings.size()) d_buffer = detail::copy_string(d_buffer, d_separator);
     });
 
-  return make_strings_column(1,
-                             std::move(offsets_column),
-                             std::move(chars_column),
-                             null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+  return make_strings_column(
+    1, std::move(offsets_column), std::move(chars_column), null_count, std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/combine/join_list_elements.cu b/cpp/src/strings/combine/join_list_elements.cu
index 3e0bb8704b6..3962dfcea57 100644
--- a/cpp/src/strings/combine/join_list_elements.cu
+++ b/cpp/src/strings/combine/join_list_elements.cu
@@ -208,13 +208,8 @@ std::unique_ptr<column> join_list_elements(lists_column_view const& lists_string
                            stream,
                            mr);
 
-  return make_strings_column(num_rows,
-                             std::move(offsets_column),
-                             std::move(chars_column),
-                             null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+  return make_strings_column(
+    num_rows, std::move(offsets_column), std::move(chars_column), null_count, std::move(null_mask));
 }
 
 namespace {
@@ -288,13 +283,8 @@ std::unique_ptr<column> join_list_elements(lists_column_view const& lists_string
                            stream,
                            mr);
 
-  return make_strings_column(num_rows,
-                             std::move(offsets_column),
-                             std::move(chars_column),
-                             null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+  return make_strings_column(
+    num_rows, std::move(offsets_column), std::move(chars_column), null_count, std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/convert/convert_booleans.cu b/cpp/src/strings/convert/convert_booleans.cu
index 8823b7cf416..acfce097eed 100644
--- a/cpp/src/strings/convert/convert_booleans.cu
+++ b/cpp/src/strings/convert/convert_booleans.cu
@@ -140,9 +140,7 @@ std::unique_ptr<column> from_booleans(column_view const& booleans,
                              std::move(offsets_column),
                              std::move(chars_column),
                              booleans.null_count(),
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/convert/convert_datetime.cu b/cpp/src/strings/convert/convert_datetime.cu
index ce5eb015039..4108e23d4ab 100644
--- a/cpp/src/strings/convert/convert_datetime.cu
+++ b/cpp/src/strings/convert/convert_datetime.cu
@@ -1069,9 +1069,7 @@ std::unique_ptr<column> from_timestamps(column_view const& timestamps,
                              std::move(offsets_column),
                              std::move(chars_column),
                              timestamps.null_count(),
-                             cudf::detail::copy_bitmask(timestamps, stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(timestamps,stream,mr));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/convert/convert_durations.cu b/cpp/src/strings/convert/convert_durations.cu
index c8b4b859020..eb733f0a302 100644
--- a/cpp/src/strings/convert/convert_durations.cu
+++ b/cpp/src/strings/convert/convert_durations.cu
@@ -441,9 +441,7 @@ struct dispatch_from_durations_fn {
                                std::move(offsets_column),
                                std::move(chars_column),
                                durations.null_count(),
-                               std::move(null_mask),
-                               stream,
-                               mr);
+                               std::move(null_mask));
   }
 
   // non-duration types throw an exception
diff --git a/cpp/src/strings/convert/convert_fixed_point.cu b/cpp/src/strings/convert/convert_fixed_point.cu
index 6f7076422c4..f49a439a257 100644
--- a/cpp/src/strings/convert/convert_fixed_point.cu
+++ b/cpp/src/strings/convert/convert_fixed_point.cu
@@ -296,9 +296,7 @@ struct dispatch_from_fixed_point_fn {
                                std::move(offsets_column),
                                std::move(chars_column),
                                input.null_count(),
-                               cudf::detail::copy_bitmask(input, stream, mr),
-                               stream,
-                               mr);
+                               cudf::detail::copy_bitmask(input, stream, mr));
   }
 
   template <typename T, std::enable_if_t<not cudf::is_fixed_point<T>()>* = nullptr>
diff --git a/cpp/src/strings/convert/convert_floats.cu b/cpp/src/strings/convert/convert_floats.cu
index b0910acb2a2..39215dd2721 100644
--- a/cpp/src/strings/convert/convert_floats.cu
+++ b/cpp/src/strings/convert/convert_floats.cu
@@ -505,9 +505,7 @@ struct dispatch_from_floats_fn {
                                std::move(offsets_column),
                                std::move(chars_column),
                                floats.null_count(),
-                               std::move(null_mask),
-                               stream,
-                               mr);
+                               std::move(null_mask));
   }
 
   // non-float types throw an exception
diff --git a/cpp/src/strings/convert/convert_hex.cu b/cpp/src/strings/convert/convert_hex.cu
index c624819999f..964fdccc849 100644
--- a/cpp/src/strings/convert/convert_hex.cu
+++ b/cpp/src/strings/convert/convert_hex.cu
@@ -188,9 +188,7 @@ struct dispatch_integers_to_hex_fn {
                                std::move(children.first),
                                std::move(children.second),
                                input.null_count(),
-                               cudf::detail::copy_bitmask(input, stream, mr),
-                               stream,
-                               mr);
+                               cudf::detail::copy_bitmask(input, stream, mr));
   }
   // non-integral types throw an exception
   template <typename T, typename... Args>
diff --git a/cpp/src/strings/convert/convert_integers.cu b/cpp/src/strings/convert/convert_integers.cu
index ce06743de6c..e22283522e8 100644
--- a/cpp/src/strings/convert/convert_integers.cu
+++ b/cpp/src/strings/convert/convert_integers.cu
@@ -362,9 +362,7 @@ struct dispatch_from_integers_fn {
                                std::move(offsets_column),
                                std::move(chars_column),
                                integers.null_count(),
-                               std::move(null_mask),
-                               stream,
-                               mr);
+                               std::move(null_mask));
   }
 
   // non-integral types throw an exception
diff --git a/cpp/src/strings/convert/convert_ipv4.cu b/cpp/src/strings/convert/convert_ipv4.cu
index 4e323b98a2e..5b708c52dd2 100644
--- a/cpp/src/strings/convert/convert_ipv4.cu
+++ b/cpp/src/strings/convert/convert_ipv4.cu
@@ -204,9 +204,7 @@ std::unique_ptr<column> integers_to_ipv4(
                              std::move(offsets_column),
                              std::move(chars_column),
                              integers.null_count(),
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 std::unique_ptr<column> is_ipv4(strings_column_view const& strings,
diff --git a/cpp/src/strings/convert/convert_urls.cu b/cpp/src/strings/convert/convert_urls.cu
index 80d870abb8e..fb494a9634c 100644
--- a/cpp/src/strings/convert/convert_urls.cu
+++ b/cpp/src/strings/convert/convert_urls.cu
@@ -159,9 +159,7 @@ std::unique_ptr<column> url_encode(
                              std::move(offsets_column),
                              std::move(chars_column),
                              strings.null_count(),
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
@@ -442,9 +440,7 @@ std::unique_ptr<column> url_decode(
                              std::move(offsets_column),
                              std::move(chars_column),
                              strings.null_count(),
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/copying/concatenate.cu b/cpp/src/strings/copying/concatenate.cu
index 8d77c7da4cc..f131f0e40a3 100644
--- a/cpp/src/strings/copying/concatenate.cu
+++ b/cpp/src/strings/copying/concatenate.cu
@@ -307,9 +307,7 @@ std::unique_ptr<column> concatenate(host_span<column_view const> columns,
                              std::move(offsets_column),
                              std::move(chars_column),
                              null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/copying/copying.cu b/cpp/src/strings/copying/copying.cu
index a6b1d227f74..24572576498 100644
--- a/cpp/src/strings/copying/copying.cu
+++ b/cpp/src/strings/copying/copying.cu
@@ -71,9 +71,7 @@ std::unique_ptr<cudf::column> copy_slice(strings_column_view const& strings,
                              std::move(offsets_column),
                              std::move(chars_column),
                              UNKNOWN_NULL_COUNT,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/copying/shift.cu b/cpp/src/strings/copying/shift.cu
index 3545ec6d259..b4219585b78 100644
--- a/cpp/src/strings/copying/shift.cu
+++ b/cpp/src/strings/copying/shift.cu
@@ -132,13 +132,8 @@ std::unique_ptr<column> shift(strings_column_view const& input,
                     shift_chars_fn{*d_input_chars, d_fill_str, shift_offset});
 
   // caller sets the null-mask
-  return make_strings_column(input.size(),
-                             std::move(offsets_column),
-                             std::move(chars_column),
-                             0,
-                             rmm::device_buffer{},
-                             stream,
-                             mr);
+  return make_strings_column(
+    input.size(), std::move(offsets_column), std::move(chars_column), 0, rmm::device_buffer{});
 }
 
 }  // namespace cudf::strings::detail
diff --git a/cpp/src/strings/filling/fill.cu b/cpp/src/strings/filling/fill.cu
index 7ee64e75ae8..8779aef57fb 100644
--- a/cpp/src/strings/filling/fill.cu
+++ b/cpp/src/strings/filling/fill.cu
@@ -98,9 +98,7 @@ std::unique_ptr<column> fill(
                              std::move(offsets_column),
                              std::move(chars_column),
                              null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/filter_chars.cu b/cpp/src/strings/filter_chars.cu
index be0715c97df..5408cc43d1f 100644
--- a/cpp/src/strings/filter_chars.cu
+++ b/cpp/src/strings/filter_chars.cu
@@ -143,9 +143,7 @@ std::unique_ptr<column> filter_characters(
                              std::move(children.first),
                              std::move(children.second),
                              strings.null_count(),
-                             cudf::detail::copy_bitmask(strings.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(strings.parent(), stream, mr));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/json/json_path.cu b/cpp/src/strings/json/json_path.cu
index 409e1892c91..e2c342482f1 100644
--- a/cpp/src/strings/json/json_path.cu
+++ b/cpp/src/strings/json/json_path.cu
@@ -1038,9 +1038,7 @@ std::unique_ptr<cudf::column> get_json_object(cudf::strings_column_view const& c
                              std::move(offsets),
                              std::move(chars),
                              col.size() - d_valid_count.value(stream),
-                             std::move(validity),
-                             stream,
-                             mr);
+                             std::move(validity));
 }
 
 }  // namespace
diff --git a/cpp/src/strings/padding.cu b/cpp/src/strings/padding.cu
index 6fee47ea225..9baa84e00be 100644
--- a/cpp/src/strings/padding.cu
+++ b/cpp/src/strings/padding.cu
@@ -138,9 +138,7 @@ std::unique_ptr<column> pad(
                              std::move(offsets_column),
                              std::move(chars_column),
                              strings.null_count(),
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 //
@@ -194,9 +192,7 @@ std::unique_ptr<column> zfill(
                              std::move(offsets_column),
                              std::move(chars_column),
                              strings.null_count(),
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/repeat_strings.cu b/cpp/src/strings/repeat_strings.cu
index d495b412b87..2e919c5000c 100644
--- a/cpp/src/strings/repeat_strings.cu
+++ b/cpp/src/strings/repeat_strings.cu
@@ -87,9 +87,7 @@ auto generate_empty_output(strings_column_view const& input,
                              std::move(offsets_column),
                              std::move(chars_column),
                              input.null_count(),
-                             cudf::detail::copy_bitmask(input.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(input.parent(), stream, mr));
 }
 
 /**
@@ -163,9 +161,7 @@ std::unique_ptr<column> repeat_strings(strings_column_view const& input,
                              std::move(offsets_column),
                              std::move(chars_column),
                              input.null_count(),
-                             cudf::detail::copy_bitmask(input.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(input.parent(), stream, mr));
 }
 
 namespace {
@@ -330,9 +326,7 @@ std::unique_ptr<column> repeat_strings(strings_column_view const& input,
                              std::move(offsets_column),
                              std::move(chars_column),
                              UNKNOWN_NULL_COUNT,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 std::pair<std::unique_ptr<column>, int64_t> repeat_strings_output_sizes(
diff --git a/cpp/src/strings/replace/backref_re.cu b/cpp/src/strings/replace/backref_re.cu
index 5f7b195e8f9..d8c0e61aafe 100644
--- a/cpp/src/strings/replace/backref_re.cu
+++ b/cpp/src/strings/replace/backref_re.cu
@@ -164,9 +164,7 @@ std::unique_ptr<column> replace_with_backrefs(
                              std::move(offsets),
                              std::move(chars),
                              strings.null_count(),
-                             cudf::detail::copy_bitmask(strings.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(strings.parent(), stream, mr));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/replace/multi_re.cu b/cpp/src/strings/replace/multi_re.cu
index 5b058d7b696..e6f9cbc65c4 100644
--- a/cpp/src/strings/replace/multi_re.cu
+++ b/cpp/src/strings/replace/multi_re.cu
@@ -206,9 +206,7 @@ std::unique_ptr<column> replace_re(
                              std::move(children.first),
                              std::move(children.second),
                              strings.null_count(),
-                             cudf::detail::copy_bitmask(strings.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(strings.parent(), stream, mr));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/replace/replace.cu b/cpp/src/strings/replace/replace.cu
index 979974a2fdb..1d5df3c0a29 100644
--- a/cpp/src/strings/replace/replace.cu
+++ b/cpp/src/strings/replace/replace.cu
@@ -494,9 +494,7 @@ std::unique_ptr<column> replace_char_parallel(strings_column_view const& strings
                              std::move(offsets_column),
                              std::move(chars_column),
                              strings.null_count(),
-                             cudf::detail::copy_bitmask(strings.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(strings.parent(), stream, mr));
 }
 
 /**
@@ -532,9 +530,7 @@ std::unique_ptr<column> replace_row_parallel(strings_column_view const& strings,
                              std::move(children.first),
                              std::move(children.second),
                              strings.null_count(),
-                             cudf::detail::copy_bitmask(strings.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(strings.parent(), stream, mr));
 }
 
 }  // namespace
@@ -699,9 +695,7 @@ std::unique_ptr<column> replace_slice(strings_column_view const& strings,
                              std::move(children.first),
                              std::move(children.second),
                              strings.null_count(),
-                             cudf::detail::copy_bitmask(strings.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(strings.parent(), stream, mr));
 }
 
 namespace {
@@ -787,9 +781,7 @@ std::unique_ptr<column> replace(strings_column_view const& strings,
                              std::move(children.first),
                              std::move(children.second),
                              strings.null_count(),
-                             cudf::detail::copy_bitmask(strings.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(strings.parent(), stream, mr));
 }
 
 std::unique_ptr<column> replace_nulls(strings_column_view const& strings,
@@ -830,13 +822,8 @@ std::unique_ptr<column> replace_nulls(strings_column_view const& strings,
                        memcpy(d_chars + d_offsets[idx], d_str.data(), d_str.size_bytes());
                      });
 
-  return make_strings_column(strings_count,
-                             std::move(offsets_column),
-                             std::move(chars_column),
-                             0,
-                             rmm::device_buffer{0, stream, mr},
-                             stream,
-                             mr);
+  return make_strings_column(
+    strings_count, std::move(offsets_column), std::move(chars_column), 0, rmm::device_buffer{});
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/replace/replace_re.cu b/cpp/src/strings/replace/replace_re.cu
index 9781a3fe7c6..b2f1ef37a74 100644
--- a/cpp/src/strings/replace/replace_re.cu
+++ b/cpp/src/strings/replace/replace_re.cu
@@ -158,9 +158,7 @@ std::unique_ptr<column> replace_re(
                              std::move(children.first),
                              std::move(children.second),
                              null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/strings_column_factories.cu b/cpp/src/strings/strings_column_factories.cu
index c89f1b756d6..e7ee8215b3d 100644
--- a/cpp/src/strings/strings_column_factories.cu
+++ b/cpp/src/strings/strings_column_factories.cu
@@ -114,9 +114,7 @@ std::unique_ptr<column> make_strings_column(size_type num_strings,
                                             std::unique_ptr<column> offsets_column,
                                             std::unique_ptr<column> chars_column,
                                             size_type null_count,
-                                            rmm::device_buffer&& null_mask,
-                                            rmm::cuda_stream_view stream,
-                                            rmm::mr::device_memory_resource* mr)
+                                            rmm::device_buffer&& null_mask)
 {
   CUDF_FUNC_RANGE();
 
diff --git a/cpp/src/strings/strip.cu b/cpp/src/strings/strip.cu
index 8eb56918071..0c4fe841401 100644
--- a/cpp/src/strings/strip.cu
+++ b/cpp/src/strings/strip.cu
@@ -115,9 +115,7 @@ std::unique_ptr<column> strip(
                              std::move(children.first),
                              std::move(children.second),
                              strings.null_count(),
-                             cudf::detail::copy_bitmask(strings.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(strings.parent(), stream, mr));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/substring.cu b/cpp/src/strings/substring.cu
index 834bac5e1ac..72359ada8c9 100644
--- a/cpp/src/strings/substring.cu
+++ b/cpp/src/strings/substring.cu
@@ -125,9 +125,7 @@ std::unique_ptr<column> slice_strings(
                              std::move(children.first),
                              std::move(children.second),
                              strings.null_count(),
-                             cudf::detail::copy_bitmask(strings.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(strings.parent(), stream, mr));
 }
 
 }  // namespace detail
@@ -220,9 +218,7 @@ std::unique_ptr<column> compute_substrings_from_fn(column_device_view const& d_c
                              std::move(children.first),
                              std::move(children.second),
                              null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 /**
diff --git a/cpp/src/strings/translate.cu b/cpp/src/strings/translate.cu
index cbb2f85c6a6..6425085b5ad 100644
--- a/cpp/src/strings/translate.cu
+++ b/cpp/src/strings/translate.cu
@@ -117,9 +117,7 @@ std::unique_ptr<column> translate(
                              std::move(children.first),
                              std::move(children.second),
                              strings.null_count(),
-                             cudf::detail::copy_bitmask(strings.parent(), stream, mr),
-                             stream,
-                             mr);
+                             cudf::detail::copy_bitmask(strings.parent(), stream, mr));
 }
 
 }  // namespace detail
diff --git a/cpp/src/strings/wrap.cu b/cpp/src/strings/wrap.cu
index a9346566e78..ca96e4d5f53 100644
--- a/cpp/src/strings/wrap.cu
+++ b/cpp/src/strings/wrap.cu
@@ -125,9 +125,7 @@ std::unique_ptr<column> wrap(
                              std::move(offsets_column),
                              std::move(chars_column),
                              null_count,
-                             std::move(null_mask),
-                             stream,
-                             mr);
+                             std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/text/detokenize.cu b/cpp/src/text/detokenize.cu
index 8402f4acf1b..fda2a2ca786 100644
--- a/cpp/src/text/detokenize.cu
+++ b/cpp/src/text/detokenize.cu
@@ -185,13 +185,8 @@ std::unique_ptr<cudf::column> detokenize(cudf::strings_column_view const& string
   chars_column->set_null_count(0);
 
   // make the output strings column from the offsets and chars column
-  return cudf::make_strings_column(output_count,
-                                   std::move(offsets_column),
-                                   std::move(chars_column),
-                                   0,
-                                   rmm::device_buffer{0, stream, mr},
-                                   stream,
-                                   mr);
+  return cudf::make_strings_column(
+    output_count, std::move(offsets_column), std::move(chars_column), 0, rmm::device_buffer{});
 }
 
 }  // namespace detail
diff --git a/cpp/src/text/generate_ngrams.cu b/cpp/src/text/generate_ngrams.cu
index f9b2355b2ff..b41fe6150e7 100644
--- a/cpp/src/text/generate_ngrams.cu
+++ b/cpp/src/text/generate_ngrams.cu
@@ -134,13 +134,8 @@ std::unique_ptr<cudf::column> generate_ngrams(
     ngram_generator_fn{d_strings, ngrams, d_separator}, ngrams_count, stream, mr);
 
   // make the output strings column from the offsets and chars column
-  return cudf::make_strings_column(ngrams_count,
-                                   std::move(children.first),
-                                   std::move(children.second),
-                                   0,
-                                   rmm::device_buffer{0, stream, mr},
-                                   stream,
-                                   mr);
+  return cudf::make_strings_column(
+    ngrams_count, std::move(children.first), std::move(children.second), 0, rmm::device_buffer{});
 }
 
 }  // namespace detail
@@ -250,13 +245,8 @@ std::unique_ptr<cudf::column> generate_character_ngrams(cudf::strings_column_vie
                      strings_count,
                      generator);
 
-  return cudf::make_strings_column(total_ngrams,
-                                   std::move(offsets_column),
-                                   std::move(chars_column),
-                                   0,  // no nulls in the result
-                                   rmm::device_buffer{0, stream, mr},
-                                   stream,
-                                   mr);
+  return cudf::make_strings_column(
+    total_ngrams, std::move(offsets_column), std::move(chars_column), 0, rmm::device_buffer{});
 }
 
 }  // namespace detail
diff --git a/cpp/src/text/ngrams_tokenize.cu b/cpp/src/text/ngrams_tokenize.cu
index 3b0945f05b9..5361dae7b5f 100644
--- a/cpp/src/text/ngrams_tokenize.cu
+++ b/cpp/src/text/ngrams_tokenize.cu
@@ -243,13 +243,8 @@ std::unique_ptr<cudf::column> ngrams_tokenize(
   chars_column->set_null_count(0);
   offsets_column->set_null_count(0);
   // create the output strings column
-  return make_strings_column(total_ngrams,
-                             std::move(offsets_column),
-                             std::move(chars_column),
-                             0,
-                             rmm::device_buffer{0, stream, mr},
-                             stream,
-                             mr);
+  return make_strings_column(
+    total_ngrams, std::move(offsets_column), std::move(chars_column), 0, rmm::device_buffer{});
 }
 
 }  // namespace detail
diff --git a/cpp/src/text/normalize.cu b/cpp/src/text/normalize.cu
index 84a7db5dd4e..c6dd11c1d82 100644
--- a/cpp/src/text/normalize.cu
+++ b/cpp/src/text/normalize.cu
@@ -185,9 +185,7 @@ std::unique_ptr<cudf::column> normalize_spaces(
                                    std::move(children.first),
                                    std::move(children.second),
                                    strings.null_count(),
-                                   cudf::detail::copy_bitmask(strings.parent(), stream, mr),
-                                   stream,
-                                   mr);
+                                   cudf::detail::copy_bitmask(strings.parent(), stream, mr));
 }
 
 /**
@@ -230,9 +228,7 @@ std::unique_ptr<cudf::column> normalize_characters(cudf::strings_column_view con
                                    std::move(children.first),
                                    std::move(children.second),
                                    strings.null_count(),
-                                   cudf::detail::copy_bitmask(strings.parent(), stream, mr),
-                                   stream,
-                                   mr);
+                                   cudf::detail::copy_bitmask(strings.parent(), stream, mr));
 }
 
 }  // namespace detail
diff --git a/cpp/src/text/replace.cu b/cpp/src/text/replace.cu
index 007011c1b6f..d7128803ca0 100644
--- a/cpp/src/text/replace.cu
+++ b/cpp/src/text/replace.cu
@@ -229,9 +229,7 @@ std::unique_ptr<cudf::column> replace_tokens(cudf::strings_column_view const& st
                                    std::move(children.first),
                                    std::move(children.second),
                                    strings.null_count(),
-                                   std::move(null_mask),
-                                   stream,
-                                   mr);
+                                   std::move(null_mask));
 }
 
 std::unique_ptr<cudf::column> filter_tokens(cudf::strings_column_view const& strings,
@@ -263,9 +261,7 @@ std::unique_ptr<cudf::column> filter_tokens(cudf::strings_column_view const& str
                                    std::move(children.first),
                                    std::move(children.second),
                                    strings.null_count(),
-                                   std::move(null_mask),
-                                   stream,
-                                   mr);
+                                   std::move(null_mask));
 }
 
 }  // namespace detail
diff --git a/cpp/src/text/tokenize.cu b/cpp/src/text/tokenize.cu
index 0a8b3f5bb48..fc38a13334a 100644
--- a/cpp/src/text/tokenize.cu
+++ b/cpp/src/text/tokenize.cu
@@ -214,13 +214,8 @@ std::unique_ptr<cudf::column> character_tokenize(cudf::strings_column_view const
   auto chars_column = std::make_unique<cudf::column>(chars_view, stream, mr);
 
   // return new strings column
-  return cudf::make_strings_column(num_characters,
-                                   std::move(offsets_column),
-                                   std::move(chars_column),
-                                   0,
-                                   rmm::device_buffer{},
-                                   stream,
-                                   mr);
+  return cudf::make_strings_column(
+    num_characters, std::move(offsets_column), std::move(chars_column), 0, rmm::device_buffer{});
 }
 
 }  // namespace detail