diff --git a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
index 32280f6d4e721..477afcd71dd16 100644
--- a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
+++ b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
@@ -22,7 +22,6 @@ import {
   localTimestampToUtc,
   timeSeries as timeSeriesBase,
   timeSeriesFromCustomInterval,
-  parseSqlInterval,
   findMinGranularityDimension
 } from '@cubejs-backend/shared';
 
@@ -436,81 +435,32 @@ export class BaseQuery {
    */
   get allJoinHints() {
     if (!this.collectedJoinHints) {
-      const [rootOfJoin, ...allMembersJoinHints] = this.collectJoinHintsFromMembers(this.allMembersConcat(false));
+      const allMembersJoinHints = this.collectJoinHintsFromMembers(this.allMembersConcat(false));
       const customSubQueryJoinHints = this.collectJoinHintsFromMembers(this.joinMembersFromCustomSubQuery());
-      let joinMembersJoinHints = this.collectJoinHintsFromMembers(this.joinMembersFromJoin(this.join));
-
-      // 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));
-        return [
-          ...this.queryLevelJoinHints,
-          ...(rootOfJoin ? [rootOfJoin] : []),
-          ...filteredJoinMembersJoinHints,
-          ...allMembersJoinHints,
-          ...customSubQueryJoinHints,
-        ];
-      };
-
-      let prevJoins = this.join;
-      let prevJoinMembersJoinHints = joinMembersJoinHints;
-      let newJoin = this.joinGraph.buildJoin(constructJH());
-
-      const isOrderPreserved = (base, updated) => {
-        const common = base.filter(value => updated.includes(value));
-        const bFiltered = updated.filter(value => common.includes(value));
-
-        return common.every((x, i) => x === bFiltered[i]);
-      };
-
-      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;
-      };
+      const allJoinHints = [
+        ...this.queryLevelJoinHints,
+        ...allMembersJoinHints,
+        ...customSubQueryJoinHints,
+      ];
 
-      // Safeguard against infinite loop in case of cyclic joins somehow managed to slip through
-      let cnt = 0;
+      const tempJoin = this.joinGraph.buildJoin(allJoinHints);
 
-      while (newJoin?.joins.length > 0 && !isJoinTreesEqual(prevJoins, newJoin) && cnt < 10000) {
-        prevJoins = newJoin;
-        joinMembersJoinHints = this.collectJoinHintsFromMembers(this.joinMembersFromJoin(newJoin));
-        if (!isOrderPreserved(prevJoinMembersJoinHints, joinMembersJoinHints)) {
-          throw new UserError(`Can not construct joins for the query, potential loop detected: ${prevJoinMembersJoinHints.join('->')} vs ${joinMembersJoinHints.join('->')}`);
-        }
-        newJoin = this.joinGraph.buildJoin(constructJH());
-        prevJoinMembersJoinHints = joinMembersJoinHints;
-        cnt++;
+      if (!tempJoin) {
+        this.collectedJoinHints = allJoinHints;
+        return allJoinHints;
       }
 
-      if (cnt >= 10000) {
-        throw new UserError('Can not construct joins for the query, potential loop detected');
-      }
+      const joinMembersJoinHints = this.collectJoinHintsFromMembers(this.joinMembersFromJoin(tempJoin));
+      const allJoinHintsFlatten = new Set(allJoinHints.flat());
+      const newCollectedHints = joinMembersJoinHints.filter(j => !allJoinHintsFlatten.has(j));
 
-      this.collectedJoinHints = R.uniq(constructJH());
+      this.collectedJoinHints = [
+        ...this.queryLevelJoinHints,
+        tempJoin.root,
+        ...newCollectedHints,
+        ...allMembersJoinHints,
+        ...customSubQueryJoinHints,
+      ];
     }
     return this.collectedJoinHints;
   }
diff --git a/packages/cubejs-schema-compiler/test/integration/postgres/sql-generation.test.ts b/packages/cubejs-schema-compiler/test/integration/postgres/sql-generation.test.ts
index 64e1d54b3cb02..298f800a895c2 100644
--- a/packages/cubejs-schema-compiler/test/integration/postgres/sql-generation.test.ts
+++ b/packages/cubejs-schema-compiler/test/integration/postgres/sql-generation.test.ts
@@ -5198,7 +5198,7 @@ cubes:
         sql: amount
         type: sum
 
-# Join loop for testing transitive joins
+# Model for testing multiple joins to the same cube via transitive joins
   - name: alpha_facts
     sql: |
       (
@@ -5256,9 +5256,9 @@ cubes:
   - name: gamma_dims
     sql: |
       (
-        SELECT 10 AS b_id, 'Beta1' AS b_name
+        SELECT 10 AS b_id, 'Beta1' AS b_name, 'Gamma1' AS c_name
         UNION ALL
-        SELECT 20 AS b_id, 'Beta2' AS b_name
+        SELECT 20 AS b_id, 'Beta2' AS b_name, 'Gamma2' AS c_name
       )
     dimensions:
       - name: b_id
@@ -5272,16 +5272,16 @@ cubes:
   - name: delta_bridge
     sql: |
       (
-        SELECT 'Alpha1' AS a_name, 'Beta1' AS b_name, 'Organic' AS channel
+        SELECT 'Alpha1' AS a_name, 'Beta1' AS b_name, 'Gamma1' AS c_name, 'Organic' AS channel
         UNION ALL
-        SELECT 'Alpha1' AS a_name, 'Beta2' AS b_name, 'Paid' AS channel
+        SELECT 'Alpha1' AS a_name, 'Beta2' AS b_name, 'Gamma2' AS c_name, 'Paid' AS channel
         UNION ALL
-        SELECT 'Alpha2' AS a_name, 'Beta1' AS b_name, 'Referral' AS channel
+        SELECT 'Alpha2' AS a_name, 'Beta1' AS b_name, 'Gamma3' AS c_name, 'Referral' AS channel
       )
     joins:
       - name: gamma_dims
         relationship: many_to_one
-        sql: "{CUBE}.b_name = {gamma_dims.b_name}"
+        sql: "{CUBE}.c_name = {gamma_dims.c_name}"
     dimensions:
       - name: a_name
         sql: a_name
@@ -5290,7 +5290,9 @@ cubes:
       - name: b_name
         sql: "{gamma_dims.b_name}"
         type: string
-        primary_key: true
+      - name: c_name
+        sql: c_name
+        type: string
       - name: channel
         sql: channel
         type: string
@@ -5343,34 +5345,31 @@ cubes:
       });
     }
 
-    if (!getEnv('nativeSqlPlanner')) {
-      it('querying cube with transitive joins with loop', async () => {
-        await compiler.compile();
-
-        try {
-          const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
-            measures: [],
-            dimensions: [
-              'alpha_facts.reporting_date',
-              'delta_bridge.b_name',
-              'alpha_facts.channel'
-            ],
-            order: [{
-              id: 'alpha_facts.reporting_date'
-            }],
-            timezone: 'America/Los_Angeles'
-          });
-
-          await dbRunner.testQuery(query.buildSqlAndParams());
-          throw new Error('Should have thrown an error');
-        } catch (err: any) {
-          expect(err.message).toContain('Can not construct joins for the query, potential loop detected');
-        }
-      });
-    } else {
-      it.skip('FIXME(tesseract): querying cube dimension that require transitive joins', async () => {
-        // FIXME should be implemented in Tesseract
-      });
-    }
+    it('querying cube with transitive joins with a few joins to same cube', async () => {
+      // TODO: This is not supported atm, but it's a good case, so keeeping this test
+      // for the future implementation
+
+      // await compiler.compile();
+      //
+      // const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
+      //   measures: [],
+      //   dimensions: [
+      //     'alpha_facts.reporting_date',
+      //     'delta_bridge.b_name',
+      //     'alpha_facts.channel'
+      //   ],
+      //   order: [{
+      //     id: 'alpha_facts.reporting_date'
+      //   }],
+      //   timezone: 'America/Los_Angeles'
+      // });
+      //
+      // const res = await dbRunner.testQuery(query.buildSqlAndParams());
+      // console.log(JSON.stringify(res));
+      //
+      // expect(res).toEqual([
+      //   // Fill
+      // ]);
+    });
   });
 });
diff --git a/packages/cubejs-schema-compiler/test/integration/postgres/views-join-order-2.test.ts b/packages/cubejs-schema-compiler/test/integration/postgres/views-join-order-2.test.ts
index 20dac065bec76..9abbcdc2e643e 100644
--- a/packages/cubejs-schema-compiler/test/integration/postgres/views-join-order-2.test.ts
+++ b/packages/cubejs-schema-compiler/test/integration/postgres/views-join-order-2.test.ts
@@ -60,14 +60,14 @@ cube('A', {
 
 cube('B', {
   sql: \`
-    SELECT 2 id, 'b'::text as "name"\`,
+    SELECT 2 id, 4 as fk_e, 'b'::text as "name"\`,
   joins: {
     A: {
       relationship: \`many_to_one\`,
       sql: \`\${CUBE.fk} = \${A.id}\`,
     },
     E: {
-      sql: \`\${CUBE.name} = \${E.id}\`,
+      sql: \`\${CUBE}.fk_e = \${E.id}\`,
       relationship: \`many_to_one\`,
     },
   },
diff --git a/packages/cubejs-schema-compiler/test/integration/postgres/views-join-order-3.test.ts b/packages/cubejs-schema-compiler/test/integration/postgres/views-join-order-3.test.ts
new file mode 100644
index 0000000000000..3432a39331931
--- /dev/null
+++ b/packages/cubejs-schema-compiler/test/integration/postgres/views-join-order-3.test.ts
@@ -0,0 +1,328 @@
+import { getEnv } from '@cubejs-backend/shared';
+import { prepareJsCompiler } from '../../unit/PrepareCompiler';
+import { dbRunner } from './PostgresDBRunner';
+
+/**
+ * This tests the cube join correctness for cases, when there are
+ * multiple equal-cost paths between few cubes via transitive joins.
+ */
+
+describe('Views Join Order 3', () => {
+  jest.setTimeout(200000);
+
+  const { compiler, joinGraph, cubeEvaluator } = prepareJsCompiler(
+    // language=JavaScript
+    `
+cube(\`D\`, {
+  sql: \`SELECT 1 id, 125 as balance\`,
+  dimensions: {
+    Balance: {
+      sql: \`balance\`,
+      type: \`number\`
+    }
+  }
+});
+
+cube(\`A\`, {
+  sql: \`SELECT 1 id, 250 as balance\`,
+  joins: {
+    E: {
+      sql: \`\${CUBE}.id = \${E}.id\`,
+      relationship: \`many_to_one\`
+    },
+    B: {
+      sql: \`\${CUBE}.id = \${B}.id\`,
+      relationship: \`many_to_one\`
+    },
+    C: {
+      sql: \`\${CUBE}.id = \${C}.id\`,
+      relationship: \`many_to_one\`
+    }
+  },
+  dimensions: {
+    Balance: {
+      sql: \`balance\`,
+      type: \`number\`
+    }
+  }
+});
+
+cube('B', {
+  sql: \`SELECT 1 id\`,
+  joins: {
+    D: {
+      sql: \`\${CUBE}.id = \${D}.id\`,
+      relationship: \`many_to_one\`
+    },
+    E: {
+      sql: \`\${CUBE}.id = \${E}.id\`,
+      relationship: \`many_to_one\`
+    }
+  },
+  dimensions: {
+    ActivityBalance: {
+      sql: \`\${D.Balance}\`,
+      type: \`number\`
+    }
+  }
+});
+
+cube(\`E\`, {
+  sql: \`SELECT 1 id, 1 as plan_id, 1 as party_id\`,
+  joins: {
+    D: {
+      sql: \`\${CUBE}.id = \${D}.id\`,
+      relationship: \`many_to_one\`
+    },
+    F: {
+      sql: \`\${CUBE}.plan_id = \${F}.plan_id\`,
+      relationship: \`many_to_one\`
+    },
+    C: {
+      sql: \`\${CUBE}.party_id = \${C}.party_id\`,
+      relationship: \`many_to_one\`
+    }
+  }
+});
+
+cube('C', {
+  sql: \`SELECT 1 id, 1 as plan_id, 1 as party_id\`,
+  joins: {
+    F: {
+      sql: \`\${CUBE}.plan_id = \${F}.plan_id\`,
+      relationship: \`many_to_one\`
+    }
+  }
+});
+
+cube(\`F\`, {
+  sql: \`SELECT 1 id, 1 as plan_id, 'PLAN_CODE'::text as plan_code\`,
+  dimensions: {
+    PlanCode: {
+      sql: \`plan_code\`,
+      type: \`string\`
+    }
+  }
+});
+
+view(\`V\`, {
+  cubes: [
+    {
+      join_path: A.B,
+      includes: [\`ActivityBalance\`]
+    },
+    {
+      join_path: A.C.F,
+      includes: [\`PlanCode\`]
+    }
+  ]
+});
+    `
+  );
+
+  if (getEnv('nativeSqlPlanner')) {
+    it('correct join for simple cube B dimension', async () => {
+      const [sql, _params] = await dbRunner.runQueryTest({
+        dimensions: ['B.ActivityBalance'],
+        timeDimensions: [],
+        segments: [],
+        filters: [],
+      }, [{
+        b__activity_balance: 125,
+      }], { compiler, joinGraph, cubeEvaluator });
+
+      expect(sql).toMatch(/AS "b"/);
+      expect(sql).toMatch(/AS "d"/);
+      expect(sql).toMatch(/ON "b".id = "d".id/);
+      expect(sql).not.toMatch(/AS "a"/);
+      expect(sql).not.toMatch(/AS "e"/);
+      expect(sql).not.toMatch(/AS "c"/);
+    });
+
+    it('correct join for simple view B-dimension', async () => {
+      const [sql, _params] = await dbRunner.runQueryTest({
+        dimensions: ['V.ActivityBalance'],
+        timeDimensions: [],
+        segments: [],
+        filters: [],
+      }, [{
+        v__activity_balance: 125,
+      }], { compiler, joinGraph, cubeEvaluator });
+
+      // expect(sql).toMatch(/AS "a"/);
+      // expect(sql).toMatch(/AS "b"/);
+      // expect(sql).toMatch(/AS "d"/);
+      // expect(sql).toMatch(/ON "a".id = "b".id/);
+      // expect(sql).toMatch(/ON "b".id = "d".id/);
+      // expect(sql).not.toMatch(/AS "e"/);
+    });
+
+    it('correct join for simple view F-dimension', async () => {
+      const [sql, _params] = await dbRunner.runQueryTest({
+        dimensions: ['V.PlanCode'],
+        timeDimensions: [],
+        segments: [],
+        filters: [],
+      }, [{
+        v__plan_code: 'PLAN_CODE',
+      }], { compiler, joinGraph, cubeEvaluator });
+
+      // expect(sql).toMatch(/AS "a"/);
+      // expect(sql).toMatch(/AS "c"/);
+      // expect(sql).toMatch(/AS "f"/);
+      // expect(sql).toMatch(/ON "a".id = "c".id/);
+      // expect(sql).toMatch(/ON "c".plan_id = "f".plan_id/);
+      // expect(sql).not.toMatch(/AS "b"/);
+      // expect(sql).not.toMatch(/AS "d"/);
+      // expect(sql).not.toMatch(/AS "e"/);
+    });
+
+    it('correct join for view F-dimension + B-dimension', async () => {
+      const [sql, _params] = await dbRunner.runQueryTest({
+        dimensions: ['V.PlanCode', 'V.ActivityBalance'],
+        timeDimensions: [],
+        segments: [],
+        filters: [],
+      }, [{
+        v__plan_code: 'PLAN_CODE',
+        v__activity_balance: 125,
+      }], { compiler, joinGraph, cubeEvaluator });
+
+      // expect(sql).toMatch(/AS "a"/);
+      // expect(sql).toMatch(/AS "c"/);
+      // expect(sql).toMatch(/AS "f"/);
+      // expect(sql).toMatch(/AS "b"/);
+      // expect(sql).toMatch(/AS "d"/);
+      // expect(sql).toMatch(/ON "a".id = "c".id/);
+      // expect(sql).toMatch(/ON "a".id = "b".id/);
+      // expect(sql).toMatch(/ON "c".plan_id = "f".plan_id/);
+      // expect(sql).toMatch(/ON "b".id = "d".id/);
+      // expect(sql).not.toMatch(/AS "e"/);
+    });
+
+    it('correct join for view B-dimension + F-dimension', async () => {
+      const [sql, _params] = await dbRunner.runQueryTest({
+        dimensions: ['V.ActivityBalance', 'V.PlanCode'],
+        timeDimensions: [],
+        segments: [],
+        filters: [],
+      }, [{
+        v__activity_balance: 125,
+        v__plan_code: 'PLAN_CODE',
+      }], { compiler, joinGraph, cubeEvaluator });
+
+      // expect(sql).toMatch(/AS "a"/);
+      // expect(sql).toMatch(/AS "c"/);
+      // expect(sql).toMatch(/AS "f"/);
+      // expect(sql).toMatch(/AS "b"/);
+      // expect(sql).toMatch(/AS "d"/);
+      // expect(sql).toMatch(/ON "a".id = "c".id/);
+      // expect(sql).toMatch(/ON "a".id = "b".id/);
+      // expect(sql).toMatch(/ON "c".plan_id = "f".plan_id/);
+      // expect(sql).toMatch(/ON "b".id = "d".id/);
+      // expect(sql).not.toMatch(/AS "e"/);
+    });
+  } else {
+    it('correct join for simple cube B dimension', async () => {
+      const [sql, _params] = await dbRunner.runQueryTest({
+        dimensions: ['B.ActivityBalance'],
+        timeDimensions: [],
+        segments: [],
+        filters: [],
+      }, [{
+        b___activity_balance: 125,
+      }], { compiler, joinGraph, cubeEvaluator });
+
+      expect(sql).toMatch(/AS "b"/);
+      expect(sql).toMatch(/AS "d"/);
+      expect(sql).toMatch(/ON "b".id = "d".id/);
+      expect(sql).not.toMatch(/AS "a"/);
+      expect(sql).not.toMatch(/AS "e"/);
+      expect(sql).not.toMatch(/AS "c"/);
+    });
+
+    it('correct join for simple view B-dimension', async () => {
+      const [sql, _params] = await dbRunner.runQueryTest({
+        dimensions: ['V.ActivityBalance'],
+        timeDimensions: [],
+        segments: [],
+        filters: [],
+      }, [{
+        v___activity_balance: 125,
+      }], { compiler, joinGraph, cubeEvaluator });
+
+      // expect(sql).toMatch(/AS "a"/);
+      // expect(sql).toMatch(/AS "b"/);
+      // expect(sql).toMatch(/AS "d"/);
+      // expect(sql).toMatch(/ON "a".id = "b".id/);
+      // expect(sql).toMatch(/ON "b".id = "d".id/);
+      // expect(sql).not.toMatch(/AS "e"/);
+    });
+
+    it('correct join for simple view F-dimension', async () => {
+      const [sql, _params] = await dbRunner.runQueryTest({
+        dimensions: ['V.PlanCode'],
+        timeDimensions: [],
+        segments: [],
+        filters: [],
+      }, [{
+        v___plan_code: 'PLAN_CODE',
+      }], { compiler, joinGraph, cubeEvaluator });
+
+      // expect(sql).toMatch(/AS "a"/);
+      // expect(sql).toMatch(/AS "c"/);
+      // expect(sql).toMatch(/AS "f"/);
+      // expect(sql).toMatch(/ON "a".id = "c".id/);
+      // expect(sql).toMatch(/ON "c".plan_id = "f".plan_id/);
+      // expect(sql).not.toMatch(/AS "b"/);
+      // expect(sql).not.toMatch(/AS "d"/);
+      // expect(sql).not.toMatch(/AS "e"/);
+    });
+
+    it('correct join for view F-dimension + B-dimension', async () => {
+      const [sql, _params] = await dbRunner.runQueryTest({
+        dimensions: ['V.PlanCode', 'V.ActivityBalance'],
+        timeDimensions: [],
+        segments: [],
+        filters: [],
+      }, [{
+        v___plan_code: 'PLAN_CODE',
+        v___activity_balance: 125,
+      }], { compiler, joinGraph, cubeEvaluator });
+
+      // expect(sql).toMatch(/AS "a"/);
+      // expect(sql).toMatch(/AS "c"/);
+      // expect(sql).toMatch(/AS "f"/);
+      // expect(sql).toMatch(/AS "b"/);
+      // expect(sql).toMatch(/AS "d"/);
+      // expect(sql).toMatch(/ON "a".id = "c".id/);
+      // expect(sql).toMatch(/ON "a".id = "b".id/);
+      // expect(sql).toMatch(/ON "c".plan_id = "f".plan_id/);
+      // expect(sql).toMatch(/ON "b".id = "d".id/);
+      // expect(sql).not.toMatch(/AS "e"/);
+    });
+
+    it('correct join for view B-dimension + F-dimension', async () => {
+      const [sql, _params] = await dbRunner.runQueryTest({
+        dimensions: ['V.ActivityBalance', 'V.PlanCode'],
+        timeDimensions: [],
+        segments: [],
+        filters: [],
+      }, [{
+        v___activity_balance: 125,
+        v___plan_code: 'PLAN_CODE',
+      }], { compiler, joinGraph, cubeEvaluator });
+
+      // expect(sql).toMatch(/AS "a"/);
+      // expect(sql).toMatch(/AS "c"/);
+      // expect(sql).toMatch(/AS "f"/);
+      // expect(sql).toMatch(/AS "b"/);
+      // expect(sql).toMatch(/AS "d"/);
+      // expect(sql).toMatch(/ON "a".id = "c".id/);
+      // expect(sql).toMatch(/ON "a".id = "b".id/);
+      // expect(sql).toMatch(/ON "c".plan_id = "f".plan_id/);
+      // expect(sql).toMatch(/ON "b".id = "d".id/);
+      // expect(sql).not.toMatch(/AS "e"/);
+    });
+  }
+});
diff --git a/packages/cubejs-schema-compiler/test/unit/error-reporter.test.ts b/packages/cubejs-schema-compiler/test/unit/error-reporter.test.ts
index 889d34727d0ba..a846bacbda5d8 100644
--- a/packages/cubejs-schema-compiler/test/unit/error-reporter.test.ts
+++ b/packages/cubejs-schema-compiler/test/unit/error-reporter.test.ts
@@ -11,7 +11,7 @@ describe('ErrorReporter', () => {
     // Test inFile and exitFile
     reporter.inFile({
       fileName: 'schema/users.js',
-      content: `cube('Users', {\n  sql: \`SELECT * FROM users\`,\n  measures: {\n    count: {\n      type: 'count'\n    }\n  }\n});`
+      content: 'cube(\'Users\', {\n  sql: `SELECT * FROM users`,\n  measures: {\n    count: {\n      type: \'count\'\n    }\n  }\n});'
     });
 
     // Test syntaxError with location
@@ -45,7 +45,7 @@ describe('ErrorReporter', () => {
     // Test inFile for another file
     reporter.inFile({
       fileName: 'schema/orders.js',
-      content: `cube('Orders', {\n  sql: \`SELECT * FROM orders\`\n});`
+      content: 'cube(\'Orders\', {\n  sql: `SELECT * FROM orders`\n});'
     });
 
     // Test syntaxError without location but with file context