chore(tesseract): Split member symbol business model and SQL rendering (cube-js#10835)

Author: waralexrom

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

@@ -9,6 +9,7 @@ pub mod order;
 pub mod query_plan;
 pub mod schema;
 pub mod select;
+pub mod symbols;
 pub mod time_series;
 pub mod union;
 

rust/cube/cubesqlplanner/cubesqlplanner/src/plan/symbols/dimension_kinds/case_dimension.rs

@@ -0,0 +1,16 @@
+use super::super::{MemberSqlContext, ToSql};
+use crate::planner::sql_evaluator::symbols::dimension_kinds::CaseDimension;
+use cubenativeutils::CubeError;
+
+impl ToSql for CaseDimension {
+    fn to_sql(&self, ctx: &MemberSqlContext) -> Result<String, CubeError> {
+        if let Some(member_sql) = self.member_sql() {
+            ctx.eval_sql_call(member_sql)
+        } else {
+            Err(CubeError::internal(format!(
+                "Dimension {} has no sql evaluator",
+                ctx.full_name
+            )))
+        }
+    }
+}

rust/cube/cubesqlplanner/cubesqlplanner/src/plan/symbols/dimension_kinds/mod.rs

@@ -0,0 +1,21 @@
+pub mod case_dimension;
+pub mod regular;
+pub mod switch;
+
+use super::{MemberSqlContext, ToSql};
+use crate::planner::sql_evaluator::DimensionKind;
+use cubenativeutils::CubeError;
+
+impl ToSql for DimensionKind {
+    fn to_sql(&self, ctx: &MemberSqlContext) -> Result<String, CubeError> {
+        match self {
+            Self::Regular(r) => r.to_sql(ctx),
+            Self::Geo(_) => Err(CubeError::internal(format!(
+                "Geo dimension {} doesn't support evaluate_sql directly",
+                ctx.full_name
+            ))),
+            Self::Switch(s) => s.to_sql(ctx),
+            Self::Case(c) => c.to_sql(ctx),
+        }
+    }
+}

rust/cube/cubesqlplanner/cubesqlplanner/src/plan/symbols/dimension_kinds/regular.rs

@@ -0,0 +1,9 @@
+use super::super::{MemberSqlContext, ToSql};
+use crate::planner::sql_evaluator::symbols::dimension_kinds::RegularDimension;
+use cubenativeutils::CubeError;
+
+impl ToSql for RegularDimension {
+    fn to_sql(&self, ctx: &MemberSqlContext) -> Result<String, CubeError> {
+        ctx.eval_sql_call(self.member_sql())
+    }
+}

rust/cube/cubesqlplanner/cubesqlplanner/src/plan/symbols/dimension_kinds/switch.rs

@@ -0,0 +1,13 @@
+use super::super::{MemberSqlContext, ToSql};
+use crate::planner::sql_evaluator::symbols::dimension_kinds::SwitchDimension;
+use cubenativeutils::CubeError;
+
+impl ToSql for SwitchDimension {
+    fn to_sql(&self, ctx: &MemberSqlContext) -> Result<String, CubeError> {
+        if let Some(member_sql) = self.member_sql() {
+            ctx.eval_sql_call(member_sql)
+        } else {
+            ctx.templates.quote_identifier(ctx.name)
+        }
+    }
+}

rust/cube/cubesqlplanner/cubesqlplanner/src/plan/symbols/dimension_symbol.rs

@@ -0,0 +1,9 @@
+use super::{MemberSqlContext, ToSql};
+use crate::planner::sql_evaluator::DimensionSymbol;
+use cubenativeutils::CubeError;
+
+impl ToSql for DimensionSymbol {
+    fn to_sql(&self, ctx: &MemberSqlContext) -> Result<String, CubeError> {
+        self.kind().to_sql(ctx)
+    }
+}

rust/cube/cubesqlplanner/cubesqlplanner/src/plan/symbols/measure_kinds/aggregated.rs

@@ -0,0 +1,14 @@
+use super::super::{MemberSqlContext, ToSql};
+use crate::planner::sql_evaluator::symbols::measure_kinds::AggregatedMeasure;
+use cubenativeutils::CubeError;
+
+impl ToSql for AggregatedMeasure {
+    fn to_sql(&self, ctx: &MemberSqlContext) -> Result<String, CubeError> {
+        match self.member_sql() {
+            Some(sql) => ctx.eval_sql_call(sql),
+            None => Err(CubeError::internal(
+                "Aggregated measure without sql cannot be evaluated directly".to_string(),
+            )),
+        }
+    }
+}

rust/cube/cubesqlplanner/cubesqlplanner/src/plan/symbols/measure_kinds/calculated.rs

@@ -0,0 +1,14 @@
+use super::super::{MemberSqlContext, ToSql};
+use crate::planner::sql_evaluator::symbols::measure_kinds::CalculatedMeasure;
+use cubenativeutils::CubeError;
+
+impl ToSql for CalculatedMeasure {
+    fn to_sql(&self, ctx: &MemberSqlContext) -> Result<String, CubeError> {
+        match self.member_sql() {
+            Some(sql) => ctx.eval_sql_call(sql),
+            None => Err(CubeError::internal(
+                "Calculated measure without sql cannot be evaluated directly".to_string(),
+            )),
+        }
+    }
+}

rust/cube/cubesqlplanner/cubesqlplanner/src/plan/symbols/measure_kinds/count.rs

@@ -0,0 +1,27 @@
+use super::super::{MemberSqlContext, ToSql};
+use crate::planner::sql_evaluator::symbols::measure_kinds::{CountMeasure, CountSql};
+use cubenativeutils::CubeError;
+
+impl ToSql for CountMeasure {
+    fn to_sql(&self, ctx: &MemberSqlContext) -> Result<String, CubeError> {
+        match self.sql() {
+            CountSql::Explicit(sql) => ctx.eval_sql_call(sql),
+            CountSql::Auto(pk_sqls) => {
+                if pk_sqls.len() > 1 {
+                    let pk_strings = pk_sqls
+                        .iter()
+                        .map(|pk| -> Result<_, CubeError> {
+                            let res = ctx.eval_sql_call(pk)?;
+                            ctx.templates.cast_to_string(&res)
+                        })
+                        .collect::<Result<Vec<_>, _>>()?;
+                    ctx.templates.concat_strings(&pk_strings)
+                } else if let Some(pk_sql) = pk_sqls.first() {
+                    ctx.eval_sql_call(pk_sql)
+                } else {
+                    Ok("*".to_string())
+                }
+            }
+        }
+    }
+}

rust/cube/cubesqlplanner/cubesqlplanner/src/plan/symbols/measure_kinds/mod.rs

@@ -0,0 +1,21 @@
+pub mod aggregated;
+pub mod calculated;
+pub mod count;
+
+use super::{MemberSqlContext, ToSql};
+use crate::planner::sql_evaluator::MeasureKind;
+use cubenativeutils::CubeError;
+
+impl ToSql for MeasureKind {
+    fn to_sql(&self, ctx: &MemberSqlContext) -> Result<String, CubeError> {
+        match self {
+            Self::Count(c) => c.to_sql(ctx),
+            Self::Aggregated(a) => a.to_sql(ctx),
+            Self::Calculated(c) => c.to_sql(ctx),
+            Self::Rank => Err(CubeError::internal(format!(
+                "Rank measure doesn't support direct evaluation for {}",
+                ctx.full_name
+            ))),
+        }
+    }
+}