chore(tesseract): Split filter business model and SQL rendering (cube-js#10828)

Author: waralexrom

rust/cube/cubesqlplanner/cubesqlplanner/src/logical_plan/filter.rs

@@ -1,5 +1,5 @@
 use super::pretty_print::*;
-use crate::plan::{Filter, FilterItem};
+use crate::planner::filter::{Filter, FilterItem};
 use itertools::Itertools;
 
 #[derive(Default)]

rust/cube/cubesqlplanner/cubesqlplanner/src/logical_plan/optimizers/common/helper.rs

@@ -1,7 +1,7 @@
 use itertools::Itertools;
 
 use crate::logical_plan::*;
-use crate::plan::FilterItem;
+use crate::planner::filter::FilterItem;
 use crate::planner::sql_evaluator::MemberSymbol;
 use std::rc::Rc;
 

rust/cube/cubesqlplanner/cubesqlplanner/src/logical_plan/optimizers/pre_aggregation/dimension_matcher.rs

@@ -1,7 +1,5 @@
 use super::CompiledPreAggregation;
-use crate::plan::filter::FilterGroupOperator;
-use crate::plan::FilterItem;
-use crate::planner::filter::BaseFilter;
+use crate::planner::filter::{BaseFilter, FilterGroupOperator, FilterItem};
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::DimensionSymbol;
 use crate::planner::sql_evaluator::MemberSymbol;

rust/cube/cubesqlplanner/cubesqlplanner/src/logical_plan/optimizers/pre_aggregation/optimizer.rs

@@ -2,7 +2,7 @@ use super::PreAggregationsCompiler;
 use super::*;
 use crate::logical_plan::visitor::{LogicalPlanRewriter, NodeRewriteResult};
 use crate::logical_plan::*;
-use crate::plan::FilterItem;
+use crate::planner::filter::FilterItem;
 use crate::planner::filter::FilterOp;
 use crate::planner::join_hints::JoinHints;
 use crate::planner::multi_fact_join_groups::{MeasuresJoinHints, MultiFactJoinGroups};

rust/cube/cubesqlplanner/cubesqlplanner/src/logical_plan/pretty_print.rs

@@ -1,4 +1,4 @@
-use crate::plan::FilterItem;
+use crate::planner::filter::FilterItem;
 use crate::planner::sql_evaluator::MemberSymbol;
 use std::rc::Rc;
 

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

@@ -1,7 +1,8 @@
 use crate::plan::{
-    AliasedExpr, Cte, Expr, Filter, From, FromSource, MemberExpression, OrderBy,
-    QualifiedColumnName, Schema, SchemaColumn, Select, SingleAliasedSource, SingleSource,
+    AliasedExpr, Cte, Expr, From, FromSource, MemberExpression, OrderBy, QualifiedColumnName,
+    Schema, SchemaColumn, Select, SingleAliasedSource, SingleSource,
 };
+use crate::planner::filter::Filter;
 
 use crate::plan::expression::FunctionExpression;
 use crate::planner::query_tools::QueryTools;

rust/cube/cubesqlplanner/cubesqlplanner/src/plan/filter/base_filter.rs

@@ -0,0 +1,38 @@
+use super::ToSql;
+use crate::planner::filter::typed_filter::resolve_base_symbol;
+use crate::planner::filter::BaseFilter;
+use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::sql_nodes::SqlNode;
+use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
+use crate::planner::FiltersContext;
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+impl ToSql for BaseFilter {
+    fn to_sql(
+        &self,
+        visitor: &SqlEvaluatorVisitor,
+        node_processor: Rc<dyn SqlNode>,
+        query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
+        filters_ctx: &FiltersContext,
+    ) -> Result<String, CubeError> {
+        if !filters_ctx.filter_params_columns.is_empty() {
+            let symbol_to_match =
+                resolve_base_symbol(self.raw_member_evaluator_ref()).resolve_reference_chain();
+            if let Some(filter_params_column) = filters_ctx
+                .filter_params_columns
+                .get(&symbol_to_match.full_name())
+            {
+                return self.typed_filter().to_sql_for_filter_params(
+                    filter_params_column,
+                    templates,
+                    filters_ctx,
+                );
+            }
+        }
+        self.typed_filter()
+            .to_sql(visitor, node_processor, query_tools, templates, filters_ctx)
+    }
+}

rust/cube/cubesqlplanner/cubesqlplanner/src/plan/filter/base_segment.rs

@@ -0,0 +1,22 @@
+use super::ToSql;
+use crate::planner::filter::BaseSegment;
+use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::sql_nodes::SqlNode;
+use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
+use crate::planner::FiltersContext;
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+impl ToSql for BaseSegment {
+    fn to_sql(
+        &self,
+        visitor: &SqlEvaluatorVisitor,
+        node_processor: Rc<dyn SqlNode>,
+        _query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
+        _filters_ctx: &FiltersContext,
+    ) -> Result<String, CubeError> {
+        visitor.apply(&self.member_evaluator(), node_processor, templates)
+    }
+}

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

@@ -0,0 +1,86 @@
+use super::ToSql;
+use crate::planner::filter::{Filter, FilterItem};
+use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::sql_nodes::SqlNode;
+use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
+use crate::planner::FiltersContext;
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+impl ToSql for FilterItem {
+    fn to_sql(
+        &self,
+        visitor: &SqlEvaluatorVisitor,
+        node_processor: Rc<dyn SqlNode>,
+        query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
+        filters_ctx: &FiltersContext,
+    ) -> Result<String, CubeError> {
+        let res = match self {
+            FilterItem::Group(group) => {
+                let operator = format!(" {} ", group.operator.to_string());
+                let items_sql = group
+                    .items
+                    .iter()
+                    .map(|itm| {
+                        itm.to_sql(
+                            visitor,
+                            node_processor.clone(),
+                            query_tools.clone(),
+                            templates,
+                            filters_ctx,
+                        )
+                    })
+                    .collect::<Result<Vec<_>, _>>()?
+                    .into_iter()
+                    .filter(|itm| !itm.is_empty())
+                    .collect::<Vec<_>>();
+                if items_sql.is_empty() {
+                    "".to_string()
+                } else {
+                    let result = items_sql.join(&operator);
+                    format!("({})", result)
+                }
+            }
+            FilterItem::Item(item) => {
+                let sql =
+                    item.to_sql(visitor, node_processor, query_tools, templates, filters_ctx)?;
+                format!("({})", sql)
+            }
+            FilterItem::Segment(item) => {
+                let sql =
+                    item.to_sql(visitor, node_processor, query_tools, templates, filters_ctx)?;
+                format!("({})", sql)
+            }
+        };
+        Ok(res)
+    }
+}
+
+impl ToSql for Filter {
+    fn to_sql(
+        &self,
+        visitor: &SqlEvaluatorVisitor,
+        node_processor: Rc<dyn SqlNode>,
+        query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
+        filters_ctx: &FiltersContext,
+    ) -> Result<String, CubeError> {
+        let res = self
+            .items
+            .iter()
+            .map(|itm| {
+                itm.to_sql(
+                    visitor,
+                    node_processor.clone(),
+                    query_tools.clone(),
+                    templates,
+                    filters_ctx,
+                )
+            })
+            .collect::<Result<Vec<_>, _>>()?
+            .join(" AND ");
+        Ok(res)
+    }
+}

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

@@ -0,0 +1,10 @@
+pub mod base_filter;
+pub mod base_segment;
+pub mod filter;
+pub(crate) mod operators;
+pub mod render_filter;
+pub mod to_sql;
+pub mod typed_filter;
+
+pub use render_filter::{render_filter, render_filter_item};
+pub use to_sql::ToSql;