fix(schema-compiler): Fix incorrect cache that affects query joins

+ tests

Author: KSDaemon

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

@@ -2794,12 +2794,22 @@ export class BaseQuery {
    */
   collectFrom(membersToCollectFrom, fn, methodName, cache) {
     const methodCacheKey = Array.isArray(methodName) ? methodName : [methodName];
+    const memberCubesCacheKey = membersToCollectFrom
+      .reduce((acc, m) => {
+        const name = m.cube?.().name;
+        if (name) {
+          acc.push(name);
+        }
+        return acc;
+      }, [])
+      .sort();
+
     return R.pipe(
       R.map(f => f.getMembers()),
       R.flatten,
       R.map(s => (
         (cache || this.compilerCache).cache(
-          ['collectFrom'].concat(methodCacheKey).concat(
+          ['collectFrom'].concat(methodCacheKey).concat(memberCubesCacheKey).concat(
             s.path() ? [s.path().join('.')] : [s.cube().name, s.expression?.toString() || s.expressionName || s.definition().sql]
           ),
           () => fn(() => this.traverseSymbol(s))

packages/cubejs-schema-compiler/test/unit/base-query.test.ts

@@ -961,7 +961,7 @@ describe('SQL Generation', () => {
 
     ]);
 
-    it('Base joins - one-one join', async () => {
+    it('one-one join', async () => {
       await compilers.compiler.compile();
 
       const query = new PostgresQuery(compilers, {
@@ -980,7 +980,7 @@ describe('SQL Generation', () => {
       expect(queryAndParams[0]).toContain('LEFT JOIN card3_tbl AS "cards_c" ON "cards_b".other_id = "cards_c".id');
     });
 
-    it('Base joins - multiplied join', async () => {
+    it('multiplied join', async () => {
       await compilers.compiler.compile();
 
       const query = new PostgresQuery(compilers, {
@@ -994,12 +994,59 @@ describe('SQL Generation', () => {
         timezone: 'America/Los_Angeles',
       });
 
-      const queryAndParams = query.buildSqlAndParams();
+      const _queryAndParams = query.buildSqlAndParams();
 
       /* expect(queryAndParams[0]).toContain('LEFT JOIN card2_tbl AS "cards_b" ON "cards_a".other_id = "cards_b".id');
       expect(queryAndParams[0]).toContain('LEFT JOIN card3_tbl AS "cards_c" ON "cards_b".other_id = "cards_c".id'); */
     });
+
+    it('join hint cache', async () => {
+      // Create a schema with a segment that uses FILTER_PARAMS
+      const filterParamsCompilers = /** @type Compilers */ prepareJsCompiler([
+        createCubeSchema({
+          name: 'cardsA',
+          sqlTable: 'card_tbl',
+          joins: `{
+            cardsB: {
+              sql: \`\${CUBE}.other_id = \${cardsB}.id\`,
+              relationship: 'one_to_one'
+            },
+          }`
+        }).replace(`sql: \`\${CUBE}.location = 'San Francisco'\``, `sql: \`\${FILTER_PARAMS.cardsA.location.filter('location')}\``),
+        createCubeSchema({
+          name: 'cardsB',
+          sqlTable: 'card2_tbl',
+        }),
+      ]);
+      await filterParamsCompilers.compiler.compile();
+
+      // First query requires a join
+      const queryWithJoin = new PostgresQuery(filterParamsCompilers, {
+        dimensions: [
+          'cardsA.id',
+          'cardsB.id',
+        ],
+        segments: [
+          'cardsA.sfUsers',
+        ],
+      });
+      const queryAndParamsWithJoin = queryWithJoin.buildSqlAndParams();
+      expect(queryAndParamsWithJoin[0]).toContain('LEFT JOIN card2_tbl AS "cards_b" ON "cards_a".other_id = "cards_b".id');
+
+      // Second query does not require a join and should not be impacted by the first query
+      const queryWithoutJoin = new PostgresQuery(filterParamsCompilers, {
+        dimensions: [
+          'cardsA.id',
+        ],
+        segments: [
+          'cardsA.sfUsers',
+        ],
+      });
+      const queryAndParamsWithoutJoin = queryWithoutJoin.buildSqlAndParams();
+      expect(queryAndParamsWithoutJoin[0]).not.toContain('JOIN');
+    });
   });
+
   describe('Common - JS', () => {
     const compilers = /** @type Compilers */ prepareJsCompiler(
       createCubeSchema({