fix(schema-compiler): remove hardcoded AS keyword in subquery aliases for Oracle compatibility

Tankilevitch · Tankilevitch · commit ea3ba21b13b8 · 2025-10-19T17:29:40.000+03:00
Oracle database does not support the AS keyword for table/subquery aliasing,
while other databases like PostgreSQL and MySQL do. The existing BaseQuery
implementation hardcoded 'as' in subquery alias generation, causing Oracle
queries to fail.

This change:
- Replaces hardcoded 'as' with asSyntaxJoin property in BaseQuery
- Oracle returns empty string for asSyntaxJoin (no AS keyword)
- PostgreSQL/MySQL return 'AS' (maintains existing behavior)
- Adds comprehensive Oracle query test suite validating AS syntax removal
- Adds PostgreSQL regression test ensuring AS keyword is still present

This fixes queries with rolling windows and multiple subqueries on Oracle,
which previously generated invalid SQL like:
  SELECT ... FROM (...) as q_0 INNER JOIN (...) as q_1 ON ...

Now Oracle correctly generates:
  SELECT ... FROM (...) q_0 INNER JOIN (...) q_1 ON ...
diff --git a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
@@ -1380,8 +1380,8 @@ export class BaseQuery {
     const join = R.drop(1, toJoin)
       .map(
         (q, i) => (this.dimensionAliasNames().length ?
-          `INNER JOIN ${this.wrapInParenthesis((q))} as q_${i + 1} ON ${this.dimensionsJoinCondition(`q_${i}`, `q_${i + 1}`)}` :
-          `, ${this.wrapInParenthesis(q)} as q_${i + 1}`),
+          `INNER JOIN ${this.wrapInParenthesis((q))} ${this.asSyntaxJoin} q_${i + 1} ON ${this.dimensionsJoinCondition(`q_${i}`, `q_${i + 1}`)}` :
+          `, ${this.wrapInParenthesis(q)} ${this.asSyntaxJoin} q_${i + 1}`),
       ).join('\n');
 
     const columnsToSelect = this.evaluateSymbolSqlWithContext(
@@ -1410,7 +1410,7 @@ export class BaseQuery {
       return `${toJoin[0].replace(/^SELECT/, `SELECT ${this.topLimit()}`)} ${this.orderBy()}${this.groupByDimensionLimit()}`;
     }
 
-    return `SELECT ${this.topLimit()}${columnsToSelect} FROM ${this.wrapInParenthesis(toJoin[0])} as q_0 ${join}${havingFilters}${this.orderBy()}${this.groupByDimensionLimit()}`;
+    return `SELECT ${this.topLimit()}${columnsToSelect} FROM ${this.wrapInParenthesis(toJoin[0])} ${this.asSyntaxJoin} q_0 ${join}${havingFilters}${this.orderBy()}${this.groupByDimensionLimit()}`;
   }
 
   wrapInParenthesis(select) {
diff --git a/packages/cubejs-schema-compiler/test/unit/oracle-query.test.ts b/packages/cubejs-schema-compiler/test/unit/oracle-query.test.ts
@@ -0,0 +1,308 @@
+/* eslint-disable no-restricted-syntax */
+import { OracleQuery } from '../../src/adapter/OracleQuery';
+import { prepareJsCompiler } from './PrepareCompiler';
+
+describe('OracleQuery', () => {
+  const { compiler, joinGraph, cubeEvaluator } = prepareJsCompiler(`
+    cube(\`visitors\`, {
+      sql: \`
+      select * from visitors
+      \`,
+
+      measures: {
+        count: {
+          type: 'count'
+        },
+
+        unboundedCount: {
+          type: 'count',
+          rollingWindow: {
+            trailing: 'unbounded'
+          }
+        },
+
+        thisPeriod: {
+          sql: 'amount',
+          type: 'sum',
+          rollingWindow: {
+            trailing: '1 year',
+            offset: 'end'
+          }
+        },
+
+        priorPeriod: {
+          sql: 'amount',
+          type: 'sum',
+          rollingWindow: {
+            trailing: '1 year',
+            offset: 'start'
+          }
+        }
+      },
+
+      dimensions: {
+        id: {
+          sql: 'id',
+          type: 'number',
+          primaryKey: true
+        },
+
+        createdAt: {
+          type: 'time',
+          sql: 'created_at'
+        },
+
+        source: {
+          type: 'string',
+          sql: 'source'
+        }
+      }
+    })
+
+    cube(\`Deals\`, {
+      sql: \`select * from deals\`,
+
+      measures: {
+        amount: {
+          sql: \`amount\`,
+          type: \`sum\`
+        }
+      },
+
+      dimensions: {
+        salesManagerId: {
+          sql: \`sales_manager_id\`,
+          type: 'string',
+          primaryKey: true
+        }
+      }
+    })
+
+    cube(\`SalesManagers\`, {
+      sql: \`select * from sales_managers\`,
+
+      joins: {
+        Deals: {
+          relationship: \`hasMany\`,
+          sql: \`\${SalesManagers}.id = \${Deals}.sales_manager_id\`
+        }
+      },
+
+      measures: {
+        averageDealAmount: {
+          sql: \`\${dealsAmount}\`,
+          type: \`avg\`
+        }
+      },
+
+      dimensions: {
+        id: {
+          sql: \`id\`,
+          type: \`string\`,
+          primaryKey: true
+        },
+
+        dealsAmount: {
+          sql: \`\${Deals.amount}\`,
+          type: \`number\`,
+          subQuery: true
+        }
+      }
+    });
+    `, { adapter: 'oracle' });
+
+  it('basic query without subqueries', async () => {
+    await compiler.compile();
+
+    const query = new OracleQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [
+        'visitors.count'
+      ],
+      timeDimensions: [],
+      timezone: 'UTC'
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    const sql = queryAndParams[0];
+
+    // Basic query should work
+    expect(sql).toContain('SELECT');
+    expect(sql).toMatch(/FROM\s+visitors/i);
+    // Should not have subquery aliases in simple query
+    expect(sql).not.toMatch(/\bq_\d+\b/);
+    // Should use Oracle FETCH NEXT
+    expect(sql).toContain('FETCH NEXT');
+  });
+
+  it('does not use AS keyword in subquery aliases with single rolling window', async () => {
+    await compiler.compile();
+
+    const query = new OracleQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [
+        'visitors.count',
+        'visitors.unboundedCount'
+      ],
+      timeDimensions: [{
+        dimension: 'visitors.createdAt',
+        granularity: 'day',
+        dateRange: ['2020-01-01', '2020-01-31']
+      }],
+      timezone: 'UTC'
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    const sql = queryAndParams[0];
+
+    // Oracle should NOT have AS keyword before subquery aliases
+    expect(sql).not.toMatch(/\bAS\s+q_\d+/i);
+    expect(sql).not.toMatch(/\bas\s+q_\d+/);
+    
+    // Should have q_0 alias (with space around it, indicating no AS)
+    expect(sql).toMatch(/\)\s+q_0\s+/);
+  });
+
+  it('does not use AS keyword with multiple rolling window measures (YoY scenario)', async () => {
+    await compiler.compile();
+
+    const query = new OracleQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [
+        'visitors.thisPeriod',
+        'visitors.priorPeriod'
+      ],
+      timeDimensions: [{
+        dimension: 'visitors.createdAt',
+        granularity: 'year',
+        dateRange: ['2020-01-01', '2022-12-31']
+      }],
+      timezone: 'UTC'
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    const sql = queryAndParams[0];
+
+    // Should have multiple subquery aliases (q_0, q_1, q_2, etc.)
+    expect(sql).toMatch(/\bq_0\b/);
+    expect(sql).toMatch(/\bq_1\b/);
+    
+    // Oracle should NOT have AS keyword anywhere before q_ aliases
+    expect(sql).not.toMatch(/\bAS\s+q_\d+/i);
+    expect(sql).not.toMatch(/\bas\s+q_\d+/);
+    
+    // Verify pattern is ) q_X not ) AS q_X
+    expect(sql).toMatch(/\)\s+q_\d+/);
+  });
+
+  it('does not use AS keyword in INNER JOIN subqueries', async () => {
+    await compiler.compile();
+
+    const query = new OracleQuery({ joinGraph, cubeEvaluator, compiler }, {
+      dimensions: [
+        'SalesManagers.id',
+        'SalesManagers.dealsAmount'
+      ]
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    const sql = queryAndParams[0];
+
+    // Should have INNER JOIN for subquery dimension
+    if (sql.includes('INNER JOIN')) {
+      // Oracle should NOT have AS keyword in INNER JOIN
+      expect(sql).not.toMatch(/INNER\s+JOIN\s+\([^)]+\)\s+AS\s+/i);
+      expect(sql).not.toMatch(/INNER\s+JOIN\s+\([^)]+\)\s+as\s+/);
+    }
+  });
+
+  it('uses FETCH NEXT syntax instead of LIMIT', async () => {
+    await compiler.compile();
+
+    const query = new OracleQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [
+        'visitors.count'
+      ],
+      timezone: 'UTC',
+      limit: 100
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    const sql = queryAndParams[0];
+
+    // Oracle should use FETCH NEXT instead of LIMIT
+    expect(sql).toContain('FETCH NEXT');
+    expect(sql).toContain('ROWS ONLY');
+    expect(sql).not.toContain('LIMIT');
+  });
+
+  it('uses FETCH NEXT syntax with subqueries and rolling windows', async () => {
+    await compiler.compile();
+
+    const query = new OracleQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [
+        'visitors.thisPeriod',
+        'visitors.priorPeriod'
+      ],
+      timeDimensions: [{
+        dimension: 'visitors.createdAt',
+        granularity: 'month',
+        dateRange: ['2020-01-01', '2020-12-31']
+      }],
+      timezone: 'UTC',
+      limit: 50
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    const sql = queryAndParams[0];
+
+    // Should have subqueries without AS
+    expect(sql).not.toMatch(/\bAS\s+q_\d+/i);
+    
+    // Should use Oracle-specific FETCH NEXT
+    expect(sql).toContain('FETCH NEXT');
+    expect(sql).toContain('ROWS ONLY');
+    expect(sql).not.toContain('LIMIT');
+  });
+
+  it('does not use AS keyword with comma-separated subqueries', async () => {
+    await compiler.compile();
+
+    const query = new OracleQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [
+        'visitors.thisPeriod',
+        'visitors.priorPeriod'
+      ],
+      timezone: 'UTC'
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    const sql = queryAndParams[0];
+
+    // Should have multiple subquery aliases
+    expect(sql).toMatch(/\)\s+q_0\s+,/);
+    expect(sql).toMatch(/\)\s+q_1\s+/);
+    
+    // Should NOT have AS before q_ aliases
+    expect(sql).not.toMatch(/\bAS\s+q_\d+/i);
+    expect(sql).not.toMatch(/\bas\s+q_\d+/);
+  });
+
+  it('group by dimensions not indexes', async () => {
+    await compiler.compile();
+
+    const query = new OracleQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [
+        'visitors.count'
+      ],
+      dimensions: [
+        'visitors.source'
+      ],
+      timezone: 'UTC'
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    const sql = queryAndParams[0];
+
+    // Oracle should group by actual dimension SQL, not by index
+    expect(sql).toMatch(/GROUP BY.*"visitors"\.source/i);
+    expect(sql).not.toMatch(/GROUP BY\s+\d+/);
+  });
+});
diff --git a/packages/cubejs-schema-compiler/test/unit/postgres-query.test.ts b/packages/cubejs-schema-compiler/test/unit/postgres-query.test.ts
@@ -328,4 +328,32 @@ describe('PostgresQuery', () => {
       expect(queryAndParams[0]).toContain('ORDER BY 3 ASC');
     });
   });
+
+  it('uses AS keyword in subquery aliases (regression test)', async () => {
+    await compiler.compile();
+
+    const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [
+        'visitors.count',
+        'visitors.unboundedCount'
+      ],
+      timeDimensions: [{
+        dimension: 'visitors.createdAt',
+        granularity: 'day',
+        dateRange: ['2020-01-01', '2020-01-31']
+      }],
+      timezone: 'UTC'
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    const sql = queryAndParams[0];
+
+    // PostgreSQL should use AS keyword for subquery aliases
+    expect(sql).toMatch(/\s+AS\s+q_0\s+/);
+    
+    // Should NOT have pattern ) q_0 (without AS)
+    // This regex checks for closing paren followed by space(s), q_0, space, but NOT preceded by AS
+    const hasAsKeyword = /\s+AS\s+q_0\s+/.test(sql);
+    expect(hasAsKeyword).toBe(true);
+  });
 });
