in work

Author: waralexrom

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

@@ -628,6 +628,30 @@ export class BaseQuery {
     return res;
   }
 
+  buildSqlAndParamsTest(exportAnnotatedSql) {
+    if (!this.options.preAggregationQuery && !this.options.disableExternalPreAggregations && this.externalQueryClass) {
+      if (this.externalPreAggregationQuery()) { // TODO performance
+        return this.externalQuery().buildSqlAndParams(exportAnnotatedSql);
+      }
+    }
+    const js_res = this.compilers.compiler.withQuery(
+      this,
+      () => this.cacheValue(
+        ['buildSqlAndParams', exportAnnotatedSql],
+        () => this.paramAllocator.buildSqlAndParams(
+          this.buildParamAnnotatedSql(),
+          exportAnnotatedSql,
+          this.shouldReuseParams
+        ),
+        { cache: this.queryCache }
+      )
+    );
+    const rust = this.buildSqlAndParamsRust(exportAnnotatedSql);
+    console.log('js result: ', js_res[0]);
+    console.log('rust result: ', rust[0]);
+    return js_res;
+  }
+
   get shouldReuseParams() {
     return false;
   }

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/sql_templates_render.rs

@@ -9,6 +9,7 @@ use std::marker::PhantomData;
 pub trait SqlTemplatesRender {
     fn contains_template(&self, template_name: &str) -> bool;
     fn render_template(&self, name: &str, ctx: Value) -> Result<String, CubeError>;
+    fn get_template(&self, template_name: &str) -> Result<&String, CubeError>;
 }
 
 pub struct NativeSqlTemplatesRender<IT: InnerTypes> {
@@ -44,6 +45,12 @@ impl<IT: InnerTypes> SqlTemplatesRender for NativeSqlTemplatesRender<IT> {
         self.templates.contains_key(template_name)
     }
 
+    fn get_template(&self, template_name: &str) -> Result<&String, CubeError> {
+        self.templates
+            .get(template_name)
+            .ok_or_else(|| CubeError::user("{template_name} template not found".to_string()))
+    }
+
     fn render_template(&self, name: &str, ctx: Value) -> Result<String, CubeError> {
         Ok(self
             .jinja

rust/cubesqlplanner/cubesqlplanner/src/plan/expression.rs

@@ -1,3 +1,4 @@
+use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::{BaseMember, VisitorContext};
 use cubenativeutils::CubeError;
 use std::rc::Rc;
@@ -10,9 +11,16 @@ pub enum Expr {
 }
 
 impl Expr {
-    pub fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
+    pub fn to_sql(
+        &self,
+        templates: &PlanSqlTemplates,
+        context: Rc<VisitorContext>,
+    ) -> Result<String, CubeError> {
         match self {
-            Expr::Field(field) => field.to_sql(context),
+            Expr::Field(field) => {
+                let sql = field.to_sql(context)?;
+                Ok(sql)
+            }
             Expr::Reference(cube_alias, field_alias) => {
                 if let Some(cube_alias) = cube_alias {
                     Ok(format!("{}.{}", cube_alias, field_alias))

rust/cubesqlplanner/cubesqlplanner/src/plan/from.rs

@@ -1,15 +1,27 @@
 use super::{Join, QueryPlan, Subquery};
+use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::{BaseCube, VisitorContext};
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
+#[derive(Clone)]
+pub enum SingleSource {
+    Subquery(Subquery),
+    Cube(Rc<BaseCube>),
+    TableReference(String),
+}
+
+#[derive(Clone)]
+pub struct SingleAliasedSource {
+    source: SingleSource,
+    alias: Option<String>,
+}
+
 #[derive(Clone)]
 pub enum FromSource {
     Empty,
-    Cube(Rc<BaseCube>),
+    Single(SingleAliasedSource),
     Join(Rc<Join>),
-    Subquery(Subquery),
-    TableReference(String, Option<String>),
 }
 
 #[derive(Clone)]
@@ -38,17 +50,21 @@ impl From {
         Self::new(FromSource::Subquery(Subquery::new(plan, alias)))
     }
 
-    pub fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
+    pub fn to_sql(
+        &self,
+        templates: &PlanSqlTemplates,
+        context: Rc<VisitorContext>,
+    ) -> Result<String, CubeError> {
         let sql = match &self.source {
             FromSource::Empty => format!(""),
             FromSource::Cube(cube) => {
                 let cubesql = cube.to_sql(context.clone())?;
                 format!("      {} ", cubesql)
             }
             FromSource::Join(j) => {
-                format!("{}", j.to_sql(context.clone())?)
+                format!("{}", j.to_sql(templates, context.clone())?)
             }
-            FromSource::Subquery(s) => s.to_sql()?,
+            FromSource::Subquery(s) => s.to_sql(templates)?,
             FromSource::TableReference(r, alias) => {
                 if let Some(alias) = alias {
                     format!(" {} as {} ", r, alias)

rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs

@@ -1,4 +1,5 @@
-use super::{QueryPlan, Select, Subquery};
+use super::{QueryPlan, Select, SingleAliasedSource, Subquery};
+use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::{BaseCube, BaseJoinCondition, VisitorContext};
 use cubenativeutils::CubeError;
 
@@ -27,53 +28,65 @@ impl JoinSource {
         Self::TableReference(reference, alias)
     }
 
-    pub fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
+    pub fn to_sql(
+        &self,
+        templates: &PlanSqlTemplates,
+        context: Rc<VisitorContext>,
+    ) -> Result<String, CubeError> {
         let sql = match &self {
             JoinSource::Cube(cube) => {
                 let cubesql = cube.to_sql(context.clone())?;
                 format!(" {} ", cubesql)
             }
-            JoinSource::Subquery(s) => s.to_sql()?,
+            JoinSource::Subquery(s) => s.to_sql(templates)?,
             JoinSource::TableReference(r, alias) => format!(" {} as {} ", r, alias),
         };
         Ok(sql)
     }
 }
 
 pub struct JoinItem {
-    pub from: JoinSource,
+    pub from: SingleAliasedSource,
     pub on: Rc<dyn BaseJoinCondition>,
     pub is_inner: bool,
 }
 
 pub struct Join {
-    pub root: JoinSource,
+    pub root: SingleAliasedSource,
     pub joins: Vec<JoinItem>,
 }
 
 impl JoinItem {
-    pub fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
+    pub fn to_sql(
+        &self,
+        templates: &PlanSqlTemplates,
+        context: Rc<VisitorContext>,
+    ) -> Result<String, CubeError> {
         let operator = if self.is_inner { "INNER" } else { "LEFT" };
         let on_sql = self.on.to_sql(context.clone())?;
         Ok(format!(
             "{} JOIN {} ON {}",
             operator,
-            self.from.to_sql(context)?,
+            self.from.to_sql(templates, context)?,
             on_sql
         ))
     }
 }
 
 impl Join {
-    pub fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
+    pub fn to_sql(
+        &self,
+        templates: &PlanSqlTemplates,
+        context: Rc<VisitorContext>,
+    ) -> Result<String, CubeError> {
         let joins_sql = self
             .joins
             .iter()
-            .map(|j| j.to_sql(context.clone()))
+            .map(|j| j.to_sql(templates, context.clone()))
             .collect::<Result<Vec<_>, _>>()?;
         let res = format!(
             "{}\n{}",
-            self.root.to_sql(context.clone())?,
+            self.root.to_sql(templates, context.clone())?,
             joins_sql.join("\n")
         );
         Ok(res)

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

@@ -5,16 +5,19 @@ pub mod from;
 pub mod join;
 pub mod order;
 pub mod query_plan;
+pub mod schema;
 pub mod select;
+pub mod select_builder;
 pub mod subquery;
 pub mod union;
 
 pub use expression::Expr;
 pub use filter::{Filter, FilterGroup, FilterItem};
-pub use from::{From, FromSource};
+pub use from::{From, FromSource, SingleAliasedSource};
 pub use join::{Join, JoinItem, JoinSource};
 pub use order::OrderBy;
 pub use query_plan::QueryPlan;
 pub use select::Select;
+pub use select_builder::SelectBuilder;
 pub use subquery::Subquery;
 pub use union::Union;

rust/cubesqlplanner/cubesqlplanner/src/plan/query_plan.rs

@@ -1,5 +1,6 @@
 use super::Select;
 use super::Union;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -9,10 +10,10 @@ pub enum QueryPlan {
 }
 
 impl QueryPlan {
-    pub fn to_sql(&self) -> Result<String, CubeError> {
+    pub fn to_sql(&self, templates: &PlanSqlTemplates) -> Result<String, CubeError> {
         match self {
-            QueryPlan::Select(s) => s.to_sql(),
-            QueryPlan::Union(u) => u.to_sql(),
+            QueryPlan::Select(s) => s.to_sql(templates),
+            QueryPlan::Union(u) => u.to_sql(templates),
         }
     }
 }

rust/cubesqlplanner/cubesqlplanner/src/plan/schema.rs

@@ -0,0 +1,18 @@
+use cubenativeutils::CubeError;
+
+pub struct SchemaColumn {
+    table_name: String,
+    name: String,
+    origin_member: String,
+}
+
+impl SchemaColumn {
+    pub fn new(table_name: String, name: String, origin_member: String) -> Self {
+        Self {
+            table_name,
+            name,
+            origin_member,
+        }
+    }
+}
+pub struct Schema {}

rust/cubesqlplanner/cubesqlplanner/src/plan/select.rs

@@ -1,30 +1,31 @@
 use itertools::Itertools;
 
 use super::{Expr, Filter, From, OrderBy, Subquery};
+use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::VisitorContext;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
 pub struct Select {
-    pub projection: Vec<Expr>,
-    pub from: From,
-    pub filter: Option<Filter>,
-    pub group_by: Vec<Expr>,
-    pub having: Option<Filter>,
-    pub order_by: Vec<OrderBy>,
-    pub context: Rc<VisitorContext>,
-    pub ctes: Vec<Rc<Subquery>>,
-    pub is_distinct: bool,
-    pub limit: Option<usize>,
-    pub offset: Option<usize>,
+    pub(super) projection: Vec<Expr>,
+    pub(super) from: From,
+    pub(super) filter: Option<Filter>,
+    pub(super) group_by: Vec<Expr>,
+    pub(super) having: Option<Filter>,
+    pub(super) order_by: Vec<OrderBy>,
+    pub(super) context: Rc<VisitorContext>,
+    pub(super) ctes: Vec<Rc<Subquery>>,
+    pub(super) is_distinct: bool,
+    pub(super) limit: Option<usize>,
+    pub(super) offset: Option<usize>,
 }
 
 impl Select {
-    pub fn to_sql(&self) -> Result<String, CubeError> {
+    pub fn to_sql(&self, templates: &PlanSqlTemplates) -> Result<String, CubeError> {
         let projection = self
             .projection
             .iter()
-            .map(|p| p.to_sql(self.context.clone()))
+            .map(|p| p.to_sql(templates, self.context.clone()))
             .collect::<Result<Vec<_>, _>>()?
             .join(", ");
         let where_condition = if let Some(filter) = &self.filter {
@@ -56,7 +57,11 @@ impl Select {
                 .ctes
                 .iter()
                 .map(|cte| -> Result<_, CubeError> {
-                    Ok(format!(" {} as ({})", cte.alias(), cte.query().to_sql()?))
+                    Ok(format!(
+                        " {} as ({})",
+                        cte.alias(),
+                        cte.query().to_sql(templates)?
+                    ))
                 })
                 .collect::<Result<Vec<_>, _>>()?
                 .join(",\n");
@@ -78,7 +83,7 @@ impl Select {
         };
 
         let distinct = if self.is_distinct { "DISTINCT " } else { "" };
-        let from = self.from.to_sql(self.context.clone())?;
+        let from = self.from.to_sql(templates, self.context.clone())?;
         let limit = if let Some(limit) = self.limit {
             format!(" LIMIT {limit}")
         } else {