Skip to content

Commit 79b8c1d

Browse files
waralexromwaralexrom
committed
remove base members first step
1 parent 4fe655c commit 79b8c1d

21 files changed

+121
-110
lines changed

‎rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/cube_definition.rs

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,16 @@ pub struct CubeDefinitionStatic {
2020
pub is_calendar: Option<bool>,
2121
}
2222

23+
impl CubeDefinitionStatic {
24+
pub fn resolved_alias(&self) -> &String {
25+
if let Some(alias) = &self.sql_alias {
26+
alias
27+
} else {
28+
&self.name
29+
}
30+
}
31+
}
32+
2333
#[nativebridge::native_bridge(CubeDefinitionStatic)]
2434
pub trait CubeDefinition {
2535
#[nbridge(field, optional)]

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

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -729,14 +729,13 @@ impl PhysicalPlanBuilder {
729729
let conditions = primary_keys_dimensions
730730
.iter()
731731
.map(|dim| -> Result<_, CubeError> {
732-
let dim = dim.clone().as_base_member(self.query_tools.clone())?;
733732
let alias_in_sub_query = sub_query.schema().resolve_member_alias(&dim);
734733
let sub_query_ref = Expr::Reference(QualifiedColumnName::new(
735734
Some(sub_query_alias.clone()),
736735
alias_in_sub_query.clone(),
737736
));
738737

739-
Ok(vec![(sub_query_ref, Expr::new_member(dim))])
738+
Ok(vec![(sub_query_ref, Expr::new_member(dim.clone()))])
740739
})
741740
.collect::<Result<Vec<_>, _>>()?;
742741

@@ -1002,10 +1001,8 @@ impl PhysicalPlanBuilder {
10021001
let mut result = Vec::new();
10031002
for o in order_by.iter() {
10041003
for position in logical_schema.find_member_positions(&o.name()) {
1005-
let member_ref: Rc<dyn BaseMember> =
1006-
MemberSymbolRef::try_new(o.member_symbol(), self.query_tools.clone())?;
10071004
result.push(OrderBy::new(
1008-
Expr::Member(MemberExpression::new(member_ref)),
1005+
Expr::Member(MemberExpression::new(o.member_symbol())),
10091006
position + 1,
10101007
o.desc(),
10111008
));

‎rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/aggregate_multiplied_subquery.rs

Lines changed: 9 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -54,14 +54,12 @@ impl<'a> LogicalNodeProcessor<'a, AggregateMultipliedSubquery>
5454
let conditions = primary_keys_dimensions
5555
.iter()
5656
.map(|dim| -> Result<_, CubeError> {
57-
let member_ref = dim.clone().as_base_member(query_tools.clone())?;
58-
let alias_in_keys_query =
59-
keys_query.schema().resolve_member_alias(&member_ref);
57+
let alias_in_keys_query = keys_query.schema().resolve_member_alias(dim);
6058
let keys_query_ref = Expr::Reference(QualifiedColumnName::new(
6159
Some(keys_query_alias.clone()),
6260
alias_in_keys_query,
6361
));
64-
let pk_cube_expr = Expr::Member(MemberExpression::new(member_ref.clone()));
62+
let pk_cube_expr = Expr::Member(MemberExpression::new(dim.clone()));
6563
Ok(vec![(keys_query_ref, pk_cube_expr)])
6664
})
6765
.collect::<Result<Vec<_>, _>>()?;
@@ -87,15 +85,12 @@ impl<'a> LogicalNodeProcessor<'a, AggregateMultipliedSubquery>
8785
let conditions = primary_keys_dimensions
8886
.iter()
8987
.map(|dim| -> Result<_, CubeError> {
90-
let dim_ref = dim.clone().as_base_member(query_tools.clone())?;
91-
let alias_in_keys_query =
92-
keys_query.schema().resolve_member_alias(&dim_ref);
88+
let alias_in_keys_query = keys_query.schema().resolve_member_alias(dim);
9389
let keys_query_ref = Expr::Reference(QualifiedColumnName::new(
9490
Some(keys_query_alias.clone()),
9591
alias_in_keys_query,
9692
));
97-
let alias_in_measure_subquery =
98-
subquery.schema().resolve_member_alias(&dim_ref);
93+
let alias_in_measure_subquery = subquery.schema().resolve_member_alias(dim);
9994
let measure_subquery_ref = Expr::Reference(QualifiedColumnName::new(
10095
Some(pk_cube_alias.clone()),
10196
alias_in_measure_subquery,
@@ -109,9 +104,7 @@ impl<'a> LogicalNodeProcessor<'a, AggregateMultipliedSubquery>
109104
meas.full_name(),
110105
QualifiedColumnName::new(
111106
Some(pk_cube_alias.clone()),
112-
subquery.schema().resolve_member_alias(
113-
&meas.clone().as_base_member(query_tools.clone())?,
114-
),
107+
subquery.schema().resolve_member_alias(meas),
115108
),
116109
);
117110
}
@@ -144,15 +137,13 @@ impl<'a> LogicalNodeProcessor<'a, AggregateMultipliedSubquery>
144137
&mut render_references,
145138
)?;
146139
let alias = references_builder.resolve_alias_for_member(&member.full_name(), &None);
147-
let member_ref = member.clone().as_base_member(query_tools.clone())?;
148-
group_by.push(Expr::Member(MemberExpression::new(member_ref.clone())));
149-
select_builder.add_projection_member(&member_ref, alias);
140+
group_by.push(Expr::Member(MemberExpression::new(member.clone())));
141+
select_builder.add_projection_member(&member, alias);
150142
}
151143
for (measure, exists) in self
152144
.builder
153145
.measures_for_query(&aggregate_multiplied_subquery.schema.measures, &context)
154146
{
155-
let member_ref = measure.clone().as_base_member(query_tools.clone())?;
156147
if exists {
157148
if matches!(
158149
aggregate_multiplied_subquery.source.as_ref(),
@@ -164,9 +155,9 @@ impl<'a> LogicalNodeProcessor<'a, AggregateMultipliedSubquery>
164155
&mut render_references,
165156
)?;
166157
}
167-
select_builder.add_projection_member(&member_ref, None);
158+
select_builder.add_projection_member(&measure, None);
168159
} else {
169-
select_builder.add_null_projection(&member_ref, None);
160+
select_builder.add_null_projection(&measure, None);
170161
}
171162
}
172163
select_builder.set_group_by(group_by);

‎rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/full_key_aggregate.rs

Lines changed: 7 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -86,10 +86,9 @@ impl<'a> FullKeyAggregateStrategy for KeysFullKeyAggregateStrategy<'a> {
8686
let mut keys_select_builder =
8787
SelectBuilder::new(From::new(FromSource::Single(multi_stage_source.clone())));
8888
for dim in full_key_aggregate.schema.all_dimensions() {
89-
let member_ref = dim.clone().as_base_member(query_tools.clone())?;
90-
let alias = multi_stage_schema.resolve_member_alias(&member_ref);
89+
let alias = multi_stage_schema.resolve_member_alias(dim);
9190
let reference = QualifiedColumnName::new(None, alias);
92-
keys_select_builder.add_projection_member_reference(&member_ref, reference);
91+
keys_select_builder.add_projection_member_reference(dim, reference);
9392
}
9493
let sql_context = SqlNodesFactory::new();
9594
keys_select_builder.set_distinct();
@@ -131,8 +130,7 @@ impl<'a> FullKeyAggregateStrategy for KeysFullKeyAggregateStrategy<'a> {
131130
)));
132131
}
133132
let reference = QualifiedColumnName::new(None, alias.unwrap());
134-
let member_ref = member.clone().as_base_member(query_tools.clone())?;
135-
keys_select_builder.add_projection_member_reference(&member_ref, reference);
133+
keys_select_builder.add_projection_member_reference(member, reference);
136134
}
137135
keys_select_builder.set_distinct();
138136

@@ -150,14 +148,12 @@ impl<'a> FullKeyAggregateStrategy for KeysFullKeyAggregateStrategy<'a> {
150148
.schema
151149
.all_dimensions()
152150
.map(|dim| -> Result<_, CubeError> {
153-
let member_ref = dim.clone().as_base_member(query_tools.clone())?;
154-
let alias_in_keys_query =
155-
keys_select.schema().resolve_member_alias(&member_ref);
151+
let alias_in_keys_query = keys_select.schema().resolve_member_alias(dim);
156152
let keys_query_ref = Expr::Reference(QualifiedColumnName::new(
157153
Some(keys_alias.clone()),
158154
alias_in_keys_query,
159155
));
160-
let alias_in_data_query = query.schema().resolve_member_alias(&member_ref);
156+
let alias_in_data_query = query.schema().resolve_member_alias(dim);
161157
let data_query_ref = Expr::Reference(QualifiedColumnName::new(
162158
Some(query_alias.clone()),
163159
alias_in_data_query,
@@ -264,14 +260,12 @@ impl<'a> FullKeyAggregateStrategy for InnerJoinFullKeyAggregateStrategy<'a> {
264260
.schema
265261
.all_dimensions()
266262
.map(|dim| -> Result<_, CubeError> {
267-
let member_ref = dim.clone().as_base_member(query_tools.clone())?;
268-
let alias_in_prev_query =
269-
data_queries[i].schema().resolve_member_alias(&member_ref);
263+
let alias_in_prev_query = data_queries[i].schema().resolve_member_alias(dim);
270264
let prev_query_ref = Expr::Reference(QualifiedColumnName::new(
271265
Some(prev_alias.clone()),
272266
alias_in_prev_query,
273267
));
274-
let alias_in_data_query = query.schema().resolve_member_alias(&member_ref);
268+
let alias_in_data_query = query.schema().resolve_member_alias(dim);
275269
let data_query_ref = Expr::Reference(QualifiedColumnName::new(
276270
Some(query_alias.clone()),
277271
alias_in_data_query,

‎rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/keys_sub_query.rs

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -49,10 +49,8 @@ impl<'a> LogicalNodeProcessor<'a, KeysSubQuery> for KeysSubQueryProcessor<'a> {
4949
.all_dimensions()
5050
.chain(keys_subquery.primary_keys_dimensions.iter())
5151
{
52-
let member_ref: Rc<dyn BaseMember> =
53-
MemberSymbolRef::try_new(member.clone(), query_tools.clone())?;
54-
let alias = member_ref.alias_name();
55-
select_builder.add_projection_member(&member_ref, Some(alias.clone()));
52+
let alias = member.alias();
53+
select_builder.add_projection_member(member, Some(alias));
5654
}
5755

5856
select_builder.set_distinct();

‎rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/measure_subquery.rs

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -46,12 +46,10 @@ impl<'a> LogicalNodeProcessor<'a, MeasureSubquery> for MeasureSubqueryProcessor<
4646
&mut render_references,
4747
)?;
4848
for dim in measure_subquery.schema.dimensions.iter() {
49-
select_builder
50-
.add_projection_member(&dim.clone().as_base_member(query_tools.clone())?, None);
49+
select_builder.add_projection_member(dim, None);
5150
}
5251
for meas in measure_subquery.schema.measures.iter() {
53-
select_builder
54-
.add_projection_member(&meas.clone().as_base_member(query_tools.clone())?, None);
52+
select_builder.add_projection_member(meas, None);
5553
}
5654

5755
context_factory.set_ungrouped_measure(true);

‎rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/multi_stage_get_date_range.rs

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -31,10 +31,7 @@ impl<'a> LogicalNodeProcessor<'a, MultiStageGetDateRange> for MultiStageGetDateR
3131
let references_builder = ReferencesBuilder::new(from.clone());
3232
let mut select_builder = SelectBuilder::new(from);
3333
let mut context_factory = context.make_sql_nodes_factory()?;
34-
let args = vec![get_date_range
35-
.time_dimension
36-
.clone()
37-
.as_base_member(query_tools.clone())?];
34+
let args = vec![get_date_range.time_dimension.clone()];
3835
select_builder.add_projection_function_expression(
3936
"MAX",
4037
args.clone(),

‎rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/multi_stage_measure_calculation.rs

Lines changed: 3 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -46,8 +46,7 @@ impl<'a> LogicalNodeProcessor<'a, MultiStageMeasureCalculation>
4646
&None,
4747
&mut render_references,
4848
)?;
49-
let member_ref = member.clone().as_base_member(query_tools.clone())?;
50-
select_builder.add_projection_member(&member_ref, None);
49+
select_builder.add_projection_member(&member, None);
5150
}
5251

5352
for measure in measure_calculation.schema.measures.iter() {
@@ -57,18 +56,14 @@ impl<'a> LogicalNodeProcessor<'a, MultiStageMeasureCalculation>
5756
&mut render_references,
5857
)?;
5958
let alias = references_builder.resolve_alias_for_member(&measure.full_name(), &None);
60-
select_builder.add_projection_member(
61-
&measure.clone().as_base_member(query_tools.clone())?,
62-
alias,
63-
);
59+
select_builder.add_projection_member(measure, alias);
6460
}
6561

6662
if !measure_calculation.is_ungrouped {
6763
let group_by = all_dimensions
6864
.iter()
6965
.map(|dim| -> Result<_, CubeError> {
70-
let member_ref = dim.clone().as_base_member(query_tools.clone())?;
71-
Ok(Expr::Member(MemberExpression::new(member_ref.clone())))
66+
Ok(Expr::Member(MemberExpression::new(dim.clone())))
7267
})
7368
.collect::<Result<Vec<_>, _>>()?;
7469
select_builder.set_group_by(group_by);

‎rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/multi_stage_rolling_window.rs

Lines changed: 7 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -37,12 +37,8 @@ impl<'a> LogicalNodeProcessor<'a, MultiStageRollingWindow>
3737

3838
let measure_input_schema = context.get_multi_stage_schema(&measure_input_ref)?;
3939

40-
let base_time_dimension_alias = measure_input_schema.resolve_member_alias(
41-
&rolling_window
42-
.time_dimension_in_measure_input
43-
.clone()
44-
.as_base_member(query_tools.clone())?,
45-
);
40+
let base_time_dimension_alias = measure_input_schema
41+
.resolve_member_alias(&rolling_window.time_dimension_in_measure_input);
4642

4743
let root_alias = format!("time_series");
4844
let measure_input_alias = format!("rolling_source");
@@ -119,8 +115,7 @@ impl<'a> LogicalNodeProcessor<'a, MultiStageRollingWindow>
119115
context_factory.add_dimensions_with_ignored_timezone(dim.full_name());
120116
let alias = references_builder
121117
.resolve_alias_for_member(&dim.full_name(), &Some(measure_input_alias.clone()));
122-
select_builder
123-
.add_projection_member(&dim.clone().as_base_member(query_tools.clone())?, alias);
118+
select_builder.add_projection_member(dim, alias);
124119
}
125120

126121
for dim in rolling_window.schema.dimensions.iter() {
@@ -131,28 +126,25 @@ impl<'a> LogicalNodeProcessor<'a, MultiStageRollingWindow>
131126
)?;
132127
let alias = references_builder
133128
.resolve_alias_for_member(&dim.full_name(), &Some(measure_input_alias.clone()));
134-
select_builder
135-
.add_projection_member(&dim.clone().as_base_member(query_tools.clone())?, alias);
129+
select_builder.add_projection_member(dim, alias);
136130
}
137131

138132
for measure in rolling_window.schema.measures.iter() {
139-
let measure_ref = measure.clone().as_base_member(query_tools.clone())?;
140-
let name_in_base_query = measure_input_schema.resolve_member_alias(&measure_ref);
133+
let name_in_base_query = measure_input_schema.resolve_member_alias(measure);
141134
context_factory.add_ungrouped_measure_reference(
142135
measure.full_name(),
143136
QualifiedColumnName::new(Some(measure_input_alias.clone()), name_in_base_query),
144137
);
145138

146-
select_builder.add_projection_member(&measure_ref, None);
139+
select_builder.add_projection_member(&measure, None);
147140
}
148141

149142
if !rolling_window.is_ungrouped {
150143
let group_by = rolling_window
151144
.schema
152145
.all_dimensions()
153146
.map(|dim| -> Result<_, CubeError> {
154-
let member_ref = dim.clone().as_base_member(query_tools.clone())?;
155-
Ok(Expr::Member(MemberExpression::new(member_ref.clone())))
147+
Ok(Expr::Member(MemberExpression::new(dim.clone())))
156148
})
157149
.collect::<Result<Vec<_>, _>>()?;
158150
select_builder.set_group_by(group_by);

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

Lines changed: 4 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -90,24 +90,22 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
9090
&None,
9191
&mut render_references,
9292
)?;
93-
let member_ref = member.clone().as_base_member(query_tools.clone())?;
94-
select_builder.add_projection_member(&member_ref, None);
93+
select_builder.add_projection_member(member, None);
9594
}
9695

9796
for (measure, exists) in self
9897
.builder
9998
.measures_for_query(&logical_plan.schema.measures, &context)
10099
{
101-
let member_ref = measure.clone().as_base_member(query_tools.clone())?;
102100
if exists {
103101
references_builder.resolve_references_for_member(
104102
measure.clone(),
105103
&None,
106104
&mut render_references,
107105
)?;
108-
select_builder.add_projection_member(&member_ref, None);
106+
select_builder.add_projection_member(&measure, None);
109107
} else {
110-
select_builder.add_null_projection(&member_ref, None);
108+
select_builder.add_null_projection(&measure, None);
111109
}
112110
}
113111

@@ -123,9 +121,7 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
123121
.schema
124122
.all_dimensions()
125123
.map(|symbol| -> Result<_, CubeError> {
126-
Ok(Expr::Member(MemberExpression::new(
127-
symbol.clone().as_base_member(query_tools.clone())?,
128-
)))
124+
Ok(Expr::Member(MemberExpression::new(symbol.clone())))
129125
})
130126
.collect::<Result<Vec<_>, _>>()?;
131127
select_builder.set_group_by(group_by);

0 commit comments

Comments
 (0)