fix(tesseract): multi_stage reduce_by/group_by no-ops on time dimensions

A bare reduce_by/group_by (or grain exclude/keep_only) entry referencing
a time dimension never matched the projected TimeDimensionSymbol, whose
full_name carries a granularity suffix (_day, _month, ...). The entry
was silently ignored: the time dimension stayed in (or vanished from)
the window PARTITION BY / the JOIN-model leaf grain, collapsing window
aggregates to one-row partitions.

The granularity-aware matching lives on MultiStageGrain itself
(partition_dimensions): entries with an explicit granularity match
strictly on full_name; bare entries match across granularities by
unwrapping both sides to their base symbol. Both consumers — the window
path's member_partition_by_logical and the JOIN-model's partition_filter
— now delegate to it, removing the duplicated body and discharging the
FIXME about the two copies drifting.

Fixes #10854.

Author: tlangton3

rust/cube/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs

@@ -538,24 +538,7 @@ impl MultiStageMemberQueryPlanner {
     }
 
     fn member_partition_by_logical(&self, grain: &MultiStageGrain) -> Vec<Rc<MemberSymbol>> {
-        let dimensions = self.all_dimensions();
-        let dimensions = if let Some(exclude) = &grain.exclude {
-            dimensions
-                .into_iter()
-                .filter(|d| !exclude.iter().any(|m| d.has_member_in_reference_chain(m)))
-                .collect_vec()
-        } else {
-            dimensions
-        };
-        let dimensions = if let Some(keep_only) = &grain.keep_only {
-            dimensions
-                .into_iter()
-                .filter(|d| keep_only.iter().any(|m| d.has_member_in_reference_chain(m)))
-                .collect_vec()
-        } else {
-            dimensions
-        };
-        dimensions
+        grain.partition_dimensions(&self.all_dimensions())
     }
 
     fn query_order_by(&self) -> Result<Vec<OrderByItem>, CubeError> {

rust/cube/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/multi_stage_query_planner.rs

@@ -279,35 +279,6 @@ impl MultiStageQueryPlanner {
         }
     }
 
-    /// Applies the partition-shaping part of `grain` to a parent-state
-    /// dimension list: `exclude` removes matching dims, then `keep_only`
-    /// intersects what's left. `include` is appended outside this helper
-    /// via `add_dimensions`.
-    ///
-    /// FIXME: merge with `MultiStageMemberQueryPlanner::member_partition_by_logical`
-    /// — both apply the same grain reshape on different inputs; keeping two
-    /// copies invites silent drift when only one is updated.
-    fn partition_filter(
-        dims: &Vec<Rc<MemberSymbol>>,
-        grain: &MultiStageGrain,
-    ) -> Vec<Rc<MemberSymbol>> {
-        let dims: Vec<Rc<MemberSymbol>> = if let Some(exclude) = &grain.exclude {
-            dims.iter()
-                .filter(|d| !exclude.iter().any(|m| d.has_member_in_reference_chain(m)))
-                .cloned()
-                .collect()
-        } else {
-            dims.clone()
-        };
-        if let Some(keep_only) = &grain.keep_only {
-            dims.into_iter()
-                .filter(|d| keep_only.iter().any(|m| d.has_member_in_reference_chain(m)))
-                .collect()
-        } else {
-            dims
-        }
-    }
-
     /// Default child-generation path: for each measure or
     /// multi-stage-dimension dependency, recurses into
     /// `make_queries_descriptions` and adds the result as an input
@@ -556,8 +527,8 @@ impl MultiStageQueryPlanner {
                     )
                 {
                     let grain = multi_stage_member.grain();
-                    let dims = Self::partition_filter(new_state.dimensions(), grain);
-                    let time_dims = Self::partition_filter(new_state.time_dimensions(), grain);
+                    let dims = grain.partition_dimensions(new_state.dimensions());
+                    let time_dims = grain.partition_dimensions(new_state.time_dimensions());
                     new_state.set_dimensions(dims);
                     new_state.set_time_dimensions(time_dims);
                 }

rust/cube/cubesqlplanner/cubesqlplanner/src/planner/symbols/common/multi_stage.rs

@@ -63,6 +63,50 @@ pub struct MultiStageGrain {
     pub include: Option<Vec<Rc<MemberSymbol>>>,
 }
 
+impl MultiStageGrain {
+    // A grain entry with an explicit granularity (`created_at.month`) matches
+    // only that granularity; a bare entry matches the dimension at any
+    // granularity. Projected time dimensions carry a granularity suffix in
+    // full_name, so bare entries need both sides unwrapped to their base
+    // symbol — otherwise they silently match nothing, see cube-js/cube#10854.
+    fn member_matches(dim: &Rc<MemberSymbol>, entry: &Rc<MemberSymbol>) -> bool {
+        let entry_has_explicit_granularity = matches!(
+            entry.as_ref(),
+            MemberSymbol::TimeDimension(td) if td.has_granularity()
+        );
+        if entry_has_explicit_granularity {
+            dim.has_member_in_reference_chain(entry)
+        } else {
+            let base = |x: &Rc<MemberSymbol>| match x.as_ref() {
+                MemberSymbol::TimeDimension(td) => td.base_symbol().clone(),
+                _ => x.clone(),
+            };
+            base(dim).has_member_in_reference_chain(&base(entry))
+        }
+    }
+
+    /// Applies the partition-shaping part of the grain to a dimension list:
+    /// `exclude` removes matching dims, then `keep_only` intersects what's
+    /// left. `include` is appended by callers via `add_dimensions`.
+    pub fn partition_dimensions(&self, dims: &[Rc<MemberSymbol>]) -> Vec<Rc<MemberSymbol>> {
+        let dims: Vec<Rc<MemberSymbol>> = if let Some(exclude) = &self.exclude {
+            dims.iter()
+                .filter(|d| !exclude.iter().any(|m| Self::member_matches(d, m)))
+                .cloned()
+                .collect()
+        } else {
+            dims.to_vec()
+        };
+        if let Some(keep_only) = &self.keep_only {
+            dims.into_iter()
+                .filter(|d| keep_only.iter().any(|m| Self::member_matches(d, m)))
+                .collect()
+        } else {
+            dims
+        }
+    }
+}
+
 #[derive(Clone)]
 pub struct MultiStageProperties {
     pub grain: MultiStageGrain,

rust/cube/cubesqlplanner/cubesqlplanner/src/test_fixtures/schemas/yaml_files/common/integration_multi_stage.yaml

@@ -194,6 +194,35 @@ cubes:
                 - orders.status
                 - orders.category
 
+          - name: amount_reduce_created_at
+            type: sum
+            sql: "{CUBE.total_amount}"
+            multi_stage: true
+            reduce_by:
+                - orders.created_at
+
+          # Non-sum outer aggregation forces the JOIN-model path (not
+          # window-eligible) — exercises the partition_filter site of
+          # cube-js/cube#10854.
+          - name: max_amount_reduce_created_at
+            type: max
+            sql: "{CUBE.total_amount}"
+            multi_stage: true
+            reduce_by:
+                - orders.created_at
+
+          # grain.include also forces the JOIN-model path; bare time-dim
+          # exclude via the grain directive.
+          - name: amount_grain_exclude_created_at_include_category
+            type: sum
+            sql: "{CUBE.total_amount}"
+            multi_stage: true
+            grain:
+                exclude:
+                    - orders.created_at
+                include:
+                    - orders.category
+
           - name: amount_group_by_status
             type: sum
             sql: "{CUBE.total_amount}"

rust/cube/cubesqlplanner/cubesqlplanner/src/tests/integration/multi_stage/group_by.rs

@@ -121,3 +121,41 @@ async fn test_grain_keep_only_status_top_level() {
         insta::assert_snapshot!(result);
     }
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_group_by_time_dim_multiple_granularities() {
+    let ctx = create_context();
+
+    // Regression test mirroring the BigECommerce postgres-driver case (see
+    // packages/cubejs-testing-drivers/src/tests/testQueries.ts
+    // "multi-stage group by time dimension"). The query projects two
+    // granularities of the same time dim (month + week), while the measure
+    // `amount_group_by_status_time` has `group_by: [status, created_at.month]`
+    // — only the month granularity should stay in PARTITION BY.
+    //
+    // Expected: every (month, week) row reports the per-month grand total
+    // (Jan=500, Feb=750, Mar=1000), NOT the per-week sum. If `group_by`
+    // matched via TimeDimensionSymbol → base unwrapping, the week granularity
+    // would also stay in PARTITION BY and the result would collapse to
+    // per-(month, week) sums.
+    let query = indoc! {r#"
+        measures:
+          - orders.amount_group_by_status_time
+        time_dimensions:
+          - dimension: orders.created_at
+            granularity: month
+            dateRange:
+              - "2024-01-01"
+              - "2024-03-31"
+          - dimension: orders.created_at
+            granularity: week
+        order:
+          - id: orders.created_at
+    "#};
+
+    ctx.build_sql(query).unwrap();
+
+    if let Some(result) = ctx.try_execute_pg(query, SEED).await {
+        insta::assert_snapshot!(result);
+    }
+}

rust/cube/cubesqlplanner/cubesqlplanner/src/tests/integration/multi_stage/reduce_by.rs

@@ -343,3 +343,104 @@ async fn test_reduce_by_with_time() {
         insta::assert_snapshot!(result);
     }
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_reduce_by_time_dim() {
+    let ctx = create_context();
+
+    // Regression test for cube-js/cube#10854: `reduce_by: [<time_dim>]` was
+    // silently ignored because `TimeDimensionSymbol::full_name` carries a
+    // granularity suffix (defaulting to "_day" even with no granularity)
+    // while the reduce_by entry resolves to a base DimensionSymbol without
+    // the suffix — string equality at the comparison site failed and the
+    // time dim stayed in PARTITION BY, collapsing each window to a one-row
+    // partition.
+    //
+    // Expected: `amount_reduce_created_at` (sum reducing by created_at)
+    // returns the per-status grand total across all months, not split per
+    // (status, month). Status totals from seed: completed=1400, pending=650,
+    // cancelled=200. With reduce_by working, every row for a given status
+    // shows the same total regardless of month.
+    let query = indoc! {r#"
+        measures:
+          - orders.amount_reduce_created_at
+        dimensions:
+          - orders.status
+        time_dimensions:
+          - dimension: orders.created_at
+            granularity: month
+            dateRange:
+              - "2024-01-01"
+              - "2024-03-31"
+        order:
+          - id: orders.status
+          - id: orders.created_at
+    "#};
+
+    ctx.build_sql(query).unwrap();
+
+    if let Some(result) = ctx.try_execute_pg(query, SEED).await {
+        insta::assert_snapshot!(result);
+    }
+}
+
+// Same bug as test_reduce_by_time_dim, but on the JOIN-model path: a non-sum
+// outer aggregation is not window-eligible, so the grain is applied via
+// partition_filter on the leaf state instead of PARTITION BY. Expected: each
+// status row carries the per-status max across all months.
+#[tokio::test(flavor = "multi_thread")]
+async fn test_reduce_by_time_dim_join_model() {
+    let ctx = create_context();
+
+    let query = indoc! {r#"
+        measures:
+          - orders.max_amount_reduce_created_at
+        dimensions:
+          - orders.status
+        time_dimensions:
+          - dimension: orders.created_at
+            granularity: month
+            dateRange:
+              - "2024-01-01"
+              - "2024-03-31"
+        order:
+          - id: orders.status
+          - id: orders.created_at
+    "#};
+
+    ctx.build_sql(query).unwrap();
+
+    if let Some(result) = ctx.try_execute_pg(query, SEED).await {
+        insta::assert_snapshot!(result);
+    }
+}
+
+// Bare time-dim exclude spelled via the `grain:` directive, with a non-empty
+// include (which forces the JOIN-model path). Expected: per-status totals
+// independent of month.
+#[tokio::test(flavor = "multi_thread")]
+async fn test_grain_exclude_time_dim_join_model() {
+    let ctx = create_context();
+
+    let query = indoc! {r#"
+        measures:
+          - orders.amount_grain_exclude_created_at_include_category
+        dimensions:
+          - orders.status
+        time_dimensions:
+          - dimension: orders.created_at
+            granularity: month
+            dateRange:
+              - "2024-01-01"
+              - "2024-03-31"
+        order:
+          - id: orders.status
+          - id: orders.created_at
+    "#};
+
+    ctx.build_sql(query).unwrap();
+
+    if let Some(result) = ctx.try_execute_pg(query, SEED).await {
+        insta::assert_snapshot!(result);
+    }
+}

rust/cube/cubesqlplanner/cubesqlplanner/src/tests/integration/multi_stage/snapshots/cubesqlplanner__tests__integration__multi_stage__group_by__group_by_time_dim_multiple_granularities.snap

@@ -0,0 +1,18 @@
+---
+source: cubesqlplanner/cubesqlplanner/src/tests/integration/multi_stage/group_by.rs
+expression: result
+---
+orders__created_at_month | orders__created_at_week | orders__amount_group_by_status_time
+-------------------------+-------------------------+------------------------------------
+2024-01-01 00:00:00      | 2024-01-01 00:00:00     | 500.00                             
+2024-01-01 00:00:00      | 2024-01-08 00:00:00     | 500.00                             
+2024-01-01 00:00:00      | 2024-01-15 00:00:00     | 500.00                             
+2024-01-01 00:00:00      | 2024-01-22 00:00:00     | 500.00                             
+2024-02-01 00:00:00      | 2024-01-29 00:00:00     | 750.00                             
+2024-02-01 00:00:00      | 2024-02-05 00:00:00     | 750.00                             
+2024-02-01 00:00:00      | 2024-02-12 00:00:00     | 750.00                             
+2024-02-01 00:00:00      | 2024-02-19 00:00:00     | 750.00                             
+2024-03-01 00:00:00      | 2024-02-26 00:00:00     | 1000.00                            
+2024-03-01 00:00:00      | 2024-03-04 00:00:00     | 1000.00                            
+2024-03-01 00:00:00      | 2024-03-11 00:00:00     | 1000.00                            
+2024-03-01 00:00:00      | 2024-03-18 00:00:00     | 1000.00

rust/cube/cubesqlplanner/cubesqlplanner/src/tests/integration/multi_stage/snapshots/cubesqlplanner__tests__integration__multi_stage__reduce_by__grain_exclude_time_dim_join_model.snap

@@ -0,0 +1,15 @@
+---
+source: cubesqlplanner/cubesqlplanner/src/tests/integration/multi_stage/reduce_by.rs
+expression: result
+---
+orders__status | orders__created_at_month | orders__amount_grain_exclude_created_at_include_category
+---------------+--------------------------+---------------------------------------------------------
+cancelled      | 2024-01-01 00:00:00      | 200.00                                                  
+cancelled      | 2024-02-01 00:00:00      | 200.00                                                  
+cancelled      | 2024-03-01 00:00:00      | 200.00                                                  
+completed      | 2024-01-01 00:00:00      | 1400.00                                                 
+completed      | 2024-02-01 00:00:00      | 1400.00                                                 
+completed      | 2024-03-01 00:00:00      | 1400.00                                                 
+pending        | 2024-01-01 00:00:00      | 650.00                                                  
+pending        | 2024-02-01 00:00:00      | 650.00                                                  
+pending        | 2024-03-01 00:00:00      | 650.00

rust/cube/cubesqlplanner/cubesqlplanner/src/tests/integration/multi_stage/snapshots/cubesqlplanner__tests__integration__multi_stage__reduce_by__reduce_by_time_dim.snap

@@ -0,0 +1,15 @@
+---
+source: cubesqlplanner/src/tests/integration/multi_stage/reduce_by.rs
+expression: result
+---
+orders__status | orders__created_at_month | orders__amount_reduce_created_at
+---------------+--------------------------+---------------------------------
+cancelled      | 2024-01-01 00:00:00      | 200.00                          
+cancelled      | 2024-02-01 00:00:00      | 200.00                          
+cancelled      | 2024-03-01 00:00:00      | 200.00                          
+completed      | 2024-01-01 00:00:00      | 1400.00                         
+completed      | 2024-02-01 00:00:00      | 1400.00                         
+completed      | 2024-03-01 00:00:00      | 1400.00                         
+pending        | 2024-01-01 00:00:00      | 650.00                          
+pending        | 2024-02-01 00:00:00      | 650.00                          
+pending        | 2024-03-01 00:00:00      | 650.00

rust/cube/cubesqlplanner/cubesqlplanner/src/tests/integration/multi_stage/snapshots/cubesqlplanner__tests__integration__multi_stage__reduce_by__reduce_by_time_dim_join_model.snap

@@ -0,0 +1,15 @@
+---
+source: cubesqlplanner/cubesqlplanner/src/tests/integration/multi_stage/reduce_by.rs
+expression: result
+---
+orders__status | orders__created_at_month | orders__max_amount_reduce_created_at
+---------------+--------------------------+-------------------------------------
+cancelled      | 2024-01-01 00:00:00      | 200.00                              
+cancelled      | 2024-02-01 00:00:00      | 200.00                              
+cancelled      | 2024-03-01 00:00:00      | 200.00                              
+completed      | 2024-01-01 00:00:00      | 1400.00                             
+completed      | 2024-02-01 00:00:00      | 1400.00                             
+completed      | 2024-03-01 00:00:00      | 1400.00                             
+pending        | 2024-01-01 00:00:00      | 650.00                              
+pending        | 2024-02-01 00:00:00      | 650.00                              
+pending        | 2024-03-01 00:00:00      | 650.00