filter_group in segments

Author: waralexrom

rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs

@@ -129,6 +129,7 @@ impl BaseDimension {
             name.clone(),
             MemberExpressionExpression::SqlCall(expression),
             member_expression_definition.clone(),
+            query_tools.base_tools().clone(),
         )?;
         let full_name = member_expression_symbol.full_name();
         let member_evaluator = Rc::new(MemberSymbol::MemberExpression(member_expression_symbol));

rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs

@@ -136,6 +136,7 @@ impl BaseMeasure {
             name.clone(),
             expression,
             member_expression_definition.clone(),
+            query_tools.base_tools().clone(),
         )?;
         let full_name = member_expression_symbol.full_name();
         let member_evaluator = Rc::new(MemberSymbol::MemberExpression(member_expression_symbol));

rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_segment.rs

@@ -1,5 +1,7 @@
 use crate::planner::query_tools::QueryTools;
-use crate::planner::sql_evaluator::{MemberExpressionExpression, MemberExpressionSymbol, MemberSymbol, SqlCall};
+use crate::planner::sql_evaluator::{
+    MemberExpressionExpression, MemberExpressionSymbol, MemberSymbol, SqlCall,
+};
 use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::{evaluate_with_context, VisitorContext};
 use cubenativeutils::CubeError;
@@ -27,8 +29,13 @@ impl BaseSegment {
         full_name: Option<String>,
         query_tools: Rc<QueryTools>,
     ) -> Result<Rc<Self>, CubeError> {
-        let member_expression_symbol =
-            MemberExpressionSymbol::try_new(cube_name.clone(), name.clone(), MemberExpressionExpression::SqlCall(expression), None)?;
+        let member_expression_symbol = MemberExpressionSymbol::try_new(
+            cube_name.clone(),
+            name.clone(),
+            MemberExpressionExpression::SqlCall(expression),
+            None,
+            query_tools.base_tools().clone(),
+        )?;
         let full_name = full_name.unwrap_or(member_expression_symbol.full_name());
         let member_evaluator = Rc::new(MemberSymbol::MemberExpression(member_expression_symbol));
 

rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs

@@ -142,6 +142,7 @@ impl QueryTools {
         };
         let evaluator_compiler = Rc::new(RefCell::new(Compiler::new(
             cube_evaluator.clone(),
+            base_tools.clone(),
             timezone.clone(),
         )));
         Ok(Rc::new(Self {

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs

@@ -5,6 +5,7 @@ use super::{
     CubeNameSymbolFactory, CubeTableSymbolFactory, DimensionSymbolFactory, MeasureSymbolFactory,
     SqlCall, SymbolFactory, TraversalVisitor,
 };
+use crate::cube_bridge::base_tools::BaseTools;
 use crate::cube_bridge::evaluator::CubeEvaluator;
 use crate::cube_bridge::join_hints::JoinHintItem;
 use crate::cube_bridge::member_sql::MemberSql;
@@ -14,15 +15,21 @@ use std::collections::HashMap;
 use std::rc::Rc;
 pub struct Compiler {
     cube_evaluator: Rc<dyn CubeEvaluator>,
+    base_tools: Rc<dyn BaseTools>,
     timezone: Tz,
     /* (type, name) */
     members: HashMap<(String, String), Rc<MemberSymbol>>,
 }
 
 impl Compiler {
-    pub fn new(cube_evaluator: Rc<dyn CubeEvaluator>, timezone: Tz) -> Self {
+    pub fn new(
+        cube_evaluator: Rc<dyn CubeEvaluator>,
+        base_tools: Rc<dyn BaseTools>,
+        timezone: Tz,
+    ) -> Self {
         Self {
             cube_evaluator,
+            base_tools,
             timezone,
             members: HashMap::new(),
         }
@@ -45,6 +52,10 @@ impl Compiler {
         }
     }
 
+    pub fn base_tools(&self) -> Rc<dyn BaseTools> {
+        self.base_tools.clone()
+    }
+
     pub fn add_measure_evaluator(
         &mut self,
         measure: String,

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs

@@ -4,6 +4,7 @@ use super::dependecy::{
 use super::sql_nodes::SqlNode;
 use super::{symbols::MemberSymbol, SqlEvaluatorVisitor};
 use crate::cube_bridge::base_query_options::FilterItem as NativeFilterItem;
+use crate::cube_bridge::base_tools::BaseTools;
 use crate::cube_bridge::member_sql::{ContextSymbolArg, MemberSql, MemberSqlArg, MemberSqlStruct};
 use crate::plan::{Filter, FilterItem};
 use crate::planner::query_tools::QueryTools;
@@ -45,7 +46,7 @@ impl SqlCall {
         self.member_sql.call(args)
     }
 
-    pub fn is_direct_reference(&self) -> Result<bool, CubeError> {
+    pub fn is_direct_reference(&self, base_tools: Rc<dyn BaseTools>) -> Result<bool, CubeError> {
         let dependencies = self.get_dependencies();
         if dependencies.len() != 1 {
             return Ok(false);
@@ -56,7 +57,7 @@ impl SqlCall {
         let args = self
             .deps
             .iter()
-            .map(|d| self.evaluate_single_dep_for_ref_check(&d))
+            .map(|d| self.evaluate_single_dep_for_ref_check(&d, base_tools.clone()))
             .collect::<Result<Vec<_>, _>>()?;
         let eval_result = self.member_sql.call(args)?;
 
@@ -190,14 +191,34 @@ impl SqlCall {
     fn evaluate_single_dep_for_ref_check(
         &self,
         dep: &Dependency,
+        base_tools: Rc<dyn BaseTools>,
     ) -> Result<MemberSqlArg, CubeError> {
         match dep {
             Dependency::SymbolDependency(dep) => Ok(MemberSqlArg::String(dep.full_name())),
             Dependency::TimeDimensionDependency(dep) => {
                 self.evaluate_time_dimesion_dep_for_ref_check(dep)
             }
             Dependency::CubeDependency(dep) => self.evaluate_cube_dep_for_ref_check(dep),
-            Dependency::ContextDependency(_) => Ok(MemberSqlArg::String(format!("Context Symbol"))),
+            Dependency::ContextDependency(dep) => match dep {
+                ContextSymbolDep::SecurityContext => Ok(MemberSqlArg::ContextSymbol(
+                    ContextSymbolArg::SecurityContext(base_tools.security_context_for_rust()?),
+                )),
+                ContextSymbolDep::FilterParams => {
+                    let r = base_tools.filters_proxy_for_rust(None)?;
+                    Ok(MemberSqlArg::ContextSymbol(ContextSymbolArg::FilterParams(
+                        r,
+                    )))
+                }
+                ContextSymbolDep::FilterGroup => {
+                    let r = base_tools.filter_group_function_for_rust(None)?;
+                    Ok(MemberSqlArg::ContextSymbol(ContextSymbolArg::FilterGroup(
+                        r,
+                    )))
+                }
+                ContextSymbolDep::SqlUtils => Ok(MemberSqlArg::ContextSymbol(
+                    ContextSymbolArg::SqlUtils(base_tools.sql_utils_for_rust()?),
+                )),
+            },
         }
     }
 

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs

@@ -263,7 +263,7 @@ impl SymbolFactory for DimensionSymbolFactory {
         };
 
         let is_sql_direct_ref = if let Some(sql) = &sql {
-            sql.is_direct_reference()?
+            sql.is_direct_reference(compiler.base_tools())?
         } else {
             false
         };

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs

@@ -593,7 +593,7 @@ impl SymbolFactory for MeasureSymbolFactory {
         };
 
         let is_sql_is_direct_ref = if let Some(sql) = &sql {
-            sql.is_direct_reference()?
+            sql.is_direct_reference(compiler.base_tools())?
         } else {
             false
         };

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_expression_symbol.rs

@@ -1,4 +1,5 @@
 use super::MemberSymbol;
+use crate::cube_bridge::base_tools::BaseTools;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{sql_nodes::SqlNode, SqlCall, SqlEvaluatorVisitor};
 use crate::planner::sql_templates::PlanSqlTemplates;
@@ -25,9 +26,12 @@ impl MemberExpressionSymbol {
         name: String,
         expression: MemberExpressionExpression,
         definition: Option<String>,
+        base_tools: Rc<dyn BaseTools>,
     ) -> Result<Self, CubeError> {
         let is_reference = match &expression {
-            MemberExpressionExpression::SqlCall(sql_call) => sql_call.is_direct_reference()?,
+            MemberExpressionExpression::SqlCall(sql_call) => {
+                sql_call.is_direct_reference(base_tools.clone())?
+            }
             MemberExpressionExpression::PatchedSymbol(_symbol) => false,
         };
         Ok(Self {
@@ -57,7 +61,6 @@ impl MemberExpressionSymbol {
         Ok(sql)
     }
 
-
     pub fn full_name(&self) -> String {
         format!("expr:{}.{}", self.cube_name, self.name)
     }
@@ -80,17 +83,25 @@ impl MemberExpressionSymbol {
     pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {
         let mut deps = vec![];
         match &self.expression {
-            MemberExpressionExpression::SqlCall(sql_call) => sql_call.extract_symbol_deps(&mut deps),
-            MemberExpressionExpression::PatchedSymbol(member_symbol) => deps.push(member_symbol.clone()),
+            MemberExpressionExpression::SqlCall(sql_call) => {
+                sql_call.extract_symbol_deps(&mut deps)
+            }
+            MemberExpressionExpression::PatchedSymbol(member_symbol) => {
+                deps.push(member_symbol.clone())
+            }
         }
         deps
     }
 
     pub fn get_dependencies_with_path(&self) -> Vec<(Rc<MemberSymbol>, Vec<String>)> {
         let mut deps = vec![];
         match &self.expression {
-            MemberExpressionExpression::SqlCall(sql_call) => sql_call.extract_symbol_deps_with_path(&mut deps),
-            MemberExpressionExpression::PatchedSymbol(member_symbol) => deps.push((member_symbol.clone(), vec![])),
+            MemberExpressionExpression::SqlCall(sql_call) => {
+                sql_call.extract_symbol_deps_with_path(&mut deps)
+            }
+            MemberExpressionExpression::PatchedSymbol(member_symbol) => {
+                deps.push((member_symbol.clone(), vec![]))
+            }
         }
         deps
     }