feat(tesseract): Basic pre-aggregations support

Author: waralexrom

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

@@ -638,7 +638,7 @@ export class BaseQuery {
     }
 
     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 @@ export class BaseQuery {
 
       if (isRelatedToPreAggregation) {
         return this.newQueryWithoutNative().buildSqlAndParams(exportAnnotatedSql);
-      }
+      } */
 
       return this.buildSqlAndParamsRust(exportAnnotatedSql);
     }
@@ -697,8 +697,8 @@ export class BaseQuery {
       rowLimit: this.options.rowLimit ? this.options.rowLimit.toString() : null,
       offset: this.options.offset ? this.options.offset.toString() : null,
       baseTools: this,
-      ungrouped: this.options.ungrouped
-
+      ungrouped: this.options.ungrouped,
+      preAggregationQuery: this.options.preAggregationQuery
     };
     const buildResult = nativeBuildSqlAndParams(queryParams);
 

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

@@ -515,7 +515,7 @@ export class PreAggregations {
             transformedQuery.filterDimensionsSingleValueEqual || {},
           )
         ));
-
+    
     const backAlias = (references) => references.map(r => (
       Array.isArray(r) ?
         [transformedQuery.allBackAliasMembers[r[0]] || r[0], r[1]] :

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

@@ -489,6 +489,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

@@ -230,11 +230,11 @@ describe('PreAggregations', () => {
           granularity: 'hour',
           partitionGranularity: 'month'
         },
-        countCustomGranularity: {
+/*         countCustomGranularity: {
           measures: [count],
           timeDimension: createdAt,
           granularity: 'hourTenMinOffset'
-        },
+        }, */
         sourceAndIdRollup: {
           measures: [count],
           dimensions: [sourceAndId, source],
@@ -517,7 +517,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'
@@ -534,6 +534,13 @@ 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);
+    console.log("!!!! pre aggrs fun 2", query.preAggregations?.preAggregationForQuery.preAggregation.dimensionReferences.toString());
+    expect(query.preAggregations?.preAggregationForQuery?.canUsePreAggregation).toEqual(true);
+
     return dbRunner.evaluateQueryWithPreAggregations(query).then(res => {
       expect(res).toEqual(
         [

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

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

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

@@ -21,6 +21,7 @@ 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;

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/plan/mod.rs

@@ -4,6 +4,7 @@ pub mod expression;
 pub mod filter;
 pub mod from;
 pub mod join;
+pub mod optimizer;
 pub mod order;
 pub mod query_plan;
 pub mod schema;

rust/cubesqlplanner/cubesqlplanner/src/plan/optimizer/collectors/mod.rs

@@ -0,0 +1,3 @@
+mod symbols;
+
+pub use symbols::*;