From add330b0535da4622778596202ad0c33808b5556 Mon Sep 17 00:00:00 2001 From: Jason Lowe Date: Tue, 24 Aug 2021 10:57:49 -0500 Subject: [PATCH 1/4] Fix cudf::hash_join output size for struct joins --- cpp/src/join/hash_join.cu | 31 +++++--- cpp/tests/join/join_tests.cpp | 136 ++++++++++++++++++++-------------- 2 files changed, 101 insertions(+), 66 deletions(-) diff --git a/cpp/src/join/hash_join.cu b/cpp/src/join/hash_join.cu index 50cc479fcf4..109190233a8 100644 --- a/cpp/src/join/hash_join.cu +++ b/cpp/src/join/hash_join.cu @@ -349,11 +349,15 @@ std::size_t hash_join::hash_join_impl::inner_join_size(cudf::table_view const& p CUDF_FUNC_RANGE(); CUDF_EXPECTS(_hash_table, "Hash table of hash join is null."); - auto build_table = cudf::table_device_view::create(_build, stream); - auto probe_table = cudf::table_device_view::create(probe, stream); + auto flattened_probe = structs::detail::flatten_nested_columns( + probe, {}, {}, structs::detail::column_nullability::FORCE); + auto const flattened_probe_table = std::get<0>(flattened_probe); + + auto build_table = cudf::table_device_view::create(_build, stream); + auto d_flattened_probe_table = cudf::table_device_view::create(flattened_probe_table, stream); return cudf::detail::compute_join_output_size( - *build_table, *probe_table, *_hash_table, compare_nulls, stream); + *build_table, *d_flattened_probe_table, *_hash_table, compare_nulls, stream); } std::size_t hash_join::hash_join_impl::left_join_size(cudf::table_view const& probe, @@ -365,11 +369,15 @@ std::size_t hash_join::hash_join_impl::left_join_size(cudf::table_view const& pr // Trivial left join case - exit early if (!_hash_table) { return probe.num_rows(); } - auto build_table = cudf::table_device_view::create(_build, stream); - auto probe_table = cudf::table_device_view::create(probe, stream); + auto flattened_probe = structs::detail::flatten_nested_columns( + probe, {}, {}, structs::detail::column_nullability::FORCE); + auto const flattened_probe_table = std::get<0>(flattened_probe); + + auto build_table = cudf::table_device_view::create(_build, stream); + auto d_flattened_probe_table = cudf::table_device_view::create(flattened_probe_table, stream); return cudf::detail::compute_join_output_size( - *build_table, *probe_table, *_hash_table, compare_nulls, stream); + *build_table, *d_flattened_probe_table, *_hash_table, compare_nulls, stream); } std::size_t hash_join::hash_join_impl::full_join_size(cudf::table_view const& probe, @@ -382,10 +390,15 @@ std::size_t hash_join::hash_join_impl::full_join_size(cudf::table_view const& pr // Trivial left join case - exit early if (!_hash_table) { return probe.num_rows(); } - auto build_table = cudf::table_device_view::create(_build, stream); - auto probe_table = cudf::table_device_view::create(probe, stream); + auto flattened_probe = structs::detail::flatten_nested_columns( + probe, {}, {}, structs::detail::column_nullability::FORCE); + auto const flattened_probe_table = std::get<0>(flattened_probe); + + auto build_table = cudf::table_device_view::create(_build, stream); + auto d_flattened_probe_table = cudf::table_device_view::create(flattened_probe_table, stream); - return get_full_join_size(*build_table, *probe_table, *_hash_table, compare_nulls, stream, mr); + return get_full_join_size( + *build_table, *d_flattened_probe_table, *_hash_table, compare_nulls, stream, mr); } template diff --git a/cpp/tests/join/join_tests.cpp b/cpp/tests/join/join_tests.cpp index e468368842a..627e27b609d 100644 --- a/cpp/tests/join/join_tests.cpp +++ b/cpp/tests/join/join_tests.cpp @@ -44,6 +44,28 @@ constexpr cudf::size_type NoneValue = std::numeric_limits::min(); // TODO: how to test if this isn't public? struct JoinTest : public cudf::test::BaseFixture { + void check_gather_maps( + cudf::column_view const& left_map, + cudf::column_view const& right_map, + std::pair>, + std::unique_ptr>> const& result) + { + auto result_table = + cudf::table_view({cudf::column_view{cudf::data_type{cudf::type_id::INT32}, + static_cast(result.first->size()), + result.first->data()}, + cudf::column_view{cudf::data_type{cudf::type_id::INT32}, + static_cast(result.second->size()), + result.second->data()}}); + auto result_sort_order = cudf::sorted_order(result_table); + auto sorted_result = cudf::gather(result_table, *result_sort_order); + + cudf::table_view gold({left_map, right_map}); + auto gold_sort_order = cudf::sorted_order(gold); + auto sorted_gold = cudf::gather(gold, *gold_sort_order); + + CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*sorted_gold, *sorted_result); + } }; TEST_F(JoinTest, EmptySentinelRepro) @@ -1232,28 +1254,9 @@ TEST_F(JoinTest, HashJoinSequentialProbes) EXPECT_EQ(output_size, size_gold); auto result = hash_join.full_join(t0, cudf::null_equality::EQUAL, optional_size); - auto result_table = - cudf::table_view({cudf::column_view{cudf::data_type{cudf::type_id::INT32}, - static_cast(result.first->size()), - result.first->data()}, - cudf::column_view{cudf::data_type{cudf::type_id::INT32}, - static_cast(result.second->size()), - result.second->data()}}); - auto result_sort_order = cudf::sorted_order(result_table); - auto sorted_result = cudf::gather(result_table, *result_sort_order); - column_wrapper col_gold_0{{NoneValue, NoneValue, NoneValue, NoneValue, 4, 0, 1, 2, 3}}; column_wrapper col_gold_1{{0, 1, 2, 3, 4, NoneValue, NoneValue, NoneValue, NoneValue}}; - - CVector cols_gold; - cols_gold.push_back(col_gold_0.release()); - cols_gold.push_back(col_gold_1.release()); - - Table gold(std::move(cols_gold)); - auto gold_sort_order = cudf::sorted_order(gold.view()); - auto sorted_gold = cudf::gather(gold.view(), *gold_sort_order); - - CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*sorted_gold, *sorted_result); + check_gather_maps(col_gold_0, col_gold_1, result); } { @@ -1270,28 +1273,9 @@ TEST_F(JoinTest, HashJoinSequentialProbes) EXPECT_EQ(output_size, size_gold); auto result = hash_join.left_join(t0, cudf::null_equality::EQUAL, optional_size); - auto result_table = - cudf::table_view({cudf::column_view{cudf::data_type{cudf::type_id::INT32}, - static_cast(result.first->size()), - result.first->data()}, - cudf::column_view{cudf::data_type{cudf::type_id::INT32}, - static_cast(result.second->size()), - result.second->data()}}); - auto result_sort_order = cudf::sorted_order(result_table); - auto sorted_result = cudf::gather(result_table, *result_sort_order); - column_wrapper col_gold_0{{0, 1, 2, 3, 4}}; column_wrapper col_gold_1{{NoneValue, NoneValue, NoneValue, NoneValue, 4}}; - - CVector cols_gold; - cols_gold.push_back(col_gold_0.release()); - cols_gold.push_back(col_gold_1.release()); - - Table gold(std::move(cols_gold)); - auto gold_sort_order = cudf::sorted_order(gold.view()); - auto sorted_gold = cudf::gather(gold.view(), *gold_sort_order); - - CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*sorted_gold, *sorted_result); + check_gather_maps(col_gold_0, col_gold_1, result); } { @@ -1308,28 +1292,66 @@ TEST_F(JoinTest, HashJoinSequentialProbes) EXPECT_EQ(output_size, size_gold); auto result = hash_join.inner_join(t0, cudf::null_equality::EQUAL, optional_size); - auto result_table = - cudf::table_view({cudf::column_view{cudf::data_type{cudf::type_id::INT32}, - static_cast(result.first->size()), - result.first->data()}, - cudf::column_view{cudf::data_type{cudf::type_id::INT32}, - static_cast(result.second->size()), - result.second->data()}}); - auto result_sort_order = cudf::sorted_order(result_table); - auto sorted_result = cudf::gather(result_table, *result_sort_order); - column_wrapper col_gold_0{{2, 4, 0}}; column_wrapper col_gold_1{{1, 1, 4}}; + check_gather_maps(col_gold_0, col_gold_1, result); + } +} + +TEST_F(JoinTest, HashJoinWithStructsAndNulls) +{ + auto col0_names_col = strcol_wrapper{ + "Samuel Vimes", "Carrot Ironfoundersson", "Detritus", "Samuel Vimes", "Angua von Überwald"}; + auto col0_ages_col = column_wrapper{{48, 27, 351, 31, 25}}; - CVector cols_gold; - cols_gold.push_back(col_gold_0.release()); - cols_gold.push_back(col_gold_1.release()); + auto col0_is_human_col = column_wrapper{{true, true, false, false, false}, {1, 1, 0, 1, 0}}; - Table gold(std::move(cols_gold)); - auto gold_sort_order = cudf::sorted_order(gold.view()); - auto sorted_gold = cudf::gather(gold.view(), *gold_sort_order); + auto col0 = + cudf::test::structs_column_wrapper{{col0_names_col, col0_ages_col, col0_is_human_col}}; - CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*sorted_gold, *sorted_result); + auto col1_names_col = strcol_wrapper{ + "Samuel Vimes", "Detritus", "Detritus", "Carrot Ironfoundersson", "Angua von Überwald"}; + auto col1_ages_col = column_wrapper{{48, 35, 351, 22, 25}}; + + auto col1_is_human_col = column_wrapper{{true, true, false, false, true}, {1, 1, 0, 1, 1}}; + + auto col1 = + cudf::test::structs_column_wrapper{{col1_names_col, col1_ages_col, col1_is_human_col}}; + + CVector cols0, cols1; + cols0.push_back(col0.release()); + cols1.push_back(col1.release()); + + Table t0(std::move(cols0)); + Table t1(std::move(cols1)); + + auto hash_join = cudf::hash_join(t1, cudf::null_equality::EQUAL); + + { + auto output_size = hash_join.left_join_size(t0); + EXPECT_EQ(5, output_size); + auto result = hash_join.left_join(t0, cudf::null_equality::EQUAL, output_size); + column_wrapper col_gold_0{{0, 1, 2, 3, 4}}; + column_wrapper col_gold_1{{0, NoneValue, 2, NoneValue, NoneValue}}; + check_gather_maps(col_gold_0, col_gold_1, result); + } + + { + auto output_size = hash_join.inner_join_size(t0); + EXPECT_EQ(2, output_size); + auto result = hash_join.inner_join(t0, cudf::null_equality::EQUAL, output_size); + column_wrapper col_gold_0{{0, 2}}; + column_wrapper col_gold_1{{0, 2}}; + check_gather_maps(col_gold_0, col_gold_1, result); + } + + { + auto output_size = hash_join.full_join_size(t0); + EXPECT_EQ(8, output_size); + auto result = hash_join.full_join(t0, cudf::null_equality::EQUAL, output_size); + column_wrapper col_gold_0{{NoneValue, NoneValue, NoneValue, 0, 1, 2, 3, 4}}; + column_wrapper col_gold_1{{1, 3, 4, 0, NoneValue, 2, NoneValue, NoneValue}}; + check_gather_maps(col_gold_0, col_gold_1, result); } } From b4cab6376d47613ffa669e9df63ae75c81cad9a1 Mon Sep 17 00:00:00 2001 From: Jason Lowe Date: Tue, 24 Aug 2021 18:00:41 -0500 Subject: [PATCH 2/4] Update variable names, perform table check in each test case separately --- cpp/src/join/hash_join.cu | 12 ++++++------ cpp/tests/join/join_tests.cpp | 29 ++++++++++++++++++----------- 2 files changed, 24 insertions(+), 17 deletions(-) diff --git a/cpp/src/join/hash_join.cu b/cpp/src/join/hash_join.cu index 109190233a8..4a1a1a9c060 100644 --- a/cpp/src/join/hash_join.cu +++ b/cpp/src/join/hash_join.cu @@ -353,11 +353,11 @@ std::size_t hash_join::hash_join_impl::inner_join_size(cudf::table_view const& p probe, {}, {}, structs::detail::column_nullability::FORCE); auto const flattened_probe_table = std::get<0>(flattened_probe); - auto build_table = cudf::table_device_view::create(_build, stream); - auto d_flattened_probe_table = cudf::table_device_view::create(flattened_probe_table, stream); + auto build_table_ptr = cudf::table_device_view::create(_build, stream); + auto flattened_probe_table_ptr = cudf::table_device_view::create(flattened_probe_table, stream); return cudf::detail::compute_join_output_size( - *build_table, *d_flattened_probe_table, *_hash_table, compare_nulls, stream); + *build_table_ptr, *flattened_probe_table_ptr, *_hash_table, compare_nulls, stream); } std::size_t hash_join::hash_join_impl::left_join_size(cudf::table_view const& probe, @@ -373,11 +373,11 @@ std::size_t hash_join::hash_join_impl::left_join_size(cudf::table_view const& pr probe, {}, {}, structs::detail::column_nullability::FORCE); auto const flattened_probe_table = std::get<0>(flattened_probe); - auto build_table = cudf::table_device_view::create(_build, stream); - auto d_flattened_probe_table = cudf::table_device_view::create(flattened_probe_table, stream); + auto build_table_ptr = cudf::table_device_view::create(_build, stream); + auto flattened_probe_table_ptr = cudf::table_device_view::create(flattened_probe_table, stream); return cudf::detail::compute_join_output_size( - *build_table, *d_flattened_probe_table, *_hash_table, compare_nulls, stream); + *build_table_ptr, *flattened_probe_table_ptr, *_hash_table, compare_nulls, stream); } std::size_t hash_join::hash_join_impl::full_join_size(cudf::table_view const& probe, diff --git a/cpp/tests/join/join_tests.cpp b/cpp/tests/join/join_tests.cpp index 627e27b609d..7a492fdc7ed 100644 --- a/cpp/tests/join/join_tests.cpp +++ b/cpp/tests/join/join_tests.cpp @@ -44,9 +44,9 @@ constexpr cudf::size_type NoneValue = std::numeric_limits::min(); // TODO: how to test if this isn't public? struct JoinTest : public cudf::test::BaseFixture { - void check_gather_maps( - cudf::column_view const& left_map, - cudf::column_view const& right_map, + std::pair, std::unique_ptr> gather_maps_as_tables( + cudf::column_view const& expected_left_map, + cudf::column_view const& expected_right_map, std::pair>, std::unique_ptr>> const& result) { @@ -60,11 +60,11 @@ struct JoinTest : public cudf::test::BaseFixture { auto result_sort_order = cudf::sorted_order(result_table); auto sorted_result = cudf::gather(result_table, *result_sort_order); - cudf::table_view gold({left_map, right_map}); + cudf::table_view gold({expected_left_map, expected_right_map}); auto gold_sort_order = cudf::sorted_order(gold); auto sorted_gold = cudf::gather(gold, *gold_sort_order); - CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*sorted_gold, *sorted_result); + return std::make_pair(std::move(sorted_gold), std::move(sorted_result)); } }; @@ -1256,7 +1256,9 @@ TEST_F(JoinTest, HashJoinSequentialProbes) auto result = hash_join.full_join(t0, cudf::null_equality::EQUAL, optional_size); column_wrapper col_gold_0{{NoneValue, NoneValue, NoneValue, NoneValue, 4, 0, 1, 2, 3}}; column_wrapper col_gold_1{{0, 1, 2, 3, 4, NoneValue, NoneValue, NoneValue, NoneValue}}; - check_gather_maps(col_gold_0, col_gold_1, result); + + auto table_ptrs = gather_maps_as_tables(col_gold_0, col_gold_1, result); + CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*table_ptrs.first, *table_ptrs.second); } { @@ -1275,7 +1277,8 @@ TEST_F(JoinTest, HashJoinSequentialProbes) auto result = hash_join.left_join(t0, cudf::null_equality::EQUAL, optional_size); column_wrapper col_gold_0{{0, 1, 2, 3, 4}}; column_wrapper col_gold_1{{NoneValue, NoneValue, NoneValue, NoneValue, 4}}; - check_gather_maps(col_gold_0, col_gold_1, result); + auto table_ptrs = gather_maps_as_tables(col_gold_0, col_gold_1, result); + CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*table_ptrs.first, *table_ptrs.second); } { @@ -1294,7 +1297,8 @@ TEST_F(JoinTest, HashJoinSequentialProbes) auto result = hash_join.inner_join(t0, cudf::null_equality::EQUAL, optional_size); column_wrapper col_gold_0{{2, 4, 0}}; column_wrapper col_gold_1{{1, 1, 4}}; - check_gather_maps(col_gold_0, col_gold_1, result); + auto table_ptrs = gather_maps_as_tables(col_gold_0, col_gold_1, result); + CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*table_ptrs.first, *table_ptrs.second); } } @@ -1333,7 +1337,8 @@ TEST_F(JoinTest, HashJoinWithStructsAndNulls) auto result = hash_join.left_join(t0, cudf::null_equality::EQUAL, output_size); column_wrapper col_gold_0{{0, 1, 2, 3, 4}}; column_wrapper col_gold_1{{0, NoneValue, 2, NoneValue, NoneValue}}; - check_gather_maps(col_gold_0, col_gold_1, result); + auto table_ptrs = gather_maps_as_tables(col_gold_0, col_gold_1, result); + CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*table_ptrs.first, *table_ptrs.second); } { @@ -1342,7 +1347,8 @@ TEST_F(JoinTest, HashJoinWithStructsAndNulls) auto result = hash_join.inner_join(t0, cudf::null_equality::EQUAL, output_size); column_wrapper col_gold_0{{0, 2}}; column_wrapper col_gold_1{{0, 2}}; - check_gather_maps(col_gold_0, col_gold_1, result); + auto table_ptrs = gather_maps_as_tables(col_gold_0, col_gold_1, result); + CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*table_ptrs.first, *table_ptrs.second); } { @@ -1351,7 +1357,8 @@ TEST_F(JoinTest, HashJoinWithStructsAndNulls) auto result = hash_join.full_join(t0, cudf::null_equality::EQUAL, output_size); column_wrapper col_gold_0{{NoneValue, NoneValue, NoneValue, 0, 1, 2, 3, 4}}; column_wrapper col_gold_1{{1, 3, 4, 0, NoneValue, 2, NoneValue, NoneValue}}; - check_gather_maps(col_gold_0, col_gold_1, result); + auto table_ptrs = gather_maps_as_tables(col_gold_0, col_gold_1, result); + CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*table_ptrs.first, *table_ptrs.second); } } From 8948543c1122e0014104816a8e8fd7177852ea24 Mon Sep 17 00:00:00 2001 From: Jason Lowe Date: Tue, 24 Aug 2021 18:07:48 -0500 Subject: [PATCH 3/4] Use structured binding to unpack pair of tables --- cpp/tests/join/join_tests.cpp | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/cpp/tests/join/join_tests.cpp b/cpp/tests/join/join_tests.cpp index 7a492fdc7ed..af998e366e9 100644 --- a/cpp/tests/join/join_tests.cpp +++ b/cpp/tests/join/join_tests.cpp @@ -1256,9 +1256,8 @@ TEST_F(JoinTest, HashJoinSequentialProbes) auto result = hash_join.full_join(t0, cudf::null_equality::EQUAL, optional_size); column_wrapper col_gold_0{{NoneValue, NoneValue, NoneValue, NoneValue, 4, 0, 1, 2, 3}}; column_wrapper col_gold_1{{0, 1, 2, 3, 4, NoneValue, NoneValue, NoneValue, NoneValue}}; - - auto table_ptrs = gather_maps_as_tables(col_gold_0, col_gold_1, result); - CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*table_ptrs.first, *table_ptrs.second); + auto const [sorted_gold, sorted_result] = gather_maps_as_tables(col_gold_0, col_gold_1, result); + CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*sorted_gold, *sorted_result); } { @@ -1277,8 +1276,8 @@ TEST_F(JoinTest, HashJoinSequentialProbes) auto result = hash_join.left_join(t0, cudf::null_equality::EQUAL, optional_size); column_wrapper col_gold_0{{0, 1, 2, 3, 4}}; column_wrapper col_gold_1{{NoneValue, NoneValue, NoneValue, NoneValue, 4}}; - auto table_ptrs = gather_maps_as_tables(col_gold_0, col_gold_1, result); - CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*table_ptrs.first, *table_ptrs.second); + auto const [sorted_gold, sorted_result] = gather_maps_as_tables(col_gold_0, col_gold_1, result); + CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*sorted_gold, *sorted_result); } { @@ -1297,8 +1296,8 @@ TEST_F(JoinTest, HashJoinSequentialProbes) auto result = hash_join.inner_join(t0, cudf::null_equality::EQUAL, optional_size); column_wrapper col_gold_0{{2, 4, 0}}; column_wrapper col_gold_1{{1, 1, 4}}; - auto table_ptrs = gather_maps_as_tables(col_gold_0, col_gold_1, result); - CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*table_ptrs.first, *table_ptrs.second); + auto const [sorted_gold, sorted_result] = gather_maps_as_tables(col_gold_0, col_gold_1, result); + CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*sorted_gold, *sorted_result); } } @@ -1337,8 +1336,8 @@ TEST_F(JoinTest, HashJoinWithStructsAndNulls) auto result = hash_join.left_join(t0, cudf::null_equality::EQUAL, output_size); column_wrapper col_gold_0{{0, 1, 2, 3, 4}}; column_wrapper col_gold_1{{0, NoneValue, 2, NoneValue, NoneValue}}; - auto table_ptrs = gather_maps_as_tables(col_gold_0, col_gold_1, result); - CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*table_ptrs.first, *table_ptrs.second); + auto const [sorted_gold, sorted_result] = gather_maps_as_tables(col_gold_0, col_gold_1, result); + CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*sorted_gold, *sorted_result); } { @@ -1347,8 +1346,8 @@ TEST_F(JoinTest, HashJoinWithStructsAndNulls) auto result = hash_join.inner_join(t0, cudf::null_equality::EQUAL, output_size); column_wrapper col_gold_0{{0, 2}}; column_wrapper col_gold_1{{0, 2}}; - auto table_ptrs = gather_maps_as_tables(col_gold_0, col_gold_1, result); - CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*table_ptrs.first, *table_ptrs.second); + auto const [sorted_gold, sorted_result] = gather_maps_as_tables(col_gold_0, col_gold_1, result); + CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*sorted_gold, *sorted_result); } { @@ -1357,8 +1356,8 @@ TEST_F(JoinTest, HashJoinWithStructsAndNulls) auto result = hash_join.full_join(t0, cudf::null_equality::EQUAL, output_size); column_wrapper col_gold_0{{NoneValue, NoneValue, NoneValue, 0, 1, 2, 3, 4}}; column_wrapper col_gold_1{{1, 3, 4, 0, NoneValue, 2, NoneValue, NoneValue}}; - auto table_ptrs = gather_maps_as_tables(col_gold_0, col_gold_1, result); - CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*table_ptrs.first, *table_ptrs.second); + auto const [sorted_gold, sorted_result] = gather_maps_as_tables(col_gold_0, col_gold_1, result); + CUDF_TEST_EXPECT_TABLES_EQUIVALENT(*sorted_gold, *sorted_result); } } From bba3c4986444bdef9c86bd9632373a864996d49c Mon Sep 17 00:00:00 2001 From: Jason Lowe Date: Wed, 25 Aug 2021 08:17:57 -0500 Subject: [PATCH 4/4] Fix variable names --- cpp/src/join/hash_join.cu | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/cpp/src/join/hash_join.cu b/cpp/src/join/hash_join.cu index 4a1a1a9c060..ee1eaeaed47 100644 --- a/cpp/src/join/hash_join.cu +++ b/cpp/src/join/hash_join.cu @@ -394,11 +394,11 @@ std::size_t hash_join::hash_join_impl::full_join_size(cudf::table_view const& pr probe, {}, {}, structs::detail::column_nullability::FORCE); auto const flattened_probe_table = std::get<0>(flattened_probe); - auto build_table = cudf::table_device_view::create(_build, stream); - auto d_flattened_probe_table = cudf::table_device_view::create(flattened_probe_table, stream); + auto build_table_ptr = cudf::table_device_view::create(_build, stream); + auto flattened_probe_table_ptr = cudf::table_device_view::create(flattened_probe_table, stream); return get_full_join_size( - *build_table, *d_flattened_probe_table, *_hash_table, compare_nulls, stream, mr); + *build_table_ptr, *flattened_probe_table_ptr, *_hash_table, compare_nulls, stream, mr); } template