implement join maps

Author: KSDaemon

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

@@ -436,12 +436,14 @@ export class BaseQuery {
   get allJoinHints() {
     if (!this.collectedJoinHints) {
       const allMembersJoinHints = this.collectJoinHintsFromMembers(this.allMembersConcat(false));
+      const queryJoinMaps = this.queryJoinMap();
       const customSubQueryJoinHints = this.collectJoinHintsFromMembers(this.joinMembersFromCustomSubQuery());
-      const allJoinHints = [
+      const allJoinHints = this.enrichHintsWithJoinMap([
         ...this.queryLevelJoinHints,
         ...allMembersJoinHints,
         ...customSubQueryJoinHints,
-      ];
+      ],
+      queryJoinMaps);
 
       const tempJoin = this.joinGraph.buildJoin(allJoinHints);
 
@@ -454,17 +456,63 @@ export class BaseQuery {
       const allJoinHintsFlatten = new Set(allJoinHints.flat());
       const newCollectedHints = joinMembersJoinHints.filter(j => !allJoinHintsFlatten.has(j));
 
-      this.collectedJoinHints = [
+      this.collectedJoinHints = this.enrichHintsWithJoinMap([
         ...this.queryLevelJoinHints,
         tempJoin.root,
         ...newCollectedHints,
         ...allMembersJoinHints,
         ...customSubQueryJoinHints,
-      ];
+      ],
+      queryJoinMaps);
     }
     return this.collectedJoinHints;
   }
 
+  /**
+   * @private
+   * @return { Record<string, string[][]>}
+   */
+  queryJoinMap() {
+    const queryMembers = this.allMembersConcat(false);
+    const joinMaps = {};
+
+    for (const member of queryMembers) {
+      const memberCube = member.cube?.();
+      if (memberCube?.isView && !joinMaps[memberCube.name]) {
+        joinMaps[memberCube.name] = memberCube.joinMap;
+      }
+    }
+
+    return joinMaps;
+  }
+
+  /**
+   * @private
+   * @param { (string|string[])[] } hints
+   * @param { Record<string, string[][]>} joinMap
+   * @return {(string|string[])[]}
+   */
+  enrichHintsWithJoinMap(hints, joinMap) {
+    // Potentially, if joins between views would take place, we need to distinguish
+    // join maps on per view basis.
+    const allPaths = Object.values(joinMap).flat();
+
+    return hints.map(hint => {
+      if (Array.isArray(hint)) {
+        return hint;
+      }
+
+      for (const path of allPaths) {
+        const hintIndex = path.indexOf(hint);
+        if (hintIndex !== -1) {
+          return path.slice(0, hintIndex + 1);
+        }
+      }
+
+      return hint;
+    });
+  }
+
   get dataSource() {
     const dataSources = R.uniq(this.allCubeNames.map(c => this.cubeDataSource(c)));
     if (dataSources.length > 1 && !this.externalPreAggregationQuery()) {

packages/cubejs-schema-compiler/src/compiler/CubeSymbols.ts

@@ -133,6 +133,12 @@ export type AccessPolicyDefinition = {
   };
 };
 
+export type ViewIncludedMember = {
+  type: string;
+  memberPath: string;
+  name: string;
+};
+
 export interface CubeDefinition {
   name: string;
   extends?: (...args: Array<unknown>) => { __cubeName: string };
@@ -159,7 +165,8 @@ export interface CubeDefinition {
   isView?: boolean;
   calendar?: boolean;
   isSplitView?: boolean;
-  includedMembers?: any[];
+  includedMembers?: ViewIncludedMember[];
+  joinMap?: string[][];
   fileName?: string;
 }
 
@@ -562,6 +569,8 @@ export class CubeSymbols implements TranspilerSymbolResolver {
     // `hierarchies` must be processed first
     const types = ['hierarchies', 'measures', 'dimensions', 'segments'];
 
+    const joinMap: string[][] = [];
+
     for (const type of types) {
       let cubeIncludes: any[] = [];
 
@@ -573,6 +582,11 @@ export class CubeSymbols implements TranspilerSymbolResolver {
         const split = fullPath.split('.');
         const cubeRef = split[split.length - 1];
 
+        // No need to keep a simple direct cube joins in join map
+        if (split.length > 1) {
+          joinMap.push(split);
+        }
+
         if (it.includes === '*') {
           return it;
         }
@@ -614,11 +628,7 @@ export class CubeSymbols implements TranspilerSymbolResolver {
         existing.map(({ type: t, memberPath, name }) => `${t}|${memberPath}|${name}`)
       );
 
-      const additions: {
-        type: string;
-        memberPath: string;
-        name: string;
-      }[] = [];
+      const additions: ViewIncludedMember[] = [];
 
       for (const { member, name } of cubeIncludes) {
         const parts = member.split('.');
@@ -636,6 +646,8 @@ export class CubeSymbols implements TranspilerSymbolResolver {
       }
     }
 
+    cube.joinMap = joinMap;
+
     [...memberSets.allMembers].filter(it => !memberSets.resolvedMembers.has(it)).forEach(it => {
       errorReporter.error(`Member '${it}' is included in '${cube.name}' but not defined in any cube`);
     });