feat(tesseract): Basic pre-aggregations support

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

@@ -638,7 +638,7 @@
     }
 
     if (this.useNativeSqlPlanner) {
-      let isRelatedToPreAggregation = false;
+/*       let isRelatedToPreAggregation = false;
       if (this.options.preAggregationQuery) {
         isRelatedToPreAggregation = true;
       } else if (!this.options.disableExternalPreAggregations && this.externalQueryClass) {
@@ -658,7 +658,7 @@
 
       if (isRelatedToPreAggregation) {
         return this.newQueryWithoutNative().buildSqlAndParams(exportAnnotatedSql);
-      }
+      } */
 
       return this.buildSqlAndParamsRust(exportAnnotatedSql);
     }
@@ -698,8 +698,8 @@
       offset: this.options.offset ? this.options.offset.toString() : null,
       baseTools: this,
       ungrouped: this.options.ungrouped,
-      exportAnnotatedSql: exportAnnotatedSql === true
-
+      exportAnnotatedSql: exportAnnotatedSql === true,
+      preAggregationQuery: this.options.preAggregationQuery
     };
 
     const buildResult = nativeBuildSqlAndParams(queryParams);
@@ -715,6 +715,9 @@
     const res = buildResult.result;
     // FIXME
     res[1] = [...res[1]];
+    if (res[2]) {
+      this.preAggregations.preAggregationForQuery = res[2];
+    }
     return res;
   }
 
@@ -738,6 +741,10 @@
     return timeSeriesFromCustomInterval(granularityInterval, dateRange, moment(origin), { timestampPrecision: 3 });
   }
 
+  getPreAggregationByName(cube, preAggregationName) {
+    return this.preAggregations.getRollupPreAggregationByName(cube, preAggregationName);
+  }
+
   get shouldReuseParams() {
     return false;
   }

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

@@ -515,7 +515,7 @@
             transformedQuery.filterDimensionsSingleValueEqual || {},
           )
         ));
-
+    
     const backAlias = (references) => references.map(r => (
       Array.isArray(r) ?
         [transformedQuery.allBackAliasMembers[r[0]] || r[0], r[1]] :
@@ -819,6 +819,29 @@
     )(preAggregations);
   }
 
+  getRollupPreAggregationByName(cube, preAggregationName) {
+    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)
+    )(this.query.cubeEvaluator.preAggregationsForCube(cube));
+    if (preAggregation) {
+      const tableName = this.preAggregationTableName(cube, preAggregation[0], preAggregation[1]);
+      const preAggObj = preAggregation ? this.evaluatedPreAggregationObj(cube, preAggregation[0], preAggregation[1], canUsePreAggregation) : {};
+      return {
+        tableName,
+        ...preAggObj
+      };
+    } else {
+      return {};
+    }
+  }
+
   // TODO check multiplication factor didn't change
   buildRollupJoin(preAggObj, preAggObjsToJoin) {
     return this.query.cacheValue(

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

@@ -516,6 +516,13 @@ export class CubeEvaluator extends CubeSymbols {
     return this.cubeFromPath(path).preAggregations || {};
   }
 
+  public preAggregationsForCubeAsArray(path: string) {
+    return Object.entries(this.cubeFromPath(path).preAggregations || {}).map(([name, preAggregation]) => ({
+      name,
+      ...(preAggregation as Record<string, any>)
+    }));
+  }
+
   /**
    * Returns pre-aggregations filtered by the specified selector.
    */

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

@@ -496,7 +496,7 @@ describe('PreAggregations', () => {
     });
     `);
 
-  it('simple pre-aggregation', () => compiler.compile().then(() => {
+  it('simple pre-aggregation 1', () => compiler.compile().then(() => {
     const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
       measures: [
         'visitors.count'
@@ -513,6 +513,12 @@ describe('PreAggregations', () => {
       preAggregationsSchema: ''
     });
 
+    const queryAndParams = query.buildSqlAndParams();
+    console.log(queryAndParams);
+    console.log("!!!! pre aggrs", query.preAggregations?.preAggregationForQuery);
+    console.log("!!!! pre aggrs fun", query.preAggregations?.preAggregationForQuery.preAggregation);
+    expect(query.preAggregations?.preAggregationForQuery?.canUsePreAggregation).toEqual(true);
+
     return dbRunner.evaluateQueryWithPreAggregations(query).then(res => {
       expect(res).toEqual(
         [
@@ -880,7 +886,7 @@ describe('PreAggregations', () => {
     });
   }));
 
-  it('multiplied measure match', () => compiler.compile().then(() => {
+  it('multiplied measure match 1', () => compiler.compile().then(() => {
     const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
       measures: [
         'visitors.count'

packages/cubejs-schema-compiler/test/integration/utils/BaseDbRunner.ts

@@ -171,8 +171,6 @@ export class BaseDbRunner {
 
   public async evaluateQueryWithPreAggregations(query, seed = this.nextSeed++) {
     const preAggregationsDescription = query.preAggregations?.preAggregationsDescription();
-    // console.log(preAggregationsDescription);
-
     await Promise.all(preAggregationsDescription.map(
       async desc => {
         if (desc.partitionGranularity) {

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_query_options.rs

@@ -61,6 +61,8 @@ pub struct BaseQueryOptionsStatic {
     pub ungrouped: Option<bool>,
     #[serde(rename = "exportAnnotatedSql")]
     pub export_annotated_sql: bool,
+    #[serde(rename = "preAggregationQuery")]
+    pub pre_aggregation_query: Option<bool>,
 }
 
 #[nativebridge::native_bridge(BaseQueryOptionsStatic)]

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs

@@ -1,12 +1,14 @@
 use super::base_query_options::FilterItem;
 use super::filter_group::{FilterGroup, NativeFilterGroup};
 use super::filter_params::{FilterParams, NativeFilterParams};
+use cubenativeutils::wrappers::NativeArray;
 use super::security_context::{NativeSecurityContext, SecurityContext};
 use super::sql_templates_render::{NativeSqlTemplatesRender, SqlTemplatesRender};
+use super::pre_aggregation_obj::{NativePreAggregationObj, PreAggregationObj};
 use super::sql_utils::{NativeSqlUtils, SqlUtils};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
 use cubenativeutils::wrappers::NativeContextHolder;
 use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
@@ -56,6 +58,8 @@
         &self,
         interval: String,
         source: String,
         origin: String,
     ) -> Result<String, CubeError>;
+
+    fn get_pre_aggregation_by_name(&self, cube_name: String, name: String) -> Result<Rc<dyn PreAggregationObj>, CubeError>;
 }

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/evaluator.rs

@@ -4,10 +4,14 @@ use super::dimension_definition::{
 };
 use super::measure_definition::{MeasureDefinition, NativeMeasureDefinition};
 use super::member_sql::{MemberSql, NativeMemberSql};
+use super::pre_aggregation_description::{
+    NativePreAggregationDescription, PreAggregationDescription,
+};
 use super::segment_definition::{NativeSegmentDefinition, SegmentDefinition};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
+use cubenativeutils::wrappers::NativeArray;
 use cubenativeutils::wrappers::NativeContextHolder;
 use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
@@ -51,4 +55,9 @@ pub trait CubeEvaluator {
         sql: Rc<dyn MemberSql>,
     ) -> Result<Vec<CallDep>, CubeError>;
     fn resolve_granularity(&self, path: Vec<String>) -> Result<GranularityDefinition, CubeError>;
+    #[nbridge(vec)]
+    fn pre_aggregations_for_cube_as_array(
+        &self,
+        cube_name: String,
+    ) -> Result<Vec<Rc<dyn PreAggregationDescription>>, CubeError>;
 }

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs

@@ -19,10 +19,12 @@
 pub mod member_definition;
 pub mod member_expression;
 pub mod member_order_by;
 pub mod member_sql;
 pub mod options_member;
+pub mod pre_aggregation_description;
 pub mod security_context;
 pub mod segment_definition;
 pub mod sql_templates_render;
 pub mod sql_utils;
 pub mod struct_with_sql_member;
+pub mod pre_aggregation_obj;

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/pre_aggregation_description.rs

@@ -0,0 +1,32 @@
+use super::member_sql::{MemberSql, NativeMemberSql};
+use cubenativeutils::wrappers::serializer::{
+    NativeDeserialize, NativeDeserializer, NativeSerialize,
+};
+use cubenativeutils::wrappers::NativeArray;
+use cubenativeutils::wrappers::NativeContextHolder;
+use cubenativeutils::wrappers::NativeObjectHandle;
+use cubenativeutils::CubeError;
+use serde::{Deserialize, Serialize};
+use std::any::Any;
+use std::rc::Rc;
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct PreAggregationDescriptionStatic {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub pre_aggregation_type: String,
+    pub granularity: Option<String>,
+    pub external: Option<bool>,
+}
+
+#[nativebridge::native_bridge(PreAggregationDescriptionStatic)]
+pub trait PreAggregationDescription {
+    #[nbridge(field, optional)]
+    fn measure_references(&self) -> Result<Option<Rc<dyn MemberSql>>, CubeError>;
+
+    #[nbridge(field, optional)]
+    fn dimension_references(&self) -> Result<Option<Rc<dyn MemberSql>>, CubeError>;
+
+    #[nbridge(field, optional)]
+    fn time_dimension_reference(&self) -> Result<Option<Rc<dyn MemberSql>>, CubeError>;
+}

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/pre_aggregation_obj.rs

@@ -0,0 +1,26 @@
+use super::member_sql::{MemberSql, NativeMemberSql};
+use cubenativeutils::wrappers::serializer::{
+    NativeDeserialize, NativeDeserializer, NativeSerialize,
+};
+use cubenativeutils::wrappers::NativeArray;
+use cubenativeutils::wrappers::NativeContextHolder;
+use cubenativeutils::wrappers::NativeObjectHandle;
+use cubenativeutils::CubeError;
+use serde::{Deserialize, Serialize};
+use std::any::Any;
+use std::rc::Rc;
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct PreAggregationObjStatic {
+    #[serde(rename = "tableName")]
+    pub table_name: Option<String>,
+    #[serde(rename = "preAggregationName")]
+    pub pre_aggregation_name: Option<String>,
+    pub cube: Option<String>,
+    #[serde(rename = "preAggregationId")]
+    pub pre_aggregation_id: Option<String>,
+}
+
+#[nativebridge::native_bridge(PreAggregationObjStatic)]
+pub trait PreAggregationObj {
+}

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/full_key_aggregate_query.rs

@@ -1,6 +1,6 @@
 use super::*;
-use crate::planner::query_properties::OrderByItem;
 use std::rc::Rc;
+use crate::planner::query_properties::OrderByItem;
 
 pub struct FullKeyAggregateQuery {
     pub multistage_members: Vec<Rc<LogicalMultiStageMember>>,
@@ -11,10 +11,10 @@
     pub ungrouped: bool,
     pub order_by: Vec<OrderByItem>,
     pub source: Rc<FullKeyAggregate>,
 }
 
 impl PrettyPrint for FullKeyAggregateQuery {
-    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
+    fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {  
         result.println("FullKeyAggregateQuery: ", state);
         let state = state.new_level();
         let details_state = state.new_level();
@@ -36,20 +36,13 @@
             result.println(&format!("limit:{}", limit), &state);
         }
         result.println(&format!("ungrouped:{}", self.ungrouped), &state);
         if !self.order_by.is_empty() {
             result.println("order_by:", &state);
             for order_by in self.order_by.iter() {
-                result.println(
-                    &format!(
-                        "{} {}",
-                        order_by.name(),
-                        if order_by.desc() { "desc" } else { "asc" }
-                    ),
-                    &details_state,
-                );
+                result.println(&format!("{} {}", order_by.name(), if order_by.desc() { "desc" } else { "asc" }), &details_state);
             }
         }
         result.println("source:", &state);
         self.source.pretty_print(result, &details_state);
     }
-}
+}

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/mod.rs

@@ -8,12 +8,14 @@ mod join;
 mod keys_subquery;
 mod measure_subquery;
 mod multistage;
-mod pretty_print;
+pub mod pretty_print;
 mod query;
 mod regular_measures_query;
 mod resolve_multiplied_measures;
 mod schema;
 mod simple_query;
+mod pre_aggregation;
+pub mod optimizers;
 
 pub use aggregate_multiplied_subquery::*;
 pub use cube::*;
@@ -31,3 +33,5 @@ pub use regular_measures_query::*;
 pub use resolve_multiplied_measures::*;
 pub use schema::*;
 pub use simple_query::*;
+pub use optimizers::*;
+pub use pre_aggregation::*;