in work

Author: waralexrom

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs

@@ -4,7 +4,6 @@ use super::{
     security_context::{NativeSecurityContext, SecurityContext},
     sql_utils::{NativeSqlUtils, SqlUtils},
 };
-use crate::planner::sql_evaluator::{FilterGroupItem, FilterParamsItem, SecutityContextProps};
 use crate::utils::UniqueVector;
 use cubenativeutils::wrappers::make_proxy;
 use cubenativeutils::wrappers::object::{NativeFunction, NativeStruct, NativeType};
@@ -37,6 +36,23 @@ impl<T: PartialEq> VecDedup<T> for Vec<T> {
     }
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+pub struct FilterParamsItem {
+    pub cube_name: String,
+    pub name: String,
+    pub column: String,
+}
+
+#[derive(Default, Clone, Debug, PartialEq, Eq)]
+pub struct FilterGroupItem {
+    pub filter_params: Vec<FilterParamsItem>,
+}
+
+#[derive(Default, Clone, Debug)]
+pub struct SecutityContextProps {
+    pub values: Vec<String>,
+}
+
 #[derive(Default, Clone, Debug)]
 pub struct SqlTemplateArgs {
     pub symbol_paths: Vec<Vec<String>>,

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

@@ -59,6 +59,19 @@ impl Filter {
         }
         result
     }
+
+    pub fn to_filter_item(&self) -> Option<FilterItem> {
+        if self.items.is_empty() {
+            None
+        } else if self.items.len() == 1 {
+            Some(self.items[0].clone())
+        } else {
+            Some(FilterItem::Group(Rc::new(FilterGroup::new(
+                FilterGroupOperator::And,
+                self.items.clone(),
+            ))))
+        }
+    }
 }
 
 impl FilterItem {
@@ -114,6 +127,112 @@ impl FilterItem {
             FilterItem::Segment(item) => result.push(item.member_evaluator().clone()),
         }
     }
+
+    /// Extract all member symbols from this filter tree
+    /// Returns None if filter tree is invalid (e.g., empty group)
+    /// Returns Some(set) with all member symbols found in the tree
+    fn extract_filter_members(&self) -> Option<Vec<Rc<MemberSymbol>>> {
+        match self {
+            FilterItem::Group(group) => {
+                // Empty groups are considered invalid
+                if group.items.is_empty() {
+                    return None;
+                }
+
+                let mut all_members = Vec::new();
+
+                // Recursively extract from all children
+                for child in &group.items {
+                    match child.extract_filter_members() {
+                        None => return None, // If any child is invalid, entire tree is invalid
+                        Some(mut members) => all_members.append(&mut members),
+                    }
+                }
+
+                Some(all_members)
+            }
+            FilterItem::Item(item) => Some(vec![item.member_evaluator().clone()]),
+            FilterItem::Segment(_) => None,
+        }
+    }
+
+    /// Find subtree of filters that only contains filters for the specified members
+    /// Returns None if no matching filters found
+    /// Returns Some(FilterItem) with the subtree containing only filters for target members
+    ///
+    /// This only processes AND groups - OR groups are not supported and will return None
+    pub fn find_subtree_for_members(
+        &self,
+        target_members: &[Rc<MemberSymbol>],
+    ) -> Option<FilterItem> {
+        match self {
+            FilterItem::Group(group) => {
+                // Empty groups return None
+                if group.items.is_empty() {
+                    return None;
+                }
+
+                // Extract all members from this filter subtree
+                let filter_members = self.extract_filter_members()?;
+
+                // Check if all members in this filter are in the target set
+                let all_members_match = filter_members.iter().all(|member| {
+                    target_members.iter().any(|target| {
+                        // Compare by resolved reference chains
+                        member.clone().resolve_reference_chain()
+                            == target.clone().resolve_reference_chain()
+                    })
+                });
+
+                if all_members_match {
+                    // All members match - return this entire filter subtree
+                    return Some(self.clone());
+                }
+
+                // Only process AND groups for partial matching
+                if group.operator == FilterGroupOperator::And {
+                    let matching_children: Vec<FilterItem> = group
+                        .items
+                        .iter()
+                        .filter_map(|child| child.find_subtree_for_members(target_members))
+                        .collect();
+
+                    if matching_children.is_empty() {
+                        return None;
+                    }
+
+                    if matching_children.len() == 1 {
+                        // Single match - return it directly without wrapping
+                        return Some(matching_children.into_iter().next().unwrap());
+                    }
+
+                    // Multiple matches - wrap in new AND group
+                    return Some(FilterItem::Group(Rc::new(FilterGroup::new(
+                        FilterGroupOperator::And,
+                        matching_children,
+                    ))));
+                }
+
+                // OR groups are not supported
+                None
+            }
+            FilterItem::Item(item) => {
+                let member = item.member_evaluator();
+
+                // Check if this item's member is in the target set
+                if target_members.iter().any(|target| {
+                    member.clone().resolve_reference_chain()
+                        == target.clone().resolve_reference_chain()
+                }) {
+                    Some(self.clone())
+                } else {
+                    None
+                }
+            }
+            FilterItem::Segment(_) => None,
+        }
+    }
+
     /// Find value restrictions for a given symbol across filter tree
     /// Returns:
     /// - None: no restrictions found for this symbol

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

@@ -1,8 +1,8 @@
 use super::symbols::MemberSymbol;
 use super::Compiler;
-use super::{SqlCallDependency, SqlCallNew};
+use super::{SqlCallDependency, SqlCallFilterGroupItem, SqlCallFilterParamsItem, SqlCallNew};
 use crate::cube_bridge::evaluator::CubeEvaluator;
-use crate::cube_bridge::member_sql::MemberSql;
+use crate::cube_bridge::member_sql::*;
 use crate::cube_bridge::security_context::SecurityContext;
 use crate::planner::sql_evaluator::TimeDimensionSymbol;
 use crate::planner::GranularityHelper;
@@ -41,16 +41,52 @@ impl<'a> SqlCallBuilder<'a> {
             .iter()
             .map(|path| self.build_dependency(cube_name, path))
             .collect::<Result<Vec<_>, _>>()?;
+
+        let filter_params = template_args
+            .filter_params
+            .iter()
+            .map(|itm| self.build_filter_params_item(itm))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let filter_groups = template_args
+            .filter_groups
+            .iter()
+            .map(|itm| self.build_filter_group_item(itm))
+            .collect::<Result<Vec<_>, _>>()?;
+
         let result = SqlCallNew::builder()
             .template(template)
             .deps(deps)
-            .filter_params(template_args.filter_params.clone())
-            .filter_groups(template_args.filter_groups.clone())
+            .filter_params(filter_params)
+            .filter_groups(filter_groups)
             .security_context(template_args.security_context.clone())
             .build();
         Ok(result)
     }
 
+    fn build_filter_params_item(
+        &mut self,
+        item: &FilterParamsItem,
+    ) -> Result<SqlCallFilterParamsItem, CubeError> {
+        let filter_symbol = self.build_evaluator(&item.cube_name, &item.name)?;
+        Ok(SqlCallFilterParamsItem {
+            filter_symbol,
+            column: item.column.clone(),
+        })
+    }
+
+    fn build_filter_group_item(
+        &mut self,
+        item: &FilterGroupItem,
+    ) -> Result<SqlCallFilterGroupItem, CubeError> {
+        let filter_params = item
+            .filter_params
+            .iter()
+            .map(|itm| self.build_filter_params_item(itm))
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(SqlCallFilterGroupItem { filter_params })
+    }
+
     fn build_dependency(
         &mut self,
         current_cube_name: &String,

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

@@ -5,48 +5,120 @@ 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::cube_bridge::member_sql::{
+    ContextSymbolArg, MemberSql, MemberSqlArg, MemberSqlStruct, SecutityContextProps,
+};
 use crate::plan::{Filter, FilterItem};
 use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
 use crate::planner::sql_templates::PlanSqlTemplates;
+use crate::planner::VisitorContext;
 use cubenativeutils::CubeError;
+use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 use std::rc::Rc;
 use typed_builder::TypedBuilder;
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
-pub struct FilterParamsItem {
-    pub cube_name: String,
-    pub name: String,
-    pub column: String,
-}
-
-#[derive(Default, Clone, Debug, PartialEq, Eq)]
-pub struct FilterGroupItem {
-    pub filter_params: Vec<FilterParamsItem>,
-}
-
-#[derive(Default, Clone, Debug)]
-pub struct SecutityContextProps {
-    pub values: Vec<String>,
-}
-
 #[derive(Debug, Clone)]
 pub struct SqlCallDependency {
     pub path: Vec<String>,
     pub symbol: Rc<MemberSymbol>,
 }
 
+#[derive(Debug, Clone)]
+pub struct SqlCallFilterParamsItem {
+    pub filter_symbol: Rc<MemberSymbol>,
+    pub column: String,
+}
+
+#[derive(Clone, Debug)]
+pub struct SqlCallFilterGroupItem {
+    pub filter_params: Vec<SqlCallFilterParamsItem>,
+}
+
 #[derive(Clone, TypedBuilder)]
 pub struct SqlCallNew {
     template: String,
     deps: Vec<SqlCallDependency>,
-    filter_params: Vec<FilterParamsItem>,
-    filter_groups: Vec<FilterGroupItem>,
+    filter_params: Vec<SqlCallFilterParamsItem>,
+    filter_groups: Vec<SqlCallFilterGroupItem>,
     security_context: SecutityContextProps,
 }
 
 impl SqlCallNew {
+    pub fn eval(
+        &self,
+        visitor: &SqlEvaluatorVisitor,
+        node_processor: Rc<dyn SqlNode>,
+        query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        let filter_params = self
+            .filter_params
+            .iter()
+            .map(|itm| {
+                Self::eval_filter_group(&vec![itm.clone()], visitor, query_tools.clone(), templates)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        let filter_groups = self
+            .filter_groups
+            .iter()
+            .map(|itm| {
+                Self::eval_filter_group(&itm.filter_params, visitor, query_tools.clone(), templates)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let deps = self
+            .deps
+            .iter()
+            .map(|dep| visitor.apply(&dep.symbol, node_processor.clone(), templates))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let context_values = self.eval_security_context_values(&query_tools);
+
+        todo!()
+    }
+
+    fn eval_filter_group(
+        items: &[SqlCallFilterParamsItem],
+        visitor: &SqlEvaluatorVisitor,
+        query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        if let Some(all_filters) = visitor.all_filters() {
+            if let Some(filter_item) = all_filters.to_filter_item() {
+                let symbols = items
+                    .iter()
+                    .map(|itm| itm.filter_symbol.clone())
+                    .collect_vec();
+                if let Some(subtree) = filter_item.find_subtree_for_members(&symbols) {
+                    let mut context_factory = SqlNodesFactory::new();
+                    for itm in items {
+                        context_factory.add_render_reference(
+                            itm.filter_symbol.full_name(),
+                            itm.column.clone(),
+                        );
+                    }
+                    let context = Rc::new(VisitorContext::new(
+                        query_tools.clone(),
+                        &context_factory,
+                        None,
+                    ));
+                    return subtree.to_sql(templates, context);
+                }
+            }
+        }
+        templates.always_true()
+    }
+
+    fn eval_security_context_values(&self, query_tools: &Rc<QueryTools>) -> Vec<String> {
+        self.security_context
+            .values
+            .iter()
+            .map(|itm| query_tools.allocate_param(itm))
+            .collect()
+    }
+
     pub fn is_direct_reference(&self) -> bool {
         self.dependencies_count() == 1 && self.template == "{arg:0}"
     }
@@ -104,4 +176,15 @@ impl SqlCallNew {
             }
         }
     }
+
+    pub fn apply_recursive<F: Fn(&Rc<MemberSymbol>) -> Result<Rc<MemberSymbol>, CubeError>>(
+        &self,
+        f: &F,
+    ) -> Result<Rc<Self>, CubeError> {
+        let mut result = self.clone();
+        for dep in result.deps.iter_mut() {
+            dep.symbol = dep.symbol.apply_recursive(f)?;
+        }
+        Ok(Rc::new(result))
+    }
 }