chore(tesseract): resolve join trees once per query (#10982)

Author: waralexrom

rust/cube/cubesqlplanner/cubesqlplanner/src/planner/collectors/multiplied_measures_collector.rs

@@ -1,5 +1,4 @@
-use crate::cube_bridge::join_definition::JoinDefinition;
-use crate::planner::{MemberSymbol, TraversalVisitor};
+use crate::planner::{JoinTree, MemberSymbol, TraversalVisitor};
 use cubenativeutils::CubeError;
 use std::collections::HashSet;
 use std::rc::Rc;
@@ -67,11 +66,11 @@ pub struct MeasureResult {
 pub struct MultipliedMeasuresCollector {
     composite_measures: HashSet<String>,
     colllected_measures: Vec<MeasureResult>,
-    join: Rc<dyn JoinDefinition>,
+    join: Rc<JoinTree>,
 }
 
 impl MultipliedMeasuresCollector {
-    pub fn new(composite_measures: HashSet<String>, join: Rc<dyn JoinDefinition>) -> Self {
+    pub fn new(composite_measures: HashSet<String>, join: Rc<JoinTree>) -> Self {
         Self {
             composite_measures,
             join,
@@ -94,13 +93,7 @@ impl TraversalVisitor for MultipliedMeasuresCollector {
         let res = match node.as_ref() {
             MemberSymbol::Measure(e) => {
                 let full_name = e.full_name();
-                let multiplied = self
-                    .join
-                    .static_data()
-                    .multiplication_factor
-                    .get(&e.cube_name())
-                    .unwrap_or(&false)
-                    .clone();
+                let multiplied = self.join.is_multiplied(&e.cube_name());
 
                 if !self.composite_measures.contains(&full_name) {
                     self.colllected_measures.push(MeasureResult {
@@ -126,7 +119,7 @@ impl TraversalVisitor for MultipliedMeasuresCollector {
 
 pub fn collect_multiplied_measures(
     node: &Rc<MemberSymbol>,
-    join: Rc<dyn JoinDefinition>,
+    join: &Rc<JoinTree>,
 ) -> Result<Vec<MeasureResult>, CubeError> {
     if let Ok(member_expression) = node.as_member_expression() {
         if let Some(cube_names) = member_expression.cube_names_if_dimension_only_expression()? {
@@ -138,12 +131,7 @@ pub fn collect_multiplied_measures(
                 }]
             } else if cube_names.len() == 1 {
                 let cube_name = cube_names[0].clone();
-                let multiplied = join
-                    .static_data()
-                    .multiplication_factor
-                    .get(&cube_name)
-                    .unwrap_or(&false)
-                    .clone();
+                let multiplied = join.is_multiplied(&cube_name);
 
                 vec![MeasureResult {
                     measure: node.clone(),

rust/cube/cubesqlplanner/cubesqlplanner/src/planner/collectors/sub_query_dimensions.rs

@@ -1,6 +1,4 @@
-use crate::cube_bridge::join_definition::JoinDefinition;
-use crate::planner::planners::JoinPlanner;
-use crate::planner::{DimensionSymbol, MemberSymbol, TraversalVisitor};
+use crate::planner::{DimensionSymbol, JoinTree, MemberSymbol, TraversalVisitor};
 use cubenativeutils::CubeError;
 use itertools::Itertools;
 use std::rc::Rc;
@@ -61,24 +59,21 @@ impl TraversalVisitor for SubQueryDimensionsCollector {
 
 pub fn collect_sub_query_dimensions_from_members(
     members: &Vec<Rc<MemberSymbol>>,
-    join_planner: &JoinPlanner,
-    join: &Rc<dyn JoinDefinition>,
+    join: &JoinTree,
 ) -> Result<Vec<Rc<MemberSymbol>>, CubeError> {
-    collect_sub_query_dimensions_from_symbols(&members, join_planner, join)
+    collect_sub_query_dimensions_from_symbols(members, join)
 }
 
 pub fn collect_sub_query_dimensions_from_symbols(
     members: &Vec<Rc<MemberSymbol>>,
-    join_planner: &JoinPlanner,
-    join: &Rc<dyn JoinDefinition>,
+    join: &JoinTree,
 ) -> Result<Vec<Rc<MemberSymbol>>, CubeError> {
     let mut visitor = SubQueryDimensionsCollector::new();
     for member in members.iter() {
-        visitor.apply(&member, &())?;
+        visitor.apply(member, &())?;
     }
-    for join_item in join.joins()? {
-        let condition = join_planner.compile_join_condition(join_item.clone())?;
-        for dep in condition.get_dependencies() {
+    for join_item in join.joins() {
+        for dep in join_item.on_sql().get_dependencies() {
             visitor.apply(&dep, &())?;
         }
     }

rust/cube/cubesqlplanner/cubesqlplanner/src/planner/join_tree.rs

@@ -0,0 +1,76 @@
+use crate::planner::BaseCube;
+use crate::planner::SqlCall;
+use std::collections::HashMap;
+use std::rc::Rc;
+
+/// One non-root cube of a `JoinTree` with its parent cube and the
+/// compiled ON SQL connecting them. `original_from` is the parent in
+/// the join graph; the cube itself is the `original_to`.
+pub struct JoinTreeItem {
+    cube: Rc<BaseCube>,
+    original_from: String,
+    on_sql: Rc<SqlCall>,
+}
+
+impl JoinTreeItem {
+    pub fn new(cube: Rc<BaseCube>, original_from: String, on_sql: Rc<SqlCall>) -> Self {
+        Self {
+            cube,
+            original_from,
+            on_sql,
+        }
+    }
+
+    pub fn cube(&self) -> &Rc<BaseCube> {
+        &self.cube
+    }
+
+    pub fn original_from(&self) -> &str {
+        &self.original_from
+    }
+
+    pub fn on_sql(&self) -> &Rc<SqlCall> {
+        &self.on_sql
+    }
+}
+
+/// A resolved join tree: the root cube plus its joined cubes with the
+/// ON SQL already compiled into `SqlCall`. Built once from a
+/// `JoinDefinition` so the rest of planning can assemble `LogicalJoin`
+/// nodes (and collect sub-query dimensions) without recompiling the
+/// join conditions on every use.
+pub struct JoinTree {
+    root: Rc<BaseCube>,
+    joins: Vec<JoinTreeItem>,
+    multiplication_factor: HashMap<String, bool>,
+}
+
+impl JoinTree {
+    pub fn new(
+        root: Rc<BaseCube>,
+        joins: Vec<JoinTreeItem>,
+        multiplication_factor: HashMap<String, bool>,
+    ) -> Rc<Self> {
+        Rc::new(Self {
+            root,
+            joins,
+            multiplication_factor,
+        })
+    }
+
+    pub fn root(&self) -> &Rc<BaseCube> {
+        &self.root
+    }
+
+    pub fn joins(&self) -> &Vec<JoinTreeItem> {
+        &self.joins
+    }
+
+    /// Whether joining `cube_name` into this tree multiplies its rows.
+    pub fn is_multiplied(&self, cube_name: &str) -> bool {
+        self.multiplication_factor
+            .get(cube_name)
+            .copied()
+            .unwrap_or(false)
+    }
+}

rust/cube/cubesqlplanner/cubesqlplanner/src/planner/join_tree_cache.rs

@@ -0,0 +1,41 @@
+use crate::planner::join_hints::JoinHints;
+use crate::planner::query_tools::JoinKey;
+use crate::planner::JoinTree;
+use cubenativeutils::CubeError;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+
+/// Per-query cache of join trees keyed by the `JoinHints` that produced
+/// them. The join graph is immutable within a `QueryTools` lifetime, so
+/// the same hints always resolve to the same join — caching avoids
+/// re-crossing the JS bridge and recompiling ON SQL when the same hints
+/// are resolved repeatedly (e.g. once per pre-aggregation candidate).
+#[derive(Default)]
+pub struct JoinTreeCache {
+    by_hints: RefCell<HashMap<JoinHints, (JoinKey, Rc<JoinTree>)>>,
+}
+
+impl JoinTreeCache {
+    /// Returns the cached `(JoinKey, JoinTree)` for `hints`, building and
+    /// storing it via `build` on a miss. `build` is supplied per call so
+    /// the cache holds no reference back to `QueryTools`.
+    pub fn get_or_build(
+        &self,
+        hints: &JoinHints,
+        build: impl FnOnce() -> Result<(JoinKey, Rc<JoinTree>), CubeError>,
+    ) -> Result<(JoinKey, Rc<JoinTree>), CubeError> {
+        // The lookup borrow is dropped before `build` runs and re-acquired for
+        // the insert, so `build` may itself call back into the cache. Do not
+        // fold this into a single `entry()` call — that would hold the borrow
+        // across `build` and panic on any re-entrant access.
+        if let Some(cached) = self.by_hints.borrow().get(hints) {
+            return Ok(cached.clone());
+        }
+        let built = build()?;
+        self.by_hints
+            .borrow_mut()
+            .insert(hints.clone(), built.clone());
+        Ok(built)
+    }
+}

rust/cube/cubesqlplanner/cubesqlplanner/src/planner/mod.rs

@@ -5,6 +5,8 @@ pub mod collectors;
 pub mod compiler;
 pub mod filter;
 pub mod join_hints;
+pub mod join_tree;
+pub mod join_tree_cache;
 pub mod multi_fact_join_groups;
 pub mod sql_call;
 mod sql_call_builder;
@@ -28,6 +30,8 @@ pub use base_join_condition::{BaseJoinCondition, SqlJoinCondition};
 pub use base_query::BaseQuery;
 pub use compiler::Compiler;
 pub use join_hints::JoinHints;
+pub use join_tree::{JoinTree, JoinTreeItem};
+pub use join_tree_cache::JoinTreeCache;
 pub use params_allocator::ParamsAllocator;
 pub use query_properties::{FullKeyAggregateMeasures, OrderByItem, QueryProperties};
 pub use query_properties_compiler::QueryPropertiesCompiler;

rust/cube/cubesqlplanner/cubesqlplanner/src/planner/multi_fact_join_groups.rs

@@ -1,9 +1,10 @@
-use crate::cube_bridge::join_definition::JoinDefinition;
 use crate::planner::collectors::{collect_join_hints, has_multi_stage_members};
 use crate::planner::filter::FilterItem;
 use crate::planner::join_hints::JoinHints;
+use crate::planner::planners::JoinTreeBuilder;
 use crate::planner::query_tools::JoinKey;
 use crate::planner::query_tools::QueryTools;
+use crate::planner::JoinTree;
 use crate::planner::MemberSymbol;
 use cubenativeutils::CubeError;
 use itertools::Itertools;
@@ -148,7 +149,7 @@ impl MeasuresJoinHints {
 pub struct MultiFactJoinGroups {
     query_tools: Rc<QueryTools>,
     measures_join_hints: MeasuresJoinHints,
-    groups: Vec<(Rc<dyn JoinDefinition>, Vec<Rc<MemberSymbol>>)>,
+    groups: Vec<(Rc<JoinTree>, Vec<Rc<MemberSymbol>>)>,
     /// cube_name → join path from root, computed from the first group (shared for dimensions).
     dimension_paths: HashMap<String, Vec<String>>,
     /// measure full_name → join path from root, computed per group.
@@ -163,7 +164,7 @@ impl MultiFactJoinGroups {
         measures_join_hints: MeasuresJoinHints,
     ) -> Result<Self, CubeError> {
         let groups = Self::build_groups(&query_tools, &measures_join_hints)?;
-        let (dimension_paths, measure_paths) = Self::precompute_paths(&groups)?;
+        let (dimension_paths, measure_paths) = Self::precompute_paths(&groups);
         Ok(Self {
             query_tools,
             measures_join_hints,
@@ -183,34 +184,41 @@ impl MultiFactJoinGroups {
     fn build_groups(
         query_tools: &Rc<QueryTools>,
         hints: &MeasuresJoinHints,
-    ) -> Result<Vec<(Rc<dyn JoinDefinition>, Vec<Rc<MemberSymbol>>)>, CubeError> {
+    ) -> Result<Vec<(Rc<JoinTree>, Vec<Rc<MemberSymbol>>)>, CubeError> {
+        let join_tree_builder = JoinTreeBuilder::new(query_tools.clone());
+        let resolve = |join_hints: &JoinHints| -> Result<(JoinKey, Rc<JoinTree>), CubeError> {
+            query_tools.join_tree_cache().get_or_build(join_hints, || {
+                let (key, join) = query_tools.join_for_hints(join_hints)?;
+                Ok((key, join_tree_builder.build(join)?))
+            })
+        };
+
         let measures_to_join = if hints.measure_hints.is_empty() {
             if hints.base_hints.is_empty() {
                 vec![]
             } else {
-                let (key, join) = query_tools.join_for_hints(&hints.base_hints)?;
-                vec![(Vec::new(), key, join)]
+                let (key, join_tree) = resolve(&hints.base_hints)?;
+                vec![(Vec::new(), key, join_tree)]
             }
         } else {
             hints
                 .measure_hints
                 .iter()
                 .map(|mh| -> Result<_, CubeError> {
-                    let (key, join) = query_tools.join_for_hints(&mh.hints)?;
-                    Ok((vec![mh.measure.clone()], key, join))
+                    let (key, join_tree) = resolve(&mh.hints)?;
+                    Ok((vec![mh.measure.clone()], key, join_tree))
                 })
                 .collect::<Result<Vec<_>, _>>()?
         };
 
         let mut key_order: Vec<JoinKey> = Vec::new();
-        let mut grouped: HashMap<JoinKey, (Rc<dyn JoinDefinition>, Vec<Rc<MemberSymbol>>)> =
-            HashMap::new();
-        for (measures, key, join) in measures_to_join {
+        let mut grouped: HashMap<JoinKey, (Rc<JoinTree>, Vec<Rc<MemberSymbol>>)> = HashMap::new();
+        for (measures, key, join_tree) in measures_to_join {
             if let Some(entry) = grouped.get_mut(&key) {
                 entry.1.extend(measures);
             } else {
                 key_order.push(key.clone());
-                grouped.insert(key, (join, measures));
+                grouped.insert(key, (join_tree, measures));
             }
         }
 
@@ -229,7 +237,7 @@ impl MultiFactJoinGroups {
         self.groups.len() > 1
     }
 
-    pub fn groups(&self) -> &[(Rc<dyn JoinDefinition>, Vec<Rc<MemberSymbol>>)] {
+    pub fn groups(&self) -> &[(Rc<JoinTree>, Vec<Rc<MemberSymbol>>)] {
         &self.groups
     }
 
@@ -258,55 +266,54 @@ impl MultiFactJoinGroups {
     }
 
     fn precompute_paths(
-        groups: &[(Rc<dyn JoinDefinition>, Vec<Rc<MemberSymbol>>)],
-    ) -> Result<(HashMap<String, Vec<String>>, HashMap<String, Vec<String>>), CubeError> {
+        groups: &[(Rc<JoinTree>, Vec<Rc<MemberSymbol>>)],
+    ) -> (HashMap<String, Vec<String>>, HashMap<String, Vec<String>>) {
         let dimension_paths = if groups.is_empty() {
             HashMap::new()
         } else {
-            Self::build_cube_paths(&*groups[0].0)?
+            Self::build_cube_paths(&groups[0].0)
         };
 
         let mut measure_paths = HashMap::new();
         for (join, measures) in groups {
             if measures.is_empty() {
                 continue;
             }
-            let cube_paths = Self::build_cube_paths(&**join)?;
+            let cube_paths = Self::build_cube_paths(join);
             for m in measures {
                 if let Some(path) = cube_paths.get(&m.cube_name()) {
                     measure_paths.insert(m.full_name(), path.clone());
                 }
             }
         }
 
-        Ok((dimension_paths, measure_paths))
+        (dimension_paths, measure_paths)
     }
 
-    fn build_cube_paths(
-        join: &dyn JoinDefinition,
-    ) -> Result<HashMap<String, Vec<String>>, CubeError> {
-        let root = join.static_data().root.clone();
+    fn build_cube_paths(join: &JoinTree) -> HashMap<String, Vec<String>> {
+        let root = join.root().name().clone();
         let mut paths: HashMap<String, Vec<String>> = HashMap::new();
         paths.insert(root.clone(), vec![root]);
 
-        for join_item in join.joins()? {
-            let sd = join_item.static_data();
+        for join_item in join.joins() {
+            let original_from = join_item.original_from().to_string();
+            let original_to = join_item.cube().name().clone();
             let parent_path = paths
-                .get(&sd.original_from)
+                .get(&original_from)
                 .cloned()
-                .unwrap_or_else(|| vec![sd.original_from.clone()]);
+                .unwrap_or_else(|| vec![original_from]);
             let mut path = parent_path;
-            path.push(sd.original_to.clone());
-            paths.insert(sd.original_to.clone(), path);
+            path.push(original_to.clone());
+            paths.insert(original_to, path);
         }
 
-        Ok(paths)
+        paths
     }
 
     /// The only join when the query has exactly one group; errors if
     /// the query is multi-fact, and `Ok(None)` if it has no groups
     /// at all.
-    pub fn single_join(&self) -> Result<Option<Rc<dyn JoinDefinition>>, CubeError> {
+    pub fn single_join(&self) -> Result<Option<Rc<JoinTree>>, CubeError> {
         if self.groups.is_empty() {
             return Ok(None);
         }