fix(schema-compiler): add support for time filters and rolling windows and fix subquery aliasing in Oracle dialect (#10066)

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

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 ...

* fix(oracle): add support for time filters and rolling windows

- Fix AS keyword in subquery aliases (Oracle doesn't support it)
- Handle time dimensions without granularity to prevent TypeError
- Implement Oracle-specific interval arithmetic using ADD_MONTHS and NUMTODSINTERVAL
- Add comprehensive test suite for Oracle query generation

These changes enable Oracle users to execute queries with:
- Time dimension filters without granularity specification
- Rolling windows and time-based calculations
- Multiple subqueries with proper aliasing

All changes maintain backward compatibility with other database adapters.

* add tests for subtractInterval and addInterval in oracle

* fix(oracle): exclude time dimensions without granularity from GROUP BY

Oracle's custom groupByClause() was incorrectly including time dimensions
without granularity in the GROUP BY clause, causing SQL errors when time
dimensions were used solely for filtering (no grouping).

Changes:
- Update OracleQuery.groupByClause() to check selectColumns() before
  including dimensions in GROUP BY
- Time dimensions without granularity return null from selectColumns(),
  so they are now properly excluded
- Add comprehensive tests for both PostgreSQL and Oracle covering:
  * Time dimensions without granularity (filtering only)
  * Time dimensions with granularity (grouping and filtering)
- Remove unnecessary guard in BaseQuery.dimensionTimeGroupedColumn()
  as it's no longer needed with the Oracle-specific fix

The fix aligns Oracle's behavior with PostgreSQL, which already handles
this correctly through its base implementation.

Author: Tankilevitch

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) {

packages/cubejs-schema-compiler/src/adapter/OracleQuery.ts

@@ -1,7 +1,8 @@
+import { parseSqlInterval } from '@cubejs-backend/shared';
 import { BaseQuery } from './BaseQuery';
 import { BaseFilter } from './BaseFilter';
 import { UserError } from '../compiler/UserError';
-import { BaseDimension } from './BaseDimension';
+import type { BaseDimension } from './BaseDimension';
 
 const GRANULARITY_VALUE = {
   day: 'DD',
@@ -55,7 +56,11 @@ export class OracleQuery extends BaseQuery {
    * using forSelect dimensions for grouping
    */
   public groupByClause() {
-    const dimensions = this.forSelect().filter((item: any) => !!item.dimension) as BaseDimension[];
+    // Only include dimensions that have select columns
+    // Time dimensions without granularity return null from selectColumns()
+    const dimensions = this.forSelect().filter((item: any) => (
+      !!item.dimension && item.selectColumns && item.selectColumns()
+    )) as BaseDimension[];
     if (!dimensions.length) {
       return '';
     }
@@ -92,6 +97,88 @@ export class OracleQuery extends BaseQuery {
     return `TRUNC(${dimension}, '${GRANULARITY_VALUE[granularity]}')`;
   }
 
+  /**
+   * Oracle uses ADD_MONTHS for year/month/quarter intervals
+   * and NUMTODSINTERVAL for day/hour/minute/second intervals
+   */
+  public addInterval(date: string, interval: string): string {
+    const intervalParsed = parseSqlInterval(interval);
+    let res = date;
+
+    // Handle year/month/quarter using ADD_MONTHS
+    let totalMonths = 0;
+    if (intervalParsed.year) {
+      totalMonths += intervalParsed.year * 12;
+    }
+    if (intervalParsed.quarter) {
+      totalMonths += intervalParsed.quarter * 3;
+    }
+    if (intervalParsed.month) {
+      totalMonths += intervalParsed.month;
+    }
+
+    if (totalMonths !== 0) {
+      res = `ADD_MONTHS(${res}, ${totalMonths})`;
+    }
+
+    // Handle day/hour/minute/second using NUMTODSINTERVAL
+    if (intervalParsed.day) {
+      res = `${res} + NUMTODSINTERVAL(${intervalParsed.day}, 'DAY')`;
+    }
+    if (intervalParsed.hour) {
+      res = `${res} + NUMTODSINTERVAL(${intervalParsed.hour}, 'HOUR')`;
+    }
+    if (intervalParsed.minute) {
+      res = `${res} + NUMTODSINTERVAL(${intervalParsed.minute}, 'MINUTE')`;
+    }
+    if (intervalParsed.second) {
+      res = `${res} + NUMTODSINTERVAL(${intervalParsed.second}, 'SECOND')`;
+    }
+
+    return res;
+  }
+
+  /**
+   * Oracle subtraction uses ADD_MONTHS with negative values
+   * and subtracts NUMTODSINTERVAL for time units
+   */
+  public subtractInterval(date: string, interval: string): string {
+    const intervalParsed = parseSqlInterval(interval);
+    let res = date;
+
+    // Handle year/month/quarter using ADD_MONTHS with negative values
+    let totalMonths = 0;
+    if (intervalParsed.year) {
+      totalMonths += intervalParsed.year * 12;
+    }
+    if (intervalParsed.quarter) {
+      totalMonths += intervalParsed.quarter * 3;
+    }
+    if (intervalParsed.month) {
+      totalMonths += intervalParsed.month;
+    }
+
+    if (totalMonths !== 0) {
+      res = `ADD_MONTHS(${res}, -${totalMonths})`;
+    }
+
+    // Handle day/hour/minute/second using NUMTODSINTERVAL with subtraction
+    if (intervalParsed.day) {
+      res = `${res} - NUMTODSINTERVAL(${intervalParsed.day}, 'DAY')`;
+    }
+    if (intervalParsed.hour) {
+      res = `${res} - NUMTODSINTERVAL(${intervalParsed.hour}, 'HOUR')`;
+    }
+    if (intervalParsed.minute) {
+      res = `${res} - NUMTODSINTERVAL(${intervalParsed.minute}, 'MINUTE')`;
+    }
+    if (intervalParsed.second) {
+      res = `${res} - NUMTODSINTERVAL(${intervalParsed.second}, 'SECOND')`;
+    }
+
+    return res;
+  }
+
   public newFilter(filter) {
     return new OracleFilter(this, filter);
   }