[BUG] grouped rolling produces wrong answer for structs

[revans2]

Describe the bug
The grouped rolling API lets structs in as a group by key, but produces incorrect answers.

Steps/Code to reproduce bug

diff --git a/cpp/tests/rolling/grouped_rolling_test.cpp b/cpp/tests/rolling/grouped_rolling_test.cpp
index cb123114fd..d2b75832cd 100644
--- a/cpp/tests/rolling/grouped_rolling_test.cpp
+++ b/cpp/tests/rolling/grouped_rolling_test.cpp
@@ -2439,3 +2439,32 @@ TYPED_TEST(TypedUnboundedWindowTest, UnboundedPrecedingAndFollowingWindowMultiGr
                                  fixed_width_column_wrapper<cudf::size_type>{
                                    {3, 3, 3, 3, 3, 4, 4, 4, 4, 4}, {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}});
 }
+
+TYPED_TEST(TypedUnboundedWindowTest, UnboundedPrecedingAndFollowingWindowStructGroup)
+{
+  using namespace cudf::test;
+  using T = TypeParam;
+
+  auto grp_col_inner = fixed_width_column_wrapper<T>{0, 0, 0, 0, 0, 1, 1, 1, 1, 1};
+  //std::vector<std::unique_ptr<cudf::column>> children{grp_col_inner.release()};
+  auto const grp_col = structs_column_wrapper{{grp_col_inner}};
+  
+  auto const agg_col =
+    fixed_width_column_wrapper<T>{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, {0, 1, 1, 0, 1, 0, 1, 1, 1, 1}};
+
+  auto const grouping_keys       = cudf::table_view{std::vector<cudf::column_view>{grp_col}};
+  auto const unbounded_preceding = cudf::window_bounds::unbounded();
+  auto const unbounded_following = cudf::window_bounds::unbounded();
+  auto const min_periods         = 1L;
+  auto const output =
+    cudf::grouped_rolling_window(grouping_keys,
+                                 agg_col,
+                                 unbounded_preceding,
+                                 unbounded_following,
+                                 min_periods,
+                                 *cudf::make_count_aggregation<cudf::rolling_aggregation>());
+
+  CUDF_TEST_EXPECT_COLUMNS_EQUAL(output->view(),
+                                 fixed_width_column_wrapper<cudf::size_type>{
+                                   {3, 3, 3, 3, 3, 4, 4, 4, 4, 4}, {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}});
+}

This is almost exactly the same as the test above it, but grp_col is a struct column wrapping the original grp_col. It now fails with an incorrect result.

Expected behavior
I would love it if it could produce a correct result, but I am willing to put up with it throwing an exception for group by keys it cannot support.

Environment overview (please complete the following information)
I tested this on both 20.08 and 20.10. I think think it is a blocker in any way for us. I can disable it in the Spark plugin.

[mythrocks]

I ran into a related failure, while working on groupby on struct columns. Grouping on struct columns is currently busted: it returns the input column, unmodified. This causes each row to be deemed its own group. (!!)

Since the groupby happens upstream from the window function, it is understandable that the window function's output is borked. My optimistic guess is that fixing the groupby should fix this failure as well. I'm working on this right now.

[revans2]

That is great. It would be good to also understand if there is type checking that needs to be added in somewhere? Is this a problem for list columns too?

[mythrocks]

It would be good to also understand if there is type checking that needs to be added in somewhere?

Yes, I should think so. groupby's checks to cause grouping on struct input to fail, rather than pass silently.

Is this a problem for list columns too?

Yes, this appears to be borked on list input as well. :/ I will raise a cudf issue for it, and link this current PR as a dependent.

[mythrocks]

I have verified that #9194 fixes this.

To be safe, we should probably add a test for grouping on STRUCT columns for window functions.