in work

Author: waralexrom

packages/cubejs-schema-compiler/src/compiler/CubeSymbols.ts

@@ -1010,9 +1010,9 @@ export class CubeSymbols {
           return true;
         }
         if (cube[propertyName]) {
-          depsResolveFn(propertyName, parentIndex);
+          const index = depsResolveFn(propertyName, parentIndex);
           if (cube[propertyName].type === 'time') {
-            return this.timeDimDependenciesProxy(parentIndex);
+            return this.timeDimDependenciesProxy(index);
           }
 
           return '';

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

@@ -123,12 +123,12 @@ impl BaseDimension {
         member_expression_definition: Option<String>,
         query_tools: Rc<QueryTools>,
     ) -> Result<Rc<Self>, CubeError> {
-        let member_expression_symbol = MemberExpressionSymbol::new(
+        let member_expression_symbol = MemberExpressionSymbol::try_new(
             cube_name.clone(),
             name.clone(),
             expression,
             member_expression_definition.clone(),
-        );
+        )?;
         let full_name = member_expression_symbol.full_name();
         let member_evaluator = Rc::new(MemberSymbol::MemberExpression(member_expression_symbol));
         let default_alias = PlanSqlTemplates::alias_name(&name);

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

@@ -135,12 +135,12 @@ impl BaseMeasure {
         member_expression_definition: Option<String>,
         query_tools: Rc<QueryTools>,
     ) -> Result<Rc<Self>, CubeError> {
-        let member_expression_symbol = MemberExpressionSymbol::new(
+        let member_expression_symbol = MemberExpressionSymbol::try_new(
             cube_name.clone(),
             name.clone(),
             expression,
             member_expression_definition.clone(),
-        );
+        )?;
         let full_name = member_expression_symbol.full_name();
         let member_evaluator = Rc::new(MemberSymbol::MemberExpression(member_expression_symbol));
         let default_alias = PlanSqlTemplates::alias_name(&name);

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

@@ -28,7 +28,7 @@ impl BaseSegment {
         query_tools: Rc<QueryTools>,
     ) -> Result<Rc<Self>, CubeError> {
         let member_expression_symbol =
-            MemberExpressionSymbol::new(cube_name.clone(), name.clone(), expression, None);
+            MemberExpressionSymbol::try_new(cube_name.clone(), name.clone(), expression, None)?;
         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/sql_evaluator/symbols/dimension_symbol.rs

@@ -116,6 +116,17 @@ impl DimensionSymbol {
         self.is_reference
     }
 
+    pub fn reference_member(&self) -> Option<Rc<MemberSymbol>> {
+        if !self.is_reference() {
+            return None;
+        }
+        let deps = self.get_dependencies();
+        if deps.is_empty() {
+            return None;
+        }
+        deps.first().cloned()
+    }
+
     pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {
         let mut deps = vec![];
         if let Some(member_sql) = &self.member_sql {
@@ -192,6 +203,7 @@ pub struct DimensionSymbolFactory {
     name: String,
     sql: Option<Rc<dyn MemberSql>>,
     definition: Rc<dyn DimensionDefinition>,
+    cube_evaluator: Rc<dyn CubeEvaluator>,
 }
 
 impl DimensionSymbolFactory {
@@ -210,6 +222,7 @@ impl DimensionSymbolFactory {
             name,
             sql: definition.sql()?,
             definition,
+            cube_evaluator,
         })
     }
 }
@@ -241,6 +254,7 @@ impl SymbolFactory for DimensionSymbolFactory {
             name,
             sql,
             definition,
+            cube_evaluator,
         } = self;
         let sql = if let Some(sql) = sql {
             Some(compiler.compile_sql_call(&cube_name, sql)?)
@@ -299,16 +313,19 @@ impl SymbolFactory for DimensionSymbolFactory {
         } else {
             None
         };
+        let cube = cube_evaluator.cube_from_path(cube_name.clone())?;
+        let is_view = cube.static_data().is_view.unwrap_or(false);
         let owned_by_cube = definition.static_data().owned_by_cube.unwrap_or(true);
         let is_sub_query = definition.static_data().sub_query.unwrap_or(false);
         let is_multi_stage = definition.static_data().multi_stage.unwrap_or(false);
-        let is_reference = !owned_by_cube
-            && !is_sub_query
-            && is_sql_direct_ref
-            && case.is_none()
-            && latitude.is_none()
-            && longitude.is_none()
-            && !is_multi_stage;
+        let is_reference = is_view
+            || (!owned_by_cube
+                && !is_sub_query
+                && is_sql_direct_ref
+                && case.is_none()
+                && latitude.is_none()
+                && longitude.is_none()
+                && !is_multi_stage);
         Ok(MemberSymbol::new_dimension(DimensionSymbol::new(
             cube_name,
             name,

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

@@ -235,6 +235,17 @@ impl MeasureSymbol {
         self.is_reference
     }
 
+    pub fn reference_member(&self) -> Option<Rc<MemberSymbol>> {
+        if !self.is_reference() {
+            return None;
+        }
+        let deps = self.get_dependencies();
+        if deps.is_empty() {
+            return None;
+        }
+        deps.first().cloned()
+    }
+
     pub fn measure_type(&self) -> &String {
         &self.definition.static_data().measure_type
     }

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

@@ -11,21 +11,25 @@ pub struct MemberExpressionSymbol {
     expression: Rc<SqlCall>,
     #[allow(dead_code)]
     definition: Option<String>,
+    is_reference: bool,
 }
 
 impl MemberExpressionSymbol {
-    pub fn new(
+    pub fn try_new(
         cube_name: String,
         name: String,
         expression: Rc<SqlCall>,
         definition: Option<String>,
-    ) -> Self {
-        Self {
+    ) -> Result<Self, CubeError> {
+
+        let is_reference = expression.is_direct_reference()?;
+        Ok(Self {
             cube_name,
             name,
             expression,
             definition,
-        }
+            is_reference
+        })
     }
 
     pub fn evaluate_sql(
@@ -50,7 +54,18 @@ impl MemberExpressionSymbol {
     }
 
     pub fn is_reference(&self) -> bool {
-        false
+        self.is_reference
+    }
+
+    pub fn reference_member(&self) -> Option<Rc<MemberSymbol>> {
+        if !self.is_reference() {
+            return None;
+        }
+        let deps = self.get_dependencies();
+        if deps.is_empty() {
+            return None;
+        }
+        deps.first().cloned()
     }
 
     pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {

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

@@ -137,11 +137,14 @@ impl MemberSymbol {
     }
 
     pub fn reference_member(&self) -> Option<Rc<MemberSymbol>> {
-        let deps = self.get_dependencies();
-        if deps.is_empty() || !self.is_reference() {
-            return None;
+        match self {
+            Self::Dimension(d) => d.reference_member(),
+            Self::TimeDimension(d) => d.reference_member(),
+            Self::Measure(m) => m.reference_member(),
+            Self::CubeName(_) => None,
+            Self::CubeTable(_) => None,
+            Self::MemberExpression(e) => e.reference_member(),
         }
-        deps.first().cloned()
     }
 
     pub fn resolve_reference_chain(self: Rc<Self>) -> Rc<MemberSymbol> {

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

@@ -110,6 +110,20 @@ impl TimeDimensionSymbol {
         self.base_symbol.is_reference()
     }
 
+    pub fn reference_member(&self) -> Option<Rc<MemberSymbol>> {
+        if let Some(base_symbol) = self.base_symbol.clone().reference_member() {
+            let new_time_dim = Self::new(
+                base_symbol,
+                self.granularity.clone(),
+                self.granularity_obj.clone(),
+                self.date_range.clone(),
+            );
+            Some(Rc::new(MemberSymbol::TimeDimension(new_time_dim)))
+        } else {
+            None
+        }
+    }
+
     pub fn name(&self) -> String {
         self.base_symbol.name()
     }