add support for transitive joins in tesseract

Author: KSDaemon

packages/cubejs-schema-compiler/src/adapter/BaseQuery.js

@@ -386,6 +386,53 @@ export class BaseQuery {
     }
   }
 
+  /**
+   * Is used by native
+   * This function follows the same logic as in this.collectJoinHints()
+   * @private
+   * @param {Array<(Array<string> | string)>} hints
+   * @return {import('../compiler/JoinGraph').FinishedJoinTree}
+   */
+  joinTreeForHints(hints) {
+    const explicitJoinHintMembers = new Set(hints.filter(j => Array.isArray(j)).flat());
+    const queryJoinMaps = this.queryJoinMap();
+    const newCollectedHints = [];
+
+    const constructJH = () => R.uniq(this.enrichHintsWithJoinMap([
+      ...newCollectedHints,
+      ...hints,
+    ],
+    queryJoinMaps));
+
+    let prevJoin = null;
+    let newJoin = null;
+
+    // Safeguard against infinite loop in case of cyclic joins somehow managed to slip through
+    let cnt = 0;
+    let newJoinHintsCollectedCnt;
+
+    do {
+      const allJoinHints = constructJH();
+      prevJoin = newJoin;
+      newJoin = this.joinGraph.buildJoin(allJoinHints);
+      const allJoinHintsFlatten = new Set(allJoinHints.flat());
+      const joinMembersJoinHints = this.collectJoinHintsFromMembers(this.joinMembersFromJoin(newJoin));
+
+      const iterationCollectedHints = joinMembersJoinHints.filter(j => !allJoinHintsFlatten.has(j));
+      newJoinHintsCollectedCnt = iterationCollectedHints.length;
+      cnt++;
+      if (newJoin) {
+        newCollectedHints.push(...joinMembersJoinHints.filter(j => !explicitJoinHintMembers.has(j)));
+      }
+    } while (newJoin?.joins.length > 0 && !this.isJoinTreesEqual(prevJoin, newJoin) && cnt < 10000 && newJoinHintsCollectedCnt > 0);
+
+    if (cnt >= 10000) {
+      throw new UserError('Can not construct joins for the query, potential loop detected');
+    }
+
+    return newJoin;
+  }
+
   cacheValue(key, fn, { contextPropNames, inputProps, cache } = {}) {
     const currentContext = this.safeEvaluateSymbolContext();
     if (contextPropNames) {
@@ -450,7 +497,7 @@ export class BaseQuery {
 
     for (const member of queryMembers) {
       const memberCube = member.cube?.();
-      if (memberCube?.isView && !joinMaps[memberCube.name]) {
+      if (memberCube?.isView && !joinMaps[memberCube.name] && memberCube.joinMap) {
         joinMaps[memberCube.name] = memberCube.joinMap;
       }
     }

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs

@@ -1,4 +1,5 @@
 use super::base_query_options::FilterItem;
+use super::join_definition::{JoinDefinition, NativeJoinDefinition};
 use super::driver_tools::{DriverTools, NativeDriverTools};
 use super::filter_group::{FilterGroup, NativeFilterGroup};
 use super::filter_params::{FilterParams, NativeFilterParams};
@@ -14,6 +15,7 @@ use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
 use std::any::Any;
 use std::rc::Rc;
+use crate::cube_bridge::join_hints::JoinHintItem;
 
 #[nativebridge::native_bridge]
 pub trait BaseTools {
@@ -53,4 +55,8 @@ pub trait BaseTools {
         cube_name: String,
         name: String,
     ) -> Result<String, CubeError>; //TODO move to rust
+
+    fn join_tree_for_hints(
+        &self,
+        hints: Vec<JoinHintItem>) -> Result<Rc<dyn JoinDefinition>, CubeError>;
 }

rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs

@@ -613,7 +613,7 @@ impl QueryProperties {
                 let join = query_tools
                     .cached_data_mut()
                     .join_by_hints(dimension_and_filter_join_hints_concat.clone(), |hints| {
-                        query_tools.join_graph().build_join(hints)
+                        query_tools.base_tools().join_tree_for_hints(hints)
                     })?;
                 vec![(Vec::new(), join)]
             }
@@ -628,7 +628,7 @@ impl QueryProperties {
                             .into_iter()
                             .chain(dimension_and_filter_join_hints_concat.clone().into_iter())
                             .collect::<Vec<_>>(),
-                        |hints| query_tools.join_graph().build_join(hints),
+                        |hints| query_tools.base_tools().join_tree_for_hints(hints),
                     )?;
                     Ok((vec![m.clone()], join))
                 })