Repository navigation
fix: clear groupings when clearing orderings - #26852
Conversation
1f8eb57 to
dccf624
Compare
dccf624 to
86f93b6
Compare
|
@jayzhan211 Bumping this followup fix PR 🙇 |
Backport the Apache DataFusion apache#24438 stack onto DataDog branch-55: - apache#24737: unsorted contiguous-group regression coverage - apache#24697: group-clustering terminology and aggregate APIs - apache#24698: grouping equivalence properties and propagation - apache#24497: incremental aggregation over explicitly grouped input - apache#26852: invalidate grouping assertions when clearing orderings Adapt the changes to DF55's existing aggregate streams. Single-stage clustered aggregation continues to use GroupedHashAggregateStream; partial and final aggregation retain the existing specialized streams. Do not import the unrelated DF56 aggregate-stream migration. Include the constant-key, grouping-set, and PartialReduce guards. Extend blocked-input tests across single/final and migrated/legacy execution, and retain sort-option and metadata-invalidation coverage. Update DF55 plan snapshots, the wrapped memory-limit error assertion, and the API upgrade guide. Validation: 503 SQL test files passed, 3347 focused expression/plan unit tests passed, and all-targets/all-features clippy passed. Extended tests exposed a dictionary sort-fuzzer failure also reproduced on the unchanged branch-55 base (root seed 1793724857; dataset 15872832093508421016; query 12465732596605393044; config 11717754459111916353). Upstream-Commit: 59d74ca Upstream-Commit: d93699c Upstream-Commit: 320a7d2 Upstream-Commit: 64a5955 Upstream-Commit: 3c3898e Upstream-Commit: 86f93b6 Co-authored-by: xavlee <52435309+xavlee@users.noreply.github.com>
Backport apache#26852 Invalidate both grouping metadata and its cache when ordering information is cleared. Cover coalescing and clustered aggregate property handling. The completed five-commit stack has the same Git tree as the previously validated e6b218d backport. Validation there included 3,347 focused tests and 503 SQL test files. The extended sort-fuzzer failure also reproduces on unchanged branch-55 (root seed 1793724857; dataset 15872832093508421016; query 12465732596605393044; config 11717754459111916353). Upstream-Commit: 86f93b6
kosiew
left a comment
There was a problem hiding this comment.
Thanks for fixing the grouping invalidation contract. The change is focused, and the conservative approach is appropriate. The regression tests demonstrate that clearing orderings also removes explicit grouping assertions while preserving valid ordering-derived grouping where applicable.
EquivalenceProperties is the right owner for this invariant. Centralizing invalidation prevents operators that rearrange rows from accidentally advertising contiguous groups they no longer guarantee. This avoids duplicating cleanup responsibilities across callers and keeps the distinction between ordering and explicit grouping clear.
I found no blocking correctness or architectural concerns. The helper regression reproduces the original contract violation, and the neighboring operator behavior has been checked. I've left two optional suggestions concerning single-partition property preservation and additional helper coverage. Neither needs to block this fix.
| @@ -84,9 +84,6 @@ impl CoalescePartitionsExec { | |||
| // Coalescing partitions loses existing orderings: | |||
| let mut eq_properties = input.equivalence_properties().clone(); | |||
| eq_properties.clear_orderings(); | |||
There was a problem hiding this comment.
Optional follow-up: could we preserve ordering and explicit grouping on the single-partition fast path? execute forwards the child stream directly, optionally applying fetch truncation, so neither operation splits groups. Consider conditioning sequence-property invalidation on multiple partitions, with tests for single-partition passthrough/fetch and multi-partition clearing, while retaining unrelated property handling. The current behavior is safe but conservative.
There was a problem hiding this comment.
Can you please file a ticket with what end user visible effect that would have? I can't follow the implications of the code changes you are proposing
| Ok(()) | ||
| } | ||
|
|
||
| #[test] |
There was a problem hiding this comment.
Optional test improvement: could we also cover clear_orderings() when the ordering class is already empty but explicit grouping exists? Assert that the grouping class and normalized cache are cleared and grouping_satisfy returns false. This would guard against a future early return based on an empty ordering class; existing coalesce tests already cover the behavior indirectly.
There was a problem hiding this comment.
Do we really need more unit tests for a one line code change? This PR already seems to me like it has far too many tests give the change 🤔
Which issue does this PR relate to?
Part of #24438. Follows up on the invalidation API review in #24698.
Builds on #24698 (merged). This PR and #24497 both build on the grouping metadata introduced there.
Rationale for this change
Execution operators can clone their input's equivalence properties and call
clear_orderings()when rearranging rows. Clearing grouping assertions at the same boundary prevents consumers from relying on contiguous groups that the output no longer guarantees.Note: clear_groupings() here is conservative since grouping does not imply ordering.
What changes are included in this PR?
EquivalenceProperties::clear_orderings()clear explicit grouping tuples and their normalized cache along with ordering information.clear_groupings()operation, which preserves ordering information.Stack
What is the testing strategy for this PR?
clear_orderings_clears_groupingschecks that ordering-derived grouping and explicit grouping are invalidated, including the normalized grouping cache.clear_groupings_preserves_orderingschecks that explicit grouping can be cleared while ordering and ordering-derived grouping remain available.coalesce_clears_explicit_groupingcovers one and multiple input partitions.clustered_aggregate_clears_explicit_groupingcovers partial and single aggregation, preserving the ordering onawhile clearing the explicit grouping onc.Removing the new API clear makes its regression fail. Removing the aggregate's explicit grouping clear makes both clustered aggregate cases fail.
Are there any user-facing changes?
Yes.
clear_orderings()also clears explicit grouping assertions. Operators using this API discard those assertions conservatively, including single-inputCoalescePartitionsExec.Since grouping information is new, this should not affect any existing operators.
Review this layer
View this follow-up's changes against main.