fix

Author: waralexrom

packages/cubejs-schema-compiler/src/adapter/BaseQuery.js

@@ -3487,8 +3487,7 @@ export class BaseQuery {
           });
         } else if (preAggregation.type === 'rollup') {
           const query = this.preAggregations.rollupPreAggregationQuery(cube, preAggregation);
-          const params = query.buildSqlAndParams();
-          return query.evaluateSymbolSqlWithContext(() => params, {
+          return query.evaluateSymbolSqlWithContext(() => query.buildSqlAndParams(), {
             collectOriginalSqlPreAggregations
           });
         } else if (preAggregation.type === 'originalSql') {

packages/cubejs-schema-compiler/src/adapter/PreAggregations.js

@@ -874,12 +874,8 @@ export class PreAggregations {
     const canUsePreAggregation = () => true;
     const preAggregation = R.pipe(
       R.toPairs,
-      // eslint-disable-next-line no-unused-vars
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      R.filter(([k, a]) => a.type === 'rollup' || a.type === 'rollupJoin' || a.type === 'rollupLambda'),
-      // eslint-disable-next-line no-unused-vars
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      R.find(([k, a]) => k === preAggregationName)
+      R.filter(([_, a]) => a.type === 'rollup' || a.type === 'rollupJoin' || a.type === 'rollupLambda'),
+      R.find(([_, a]) => a.name === preAggregationName)
     )(this.query.cubeEvaluator.preAggregationsForCube(cube));
     if (preAggregation) {
       const tableName = this.preAggregationTableName(cube, preAggregation[0], preAggregation[1]);

packages/cubejs-schema-compiler/src/compiler/CubeEvaluator.ts

@@ -520,7 +520,7 @@ export class CubeEvaluator extends CubeSymbols {
     return this.cubeFromPath(path).preAggregations || {};
   }
 
-  public preAggregationsForCubeAsArray(path: string) {
+  public preAggregationsForCubeAsArray(path: string): Record<string, any> {
     return Object.entries(this.cubeFromPath(path).preAggregations || {}).map(([name, preAggregation]) => ({
       name,
       ...(preAggregation as Record<string, any>)

packages/cubejs-schema-compiler/test/integration/postgres/sql-generation.test.ts

@@ -3138,7 +3138,7 @@ SELECT 1 AS revenue,  cast('2024-01-01' AS timestamp) as time UNION ALL
     }]
   ));
 
-  it('multi stage complex graph 111', async () => runQueryTest(
+  it('multi stage complex graph', async () => runQueryTest(
     {
       measures: ['visitors.adjusted_rank_sum', 'visitors.visitor_revenue'],
       dimensions: ['visitors.source'],

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/optimizers/pre_aggregation/compiled_pre_aggregation.rs

@@ -43,7 +43,7 @@ impl CompiledPreAggregation {
     ) -> Result<Rc<Self>, CubeError> {
         let static_data = description.static_data();
         let measures = if let Some(refs) = description.measure_references()? {
-            Self::symbols_from_ref(query_tools.clone(), cube_name, refs, Self::check_if_measure)?
+            Self::symbols_from_ref(query_tools.clone(), cube_name, refs, Self::check_is_measure)?
         } else {
             Vec::new()
         };
@@ -52,7 +52,7 @@ impl CompiledPreAggregation {
                 query_tools.clone(),
                 cube_name,
                 refs,
-                Self::check_if_dimension,
+                Self::check_is_dimension,
             )?
         } else {
             Vec::new()
@@ -62,7 +62,7 @@ impl CompiledPreAggregation {
                 query_tools.clone(),
                 cube_name,
                 refs,
-                Self::check_if_time_dimension,
+                Self::check_is_time_dimension,
             )?;
             /*             if dims.len() != 1 {
                 return Err(CubeError::user(format!(
@@ -107,21 +107,21 @@ impl CompiledPreAggregation {
         Ok(res)
     }
 
-    fn check_if_measure(symbol: &MemberSymbol) -> Result<(), CubeError> {
+    fn check_is_measure(symbol: &MemberSymbol) -> Result<(), CubeError> {
         symbol
             .as_measure()
             .map_err(|_| CubeError::user(format!("Pre-aggregation measure must be a measure")))?;
         Ok(())
     }
 
-    fn check_if_dimension(symbol: &MemberSymbol) -> Result<(), CubeError> {
+    fn check_is_dimension(symbol: &MemberSymbol) -> Result<(), CubeError> {
         symbol.as_dimension().map_err(|_| {
             CubeError::user(format!("Pre-aggregation dimension must be a dimension"))
         })?;
         Ok(())
     }
 
-    fn check_if_time_dimension(symbol: &MemberSymbol) -> Result<(), CubeError> {
+    fn check_is_time_dimension(symbol: &MemberSymbol) -> Result<(), CubeError> {
         let dimension = symbol.as_dimension().map_err(|_| {
             CubeError::user(format!(
                 "Pre-aggregation time dimension must be a dimension"

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/optimizers/pre_aggregation/dimension_matcher.rs

@@ -119,7 +119,7 @@ impl<'a> DimensionMatcher<'a> {
             MemberSymbol::TimeDimension(time_dimension) => {
                 self.try_match_time_dimension(time_dimension, add_to_matched_dimension)
             }
-            MemberSymbol::MemberExpression(_member_expression) => Ok(MatchState::NotMatched), //TODO We not allow to use pre-aggregations with member expressions before sqlapi ready for it
+            MemberSymbol::MemberExpression(_member_expression) => Ok(MatchState::NotMatched), //TODO We don't allow to use pre-aggregations with member expressions before SQL API is ready for it
             _ => Ok(MatchState::NotMatched),
         }
     }

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/optimizers/pre_aggregation/optimizer.rs

@@ -370,7 +370,7 @@ impl PreAggregationOptimizer {
         rewrited_multistage: &mut HashMap<String, bool>,
         pre_aggregation: &Rc<CompiledPreAggregation>,
     ) -> Result<(), CubeError> {
-        if let Some(rewrited) =
+        if let Some(rewritten) =
             self.try_rewrite_query(multi_stage_leaf_measure.query.clone(), pre_aggregation)?
         {
             let new_leaf = MultiStageLeafMeasure {
@@ -380,7 +380,7 @@ impl PreAggregationOptimizer {
                     .render_measure_for_ungrouped
                     .clone(),
                 time_shifts: multi_stage_leaf_measure.time_shifts.clone(),
-                query: rewrited,
+                query: rewritten,
             };
             let new_multistage = Rc::new(LogicalMultiStageMember {
                 name: multi_stage_name.clone(),

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs

@@ -77,7 +77,7 @@ pub fn collect_cube_names(node: &Rc<MemberSymbol>) -> Result<Vec<String>, CubeEr
     Ok(visitor.extract_result())
 }
 
-pub fn collect_cube_names_from_vec(
+pub fn collect_cube_names_from_symbols(
     nodes: &Vec<Rc<MemberSymbol>>,
 ) -> Result<Vec<String>, CubeError> {
     let mut visitor = CubeNamesCollector::new();

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs

@@ -32,7 +32,7 @@ pub struct DimensionSymbol {
     longitude: Option<Rc<SqlCall>>,
     case: Option<DimensionCaseDefinition>,
     definition: Rc<dyn DimensionDefinition>,
-    is_reference: bool, // Is symbol is direct reference to another symbol without any calculations
+    is_reference: bool, // Symbol is a direct reference to another symbol without any calculations
 }
 
 impl DimensionSymbol {
@@ -248,7 +248,7 @@ impl SymbolFactory for DimensionSymbolFactory {
             None
         };
 
-        let is_sql_is_direct_ref = if let Some(sql) = &sql {
+        let is_sql_direct_ref = if let Some(sql) = &sql {
             sql.is_direct_reference()?
         } else {
             false
@@ -304,7 +304,7 @@ impl SymbolFactory for DimensionSymbolFactory {
         let is_multi_stage = definition.static_data().multi_stage.unwrap_or(false);
         let is_reference = !owned_by_cube
             && !is_sub_query
-            && is_sql_is_direct_ref
+            && is_sql_direct_ref
             && case.is_none()
             && latitude.is_none()
             && longitude.is_none()