in work

Author: waralexrom

packages/cubejs-backend-native/js/index.ts

@@ -360,13 +360,10 @@ export const buildSqlAndParams = (cubeEvaluator: any): String => {
   const native = loadNative();
   const safeCallFn = (fn: Function, thisArg: any, ...args: any[]) => {
     try {
-      console.log("!!!! this: ", thisArg);
-      console.log("!!!! args: ", args.length);
       return {
         result: fn.apply(thisArg, args),
       };
     } catch (e: any) {
-      console.log("!!! error: ", e);
       return {
         error: e.toString(),
       };

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

@@ -1,7 +1,8 @@
 use super::{
     filter_group::{FilterGroup, NativeFilterGroup},
     filter_params::{FilterParams, NativeFilterParams},
-    proxy::CubeDepsCollectorProxyHandler,
+    proxy::{CubeDepsCollectorProxyHandler, FilterParamsCollectorProxyHandler},
+    return_string_fn::ReturnStringFn,
     security_context::{NativeSecurityContext, SecurityContext},
     sql_utils::{NativeSqlUtils, SqlUtils},
 };
@@ -44,6 +45,8 @@ pub enum MemberSqlArg {
 pub enum MemberSqlArgForResolve {
     String(String),
     CubeProxy(Rc<CubeDepsCollectorProxyHandler>),
+    FilterParamsProxy(Rc<FilterParamsCollectorProxyHandler>),
+    FilterGroupMock(),
     ContextSymbol(ContextSymbolArg),
 }
 
@@ -140,6 +143,10 @@ impl<IT: InnerTypes> NativeSerialize<IT> for MemberSqlArgForResolve {
         let res = match self {
             Self::String(s) => s.to_native(context_holder.clone()),
             Self::CubeProxy(proxy) => proxy.to_native(context_holder.clone()),
+            Self::FilterParamsProxy(proxy) => proxy.to_native(context_holder.clone()),
+            Self::FilterGroupMock() => {
+                ReturnStringFn::new(format!("")).to_native(context_holder.clone())
+            }
             Self::ContextSymbol(s) => s.to_native(context_holder.clone()),
         }?;
         Ok(NativeObjectHandle::new(res.into_object()))

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs

@@ -19,6 +19,7 @@ pub mod member_order_by;
 pub mod member_sql;
 pub mod options_member;
 pub mod proxy;
+pub mod return_string_fn;
 pub mod security_context;
 pub mod sql_templates_render;
 pub mod sql_utils;

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/proxy/cube_deps_collector.rs

@@ -12,7 +12,7 @@ use cubenativeutils::CubeError;
 use std::cell::RefCell;
 use std::rc::Rc;
 
-type CubeDepsCollectorRef = Rc<RefCell<CubeDepsCollector>>;
+pub type CubeDepsCollectorProxyHandler = ProxyHandlerImpl<CubeDepsCollector>;
 
 pub enum CubeDepsCollectorProp {
     Symbol(String),
@@ -182,5 +182,3 @@ impl Drop for CubeDepsCollector {
             .drop(self.context_holder_ref.clone());
     }
 }
-
-pub type CubeDepsCollectorProxyHandler = ProxyHandlerImpl<CubeDepsCollector>;

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/proxy/filter_params_collector.rs

@@ -0,0 +1,138 @@
+use crate::cube_bridge::base_tools::BaseTools;
+use crate::cube_bridge::return_string_fn::ReturnStringFn;
+
+use super::{ProxyCollector, ProxyHandlerImpl};
+use cubenativeutils::wrappers::context::NativeFinalize;
+use cubenativeutils::wrappers::inner_types::InnerTypes;
+use cubenativeutils::wrappers::serializer::NativeSerialize;
+use cubenativeutils::wrappers::{
+    NativeContextHolder, NativeContextHolderRef, NativeObjectHandle, NativeStruct, RootHolder,
+    Rootable,
+};
+use cubenativeutils::CubeError;
+use std::cell::RefCell;
+use std::collections::{HashMap, HashSet};
+use std::rc::Rc;
+
+pub type FilterParamsCollectorProxyHandler = ProxyHandlerImpl<FilterParamsCollector>;
+pub type FilterParamsCubeFiltersCollectorProxyHandler =
+    ProxyHandlerImpl<FilterParamsCubeFiltersCollector>;
+
+pub struct FilterParamsCollector {
+    cube_filter_proxies: Vec<Rc<FilterParamsCubeFiltersCollectorProxyHandler>>,
+    base_tools_root: Rc<dyn RootHolder<dyn BaseTools>>,
+}
+
+pub enum FilterParamsCollectorRes {
+    CupeFilterProxy(Rc<FilterParamsCubeFiltersCollectorProxyHandler>),
+}
+
+impl<IT: InnerTypes> NativeSerialize<IT> for FilterParamsCollectorRes {
+    fn to_native(
+        &self,
+        context: Rc<NativeContextHolder<IT>>,
+    ) -> Result<NativeObjectHandle<IT>, CubeError> {
+        match self {
+            FilterParamsCollectorRes::CupeFilterProxy(proxy) => proxy.to_native(context),
+        }
+    }
+}
+
+impl FilterParamsCollector {
+    pub fn try_new(base_tools: Rc<dyn BaseTools>) -> Result<Self, CubeError> {
+        let base_tools_root = base_tools.to_root()?;
+        Ok(Self {
+            cube_filter_proxies: vec![],
+            base_tools_root,
+        })
+    }
+
+    pub fn collected_result(&self) -> HashMap<String, HashSet<String>> {
+        let mut result = HashMap::new();
+        for cb in self.cube_filter_proxies.iter() {
+            let collector = cb.get_collector();
+            let entry: &mut HashSet<String> =
+                result.entry(collector.cube_name.clone()).or_default();
+            for member in collector.members.iter() {
+                entry.insert(member.clone());
+            }
+        }
+        println!("!!!! {:?}", result);
+        result
+    }
+}
+
+impl NativeFinalize for FilterParamsCollector {}
+
+impl ProxyCollector for FilterParamsCollector {
+    type ResultType = FilterParamsCollectorRes;
+
+    fn on_get(
+        &mut self,
+        property_name: String,
+        context_holder_ref: Rc<dyn NativeContextHolderRef>,
+    ) -> Result<Option<Self::ResultType>, CubeError> {
+        let base_tools = self
+            .base_tools_root
+            .clone()
+            .to_inner(context_holder_ref.clone())?;
+        let cube_filters_collector = FilterParamsCubeFiltersCollector::new(property_name.clone());
+        let cube_filters_proxy =
+            FilterParamsCubeFiltersCollectorProxyHandler::new(cube_filters_collector, base_tools);
+        self.cube_filter_proxies.push(cube_filters_proxy.clone());
+        let res = FilterParamsCollectorRes::CupeFilterProxy(cube_filters_proxy);
+        Ok(Some(res))
+    }
+}
+
+pub struct FilterParamsCubeFiltersCollector {
+    cube_name: String,
+    members: Vec<String>,
+}
+
+impl FilterParamsCubeFiltersCollector {
+    pub fn new(cube_name: String) -> Self {
+        Self {
+            cube_name,
+            members: vec![],
+        }
+    }
+}
+
+impl NativeFinalize for FilterParamsCubeFiltersCollector {}
+
+impl ProxyCollector for FilterParamsCubeFiltersCollector {
+    type ResultType = FilterParamsCubeFiltersCollectorRes;
+
+    fn on_get(
+        &mut self,
+        property_name: String,
+        _context_holder_ref: Rc<dyn NativeContextHolderRef>,
+    ) -> Result<Option<Self::ResultType>, CubeError> {
+        println!("!!!! prop name: {}", property_name);
+        self.members.push(property_name);
+        Ok(Some(FilterParamsCubeFiltersCollectorRes::new()))
+    }
+}
+
+pub struct FilterParamsCubeFiltersCollectorRes {}
+
+impl FilterParamsCubeFiltersCollectorRes {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl<IT: InnerTypes> NativeSerialize<IT> for FilterParamsCubeFiltersCollectorRes {
+    fn to_native(
+        &self,
+        context: Rc<NativeContextHolder<IT>>,
+    ) -> Result<NativeObjectHandle<IT>, CubeError> {
+        let res = context.empty_struct()?;
+        res.set_field(
+            "filter",
+            NativeObjectHandle::new_from_type(context.to_string_fn("".to_string())?),
+        )?;
+        Ok(NativeObjectHandle::new_from_type(res))
+    }
+}

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/proxy/mod.rs

@@ -1,11 +1,15 @@
 mod cube_deps_collector;
+mod filter_params_collector;
 mod handler;
 mod handler_impl;
 mod proxy;
 
 pub use cube_deps_collector::{
     CubeDepsCollector, CubeDepsCollectorProp, CubeDepsCollectorProxyHandler,
 };
+
+pub use filter_params_collector::{FilterParamsCollector, FilterParamsCollectorProxyHandler};
+
 pub use handler::{
     NativeProxyHandler, NativeProxyHandlerFunction, ProxyHandler, ProxyHandlerFunction,
 };

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/return_string_fn.rs

@@ -0,0 +1,27 @@
+use cubenativeutils::wrappers::inner_types::InnerTypes;
+use cubenativeutils::wrappers::serializer::NativeSerialize;
+use cubenativeutils::wrappers::NativeContextHolder;
+use cubenativeutils::wrappers::NativeObjectHandle;
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+pub struct ReturnStringFn {
+    value: String,
+}
+
+impl ReturnStringFn {
+    pub fn new(value: String) -> Self {
+        ReturnStringFn { value }
+    }
+}
+
+impl<IT: InnerTypes> NativeSerialize<IT> for ReturnStringFn {
+    fn to_native(
+        &self,
+        context: Rc<NativeContextHolder<IT>>,
+    ) -> Result<NativeObjectHandle<IT>, CubeError> {
+        Ok(NativeObjectHandle::new_from_type(
+            context.to_string_fn(self.value.clone())?,
+        ))
+    }
+}

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

@@ -182,7 +182,7 @@ impl SelectBuilder {
         schema
     }
 
-    pub fn build(self, mut nodes_factory: SqlNodesFactory) -> Select {
+    pub fn build(self, mut nodes_factory: SqlNodesFactory, all_filters: Option<Filter>) -> Select {
         let cube_references = self.make_cube_references();
         nodes_factory.set_cube_name_references(cube_references);
         let schema = if self.projection_columns.is_empty() {
@@ -197,7 +197,7 @@ impl SelectBuilder {
             group_by: self.group_by,
             having: self.having,
             order_by: self.order_by,
-            context: Rc::new(VisitorContext::new(&nodes_factory)),
+            context: Rc::new(VisitorContext::new(&nodes_factory, all_filters)),
             ctes: self.ctes,
             is_distinct: self.is_distinct,
             limit: self.limit,

rust/cubesqlplanner/cubesqlplanner/src/planner/planners/full_key_query_aggregate_planner.rs

@@ -161,6 +161,9 @@ impl FullKeyAggregateQueryPlanner {
         let mut context_factory = self.context_factory.clone();
         context_factory.set_render_references(render_references);
 
-        Ok(Rc::new(select_builder.build(context_factory)))
+        Ok(Rc::new(select_builder.build(
+            context_factory,
+            self.query_properties.all_filters(),
+        )))
     }
 }

rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs

@@ -19,7 +19,7 @@ use std::rc::Rc;
 
 pub struct MultiStageMemberQueryPlanner {
     query_tools: Rc<QueryTools>,
-    _query_properties: Rc<QueryProperties>,
+    query_properties: Rc<QueryProperties>,
     description: Rc<MultiStageQueryDescription>,
 }
 
@@ -31,7 +31,7 @@ impl MultiStageMemberQueryPlanner {
     ) -> Self {
         Self {
             query_tools,
-            _query_properties: query_properties,
+            query_properties: query_properties,
             description,
         }
     }
@@ -185,7 +185,7 @@ impl MultiStageMemberQueryPlanner {
         select_builder.add_projection_member(&query_member, None);
         select_builder.set_group_by(group_by);
         select_builder.set_order_by(self.query_order()?);
-        let select = select_builder.build(context_factory);
+        let select = select_builder.build(context_factory, self.query_properties.all_filters());
 
         Ok(Rc::new(Cte::new_from_select(
             Rc::new(select),
@@ -266,7 +266,7 @@ impl MultiStageMemberQueryPlanner {
         if self.description.member().is_ungrupped() {
             context_factory.set_ungrouped(true);
         }
-        let select = select_builder.build(context_factory);
+        let select = select_builder.build(context_factory, None);
 
         Ok(Rc::new(Cte::new_from_select(
             Rc::new(select),
@@ -352,7 +352,7 @@ impl MultiStageMemberQueryPlanner {
         let mut node_factory = SqlNodesFactory::new();
         node_factory.set_render_references(render_references);
         Ok(QueryPlan::Select(Rc::new(
-            select_builder.build(node_factory),
+            select_builder.build(node_factory, None),
         )))
     }