upd

Author: waralexrom

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/logical_node.rs

@@ -100,10 +100,10 @@ pub(super) fn check_inputs_len(
         Ok(())
     } else {
         Err(CubeError::internal(format!(
-            "For node {} expected {} inputs but received {}",
+            "{} received {} inputs, but {} were expected",
             node_type,
-            expected,
-            inputs.len()
+            inputs.len(),
+            expected
         )))
     }
 }

rust/cubesqlplanner/cubesqlplanner/src/logical_plan/visitor/rewriter.rs

@@ -8,9 +8,9 @@ pub struct NodeRewriteResult {
 }
 
 impl NodeRewriteResult {
-    pub fn rewritten(rewrited: PlanNode) -> Self {
+    pub fn rewritten(rewritten_node: PlanNode) -> Self {
         Self {
-            rewritten: Some(rewrited),
+            rewritten: Some(rewritten_node),
             stop: true,
         }
     }

rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs

@@ -115,6 +115,7 @@ impl PhysicalPlanBuilder {
     ) -> Result<(), CubeError> {
         let mut context = context.clone();
         context.dimensions_query = false;
+        context.measure_subquery = true;
         let sub_query = self.process_node(dimension_subquery.query.as_ref(), &context)?;
         let dim_name = dimension_subquery.subquery_dimension.name();
         let cube_name = dimension_subquery.subquery_dimension.cube_name();

rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/context.rs

@@ -16,6 +16,7 @@ pub(super) struct PushDownBuilderContext {
     pub original_sql_pre_aggregations: HashMap<String, String>,
     pub required_measures: Option<Vec<Rc<MemberSymbol>>>,
     pub dimensions_query: bool,
+    pub measure_subquery: bool,
     pub multi_stage_schemas: HashMap<String, Rc<Schema>>,
 }
 

rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/query.rs

@@ -94,7 +94,11 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
                 &None,
                 &mut render_references,
             )?;
-            select_builder.add_projection_member(member, None);
+            if context.measure_subquery {
+                select_builder.add_projection_member_without_schema(member, None);
+            } else {
+                select_builder.add_projection_member(member, None);
+            }
         }
 
         for (measure, exists) in self

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

@@ -77,6 +77,22 @@ impl SelectBuilder {
             .add_column(SchemaColumn::new(alias.clone(), Some(member.full_name())));
     }
 
+    pub fn add_projection_member_without_schema(&mut self, member: &Rc<MemberSymbol>, alias: Option<String>) {
+        let alias = if let Some(alias) = alias {
+            alias
+        } else {
+            member.alias()
+        };
+
+        let expr = Expr::Member(MemberExpression::new(member.clone()));
+        let aliased_expr = AliasedExpr {
+            expr,
+            alias: alias.clone(),
+        };
+
+        self.projection_columns.push(aliased_expr);
+    }
+
     pub fn add_projection_member_reference(
         &mut self,
         member: &Rc<MemberSymbol>,

rust/cubesqlplanner/cubesqlplanner/src/plan/subquery.rs

@@ -240,9 +240,14 @@ impl QueryProperties {
                                         }
                                     }
                                     let source_measure_compiled = evaluator_compiler.add_measure_evaluator(source_measure.clone())?;
-                                    let patched_measure = source_measure_compiled.as_measure()?.new_patched(new_measure_type, filters_to_add)?;
-                                    let patched_symbol = MemberSymbol::new_measure(patched_measure);
-                                    MemberExpressionExpression::PatchedSymbol(patched_symbol)
+                                    let symbol = if let Ok(source_measure) = source_measure_compiled.as_measure() {
+
+                                        let patched_measure = source_measure.new_patched(new_measure_type, filters_to_add)?;
+                                        MemberSymbol::new_measure(patched_measure)
+                                    } else {
+                                        source_measure_compiled
+                                    };
+                                    MemberExpressionExpression::PatchedSymbol(symbol)
 
                                 } else {
                                     return Err(CubeError::user(format!("Source measure is required for `PatchMeasure` type of memeber expression")));
@@ -808,12 +813,20 @@ impl QueryProperties {
                             .rendered_as_multiplied_measures
                             .insert(item.measure.full_name());
                     }
-                    if item.multiplied
-                        && !item
-                            .measure
-                            .as_measure()?
-                            .can_used_as_addictive_in_multplied()
-                    {
+                    let is_multiplied_measure = if item.multiplied {
+                        if let Ok(measure) = item.measure.as_measure() {
+                            if measure.can_used_as_addictive_in_multplied() {
+                                false
+                            } else {
+                                true
+                            }
+                        } else {
+                            true
+                        }
+                    } else {
+                        false
+                    };
+                    if is_multiplied_measure {
                         result
                             .multiplied_measures
                             .push(MultipliedMeasure::new(item.measure.clone(), item.cube_name));