diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 95c509efc5b..9ab8d1b16d4 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -462,8 +462,10 @@ add_library(
   src/join/mixed_join.cu
   src/join/mixed_join_kernel.cu
   src/join/mixed_join_kernel_nulls.cu
-  src/join/mixed_join_kernels_semi.cu
   src/join/mixed_join_semi.cu
+  src/join/mixed_join_kernels_semi.cu
+  src/join/mixed_join_kernels_semi_nested.cu
+  src/join/mixed_join_kernels_semi_compound.cu
   src/join/mixed_join_size_kernel.cu
   src/join/mixed_join_size_kernel_nulls.cu
   src/join/semi_join.cu
diff --git a/cpp/include/cudf/detail/distinct_hash_join.cuh b/cpp/include/cudf/detail/distinct_hash_join.cuh
index c3bc3ad89fa..2246556e035 100644
--- a/cpp/include/cudf/detail/distinct_hash_join.cuh
+++ b/cpp/include/cudf/detail/distinct_hash_join.cuh
@@ -29,6 +29,7 @@
 #include <memory>
 #include <type_traits>
 #include <utility>
+#include <variant>
 
 namespace cudf::detail {
 
@@ -85,22 +86,42 @@ struct hasher_adapter {
 template <cudf::has_nested HasNested>
 struct distinct_hash_join {
  private:
-  /// Device row equal type
-  using d_equal_type = cudf::experimental::row::equality::strong_index_comparator_adapter<
-    cudf::experimental::row::equality::device_row_comparator<HasNested == cudf::has_nested::YES,
-                                                             cudf::nullate::DYNAMIC>>;
+  using row_comparator = cudf::experimental::row::equality::device_row_comparator<
+    true,
+    cudf::nullate::DYNAMIC,
+    cudf::experimental::row::equality::nan_equal_physical_equality_comparator,
+    cudf::experimental::type_identity_t>;
+
+  using row_comparator_no_nested = cudf::experimental::row::equality::device_row_comparator<
+    false,
+    cudf::nullate::DYNAMIC,
+    cudf::experimental::row::equality::nan_equal_physical_equality_comparator,
+    cudf::experimental::dispatch_void_if_nested_t>;
+
+  using row_comparator_no_compound = cudf::experimental::row::equality::device_row_comparator<
+    false,
+    cudf::nullate::DYNAMIC,
+    cudf::experimental::row::equality::nan_equal_physical_equality_comparator,
+    cudf::experimental::dispatch_void_if_compound_t>;
+
   using hasher              = hasher_adapter<thrust::identity<hash_value_type>>;
   using probing_scheme_type = cuco::linear_probing<1, hasher>;
   using cuco_storage_type   = cuco::storage<1>;
 
   /// Hash table type
-  using hash_table_type = cuco::static_set<cuco::pair<hash_value_type, rhs_index_type>,
-                                           cuco::extent<size_type>,
-                                           cuda::thread_scope_device,
-                                           comparator_adapter<d_equal_type>,
-                                           probing_scheme_type,
-                                           cudf::detail::cuco_allocator,
-                                           cuco_storage_type>;
+  template <typename Comparator>
+  using static_set_with_comparator = cuco::static_set<
+    cuco::pair<hash_value_type, rhs_index_type>,
+    cuco::extent<size_type>,
+    cuda::thread_scope_device,
+    comparator_adapter<
+      cudf::experimental::row::equality::strong_index_comparator_adapter<Comparator>>,
+    probing_scheme_type,
+    cudf::detail::cuco_allocator,
+    cuco_storage_type>;
+  using hash_table_type = std::variant<static_set_with_comparator<row_comparator>,
+                                       static_set_with_comparator<row_comparator_no_nested>,
+                                       static_set_with_comparator<row_comparator_no_compound>>;
 
   bool _has_nulls;  ///< true if nulls are present in either build table or probe table
   cudf::null_equality _nulls_equal;  ///< whether to consider nulls as equal
@@ -109,8 +130,8 @@ struct distinct_hash_join {
   std::shared_ptr<cudf::experimental::row::equality::preprocessed_table>
     _preprocessed_build;  ///< input table preprocssed for row operators
   std::shared_ptr<cudf::experimental::row::equality::preprocessed_table>
-    _preprocessed_probe;        ///< input table preprocssed for row operators
-  hash_table_type _hash_table;  ///< hash table built on `_build`
+    _preprocessed_probe;                         ///< input table preprocssed for row operators
+  std::unique_ptr<hash_table_type> _hash_table;  ///< hash table built on `_build`
 
  public:
   distinct_hash_join()                                     = delete;
diff --git a/cpp/include/cudf/table/experimental/row_operators.cuh b/cpp/include/cudf/table/experimental/row_operators.cuh
index f05e5f4ca5c..7dcac39f22e 100644
--- a/cpp/include/cudf/table/experimental/row_operators.cuh
+++ b/cpp/include/cudf/table/experimental/row_operators.cuh
@@ -29,6 +29,8 @@
 #include <cudf/structs/structs_column_device_view.cuh>
 #include <cudf/table/row_operators.cuh>
 #include <cudf/table/table_device_view.cuh>
+#include <cudf/table/table_view.hpp>
+#include <cudf/types.hpp>
 #include <cudf/utilities/default_stream.hpp>
 #include <cudf/utilities/traits.hpp>
 #include <cudf/utilities/type_dispatcher.hpp>
@@ -52,12 +54,84 @@
 #include <memory>
 #include <optional>
 #include <type_traits>
+#include <unordered_set>
 #include <utility>
+#include <variant>
 
 namespace CUDF_EXPORT cudf {
 
 namespace experimental {
 
+/// Type identity type from C++20
+template <typename T>
+using type_identity_t = T;
+
+/**
+ * @brief Recursive template to apply type transformations sequentially. Transformations are
+ * applied first-to-last in the order specified.
+ *
+ * @tparam T Base type or initial type on which transformations are applied
+ * @tparam Rest Type transformations to apply
+ */
+template <typename T, template <typename> typename... Rest>
+struct transform_sequence;
+
+/// @copydoc transform_sequence
+template <typename T, template <typename> typename First, template <typename> typename... Rest>
+struct transform_sequence<T, First, Rest...> {
+  using type =
+    typename transform_sequence<First<T>, Rest...>::type;  ///< Resolved type after transformations
+};
+
+/// @copydoc transform_sequence
+template <typename T>
+struct transform_sequence<T> {
+  using type = T;  ///< The underlying type
+};
+
+/**
+ * @brief Helper alias for transform_sequence
+ */
+template <typename T, template <typename> typename... Rest>
+using transform_sequence_t = typename transform_sequence<T, Rest...>::type;
+
+/**
+ * @brief Void dispatcher helper
+ */
+template <bool B, typename T>
+using dispatch_void_conditional_t = std::conditional_t<B, void, T>;
+
+/**
+ * @brief Void dispatcher generator
+ */
+template <typename... Types>
+struct dispatch_void_conditional_generator {
+  /// The underlying type
+  template <typename T>
+  using type = dispatch_void_conditional_t<std::disjunction<std::is_same<T, Types>...>::value, T>;
+};
+
+/**
+ * @brief Returns `void` if it's a nested type
+ */
+template <typename T>
+using dispatch_void_if_nested_t =
+  dispatch_void_conditional_generator<id_to_type<type_id::STRUCT>,
+                                      id_to_type<type_id::LIST>>::type<T>;
+
+/**
+ * @brief Returns `void` if it's a compound type
+ *
+ */
+template <typename T>
+using dispatch_void_if_compound_t =
+  dispatch_void_conditional_generator<id_to_type<type_id::STRUCT>,
+                                      id_to_type<type_id::LIST>,
+                                      id_to_type<type_id::DECIMAL128>,
+                                      id_to_type<type_id::DECIMAL64>,
+                                      id_to_type<type_id::DECIMAL32>,
+                                      id_to_type<type_id::STRING>,
+                                      id_to_type<type_id::DICTIONARY32>>::type<T>;
 /**
  * @brief A map from cudf::type_id to cudf type that excludes LIST and STRUCT types.
  *
@@ -75,12 +149,11 @@ namespace experimental {
  */
 template <cudf::type_id t>
 struct dispatch_void_if_nested {
-  /// The type to dispatch to if the type is nested
-  using type = std::conditional_t<t == type_id::STRUCT or t == type_id::LIST, void, id_to_type<t>>;
+  /// The underlying type
+  using type = dispatch_void_if_nested_t<id_to_type<t>>;
 };
 
 namespace row {
-
 enum class lhs_index_type : size_type {};
 enum class rhs_index_type : size_type {};
 
@@ -1335,11 +1408,19 @@ struct nan_equal_physical_equality_comparator {
  */
 template <bool has_nested_columns,
           typename Nullate,
-          typename PhysicalEqualityComparator = nan_equal_physical_equality_comparator>
+          typename PhysicalEqualityComparator = nan_equal_physical_equality_comparator,
+          template <typename> typename dispatch_conditional_t = cudf::experimental::type_identity_t>
 class device_row_comparator {
   friend class self_comparator;       ///< Allow self_comparator to access private members
   friend class two_table_comparator;  ///< Allow two_table_comparator to access private members
 
+  template <cudf::type_id T>
+  using dispatch_void_if_nested =
+    transform_sequence<id_to_type<T>, dispatch_conditional_t, dispatch_void_if_nested_t>;
+
+  template <cudf::type_id T>
+  using dispatch_conditional = transform_sequence<id_to_type<T>, dispatch_conditional_t>;
+
  public:
   /**
    * @brief Checks whether the row at `lhs_index` in the `lhs` table is equal to the row at
@@ -1353,7 +1434,7 @@ class device_row_comparator {
                                        size_type const rhs_index) const noexcept
   {
     auto equal_elements = [=](column_device_view l, column_device_view r) {
-      return cudf::type_dispatcher(
+      return cudf::type_dispatcher<dispatch_conditional>(
         l.type(),
         element_comparator{check_nulls, l, r, nulls_are_equal, comparator},
         lhs_index,
@@ -1417,15 +1498,35 @@ class device_row_comparator {
     {
     }
 
+    /**
+     * @brief Dummy operator for dispatch to void type. Ideally, we want this to be unreachable, but
+     * using CUDF_UNREACHABLE leads to an increase in register usage and is avoided.
+     *
+     * @note A correct implementation should never call this function.
+     *
+     * @return False
+     */
+    template <typename Element, CUDF_ENABLE_IF(std::is_void_v<Element>)>
+    __device__ bool operator()(size_type const lhs_element_index,
+                               size_type const rhs_element_index) const noexcept
+    {
+      return false;
+    }
+
     /**
      * @brief Compares the specified elements for equality.
      *
+     * is_equality_comparable differs from implementation for std::equality_comparable and considers
+     * void as an equality comparable type. Thus we need to disable this for when type is void.
+     *
      * @param lhs_element_index The index of the first element
      * @param rhs_element_index The index of the second element
      * @return True if lhs and rhs are equal or if both lhs and rhs are null and nulls are
      * considered equal (`nulls_are_equal` == `null_equality::EQUAL`)
      */
-    template <typename Element, CUDF_ENABLE_IF(cudf::is_equality_comparable<Element, Element>())>
+    template <typename Element,
+              CUDF_ENABLE_IF(cudf::is_equality_comparable<Element, Element>() and
+                             (not std::is_void_v<Element>))>
     __device__ bool operator()(size_type const lhs_element_index,
                                size_type const rhs_element_index) const noexcept
     {
@@ -1445,14 +1546,17 @@ class device_row_comparator {
 
     template <typename Element,
               CUDF_ENABLE_IF(not cudf::is_equality_comparable<Element, Element>() and
-                             (not has_nested_columns or not cudf::is_nested<Element>())),
+                             (not has_nested_columns or not cudf::is_nested<Element>()) and
+                             (not std::is_void_v<Element>)),
               typename... Args>
     __device__ bool operator()(Args...)
     {
       CUDF_UNREACHABLE("Attempted to compare elements of uncomparable types.");
     }
 
-    template <typename Element, CUDF_ENABLE_IF(has_nested_columns and cudf::is_nested<Element>())>
+    template <typename Element,
+              CUDF_ENABLE_IF(has_nested_columns and cudf::is_nested<Element>() and
+                             (not std::is_void_v<Element>))>
     __device__ bool operator()(size_type const lhs_element_index,
                                size_type const rhs_element_index) const noexcept
     {
@@ -1655,16 +1759,83 @@ class self_comparator {
    * @return A binary callable object
    */
   template <bool has_nested_columns,
+            template <typename> typename dispatch_conditional_t = type_identity_t,
             typename Nullate,
             typename PhysicalEqualityComparator = nan_equal_physical_equality_comparator>
   auto equal_to(Nullate nullate                       = {},
                 null_equality nulls_are_equal         = null_equality::EQUAL,
                 PhysicalEqualityComparator comparator = {}) const noexcept
   {
-    return device_row_comparator<has_nested_columns, Nullate, PhysicalEqualityComparator>{
+    return device_row_comparator<has_nested_columns,
+                                 Nullate,
+                                 PhysicalEqualityComparator,
+                                 dispatch_conditional_t>{
       nullate, *d_t, *d_t, nulls_are_equal, comparator};
   }
 
+  /**
+   * @brief Get the variant of comparison operator to use on the device
+   *
+   * Returns a binary callable variant, `F`, with signature `bool F(size_type, size_type)`.
+   *
+   * `F(i,j)` returns true if and only if row `i` compares equal to row `j`.
+   *
+   * @tparam Nullate A cudf::nullate type describing whether to check for nulls.
+   * @tparam PhysicalEqualityComparator A equality comparator functor that compares individual
+   * values rather than logical elements, defaults to a comparator for which `NaN == NaN`.
+   * @param column_types Column types in the row to be compared
+   * @param nullate Indicates if any input column contains nulls.
+   * @param nulls_are_equal Indicates if nulls are equal.
+   * @param comparator Physical element equality comparison functor.
+   * @return A binary callable object variant
+   */
+  template <typename Nullate,
+            typename PhysicalEqualityComparator = nan_equal_physical_equality_comparator>
+  auto equal_to(std::unordered_set<cudf::type_id> column_types,
+                Nullate nullate                       = {},
+                null_equality nulls_are_equal         = null_equality::EQUAL,
+                PhysicalEqualityComparator comparator = {}) const noexcept
+  {
+    using row_comparator_t = std::variant<
+      device_row_comparator<true, Nullate, PhysicalEqualityComparator, type_identity_t>,
+      device_row_comparator<false, Nullate, PhysicalEqualityComparator, dispatch_void_if_nested_t>,
+      device_row_comparator<false,
+                            Nullate,
+                            PhysicalEqualityComparator,
+                            dispatch_void_if_compound_t>>;
+
+    auto find_any = [](std::initializer_list<cudf::type_id> ids,
+                       std::unordered_set<cudf::type_id> const& search_set) {
+      for (auto id : ids) {
+        if (search_set.find(id) != search_set.end()) return true;
+      }
+      return false;
+    };
+
+    if (find_any({type_id::STRUCT, type_id::LIST}, column_types)) {
+      return row_comparator_t{
+        device_row_comparator<true, Nullate, PhysicalEqualityComparator, type_identity_t>{
+          nullate, *d_t, *d_t, nulls_are_equal, comparator}};
+    } else if (find_any({type_id::DECIMAL32,
+                         type_id::DECIMAL64,
+                         type_id::DECIMAL128,
+                         type_id::STRING,
+                         type_id::DICTIONARY32},
+                        column_types)) {
+      return row_comparator_t{device_row_comparator<false,
+                                                    Nullate,
+                                                    PhysicalEqualityComparator,
+                                                    dispatch_void_if_nested_t>{
+        nullate, *d_t, *d_t, nulls_are_equal, comparator}};
+    } else {
+      return row_comparator_t{device_row_comparator<false,
+                                                    Nullate,
+                                                    PhysicalEqualityComparator,
+                                                    dispatch_void_if_compound_t>{
+        nullate, *d_t, *d_t, nulls_are_equal, comparator}};
+    }
+  }
+
  private:
   std::shared_ptr<preprocessed_table> d_t;
 };
@@ -1769,15 +1940,92 @@ class two_table_comparator {
    * @return A binary callable object
    */
   template <bool has_nested_columns,
+            template <typename> typename dispatch_conditional_t = type_identity_t,
             typename Nullate,
             typename PhysicalEqualityComparator = nan_equal_physical_equality_comparator>
   auto equal_to(Nullate nullate                       = {},
                 null_equality nulls_are_equal         = null_equality::EQUAL,
                 PhysicalEqualityComparator comparator = {}) const noexcept
   {
-    return strong_index_comparator_adapter{
-      device_row_comparator<has_nested_columns, Nullate, PhysicalEqualityComparator>(
-        nullate, *d_left_table, *d_right_table, nulls_are_equal, comparator)};
+    return strong_index_comparator_adapter{device_row_comparator<has_nested_columns,
+                                                                 Nullate,
+                                                                 PhysicalEqualityComparator,
+                                                                 dispatch_conditional_t>(
+      nullate, *d_left_table, *d_right_table, nulls_are_equal, comparator)};
+  }
+
+  /**
+   * @brief Return the binary operator for comparing rows in the table.
+   *
+   * Returns a binary callable variant, `F`, with signatures `bool F(lhs_index_type,
+   * rhs_index_type)` and `bool F(rhs_index_type, lhs_index_type)`.
+   *
+   * `F(lhs_index_type i, rhs_index_type j)` returns true if and only if row `i` of the left table
+   * compares equal to row `j` of the right table.
+   *
+   * Similarly, `F(rhs_index_type i, lhs_index_type j)` returns true if and only if row `i` of the
+   * right table compares equal to row `j` of the left table.
+   *
+   * @tparam Nullate A cudf::nullate type describing whether to check for nulls.
+   * @tparam PhysicalEqualityComparator A equality comparator functor that compares individual
+   * values rather than logical elements, defaults to a comparator for which `NaN == NaN`.
+   * @param column_types Column types in the row to be compared
+   * @param nullate Indicates if any input column contains nulls.
+   * @param nulls_are_equal Indicates if nulls are equal.
+   * @param comparator Physical element equality comparison functor.
+   * @return A binary callable object variant
+   */
+  template <typename Nullate,
+            typename PhysicalEqualityComparator = nan_equal_physical_equality_comparator>
+  auto equal_to(std::unordered_set<cudf::type_id> column_types,
+                Nullate nullate                       = {},
+                null_equality nulls_are_equal         = null_equality::EQUAL,
+                PhysicalEqualityComparator comparator = {}) const noexcept
+  {
+    using row_comparator_t = std::variant<
+      strong_index_comparator_adapter<
+        device_row_comparator<true, Nullate, PhysicalEqualityComparator, type_identity_t>>,
+      strong_index_comparator_adapter<device_row_comparator<false,
+                                                            Nullate,
+                                                            PhysicalEqualityComparator,
+                                                            dispatch_void_if_nested_t>>,
+      strong_index_comparator_adapter<device_row_comparator<false,
+                                                            Nullate,
+                                                            PhysicalEqualityComparator,
+                                                            dispatch_void_if_compound_t>>>;
+
+    auto find_any = [](std::initializer_list<cudf::type_id> ids,
+                       std::unordered_set<cudf::type_id> const& search_set) {
+      for (auto id : ids) {
+        if (search_set.find(id) != search_set.end()) return true;
+      }
+      return false;
+    };
+
+    if (find_any({type_id::STRUCT, type_id::LIST}, column_types)) {
+      return row_comparator_t{strong_index_comparator_adapter{
+        device_row_comparator<true, Nullate, PhysicalEqualityComparator, type_identity_t>(
+          nullate, *d_left_table, *d_right_table, nulls_are_equal, comparator)}};
+    } else if (find_any({type_id::DECIMAL32,
+                         type_id::DECIMAL64,
+                         type_id::DECIMAL128,
+                         type_id::STRING,
+                         type_id::DICTIONARY32},
+                        column_types)) {
+      return row_comparator_t{
+        strong_index_comparator_adapter{device_row_comparator<false,
+                                                              Nullate,
+                                                              PhysicalEqualityComparator,
+                                                              dispatch_void_if_nested_t>(
+          nullate, *d_left_table, *d_right_table, nulls_are_equal, comparator)}};
+    } else {
+      return row_comparator_t{
+        strong_index_comparator_adapter{device_row_comparator<false,
+                                                              Nullate,
+                                                              PhysicalEqualityComparator,
+                                                              dispatch_void_if_compound_t>(
+          nullate, *d_left_table, *d_right_table, nulls_are_equal, comparator)}};
+    }
   }
 
  private:
@@ -1855,9 +2103,18 @@ class element_hasher {
  * @tparam hash_function Hash functor to use for hashing elements.
  * @tparam Nullate A cudf::nullate type describing whether to check for nulls.
  */
-template <template <typename> class hash_function, typename Nullate>
+template <template <typename> class hash_function,
+          typename Nullate,
+          template <typename> typename dispatch_conditional_t = cudf::experimental::type_identity_t>
 class device_row_hasher {
   friend class row_hasher;  ///< Allow row_hasher to access private members.
+  template <cudf::type_id T>
+  using dispatch_storage_type =
+    transform_sequence<id_to_type<T>, dispatch_conditional_t, device_storage_type_t>;
+
+  template <cudf::type_id T>
+  using dispatch_void_if_nested =
+    transform_sequence<id_to_type<T>, dispatch_conditional_t, dispatch_void_if_nested_t>;
 
  public:
   /**
@@ -1901,14 +2158,29 @@ class device_row_hasher {
     {
     }
 
-    template <typename T, CUDF_ENABLE_IF(not cudf::is_nested<T>())>
+    /**
+     * @brief Dummy operator for dispatch to void type. Ideally, we want this to be unreachable, but
+     * using CUDF_UNREACHABLE leads to an increase in register usage and is avoided.
+     *
+     * @note A correct implementation should never call this function.
+     *
+     * @return 0
+     */
+    template <typename T, CUDF_ENABLE_IF(std::is_void_v<T>)>
+    __device__ hash_value_type operator()(column_device_view const& col,
+                                          size_type row_index) const noexcept
+    {
+      return 0;
+    }
+
+    template <typename T, CUDF_ENABLE_IF(not cudf::is_nested<T>() and not std::is_void_v<T>)>
     __device__ hash_value_type operator()(column_device_view const& col,
                                           size_type row_index) const noexcept
     {
       return _element_hasher.template operator()<T>(col, row_index);
     }
 
-    template <typename T, CUDF_ENABLE_IF(cudf::is_nested<T>())>
+    template <typename T, CUDF_ENABLE_IF(cudf::is_nested<T>() and not std::is_void_v<T>)>
     __device__ hash_value_type operator()(column_device_view const& col,
                                           size_type row_index) const noexcept
     {
@@ -2008,13 +2280,66 @@ class row_hasher {
    * @return A hash operator to use on the device
    */
   template <template <typename> class hash_function = cudf::hashing::detail::default_hash,
-            template <template <typename> class, typename>
+            template <template <typename> class, typename, template <typename> typename>
+            class DeviceRowHasher = device_row_hasher,
+            typename Nullate,
+            template <typename> typename dispatch_cond = type_identity_t>
+  DeviceRowHasher<hash_function, Nullate, dispatch_cond> device_hasher(
+    Nullate nullate = {}, uint32_t seed = DEFAULT_HASH_SEED) const
+  {
+    return DeviceRowHasher<hash_function, Nullate, dispatch_cond>(nullate, *d_t, seed);
+  }
+
+  /**
+   * @brief Get the hash operator to use on the device
+   *
+   * Returns a variant unary callable, `F`, with signature `hash_function::hash_value_type
+   * F(size_type)`. Concrete type in the returned variant is determined at runtime based on
+   * column_types.
+   *
+   * `F(i)` returns the hash of row i.
+   *
+   * @tparam Nullate A cudf::nullate type describing whether to check for nulls
+   * @param column_types Column types in the row, determined at runtime
+   * @param nullate Indicates if any input column contains nulls
+   * @param seed The seed to use for the hash function
+   * @return A hash operator to use on the device
+   */
+  template <template <typename> class hash_function = cudf::hashing::detail::default_hash,
+            template <template <typename> class, typename, template <typename> typename>
             class DeviceRowHasher = device_row_hasher,
             typename Nullate>
-  DeviceRowHasher<hash_function, Nullate> device_hasher(Nullate nullate = {},
-                                                        uint32_t seed   = DEFAULT_HASH_SEED) const
+  auto device_hasher(std::unordered_set<cudf::type_id> column_types,
+                     Nullate nullate = {},
+                     uint32_t seed   = DEFAULT_HASH_SEED) const
   {
-    return DeviceRowHasher<hash_function, Nullate>(nullate, *d_t, seed);
+    using row_hasher_t =
+      std::variant<DeviceRowHasher<hash_function, Nullate, type_identity_t>,
+                   DeviceRowHasher<hash_function, Nullate, dispatch_void_if_nested_t>,
+                   DeviceRowHasher<hash_function, Nullate, dispatch_void_if_compound_t>>;
+    auto find_any = [](std::initializer_list<cudf::type_id> ids,
+                       std::unordered_set<cudf::type_id> const& search_set) {
+      for (auto id : ids) {
+        if (search_set.find(id) != search_set.end()) return true;
+      }
+      return false;
+    };
+
+    if (find_any({type_id::STRUCT, type_id::LIST}, column_types)) {
+      return row_hasher_t{
+        DeviceRowHasher<hash_function, Nullate, type_identity_t>(nullate, *d_t, seed)};
+    } else if (find_any({type_id::DECIMAL32,
+                         type_id::DECIMAL64,
+                         type_id::DECIMAL128,
+                         type_id::STRING,
+                         type_id::DICTIONARY32},
+                        column_types)) {
+      return row_hasher_t{
+        DeviceRowHasher<hash_function, Nullate, dispatch_void_if_nested_t>(nullate, *d_t, seed)};
+    } else {
+      return row_hasher_t{
+        DeviceRowHasher<hash_function, Nullate, dispatch_void_if_compound_t>(nullate, *d_t, seed)};
+    }
   }
 
  private:
diff --git a/cpp/src/join/distinct_hash_join.cu b/cpp/src/join/distinct_hash_join.cu
index daa1bf17c0d..4d49e23dc01 100644
--- a/cpp/src/join/distinct_hash_join.cu
+++ b/cpp/src/join/distinct_hash_join.cu
@@ -41,22 +41,53 @@
 #include <limits>
 #include <memory>
 #include <utility>
+#include <variant>
 
 namespace cudf {
 namespace detail {
 namespace {
 
-template <cudf::has_nested HasNested>
 auto prepare_device_equal(
   std::shared_ptr<cudf::experimental::row::equality::preprocessed_table> build,
   std::shared_ptr<cudf::experimental::row::equality::preprocessed_table> probe,
   bool has_nulls,
-  cudf::null_equality compare_nulls)
+  cudf::null_equality compare_nulls,
+  std::unordered_set<cudf::type_id> const& column_types)
 {
   auto const two_table_equal =
     cudf::experimental::row::equality::two_table_comparator(probe, build);
-  return comparator_adapter{two_table_equal.equal_to<HasNested == cudf::has_nested::YES>(
-    nullate::DYNAMIC{has_nulls}, compare_nulls)};
+  auto d_comparator =
+    two_table_equal.equal_to(column_types, nullate::DYNAMIC{has_nulls}, compare_nulls);
+
+  // need to wrap types in d_comparator with comparator_adaptor. We can do this with some
+  // metaprogramming but this seems fine for now
+  using ret_type = std::variant<
+    comparator_adapter<cudf::experimental::row::equality::strong_index_comparator_adapter<
+      cudf::experimental::row::equality::device_row_comparator<
+        true,
+        nullate::DYNAMIC,
+        cudf::experimental::row::equality::nan_equal_physical_equality_comparator,
+        cudf::experimental::type_identity_t>>>,
+    comparator_adapter<cudf::experimental::row::equality::strong_index_comparator_adapter<
+      cudf::experimental::row::equality::device_row_comparator<
+        false,
+        nullate::DYNAMIC,
+        cudf::experimental::row::equality::nan_equal_physical_equality_comparator,
+        cudf::experimental::dispatch_void_if_nested_t>>>,
+    comparator_adapter<cudf::experimental::row::equality::strong_index_comparator_adapter<
+      cudf::experimental::row::equality::device_row_comparator<
+        false,
+        nullate::DYNAMIC,
+        cudf::experimental::row::equality::nan_equal_physical_equality_comparator,
+        cudf::experimental::dispatch_void_if_compound_t>>>>;
+
+  return std::visit(
+    [&](auto& comparator) {
+      return ret_type{std::in_place_type<
+                        comparator_adapter<typename std::remove_reference_t<decltype(comparator)>>>,
+                      comparator};
+    },
+    d_comparator);
 }
 
 /**
@@ -79,8 +110,8 @@ class build_keys_fn {
 };
 
 /**
- * @brief Device output transform functor to construct `size_type` with `cuco::pair<hash_value_type,
- * lhs_index_type>` or `cuco::pair<hash_value_type, rhs_index_type>`
+ * @brief Device output transform functor to construct `size_type` with
+ * `cuco::pair<hash_value_type, lhs_index_type>` or `cuco::pair<hash_value_type, rhs_index_type>`
  */
 struct output_fn {
   __device__ constexpr cudf::size_type operator()(
@@ -109,44 +140,75 @@ distinct_hash_join<HasNested>::distinct_hash_join(cudf::table_view const& build,
     _preprocessed_build{
       cudf::experimental::row::equality::preprocessed_table::create(_build, stream)},
     _preprocessed_probe{
-      cudf::experimental::row::equality::preprocessed_table::create(_probe, stream)},
-    _hash_table{build.num_rows(),
-                CUCO_DESIRED_LOAD_FACTOR,
-                cuco::empty_key{cuco::pair{std::numeric_limits<hash_value_type>::max(),
-                                           rhs_index_type{JoinNoneValue}}},
-                prepare_device_equal<HasNested>(
-                  _preprocessed_build, _preprocessed_probe, has_nulls, compare_nulls),
-                {},
-                cuco::thread_scope_device,
-                cuco_storage_type{},
-                cudf::detail::cuco_allocator{stream},
-                stream.value()}
+      cudf::experimental::row::equality::preprocessed_table::create(_probe, stream)}
 {
+  std::unordered_set<cudf::type_id> build_column_types;
+  for (auto col : this->_build) {
+    build_column_types.insert(col.type().id());
+  }
+
+  auto var_comparator_adapter = prepare_device_equal(
+    _preprocessed_build, _preprocessed_probe, has_nulls, compare_nulls, build_column_types);
+
+  std::visit(
+    [&](auto&& comparator_adapter) {
+      using static_set_type =
+        cuco::static_set<cuco::pair<hash_value_type, rhs_index_type>,
+                         cuco::extent<size_type>,
+                         cuda::thread_scope_device,
+                         typename std::remove_reference_t<decltype(comparator_adapter)>,
+                         distinct_hash_join::probing_scheme_type,
+                         cudf::detail::cuco_allocator,
+                         distinct_hash_join::cuco_storage_type>;
+
+      this->_hash_table = std::make_unique<hash_table_type>(
+        std::in_place_type<static_set_type>,
+        build.num_rows(),
+        CUCO_DESIRED_LOAD_FACTOR,
+        cuco::empty_key{
+          cuco::pair{std::numeric_limits<hash_value_type>::max(), rhs_index_type{JoinNoneValue}}},
+        comparator_adapter,
+        distinct_hash_join::probing_scheme_type{},
+        cuco::thread_scope_device,
+        distinct_hash_join::cuco_storage_type{},
+        cudf::detail::cuco_allocator{stream},
+        stream.value());
+    },
+    var_comparator_adapter);
+
   CUDF_FUNC_RANGE();
   CUDF_EXPECTS(0 != this->_build.num_columns(), "Hash join build table is empty");
 
   if (this->_build.num_rows() == 0) { return; }
 
   auto const row_hasher = experimental::row::hash::row_hasher{this->_preprocessed_build};
-  auto const d_hasher   = row_hasher.device_hasher(nullate::DYNAMIC{this->_has_nulls});
-
-  auto const iter = cudf::detail::make_counting_transform_iterator(
-    0, build_keys_fn<decltype(d_hasher), rhs_index_type>{d_hasher});
-
-  size_type const build_table_num_rows{build.num_rows()};
-  if (this->_nulls_equal == cudf::null_equality::EQUAL or (not cudf::nullable(this->_build))) {
-    this->_hash_table.insert_async(iter, iter + build_table_num_rows, stream.value());
-  } else {
-    auto stencil = thrust::counting_iterator<size_type>{0};
-    auto const row_bitmask =
-      cudf::detail::bitmask_and(this->_build, stream, rmm::mr::get_current_device_resource()).first;
-    auto const pred =
-      cudf::detail::row_is_valid{reinterpret_cast<bitmask_type const*>(row_bitmask.data())};
-
-    // insert valid rows
-    this->_hash_table.insert_if_async(
-      iter, iter + build_table_num_rows, stencil, pred, stream.value());
-  }
+  auto const d_hasher =
+    row_hasher.device_hasher(build_column_types, nullate::DYNAMIC{this->_has_nulls});
+
+  std::visit(
+    [&](auto&& hasher, auto&& hash_table) {
+      auto const iter = cudf::detail::make_counting_transform_iterator(
+        0,
+        build_keys_fn<typename std::remove_reference_t<decltype(hasher)>, rhs_index_type>{hasher});
+
+      size_type const build_table_num_rows{build.num_rows()};
+      if (this->_nulls_equal == cudf::null_equality::EQUAL or (not cudf::nullable(this->_build))) {
+        hash_table.insert_async(iter, iter + build_table_num_rows, stream.value());
+      } else {
+        auto stencil = thrust::counting_iterator<size_type>{0};
+        auto const row_bitmask =
+          cudf::detail::bitmask_and(this->_build, stream, rmm::mr::get_current_device_resource())
+            .first;
+        auto const pred =
+          cudf::detail::row_is_valid{reinterpret_cast<bitmask_type const*>(row_bitmask.data())};
+
+        // insert valid rows
+        hash_table.insert_if_async(
+          iter, iter + build_table_num_rows, stencil, pred, stream.value());
+      }
+    },
+    d_hasher,
+    *(this->_hash_table));
 }
 
 template <cudf::has_nested HasNested>
@@ -170,23 +232,39 @@ distinct_hash_join<HasNested>::inner_join(rmm::cuda_stream_view stream,
   auto probe_indices =
     std::make_unique<rmm::device_uvector<size_type>>(probe_table_num_rows, stream, mr);
 
+  std::unordered_set<cudf::type_id> probe_column_types;
+  for (auto col : this->_probe) {
+    probe_column_types.insert(col.type().id());
+  }
+
   auto const probe_row_hasher =
     cudf::experimental::row::hash::row_hasher{this->_preprocessed_probe};
-  auto const d_probe_hasher = probe_row_hasher.device_hasher(nullate::DYNAMIC{this->_has_nulls});
-  auto const iter           = cudf::detail::make_counting_transform_iterator(
-    0, build_keys_fn<decltype(d_probe_hasher), lhs_index_type>{d_probe_hasher});
+  auto const d_probe_hasher =
+    probe_row_hasher.device_hasher(probe_column_types, nullate::DYNAMIC{this->_has_nulls});
 
   auto const build_indices_begin =
     thrust::make_transform_output_iterator(build_indices->begin(), output_fn{});
   auto const probe_indices_begin =
     thrust::make_transform_output_iterator(probe_indices->begin(), output_fn{});
 
-  auto const [probe_indices_end, _] = this->_hash_table.retrieve(
-    iter, iter + probe_table_num_rows, probe_indices_begin, build_indices_begin, {stream.value()});
-
-  auto const actual_size = std::distance(probe_indices_begin, probe_indices_end);
-  build_indices->resize(actual_size, stream);
-  probe_indices->resize(actual_size, stream);
+  std::visit(
+    [&](auto&& hasher, auto&& hash_table) {
+      auto const iter = cudf::detail::make_counting_transform_iterator(
+        0,
+        build_keys_fn<typename std::remove_reference_t<decltype(hasher)>, lhs_index_type>{hasher});
+
+      auto const [probe_indices_end, _] = hash_table.retrieve(iter,
+                                                              iter + probe_table_num_rows,
+                                                              probe_indices_begin,
+                                                              build_indices_begin,
+                                                              {stream.value()});
+
+      auto const actual_size = std::distance(probe_indices_begin, probe_indices_end);
+      build_indices->resize(actual_size, stream);
+      probe_indices->resize(actual_size, stream);
+    },
+    d_probe_hasher,
+    *(this->_hash_table));
 
   return {std::move(build_indices), std::move(probe_indices)};
 }
@@ -204,6 +282,11 @@ std::unique_ptr<rmm::device_uvector<size_type>> distinct_hash_join<HasNested>::l
     return std::make_unique<rmm::device_uvector<size_type>>(0, stream, mr);
   }
 
+  std::unordered_set<cudf::type_id> probe_column_types;
+  for (auto col : _probe) {
+    probe_column_types.insert(col.type().id());
+  }
+
   auto build_indices =
     std::make_unique<rmm::device_uvector<size_type>>(probe_table_num_rows, stream, mr);
 
@@ -214,14 +297,23 @@ std::unique_ptr<rmm::device_uvector<size_type>> distinct_hash_join<HasNested>::l
   } else {
     auto const probe_row_hasher =
       cudf::experimental::row::hash::row_hasher{this->_preprocessed_probe};
-    auto const d_probe_hasher = probe_row_hasher.device_hasher(nullate::DYNAMIC{this->_has_nulls});
-    auto const iter           = cudf::detail::make_counting_transform_iterator(
-      0, build_keys_fn<decltype(d_probe_hasher), lhs_index_type>{d_probe_hasher});
-
-    auto const output_begin =
-      thrust::make_transform_output_iterator(build_indices->begin(), output_fn{});
-    // TODO conditional find for nulls once `cuco::static_set::find_if` is added
-    this->_hash_table.find_async(iter, iter + probe_table_num_rows, output_begin, stream.value());
+    auto const d_probe_hasher =
+      probe_row_hasher.device_hasher(probe_column_types, nullate::DYNAMIC{this->_has_nulls});
+
+    std::visit(
+      [&](auto&& hasher, auto&& hash_table) {
+        auto const iter = cudf::detail::make_counting_transform_iterator(
+          0,
+          build_keys_fn<typename std::remove_reference_t<decltype(hasher)>, lhs_index_type>{
+            hasher});
+
+        auto const output_begin =
+          thrust::make_transform_output_iterator(build_indices->begin(), output_fn{});
+        // TODO conditional find for nulls once `cuco::static_set::find_if` is added
+        hash_table.find_async(iter, iter + probe_table_num_rows, output_begin, stream.value());
+      },
+      d_probe_hasher,
+      *(this->_hash_table));
   }
 
   return build_indices;
diff --git a/cpp/src/join/hash_join.cu b/cpp/src/join/hash_join.cu
index eb9b687630b..a6dbbc7a15e 100644
--- a/cpp/src/join/hash_join.cu
+++ b/cpp/src/join/hash_join.cu
@@ -42,6 +42,7 @@
 #include <cstddef>
 #include <iostream>
 #include <numeric>
+#include <variant>
 
 namespace cudf {
 namespace detail {
@@ -97,12 +98,14 @@ std::size_t compute_join_output_size(
   }
 
   auto const probe_nulls = cudf::nullate::DYNAMIC{has_nulls};
+  std::unordered_set<cudf::type_id> probe_column_types;
+  for (auto col : probe_table) {
+    probe_column_types.insert(col.type().id());
+  }
 
   auto const row_hash           = cudf::experimental::row::hash::row_hasher{preprocessed_probe};
-  auto const hash_probe         = row_hash.device_hasher(probe_nulls);
+  auto const hash_probe         = row_hash.device_hasher(probe_column_types, probe_nulls);
   auto const empty_key_sentinel = hash_table.get_empty_key_sentinel();
-  auto const iter               = cudf::detail::make_counting_transform_iterator(
-    0, make_pair_function{hash_probe, empty_key_sentinel});
 
   auto const row_comparator =
     cudf::experimental::row::equality::two_table_comparator{preprocessed_probe, preprocessed_build};
@@ -110,20 +113,29 @@ std::size_t compute_join_output_size(
     pair_equality equality{device_comparator};
 
     if (join == join_kind::LEFT_JOIN) {
-      return hash_table.pair_count_outer(
-        iter, iter + probe_table_num_rows, equality, stream.value());
+      return std::visit(
+        [&](auto&& hasher) {
+          auto const iter = cudf::detail::make_counting_transform_iterator(
+            0, make_pair_function{hasher, empty_key_sentinel});
+          return hash_table.pair_count_outer(
+            iter, iter + probe_table_num_rows, equality, stream.value());
+        },
+        hash_probe);
     } else {
-      return hash_table.pair_count(iter, iter + probe_table_num_rows, equality, stream.value());
+      return std::visit(
+        [&](auto&& hasher) {
+          auto const iter = cudf::detail::make_counting_transform_iterator(
+            0, make_pair_function{hasher, empty_key_sentinel});
+          return hash_table.pair_count(iter, iter + probe_table_num_rows, equality, stream.value());
+        },
+        hash_probe);
     }
   };
 
-  if (cudf::detail::has_nested_columns(probe_table)) {
-    auto const device_comparator = row_comparator.equal_to<true>(has_nulls, nulls_equal);
-    return comparator_helper(device_comparator);
-  } else {
-    auto const device_comparator = row_comparator.equal_to<false>(has_nulls, nulls_equal);
-    return comparator_helper(device_comparator);
-  }
+  auto const device_comparator =
+    row_comparator.equal_to(probe_column_types, has_nulls, nulls_equal);
+  return std::visit([&](auto&& comparator) { return comparator_helper(comparator); },
+                    device_comparator);
 }
 
 /**
@@ -189,12 +201,14 @@ probe_join_hash_table(
   cudf::experimental::prefetch::detail::prefetch("hash_join", *right_indices, stream);
 
   auto const probe_nulls = cudf::nullate::DYNAMIC{has_nulls};
+  std::unordered_set<cudf::type_id> probe_column_types;
+  for (auto col : probe_table) {
+    probe_column_types.insert(col.type().id());
+  }
 
   auto const row_hash           = cudf::experimental::row::hash::row_hasher{preprocessed_probe};
-  auto const hash_probe         = row_hash.device_hasher(probe_nulls);
+  auto const hash_probe         = row_hash.device_hasher(probe_column_types, probe_nulls);
   auto const empty_key_sentinel = hash_table.get_empty_key_sentinel();
-  auto const iter               = cudf::detail::make_counting_transform_iterator(
-    0, make_pair_function{hash_probe, empty_key_sentinel});
 
   cudf::size_type const probe_table_num_rows = probe_table.num_rows();
 
@@ -209,13 +223,18 @@ probe_join_hash_table(
     pair_equality equality{device_comparator};
 
     if (join == cudf::detail::join_kind::FULL_JOIN or join == cudf::detail::join_kind::LEFT_JOIN) {
-      [[maybe_unused]] auto [out1_zip_end, out2_zip_end] =
-        hash_table.pair_retrieve_outer(iter,
-                                       iter + probe_table_num_rows,
-                                       out1_zip_begin,
-                                       out2_zip_begin,
-                                       equality,
-                                       stream.value());
+      [[maybe_unused]] auto [out1_zip_end, out2_zip_end] = std::visit(
+        [&](auto&& hasher) {
+          auto const iter = cudf::detail::make_counting_transform_iterator(
+            0, make_pair_function{hasher, empty_key_sentinel});
+          return hash_table.pair_retrieve_outer(iter,
+                                                iter + probe_table_num_rows,
+                                                out1_zip_begin,
+                                                out2_zip_begin,
+                                                equality,
+                                                stream.value());
+        },
+        hash_probe);
 
       if (join == cudf::detail::join_kind::FULL_JOIN) {
         auto const actual_size = thrust::distance(out1_zip_begin, out1_zip_end);
@@ -223,22 +242,23 @@ probe_join_hash_table(
         right_indices->resize(actual_size, stream);
       }
     } else {
-      hash_table.pair_retrieve(iter,
-                               iter + probe_table_num_rows,
-                               out1_zip_begin,
-                               out2_zip_begin,
-                               equality,
-                               stream.value());
+      std::visit(
+        [&](auto&& hasher) {
+          auto const iter = cudf::detail::make_counting_transform_iterator(
+            0, make_pair_function{hasher, empty_key_sentinel});
+          hash_table.pair_retrieve(iter,
+                                   iter + probe_table_num_rows,
+                                   out1_zip_begin,
+                                   out2_zip_begin,
+                                   equality,
+                                   stream.value());
+        },
+        hash_probe);
     }
   };
-
-  if (cudf::detail::has_nested_columns(probe_table)) {
-    auto const device_comparator = row_comparator.equal_to<true>(probe_nulls, compare_nulls);
-    comparator_helper(device_comparator);
-  } else {
-    auto const device_comparator = row_comparator.equal_to<false>(probe_nulls, compare_nulls);
-    comparator_helper(device_comparator);
-  }
+  auto const device_comparator =
+    row_comparator.equal_to(probe_column_types, probe_nulls, compare_nulls);
+  std::visit([&](auto&& comparator) { comparator_helper(comparator); }, device_comparator);
 
   return std::pair(std::move(left_indices), std::move(right_indices));
 }
@@ -291,12 +311,14 @@ std::size_t get_full_join_size(
   auto right_indices = std::make_unique<rmm::device_uvector<size_type>>(join_size, stream, mr);
 
   auto const probe_nulls = cudf::nullate::DYNAMIC{has_nulls};
+  std::unordered_set<cudf::type_id> probe_column_types;
+  for (auto col : probe_table) {
+    probe_column_types.insert(col.type().id());
+  }
 
   auto const row_hash           = cudf::experimental::row::hash::row_hasher{preprocessed_probe};
-  auto const hash_probe         = row_hash.device_hasher(probe_nulls);
+  auto const hash_probe         = row_hash.device_hasher(probe_column_types, probe_nulls);
   auto const empty_key_sentinel = hash_table.get_empty_key_sentinel();
-  auto const iter               = cudf::detail::make_counting_transform_iterator(
-    0, make_pair_function{hash_probe, empty_key_sentinel});
 
   cudf::size_type const probe_table_num_rows = probe_table.num_rows();
 
@@ -309,16 +331,22 @@ std::size_t get_full_join_size(
     cudf::experimental::row::equality::two_table_comparator{preprocessed_probe, preprocessed_build};
   auto const comparator_helper = [&](auto device_comparator) {
     pair_equality equality{device_comparator};
-    hash_table.pair_retrieve_outer(
-      iter, iter + probe_table_num_rows, out1_zip_begin, out2_zip_begin, equality, stream.value());
+    std::visit(
+      [&](auto&& hasher) {
+        auto const iter = cudf::detail::make_counting_transform_iterator(
+          0, make_pair_function{hasher, empty_key_sentinel});
+        hash_table.pair_retrieve_outer(iter,
+                                       iter + probe_table_num_rows,
+                                       out1_zip_begin,
+                                       out2_zip_begin,
+                                       equality,
+                                       stream.value());
+      },
+      hash_probe);
   };
-  if (cudf::detail::has_nested_columns(probe_table)) {
-    auto const device_comparator = row_comparator.equal_to<true>(probe_nulls, compare_nulls);
-    comparator_helper(device_comparator);
-  } else {
-    auto const device_comparator = row_comparator.equal_to<false>(probe_nulls, compare_nulls);
-    comparator_helper(device_comparator);
-  }
+  auto const device_comparator =
+    row_comparator.equal_to(probe_column_types, probe_nulls, compare_nulls);
+  std::visit([&](auto&& comparator) { comparator_helper(comparator); }, device_comparator);
 
   // Release intermediate memory allocation
   left_indices->resize(0, stream);
diff --git a/cpp/src/join/join_common_utils.cuh b/cpp/src/join/join_common_utils.cuh
index 3d0f3e4340d..c47e6e5b245 100644
--- a/cpp/src/join/join_common_utils.cuh
+++ b/cpp/src/join/join_common_utils.cuh
@@ -177,23 +177,37 @@ void build_join_hash_table(
   CUDF_EXPECTS(0 != build.num_columns(), "Selected build dataset is empty");
   CUDF_EXPECTS(0 != build.num_rows(), "Build side table has no rows");
 
+  std::unordered_set<cudf::type_id> build_column_types;
+  for (auto col : build) {
+    build_column_types.insert(col.type().id());
+  }
+
   auto const row_hash   = experimental::row::hash::row_hasher{preprocessed_build};
-  auto const hash_build = row_hash.device_hasher(nullate::DYNAMIC{has_nulls});
+  auto const hash_build = row_hash.device_hasher(build_column_types, nullate::DYNAMIC{has_nulls});
 
   auto const empty_key_sentinel = hash_table.get_empty_key_sentinel();
-  make_pair_function pair_func{hash_build, empty_key_sentinel};
-
-  auto const iter = cudf::detail::make_counting_transform_iterator(0, pair_func);
 
   size_type const build_table_num_rows{build.num_rows()};
   if (nulls_equal == cudf::null_equality::EQUAL or (not nullable(build))) {
-    hash_table.insert(iter, iter + build_table_num_rows, stream.value());
+    std::visit(
+      [&](auto&& hasher) {
+        make_pair_function pair_func{hasher, empty_key_sentinel};
+        auto const iter = cudf::detail::make_counting_transform_iterator(0, pair_func);
+        hash_table.insert(iter, iter + build_table_num_rows, stream.value());
+      },
+      hash_build);
   } else {
     thrust::counting_iterator<size_type> stencil(0);
     row_is_valid pred{bitmask};
 
-    // insert valid rows
-    hash_table.insert_if(iter, iter + build_table_num_rows, stencil, pred, stream.value());
+    std::visit(
+      [&](auto&& hasher) {
+        make_pair_function pair_func{hasher, empty_key_sentinel};
+        auto const iter = cudf::detail::make_counting_transform_iterator(0, pair_func);
+        // insert valid rows
+        hash_table.insert_if(iter, iter + build_table_num_rows, stencil, pred, stream.value());
+      },
+      hash_build);
   }
 }
 
diff --git a/cpp/src/join/mixed_join_common_utils.cuh b/cpp/src/join/mixed_join_common_utils.cuh
index 19701816867..87204706d64 100644
--- a/cpp/src/join/mixed_join_common_utils.cuh
+++ b/cpp/src/join/mixed_join_common_utils.cuh
@@ -31,7 +31,18 @@ namespace detail {
 
 using row_hash =
   cudf::experimental::row::hash::device_row_hasher<cudf::hashing::detail::default_hash,
-                                                   cudf::nullate::DYNAMIC>;
+                                                   cudf::nullate::DYNAMIC,
+                                                   cudf::experimental::type_identity_t>;
+
+using row_hash_no_nested =
+  cudf::experimental::row::hash::device_row_hasher<cudf::hashing::detail::default_hash,
+                                                   cudf::nullate::DYNAMIC,
+                                                   cudf::experimental::dispatch_void_if_nested_t>;
+
+using row_hash_no_compound =
+  cudf::experimental::row::hash::device_row_hasher<cudf::hashing::detail::default_hash,
+                                                   cudf::nullate::DYNAMIC,
+                                                   cudf::experimental::dispatch_void_if_compound_t>;
 
 // // This alias is used by mixed_joins, which support only non-nested types
 using row_equality = cudf::experimental::row::equality::strong_index_comparator_adapter<
diff --git a/cpp/src/join/mixed_join_kernel_semi_impl.cuh b/cpp/src/join/mixed_join_kernel_semi_impl.cuh
new file mode 100644
index 00000000000..1f6abdc33cb
--- /dev/null
+++ b/cpp/src/join/mixed_join_kernel_semi_impl.cuh
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
+ *
+ * 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 "join/join_common_utils.cuh"
+#include "join/join_common_utils.hpp"
+#include "join/mixed_join_common_utils.cuh"
+#include "join/mixed_join_kernels_semi.cuh"
+
+#include <cudf/ast/detail/expression_evaluator.cuh>
+#include <cudf/ast/detail/expression_parser.hpp>
+#include <cudf/detail/utilities/cuda.cuh>
+#include <cudf/table/table_device_view.cuh>
+#include <cudf/utilities/span.hpp>
+
+#include <cub/cub.cuh>
+
+namespace cudf {
+namespace detail {
+
+namespace cg = cooperative_groups;
+
+#pragma GCC diagnostic ignored "-Wattributes"
+
+template <cudf::size_type block_size, bool has_nulls, typename HashProbe>
+__attribute__((visibility("hidden"))) __launch_bounds__(block_size) __global__
+  void mixed_join_semi(table_device_view left_table,
+                       table_device_view right_table,
+                       table_device_view probe,
+                       table_device_view build,
+                       HashProbe const hash_probe,
+                       row_equality const equality_probe,
+                       cudf::detail::semi_map_type::device_view hash_table_view,
+                       cudf::device_span<bool> left_table_keep_mask,
+                       cudf::ast::detail::expression_device_view device_expression_data)
+{
+  // Normally the casting of a shared memory array is used to create multiple
+  // arrays of different types from the shared memory buffer, but here it is
+  // used to circumvent conflicts between arrays of different types between
+  // different template instantiations due to the extern specifier.
+  extern __shared__ char raw_intermediate_storage[];
+  cudf::ast::detail::IntermediateDataType<has_nulls>* intermediate_storage =
+    reinterpret_cast<cudf::ast::detail::IntermediateDataType<has_nulls>*>(raw_intermediate_storage);
+  auto thread_intermediate_storage =
+    &intermediate_storage[threadIdx.x * device_expression_data.num_intermediates];
+
+  cudf::size_type const left_num_rows  = left_table.num_rows();
+  cudf::size_type const right_num_rows = right_table.num_rows();
+  auto const outer_num_rows            = left_num_rows;
+
+  cudf::size_type outer_row_index = threadIdx.x + blockIdx.x * block_size;
+
+  auto evaluator = cudf::ast::detail::expression_evaluator<has_nulls>(
+    left_table, right_table, device_expression_data);
+
+  if (outer_row_index < outer_num_rows) {
+    // Figure out the number of elements for this key.
+    auto equality = single_expression_equality<has_nulls>{
+      evaluator, thread_intermediate_storage, false, equality_probe};
+
+    left_table_keep_mask[outer_row_index] =
+      hash_table_view.contains(outer_row_index, hash_probe, equality);
+  }
+}
+}  // namespace detail
+}  // namespace cudf
diff --git a/cpp/src/join/mixed_join_kernels_semi.cu b/cpp/src/join/mixed_join_kernels_semi.cu
index 1f31eaa7878..5369a99808b 100644
--- a/cpp/src/join/mixed_join_kernels_semi.cu
+++ b/cpp/src/join/mixed_join_kernels_semi.cu
@@ -14,89 +14,31 @@
  * limitations under the License.
  */
 
-#include "join/join_common_utils.cuh"
-#include "join/join_common_utils.hpp"
 #include "join/mixed_join_common_utils.cuh"
-
-#include <cudf/ast/detail/expression_evaluator.cuh>
-#include <cudf/ast/detail/expression_parser.hpp>
-#include <cudf/detail/utilities/cuda.cuh>
-#include <cudf/table/table_device_view.cuh>
-#include <cudf/utilities/export.hpp>
-#include <cudf/utilities/span.hpp>
-
-#include <cub/cub.cuh>
+#include "join/mixed_join_kernel_semi_impl.cuh"
 
 namespace cudf {
 namespace detail {
-
-namespace cg = cooperative_groups;
-
-#pragma GCC diagnostic ignored "-Wattributes"
-
-template <cudf::size_type block_size, bool has_nulls>
-CUDF_HIDDEN __launch_bounds__(block_size) __global__
-  void mixed_join_semi(table_device_view left_table,
-                       table_device_view right_table,
-                       table_device_view probe,
-                       table_device_view build,
-                       row_hash const hash_probe,
-                       row_equality const equality_probe,
-                       cudf::detail::semi_map_type::device_view hash_table_view,
-                       cudf::device_span<bool> left_table_keep_mask,
-                       cudf::ast::detail::expression_device_view device_expression_data)
-{
-  // Normally the casting of a shared memory array is used to create multiple
-  // arrays of different types from the shared memory buffer, but here it is
-  // used to circumvent conflicts between arrays of different types between
-  // different template instantiations due to the extern specifier.
-  extern __shared__ char raw_intermediate_storage[];
-  cudf::ast::detail::IntermediateDataType<has_nulls>* intermediate_storage =
-    reinterpret_cast<cudf::ast::detail::IntermediateDataType<has_nulls>*>(raw_intermediate_storage);
-  auto thread_intermediate_storage =
-    &intermediate_storage[threadIdx.x * device_expression_data.num_intermediates];
-
-  cudf::size_type const left_num_rows  = left_table.num_rows();
-  cudf::size_type const right_num_rows = right_table.num_rows();
-  auto const outer_num_rows            = left_num_rows;
-
-  cudf::size_type outer_row_index = threadIdx.x + blockIdx.x * block_size;
-
-  auto evaluator = cudf::ast::detail::expression_evaluator<has_nulls>(
-    left_table, right_table, device_expression_data);
-
-  if (outer_row_index < outer_num_rows) {
-    // Figure out the number of elements for this key.
-    auto equality = single_expression_equality<has_nulls>{
-      evaluator, thread_intermediate_storage, false, equality_probe};
-
-    left_table_keep_mask[outer_row_index] =
-      hash_table_view.contains(outer_row_index, hash_probe, equality);
-  }
-}
-
-template __global__ void mixed_join_semi<DEFAULT_JOIN_BLOCK_SIZE, true>(
+template __global__ void mixed_join_semi<DEFAULT_JOIN_BLOCK_SIZE, true, row_hash_no_compound>(
   table_device_view left_table,
   table_device_view right_table,
   table_device_view probe,
   table_device_view build,
-  row_hash const hash_probe,
+  row_hash_no_compound const hash_probe,
   row_equality const equality_probe,
   cudf::detail::semi_map_type::device_view hash_table_view,
   cudf::device_span<bool> left_table_keep_mask,
   cudf::ast::detail::expression_device_view device_expression_data);
 
-template __global__ void mixed_join_semi<DEFAULT_JOIN_BLOCK_SIZE, false>(
+template __global__ void mixed_join_semi<DEFAULT_JOIN_BLOCK_SIZE, false, row_hash_no_compound>(
   table_device_view left_table,
   table_device_view right_table,
   table_device_view probe,
   table_device_view build,
-  row_hash const hash_probe,
+  row_hash_no_compound const hash_probe,
   row_equality const equality_probe,
   cudf::detail::semi_map_type::device_view hash_table_view,
   cudf::device_span<bool> left_table_keep_mask,
   cudf::ast::detail::expression_device_view device_expression_data);
-
 }  // namespace detail
-
 }  // namespace cudf
diff --git a/cpp/src/join/mixed_join_kernels_semi.cuh b/cpp/src/join/mixed_join_kernels_semi.cuh
index 4ea404d451c..a813e43629e 100644
--- a/cpp/src/join/mixed_join_kernels_semi.cuh
+++ b/cpp/src/join/mixed_join_kernels_semi.cuh
@@ -51,16 +51,17 @@ namespace detail {
  * @param[in] device_expression_data Container of device data required to evaluate the desired
  * expression.
  */
-template <cudf::size_type block_size, bool has_nulls>
-__global__ void mixed_join_semi(table_device_view left_table,
-                                table_device_view right_table,
-                                table_device_view probe,
-                                table_device_view build,
-                                row_hash const hash_probe,
-                                row_equality const equality_probe,
-                                cudf::detail::semi_map_type::device_view hash_table_view,
-                                cudf::device_span<bool> left_table_keep_mask,
-                                cudf::ast::detail::expression_device_view device_expression_data);
+template <cudf::size_type block_size, bool has_nulls, typename HashProbe>
+__attribute__((visibility("hidden"))) __launch_bounds__(block_size) __global__
+  void mixed_join_semi(table_device_view left_table,
+                       table_device_view right_table,
+                       table_device_view probe,
+                       table_device_view build,
+                       HashProbe const hash_probe,
+                       row_equality const equality_probe,
+                       cudf::detail::semi_map_type::device_view hash_table_view,
+                       cudf::device_span<bool> left_table_keep_mask,
+                       cudf::ast::detail::expression_device_view device_expression_data);
 
 }  // namespace detail
 
diff --git a/cpp/src/join/mixed_join_kernels_semi_compound.cu b/cpp/src/join/mixed_join_kernels_semi_compound.cu
new file mode 100644
index 00000000000..f05185b4ff6
--- /dev/null
+++ b/cpp/src/join/mixed_join_kernels_semi_compound.cu
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
+ *
+ * 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 "join/mixed_join_common_utils.cuh"
+#include "join/mixed_join_kernel_semi_impl.cuh"
+
+namespace cudf {
+namespace detail {
+template __global__ void mixed_join_semi<DEFAULT_JOIN_BLOCK_SIZE, true, row_hash_no_nested>(
+  table_device_view left_table,
+  table_device_view right_table,
+  table_device_view probe,
+  table_device_view build,
+  row_hash_no_nested const hash_probe,
+  row_equality const equality_probe,
+  cudf::detail::semi_map_type::device_view hash_table_view,
+  cudf::device_span<bool> left_table_keep_mask,
+  cudf::ast::detail::expression_device_view device_expression_data);
+
+template __global__ void mixed_join_semi<DEFAULT_JOIN_BLOCK_SIZE, false, row_hash_no_nested>(
+  table_device_view left_table,
+  table_device_view right_table,
+  table_device_view probe,
+  table_device_view build,
+  row_hash_no_nested const hash_probe,
+  row_equality const equality_probe,
+  cudf::detail::semi_map_type::device_view hash_table_view,
+  cudf::device_span<bool> left_table_keep_mask,
+  cudf::ast::detail::expression_device_view device_expression_data);
+}  // namespace detail
+}  // namespace cudf
diff --git a/cpp/src/join/mixed_join_kernels_semi_nested.cu b/cpp/src/join/mixed_join_kernels_semi_nested.cu
new file mode 100644
index 00000000000..44a612bba3a
--- /dev/null
+++ b/cpp/src/join/mixed_join_kernels_semi_nested.cu
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2022-2024, NVIDIA CORPORATION.
+ *
+ * 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 "join/mixed_join_common_utils.cuh"
+#include "join/mixed_join_kernel_semi_impl.cuh"
+
+namespace cudf {
+namespace detail {
+template __global__ void mixed_join_semi<DEFAULT_JOIN_BLOCK_SIZE, true, row_hash>(
+  table_device_view left_table,
+  table_device_view right_table,
+  table_device_view probe,
+  table_device_view build,
+  row_hash const hash_probe,
+  row_equality const equality_probe,
+  cudf::detail::semi_map_type::device_view hash_table_view,
+  cudf::device_span<bool> left_table_keep_mask,
+  cudf::ast::detail::expression_device_view device_expression_data);
+
+template __global__ void mixed_join_semi<DEFAULT_JOIN_BLOCK_SIZE, false, row_hash>(
+  table_device_view left_table,
+  table_device_view right_table,
+  table_device_view probe,
+  table_device_view build,
+  row_hash const hash_probe,
+  row_equality const equality_probe,
+  cudf::detail::semi_map_type::device_view hash_table_view,
+  cudf::device_span<bool> left_table_keep_mask,
+  cudf::ast::detail::expression_device_view device_expression_data);
+}  // namespace detail
+}  // namespace cudf
diff --git a/cpp/src/join/mixed_join_semi.cu b/cpp/src/join/mixed_join_semi.cu
index c147ea3c253..4c78b892b1f 100644
--- a/cpp/src/join/mixed_join_semi.cu
+++ b/cpp/src/join/mixed_join_semi.cu
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#include "join_common_utils.cuh"
-#include "join_common_utils.hpp"
-#include "mixed_join_kernels_semi.cuh"
+#include "join/join_common_utils.cuh"
+#include "join/join_common_utils.hpp"
+#include "join/mixed_join_kernels_semi.cuh"
 
 #include <cudf/ast/detail/expression_parser.hpp>
 #include <cudf/ast/expressions.hpp>
@@ -25,6 +25,7 @@
 #include <cudf/detail/utilities/cuda.cuh>
 #include <cudf/hashing/detail/helper_functions.cuh>
 #include <cudf/join.hpp>
+#include <cudf/table/experimental/row_operators.cuh>
 #include <cudf/table/table.hpp>
 #include <cudf/table/table_device_view.cuh>
 #include <cudf/table/table_view.hpp>
@@ -41,7 +42,10 @@
 #include <thrust/scan.h>
 
 #include <optional>
+#include <set>
+#include <unordered_set>
 #include <utility>
+#include <variant>
 
 namespace cudf {
 namespace detail {
@@ -61,10 +65,16 @@ struct make_pair_function_semi {
 
 /**
  * @brief Equality comparator that composes two row_equality comparators.
+ *
+ * Note: We could replace this with a C++ lambda. But we intend to std::visit the comparator, and
+ * due to a NVCC restriction, device lambdas cannot be defined inside of generic lambda expressions.
+ * Thus, we fall back to using a regular functor.
  */
+template <typename EqualityComparator, typename ConditionalComparator>
 class double_row_equality {
  public:
-  double_row_equality(row_equality equality_comparator, row_equality conditional_comparator)
+  double_row_equality(EqualityComparator equality_comparator,
+                      ConditionalComparator conditional_comparator)
     : _equality_comparator{equality_comparator}, _conditional_comparator{conditional_comparator}
   {
   }
@@ -79,8 +89,8 @@ class double_row_equality {
   }
 
  private:
-  row_equality _equality_comparator;
-  row_equality _conditional_comparator;
+  EqualityComparator _equality_comparator;
+  ConditionalComparator _conditional_comparator;
 };
 
 }  // namespace
@@ -173,9 +183,8 @@ std::unique_ptr<rmm::device_uvector<size_type>> mixed_join_semi(
   // TODO: To add support for nested columns we will need to flatten in many
   // places. However, this probably isn't worth adding any time soon since we
   // won't be able to support AST conditions for those types anyway.
-  auto const build_nulls    = cudf::nullate::DYNAMIC{cudf::has_nulls(build)};
-  auto const row_hash_build = cudf::experimental::row::hash::row_hasher{preprocessed_build};
-  auto const hash_build     = row_hash_build.device_hasher(build_nulls);
+  auto const build_nulls = cudf::nullate::DYNAMIC{cudf::has_nulls(build)};
+
   // Since we may see multiple rows that are identical in the equality tables
   // but differ in the conditional tables, the equality comparator used for
   // insertion must account for both sets of tables. An alternative solution
@@ -187,32 +196,59 @@ std::unique_ptr<rmm::device_uvector<size_type>> mixed_join_semi(
   // scope for now.
   auto const row_comparator_build =
     cudf::experimental::row::equality::two_table_comparator{preprocessed_build, preprocessed_build};
-  auto const equality_build_equality =
-    row_comparator_build.equal_to<false>(build_nulls, compare_nulls);
+
   auto const preprocessed_build_condtional =
     experimental::row::equality::preprocessed_table::create(right_conditional, stream);
   auto const row_comparator_conditional_build =
     cudf::experimental::row::equality::two_table_comparator{preprocessed_build_condtional,
                                                             preprocessed_build_condtional};
-  auto const equality_build_conditional =
-    row_comparator_conditional_build.equal_to<false>(build_nulls, compare_nulls);
-  double_row_equality equality_build{equality_build_equality, equality_build_conditional};
+
   make_pair_function_semi pair_func_build{};
 
   auto iter = cudf::detail::make_counting_transform_iterator(0, pair_func_build);
 
+  std::unordered_set<cudf::type_id> build_column_types, probe_column_types;
+  for (auto col : build) {
+    build_column_types.insert(col.type().id());
+  }
+  for (auto col : probe) {
+    probe_column_types.insert(col.type().id());
+  }
+
+  auto const row_hash_build = cudf::experimental::row::hash::row_hasher{preprocessed_build};
+  auto const hash_build     = row_hash_build.device_hasher(build_column_types, build_nulls);
+  auto const row_hash_probe = cudf::experimental::row::hash::row_hasher{preprocessed_probe};
+  auto const hash_probe     = row_hash_probe.device_hasher(probe_column_types, has_nulls);
+  auto const equality_build_equality =
+    row_comparator_build.equal_to(build_column_types, build_nulls, compare_nulls);
+  auto const equality_build_conditional =
+    row_comparator_conditional_build.equal_to(build_column_types, build_nulls, compare_nulls);
+
   // skip rows that are null here.
   if ((compare_nulls == null_equality::EQUAL) or (not nullable(build))) {
-    hash_table.insert(iter, iter + right_num_rows, hash_build, equality_build, stream.value());
+    std::visit(
+      [&](auto&& hasher, auto&& equality_comparator, auto&& conditional_comparator) {
+        auto const comparator = double_row_equality{equality_comparator, conditional_comparator};
+        hash_table.insert(iter, iter + right_num_rows, hasher, comparator, stream.value());
+      },
+      hash_build,
+      equality_build_equality,
+      equality_build_conditional);
   } else {
     thrust::counting_iterator<cudf::size_type> stencil(0);
     auto const [row_bitmask, _] =
       cudf::detail::bitmask_and(build, stream, rmm::mr::get_current_device_resource());
     row_is_valid pred{static_cast<bitmask_type const*>(row_bitmask.data())};
-
-    // insert valid rows
-    hash_table.insert_if(
-      iter, iter + right_num_rows, stencil, pred, hash_build, equality_build, stream.value());
+    std::visit(
+      [&](auto&& hasher, auto&& equality_comparator, auto&& conditional_comparator) {
+        auto const comparator = double_row_equality{equality_comparator, conditional_comparator};
+        // insert valid rows
+        hash_table.insert_if(
+          iter, iter + right_num_rows, stencil, pred, hasher, comparator, stream.value());
+      },
+      hash_build,
+      equality_build_equality,
+      equality_build_conditional);
   }
 
   auto hash_table_view = hash_table.get_device_view();
@@ -220,36 +256,45 @@ std::unique_ptr<rmm::device_uvector<size_type>> mixed_join_semi(
   detail::grid_1d const config(outer_num_rows, DEFAULT_JOIN_BLOCK_SIZE);
   auto const shmem_size_per_block = parser.shmem_per_thread * config.num_threads_per_block;
 
-  auto const row_hash   = cudf::experimental::row::hash::row_hasher{preprocessed_probe};
-  auto const hash_probe = row_hash.device_hasher(has_nulls);
-
   // Vector used to indicate indices from left/probe table which are present in output
   auto left_table_keep_mask = rmm::device_uvector<bool>(probe.num_rows(), stream);
 
   if (has_nulls) {
-    mixed_join_semi<DEFAULT_JOIN_BLOCK_SIZE, true>
-      <<<config.num_blocks, config.num_threads_per_block, shmem_size_per_block, stream.value()>>>(
-        *left_conditional_view,
-        *right_conditional_view,
-        *probe_view,
-        *build_view,
-        hash_probe,
-        equality_probe,
-        hash_table_view,
-        cudf::device_span<bool>(left_table_keep_mask),
-        parser.device_expression_data);
+    std::visit(
+      [&](auto&& hasher) {
+        mixed_join_semi<DEFAULT_JOIN_BLOCK_SIZE, true>
+          <<<config.num_blocks,
+             config.num_threads_per_block,
+             shmem_size_per_block,
+             stream.value()>>>(*left_conditional_view,
+                               *right_conditional_view,
+                               *probe_view,
+                               *build_view,
+                               hasher,
+                               equality_probe,
+                               hash_table_view,
+                               cudf::device_span<bool>(left_table_keep_mask),
+                               parser.device_expression_data);
+      },
+      hash_probe);
   } else {
-    mixed_join_semi<DEFAULT_JOIN_BLOCK_SIZE, false>
-      <<<config.num_blocks, config.num_threads_per_block, shmem_size_per_block, stream.value()>>>(
-        *left_conditional_view,
-        *right_conditional_view,
-        *probe_view,
-        *build_view,
-        hash_probe,
-        equality_probe,
-        hash_table_view,
-        cudf::device_span<bool>(left_table_keep_mask),
-        parser.device_expression_data);
+    std::visit(
+      [&](auto&& hasher) {
+        mixed_join_semi<DEFAULT_JOIN_BLOCK_SIZE, false>
+          <<<config.num_blocks,
+             config.num_threads_per_block,
+             shmem_size_per_block,
+             stream.value()>>>(*left_conditional_view,
+                               *right_conditional_view,
+                               *probe_view,
+                               *build_view,
+                               hasher,
+                               equality_probe,
+                               hash_table_view,
+                               cudf::device_span<bool>(left_table_keep_mask),
+                               parser.device_expression_data);
+      },
+      hash_probe);
   }
 
   auto gather_map = std::make_unique<rmm::device_uvector<size_type>>(probe.num_rows(), stream, mr);