perf(cubesql): Avoid allocations in MetaContext methods (#9228)

cube-js · Feb 18, 2025 · ba753d0 · ba753d0
1 parent d2b125e
commit ba753d0
Show file tree

Hide file tree

Showing 13 changed files with 132 additions and 107 deletions.
diff --git a/packages/cubejs-backend-native/Cargo.lock b/packages/cubejs-backend-native/Cargo.lock
diff --git a/rust/cubenativeutils/Cargo.lock b/rust/cubenativeutils/Cargo.lock
diff --git a/rust/cubesql/Cargo.lock b/rust/cubesql/Cargo.lock
diff --git a/rust/cubesql/cubesql/Cargo.toml b/rust/cubesql/cubesql/Cargo.toml
@@ -21,7 +21,7 @@ sqlparser = { git = 'https://github.com/cube-js/sqlparser-rs.git', rev = "6a54d2
 base64 = "0.13.0"
 tokio = { version = "^1.35", features = ["full", "rt", "tracing"] }
 serde = { version = "^1.0", features = ["derive"] }
-itertools = "0.10.2"
+itertools = "0.14.0"
 serde_json = "^1.0"
 bytes = "1.2"
 futures = "0.3.23"

diff --git a/rust/cubesql/cubesql/src/compile/rewrite/converter.rs b/rust/cubesql/cubesql/src/compile/rewrite/converter.rs
@@ -1551,14 +1551,13 @@ impl LanguageToLogicalPlanConverter {
                                 match_data_node!(node_by_id, measure_params[0], MeasureName);
                             let expr = self.to_expr(measure_params[1])?;
                             query_measures.push(measure.to_string());
-                            let data_type = self
-                                .cube_context
-                                .meta
-                                .find_df_data_type(measure.to_string())
-                                .ok_or(CubeError::internal(format!(
-                                    "Can't find measure '{}'",
-                                    measure
-                                )))?;
+                            let data_type =
+                                self.cube_context.meta.find_df_data_type(&measure).ok_or(
+                                    CubeError::internal(format!(
+                                        "Can't find measure '{}'",
+                                        measure
+                                    )),
+                                )?;
                             fields.push((
                                 DFField::new(
                                     expr_relation(&expr),
@@ -1608,14 +1607,13 @@ impl LanguageToLogicalPlanConverter {
                         LogicalPlanLanguage::Dimension(params) => {
                             let dimension = match_data_node!(node_by_id, params[0], DimensionName);
                             let expr = self.to_expr(params[1])?;
-                            let data_type = self
-                                .cube_context
-                                .meta
-                                .find_df_data_type(dimension.to_string())
-                                .ok_or(CubeError::internal(format!(
-                                    "Can't find dimension '{}'",
-                                    dimension
-                                )))?;
+                            let data_type =
+                                self.cube_context.meta.find_df_data_type(&dimension).ok_or(
+                                    CubeError::internal(format!(
+                                        "Can't find dimension '{}'",
+                                        dimension
+                                    )),
+                                )?;
                             query_dimensions.push(dimension.to_string());
                             fields.push((
                                 DFField::new(
@@ -1705,7 +1703,7 @@ impl LanguageToLogicalPlanConverter {
                                         if self
                                             .cube_context
                                             .meta
-                                            .is_synthetic_field(column.member_name().to_string())
+                                            .is_synthetic_field(column.member_name())
                                         {
                                             fields.push((
                                                 DFField::new(

diff --git a/rust/cubesql/cubesql/src/compile/rewrite/cost.rs b/rust/cubesql/cubesql/src/compile/rewrite/cost.rs
@@ -143,7 +143,7 @@ impl BestCubePlan {
 
         let time_dimensions_used_as_dimensions = match enode {
             LogicalPlanLanguage::DimensionName(DimensionName(name)) => {
-                if let Some(dimension) = self.meta_context.find_dimension_with_name(name.clone()) {
+                if let Some(dimension) = self.meta_context.find_dimension_with_name(name) {
                     if dimension.is_time() {
                         1
                     } else {

diff --git a/rust/cubesql/cubesql/src/compile/rewrite/rules/filters.rs b/rust/cubesql/cubesql/src/compile/rewrite/rules/filters.rs
@@ -3730,15 +3730,15 @@ impl FilterRules {
         }
     }
 
-    fn filter_member_name(
+    fn filter_member_name<'meta>(
         egraph: &mut CubeEGraph,
         subst: &Subst,
-        meta_context: &Arc<MetaContext>,
+        meta_context: &'meta MetaContext,
         alias_to_cube_var: Var,
         column_var: Var,
         members_var: Var,
         aliases: &Vec<(String, String)>,
-    ) -> Option<(String, V1CubeMeta)> {
+    ) -> Option<(String, &'meta V1CubeMeta)> {
         Self::filter_member_name_with_granularity(
             egraph,
             subst,
@@ -3751,15 +3751,15 @@ impl FilterRules {
         .map(|(name, _, meta)| (name, meta))
     }
 
-    fn filter_member_name_with_granularity(
+    fn filter_member_name_with_granularity<'meta>(
         egraph: &mut CubeEGraph,
         subst: &Subst,
-        meta_context: &Arc<MetaContext>,
+        meta_context: &'meta MetaContext,
         alias_to_cube_var: Var,
         column_var: Var,
         members_var: Var,
         aliases: &Vec<(String, String)>,
-    ) -> Option<(String, Option<String>, V1CubeMeta)> {
+    ) -> Option<(String, Option<String>, &'meta V1CubeMeta)> {
         let alias_to_cubes: Vec<_> =
             var_iter!(egraph[subst[alias_to_cube_var]], FilterReplacerAliasToCube)
                 .cloned()

diff --git a/rust/cubesql/cubesql/src/compile/rewrite/rules/members.rs b/rust/cubesql/cubesql/src/compile/rewrite/rules/members.rs
@@ -2166,7 +2166,7 @@ impl MemberRules {
                             .cloned()
                             {
                                 if let Some(measure) =
-                                    meta_context.find_measure_with_name(measure_name.to_string())
+                                    meta_context.find_measure_with_name(&measure_name)
                                 {
                                     let measure_cube_name = measure_name.split(".").next().unwrap();
                                     if let Some(((_, cube_alias), _)) = alias_to_cube
@@ -2205,7 +2205,7 @@ impl MemberRules {
                                 }
 
                                 if let Some(dimension) =
-                                    meta_context.find_dimension_with_name(measure_name.to_string())
+                                    meta_context.find_dimension_with_name(&measure_name)
                                 {
                                     let alias_to_cube = alias_to_cube.clone();
                                     subst.insert(
@@ -2309,7 +2309,7 @@ impl MemberRules {
                                                 call_agg_type,
                                                 alias,
                                                 measure_out_var,
-                                                cube_alias,
+                                                cube_alias.to_string(),
                                                 subst[aggr_expr_var],
                                                 alias_to_cube,
                                                 disable_strict_agg_type_match,

diff --git a/rust/cubesql/cubesql/src/compile/rewrite/rules/old_split.rs b/rust/cubesql/cubesql/src/compile/rewrite/rules/old_split.rs
@@ -4922,7 +4922,7 @@ impl OldSplitRules {
                             // TODO unwrap
                             let name = expr.name(&DFSchema::empty()).unwrap();
                             let column1 = Column {
-                                relation: Some(alias),
+                                relation: Some(alias.to_string()),
                                 name: name.to_string(),
                             };
                             let alias = egraph.add(LogicalPlanLanguage::ColumnExprColumn(

diff --git a/rust/cubesql/cubesql/src/compile/rewrite/rules/wrapper/aggregate.rs b/rust/cubesql/cubesql/src/compile/rewrite/rules/wrapper/aggregate.rs
@@ -878,9 +878,7 @@ impl WrapperRules {
                                         &column.name,
                                     )
                                 {
-                                    if let Some(measure) =
-                                        meta.find_measure_with_name(member.to_string())
-                                    {
+                                    if let Some(measure) = meta.find_measure_with_name(member) {
                                         if call_agg_type.is_none()
                                             || measure.is_same_agg_type(
                                                 call_agg_type.as_ref().unwrap(),

diff --git a/rust/cubesql/cubesql/src/compile/rewrite/rules/wrapper/column.rs b/rust/cubesql/cubesql/src/compile/rewrite/rules/wrapper/column.rs
@@ -214,7 +214,7 @@ impl WrapperRules {
                     .data
                     .find_member_by_alias(&column.name)
                 {
-                    if let Some(measure) = meta.find_measure_with_name(member.to_string()) {
+                    if let Some(measure) = meta.find_measure_with_name(member) {
                         if measure.agg_type != Some("number".to_string()) {
                             return true;
                         }