11 tests left

Author: waralexrom

rust/cubenativeutils/src/wrappers/serializer/serializer.rs

@@ -184,14 +184,12 @@ impl<IT: InnerTypes> ser::Serializer for NativeSerdeSerializer<IT> {
         _name: &'static str,
         _variant_index: u32,
         _variant: &'static str,
-        _value: &T,
+        value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
         T: ?Sized + Serialize,
     {
-        Err(NativeObjSerializerError::Message(
-            "serialize_newtype_variant is not implemented".to_string(),
-        ))
+        NativeSerdeSerializer::serialize(value, self.context.clone())
     }
 
     fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {

rust/cubesqlplanner/\

@@ -0,0 +1,85 @@
+use crate::cube_bridge::join_hints::JoinHintItem;
+use crate::planner::sql_evaluator::{MemberSymbol, TraversalVisitor};
+use crate::planner::BaseMeasure;
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+pub struct JoinHintsCollector {
+    hints: Vec<JoinHintItem>,
+}
+
+impl JoinHintsCollector {
+    pub fn new() -> Self {
+        Self { hints: Vec::new() }
+    }
+
+    pub fn extract_result(self) -> Vec<JoinHintItem> {
+        self.hints
+    }
+}
+
+impl TraversalVisitor for JoinHintsCollector {
+    type State = ();
+    fn on_node_traverse(
+        &mut self,
+        node: &Rc<MemberSymbol>,
+        path: &Vec<String>,
+        _: &Self::State,
+    ) -> Result<Option<Self::State>, CubeError> {
+        match node.as_ref() {
+            MemberSymbol::Dimension(e) => {
+                if e.owned_by_cube() {
+                    if !path.is_empty() {
+                        if path.len() == 1 {
+                            self.hints.push(JoinHintItem::Single(path[0].clone()))
+                        } else {
+                            self.hints.push(JoinHintItem::Vector(path.clone()))
+                        }
+                    }
+                }
+                if e.is_sub_query() {
+                    return Ok(None);
+                }
+            }
+            MemberSymbol::TimeDimension(e) => return self.on_node_traverse(e.base_symbol(), path, &()),
+            MemberSymbol::Measure(e) => {
+                if e.owned_by_cube() {
+                    self.hints.push(JoinHintItem::Single(e.cube_name().clone()));
+                }
+                for name in e.get_dependent_cubes().into_iter() {
+                    self.hints.push(JoinHintItem::Single(name));
+                }
+            }
+            MemberSymbol::CubeName(e) => {
+                self.hints.push(JoinHintItem::Single(e.cube_name().clone()));
+            }
+            MemberSymbol::CubeTable(e) => {
+                self.hints.push(JoinHintItem::Single(e.cube_name().clone()));
+            }
+            MemberSymbol::SqlCall(s) => {
+                for name in s.get_dependent_cubes().into_iter() {
+                    self.hints.push(JoinHintItem::Single(name));
+                }
+            }
+        };
+        Ok(Some(()))
+    }
+}
+
+pub fn collect_join_hints(node: &Rc<MemberSymbol>) -> Result<Vec<JoinHintItem>, CubeError> {
+    let mut visitor = JoinHintsCollector::new();
+    visitor.apply(node, &())?;
+    let res = visitor.extract_result();
+    Ok(res)
+}
+
+pub fn collect_join_hints_for_measures(
+    measures: &Vec<Rc<BaseMeasure>>,
+) -> Result<Vec<JoinHintItem>, CubeError> {
+    let mut visitor = JoinHintsCollector::new();
+    for meas in measures.iter() {
+        visitor.apply(&meas.member_evaluator(), &())?;
+    }
+    let res = visitor.extract_result();
+    Ok(res)
+}

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_query_options.rs

@@ -1,11 +1,11 @@
 use super::join_graph::{JoinGraph, NativeJoinGraph};
+use super::options_member::OptionsMember;
 use crate::cube_bridge::base_tools::{BaseTools, NativeBaseTools};
 use crate::cube_bridge::evaluator::{CubeEvaluator, NativeCubeEvaluator};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
-use cubenativeutils::wrappers::NativeContextHolder;
-use cubenativeutils::wrappers::NativeObjectHandle;
+use cubenativeutils::wrappers::{NativeArray, NativeContextHolder, NativeObjectHandle};
 use cubenativeutils::CubeError;
 use serde::{Deserialize, Serialize};
 use std::any::Any;
@@ -50,7 +50,6 @@ impl FilterItem {
 #[derive(Serialize, Deserialize, Debug)]
 pub struct BaseQueryOptionsStatic {
     pub measures: Option<Vec<String>>,
-    pub dimensions: Option<Vec<String>>,
     #[serde(rename = "timeDimensions")]
     pub time_dimensions: Option<Vec<TimeDimension>>,
     pub timezone: Option<String>,
@@ -66,9 +65,13 @@ pub struct BaseQueryOptionsStatic {
 #[nativebridge::native_bridge(BaseQueryOptionsStatic)]
 pub trait BaseQueryOptions {
     #[field]
-    fn measures(&self) -> Result<Option<Vec<String>>, CubeError>;
+    #[optional]
+    #[vec]
+    fn measures(&self) -> Result<Option<Vec<OptionsMember>>, CubeError>;
     #[field]
-    fn dimensions(&self) -> Result<Option<Vec<String>>, CubeError>;
+    #[optional]
+    #[vec]
+    fn dimensions(&self) -> Result<Option<Vec<OptionsMember>>, CubeError>;
     #[field]
     fn cube_evaluator(&self) -> Result<Rc<dyn CubeEvaluator>, CubeError>;
     #[field]

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_definition.rs

@@ -1,7 +1,8 @@
-use super::join_item::{JoinItemsVec, NativeJoinItemsVec};
+use super::join_item::{JoinItem, NativeJoinItem};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
+use cubenativeutils::wrappers::NativeArray;
 use cubenativeutils::wrappers::NativeContextHolder;
 use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
@@ -20,5 +21,6 @@ pub struct JoinDefinitionStatic {
 #[nativebridge::native_bridge(JoinDefinitionStatic)]
 pub trait JoinDefinition {
     #[field]
-    fn joins(&self) -> Result<Rc<dyn JoinItemsVec>, CubeError>;
+    #[vec]
+    fn joins(&self) -> Result<Vec<Rc<dyn JoinItem>>, CubeError>;
 }

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_graph.rs

@@ -1,4 +1,5 @@
 use super::join_definition::{JoinDefinition, NativeJoinDefinition};
+use super::join_hints::JoinHintItem;
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
@@ -10,5 +11,8 @@ use std::rc::Rc;
 
 #[nativebridge::native_bridge]
 pub trait JoinGraph {
-    fn build_join(&self, cubes_to_join: Vec<String>) -> Result<Rc<dyn JoinDefinition>, CubeError>;
+    fn build_join(
+        &self,
+        cubes_to_join: Vec<JoinHintItem>,
+    ) -> Result<Rc<dyn JoinDefinition>, CubeError>;
 }

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_hints.rs

@@ -0,0 +1,7 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub enum JoinHintItem {
+    Single(String),
+    Vector(Vec<String>),
+}

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_item.rs

@@ -1,5 +1,4 @@
 use super::join_item_definition::{JoinItemDefinition, NativeJoinItemDefinition};
-use cubenativeutils::wrappers::object::NativeArray;
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
@@ -8,7 +7,6 @@ use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
 use serde::{Deserialize, Serialize};
 use std::any::Any;
-use std::marker::PhantomData;
 use std::rc::Rc;
 
 #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq, Hash)]
@@ -26,41 +24,3 @@ pub trait JoinItem {
     #[field]
     fn join(&self) -> Result<Rc<dyn JoinItemDefinition>, CubeError>;
 }
-
-pub trait JoinItemsVec {
-    fn items(&self) -> &Vec<Rc<dyn JoinItem>>;
-}
-
-pub struct NativeJoinItemsVec<IT: InnerTypes> {
-    items: Vec<Rc<dyn JoinItem>>,
-    phantom: PhantomData<IT>,
-}
-
-impl<IT: InnerTypes> NativeJoinItemsVec<IT> {
-    pub fn try_new(native_items: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
-        let items = native_items
-            .into_array()?
-            .to_vec()?
-            .into_iter()
-            .map(|v| -> Result<Rc<dyn JoinItem>, CubeError> {
-                Ok(Rc::new(NativeJoinItem::from_native(v)?))
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(Self {
-            items,
-            phantom: PhantomData::default(),
-        })
-    }
-}
-
-impl<IT: InnerTypes> JoinItemsVec for NativeJoinItemsVec<IT> {
-    fn items(&self) -> &Vec<Rc<dyn JoinItem>> {
-        &self.items
-    }
-}
-
-impl<IT: InnerTypes> NativeDeserialize<IT> for NativeJoinItemsVec<IT> {
-    fn from_native(v: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
-        Self::try_new(v)
-    }
-}

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs

@@ -1,10 +1,11 @@
 use super::cube_definition::{CubeDefinition, NativeCubeDefinition};
-use super::measure_filter::{MeasureFiltersVec, NativeMeasureFiltersVec};
-use super::member_order_by::{MemberOrderByVec, NativeMemberOrderByVec};
+use super::measure_filter::{MeasureFilter, NativeMeasureFilter};
+use super::member_order_by::{MemberOrderBy, NativeMemberOrderBy};
 use super::member_sql::{MemberSql, NativeMemberSql};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
+use cubenativeutils::wrappers::NativeArray;
 use cubenativeutils::wrappers::NativeContextHolder;
 use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
@@ -61,13 +62,16 @@ pub trait MeasureDefinition {
 
     #[optional]
     #[field]
-    fn filters(&self) -> Result<Option<Rc<dyn MeasureFiltersVec>>, CubeError>;
+    #[vec]
+    fn filters(&self) -> Result<Option<Vec<Rc<dyn MeasureFilter>>>, CubeError>;
 
     #[optional]
     #[field]
-    fn drill_filters(&self) -> Result<Option<Rc<dyn MeasureFiltersVec>>, CubeError>;
+    #[vec]
+    fn drill_filters(&self) -> Result<Option<Vec<Rc<dyn MeasureFilter>>>, CubeError>;
 
     #[optional]
     #[field]
-    fn order_by(&self) -> Result<Option<Rc<dyn MemberOrderByVec>>, CubeError>;
+    #[vec]
+    fn order_by(&self) -> Result<Option<Vec<Rc<dyn MemberOrderBy>>>, CubeError>;
 }

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_filter.rs

@@ -1,55 +1,15 @@
 use super::member_sql::{MemberSql, NativeMemberSql};
-use cubenativeutils::wrappers::object::NativeArray;
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
 use cubenativeutils::wrappers::NativeContextHolder;
 use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
 use std::any::Any;
-use std::marker::PhantomData;
 use std::rc::Rc;
 
 #[nativebridge::native_bridge]
 pub trait MeasureFilter {
     #[field]
     fn sql(&self) -> Result<Rc<dyn MemberSql>, CubeError>;
 }
-
-pub trait MeasureFiltersVec {
-    fn items(&self) -> &Vec<Rc<dyn MeasureFilter>>;
-}
-
-pub struct NativeMeasureFiltersVec<IT: InnerTypes> {
-    items: Vec<Rc<dyn MeasureFilter>>,
-    phantom: PhantomData<IT>,
-}
-
-impl<IT: InnerTypes> NativeMeasureFiltersVec<IT> {
-    pub fn try_new(native_items: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
-        let items = native_items
-            .into_array()?
-            .to_vec()?
-            .into_iter()
-            .map(|v| -> Result<Rc<dyn MeasureFilter>, CubeError> {
-                Ok(Rc::new(NativeMeasureFilter::from_native(v)?))
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(Self {
-            items,
-            phantom: PhantomData::default(),
-        })
-    }
-}
-
-impl<IT: InnerTypes> MeasureFiltersVec for NativeMeasureFiltersVec<IT> {
-    fn items(&self) -> &Vec<Rc<dyn MeasureFilter>> {
-        &self.items
-    }
-}
-
-impl<IT: InnerTypes> NativeDeserialize<IT> for NativeMeasureFiltersVec<IT> {
-    fn from_native(v: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
-        Self::try_new(v)
-    }
-}

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_expression.rs

@@ -0,0 +1,24 @@
+use super::member_sql::{MemberSql, NativeMemberSql};
+use cubenativeutils::wrappers::serializer::{
+    NativeDeserialize, NativeDeserializer, NativeSerialize,
+};
+use cubenativeutils::wrappers::{NativeContextHolder, NativeObjectHandle};
+use cubenativeutils::CubeError;
+use serde::{Deserialize, Serialize};
+use std::any::Any;
+use std::rc::Rc;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MemberExpressionDefinitionStatic {
+    #[serde(rename = "expressionName")]
+    pub expression_name: Option<String>,
+    #[serde(rename = "cubeName")]
+    pub cube_name: Option<String>,
+    pub definition: Option<String>,
+}
+
+#[nativebridge::native_bridge(MemberExpressionDefinitionStatic)]
+pub trait MemberExpressionDefinition {
+    #[field]
+    fn expression(&self) -> Result<Rc<dyn MemberSql>, CubeError>;
+}