in work

Author: waralexrom

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

@@ -1404,7 +1404,7 @@ export class PreAggregations {
     if (tables.length === 1) {
       return tables[0].tableName;
     }
-    const union = tables.map(table => `SELECT ${table.columns.join(', ')} FROM ${table.tableName}`).join(' UNION ALL ');
+    const union = tables.map(table => `SELECT ${table.columns.join(', ')} FROM ${table.tableName} un`).join(' UNION ALL ');
     return `(${union})`;
   }
 

packages/cubejs-schema-compiler/test/integration/postgres/pre-aggregations.test.ts

@@ -577,7 +577,7 @@ describe('PreAggregations', () => {
     });
     `);
 
-  it('simple pre-aggregation', async () => {
+  it('simple pre-aggregation 1', async () => {
     await compiler.compile();
 
     const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
@@ -2194,7 +2194,7 @@ describe('PreAggregations', () => {
     });
   });
 
-  if (getEnv('nativeSqlPlanner') && getEnv('nativeSqlPlannerPreAggregations')) {
+  if (true) { //getEnv('nativeSqlPlanner') && getEnv('nativeSqlPlannerPreAggregations')) {
     it('rollup lambda', async () => {
       await compiler.compile();
 

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

@@ -25,6 +25,7 @@ pub struct PreAggregationUnion {
 #[derive(Clone)]
 pub struct PreAggregationTable {
     pub cube_name: String,
+    pub cube_alias: String,
     pub name: String,
     pub alias: Option<String>,
 }

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

@@ -157,8 +157,18 @@ impl PreAggregationsCompiler {
         let source = if static_data.pre_aggregation_type == "rollupJoin" {
             PreAggregationSource::Join(self.build_join_source(&measures, &dimensions, &rollups)?)
         } else {
+            let cube = self
+                .query_tools
+                .cube_evaluator()
+                .cube_from_path(name.cube_name.clone())?;
+            let cube_alias = if let Some(alias) = &cube.static_data().sql_alias {
+                alias.clone()
+            } else {
+                name.cube_name.clone()
+            };
             PreAggregationSource::Single(PreAggregationTable {
                 cube_name: name.cube_name.clone(),
+                cube_alias,
                 name: name.name.clone(),
                 alias: static_data.sql_alias.clone(),
             })

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

@@ -1,8 +1,8 @@
 use super::*;
-use crate::planner::sql_evaluator::MemberSymbol;
+use crate::{plan::QualifiedColumnName, planner::sql_evaluator::MemberSymbol};
 use cubenativeutils::CubeError;
 use itertools::Itertools;
-use std::rc::Rc;
+use std::{collections::HashMap, rc::Rc};
 
 pub struct PreAggregation {
     pub name: String,
@@ -42,6 +42,63 @@ impl LogicalNode for PreAggregation {
     }
 }
 
+impl PreAggregation {
+    pub fn all_dimensions_refererences(&self) -> HashMap<String, QualifiedColumnName> {
+        let mut res = HashMap::new();
+
+        for dim in self.dimensions.iter() {
+            let alias = dim.alias();
+            res.insert(
+                dim.full_name(),
+                QualifiedColumnName::new(None, alias.clone()),
+            );
+        }
+        for (dim, granularity) in self.time_dimensions.iter() {
+            let base_symbol = if let Ok(td) = dim.as_time_dimension() {
+                td.base_symbol().clone()
+            } else {
+                dim.clone()
+            };
+            let suffix = if let Some(granularity) = &granularity {
+                format!("_{}", granularity.clone())
+            } else {
+                "".to_string()
+            };
+            let alias = format!("{}{}", base_symbol.alias(), suffix);
+            res.insert(
+                dim.full_name(),
+                QualifiedColumnName::new(None, alias.clone()),
+            );
+        }
+
+        if let PreAggregationSource::Join(join) = self.source.as_ref() {
+            for item in join.items.iter() {
+                for member in item.from_members.iter().chain(item.to_members.iter()) {
+                    let alias = member.alias();
+                    res.insert(
+                        member.full_name(),
+                        QualifiedColumnName::new(None, alias.clone()),
+                    );
+                }
+            }
+        }
+
+        res
+    }
+    pub fn all_measures_refererences(&self) -> HashMap<String, QualifiedColumnName> {
+        self.measures
+            .iter()
+            .map(|measure| {
+                let alias = measure.alias();
+                (
+                    measure.full_name(),
+                    QualifiedColumnName::new(None, alias.clone()),
+                )
+            })
+            .collect()
+    }
+}
+
 impl PrettyPrint for PreAggregation {
     fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
         result.println("PreAggregation: ", state);