remove old

Author: KSDaemon

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

@@ -459,124 +459,6 @@ export class BaseQuery {
         ...newCollectedHints,
         ...allMembersJoinHints,
       ]);
-
-      //
-      // let joinMembersJoinHints = [];
-      // let originalQueryMembersJoinPredecessors = {};
-      //
-      // // One cube may join the other cube via transitive joined cubes,
-      // // members from which are referenced in the join `on` clauses.
-      // // We need to collect such join hints and push them upfront of the joining one
-      // // but only if they don't exist yet. Cause in other case we might affect what
-      // // join path will be constructed in join graph.
-      // // It is important to use queryLevelJoinHints during the calculation if it is set.
-      //
-      // const constructJH = () => {
-      //   const filteredJoinMembersJoinHints = joinMembersJoinHints.filter(m => !allMembersJoinHints.includes(m) && m !== rootOfJoin);
-      //   return [
-      //     ...this.queryLevelJoinHints,
-      //     ...(rootOfJoin ? [rootOfJoin] : []),
-      //     ...filteredJoinMembersJoinHints,
-      //     ...allMembersJoinHints.filter(m => m !== rootOfJoin),
-      //     ...customSubQueryJoinHints,
-      //   ];
-      // };
-      //
-      // if (this.join) {
-      //   joinMembersJoinHints = this.collectJoinHintsFromMembers(this.joinMembersFromJoin(this.join));
-      //   originalQueryMembersJoinPredecessors = this.buildPredecessors(joinMembersJoinHints.flat());
-      //   rootOfJoin = this.join.root;
-      // }
-      //
-      // let prevJoin = this.join;
-      // let newJoin = this.joinGraph.buildJoin(constructJH());
-      // if (newJoin) {
-      //   rootOfJoin = newJoin.root;
-      // }
-      //
-      // if (!this.join) {
-      //   joinMembersJoinHints = this.collectJoinHintsFromMembers(this.joinMembersFromJoin(newJoin));
-      //   originalQueryMembersJoinPredecessors = this.buildPredecessors(joinMembersJoinHints.flat());
-      // }
-      //
-      // const isOrderPreserved = (updatedJoinHints) => {
-      //   for (let i = 0, l = updatedJoinHints.length; i < l; i++) {
-      //     const predecessors = originalQueryMembersJoinPredecessors[updatedJoinHints[i]];
-      //
-      //     if (predecessors?.length > 0) {
-      //       const predLen = predecessors.length;
-      //
-      //       let predIdx = 0;
-      //       let joinHintIdx = 0;
-      //
-      //       while (joinHintIdx < i && predIdx < predLen) {
-      //         if (updatedJoinHints[joinHintIdx] === predecessors[predIdx]) {
-      //           joinHintIdx++;
-      //           predIdx++;
-      //         } else {
-      //           joinHintIdx++;
-      //         }
-      //       }
-      //
-      //       if (predIdx < predLen) {
-      //         // We still have a must be present predecessor for current hint
-      //         return [false, `${updatedJoinHints[i]} <-> ${predecessors[predIdx]}`];
-      //       }
-      //     }
-      //   }
-      //
-      //   return [true, ''];
-      // };
-      //
-      // const isJoinTreesEqual = (a, b) => {
-      //   if (!a || !b || a.root !== b.root || a.joins.length !== b.joins.length) {
-      //     return false;
-      //   }
-      //
-      //   // We don't care about the order of joins on the same level, so
-      //   // we can compare them as sets.
-      //   const aJoinsSet = new Set(a.joins.map(j => `${j.originalFrom}->${j.originalTo}`));
-      //   const bJoinsSet = new Set(b.joins.map(j => `${j.originalFrom}->${j.originalTo}`));
-      //
-      //   if (aJoinsSet.size !== bJoinsSet.size) {
-      //     return false;
-      //   }
-      //
-      //   for (const val of aJoinsSet) {
-      //     if (!bJoinsSet.has(val)) {
-      //       return false;
-      //     }
-      //   }
-      //
-      //   return true;
-      // };
-      //
-      // // Safeguard against infinite loop in case of cyclic joins somehow managed to slip through
-      // let cnt = 0;
-      //
-      // while (newJoin?.joins.length > 0 && cnt < 10000) {
-      //   prevJoin = newJoin;
-      //   joinMembersJoinHints = this.collectJoinHintsFromMembers(this.joinMembersFromJoin(newJoin));
-      //   newJoin = this.joinGraph.buildJoin(constructJH());
-      //
-      //   if (isJoinTreesEqual(prevJoin, newJoin)) {
-      //     break;
-      //   }
-      //
-      //   const [isOrdered, msg] = isOrderPreserved(joinMembersJoinHints.flat());
-      //
-      //   if (!isOrdered) {
-      //     throw new UserError(`Can not construct joins for the query, potential loop detected around ${msg}`);
-      //   }
-      //
-      //   cnt++;
-      // }
-      //
-      // if (cnt >= 10000) {
-      //   throw new UserError('Can not construct joins for the query, potential loop detected');
-      // }
-      //
-      // this.collectedJoinHints = R.uniq(constructJH());
     }
     return this.collectedJoinHints;
   }