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.

Author: Tankilevitch

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

@@ -3857,6 +3857,11 @@ export class BaseQuery {
    * @return {string}
    */
   dimensionTimeGroupedColumn(dimension, granularity) {
+    // Handle case when granularity is not specified (e.g., time dimension used only for filtering)
+    if (!granularity) {
+      return this.timeGroupedColumn(null, dimension);
+    }
+
     let dtDate;
 
     // Interval is aligned with natural calendar, so we can use DATE_TRUNC

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',
@@ -89,6 +90,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);
   }

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

@@ -305,4 +305,50 @@ describe('OracleQuery', () => {
     expect(sql).toMatch(/GROUP BY.*"visitors"\.source/i);
     expect(sql).not.toMatch(/GROUP BY\s+\d+/);
   });
+
+  it('handles time dimension without granularity in filter', async () => {
+    await compiler.compile();
+
+    const query = new OracleQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [
+        'visitors.count'
+      ],
+      timeDimensions: [{
+        dimension: 'visitors.createdAt',
+        dateRange: ['2020-01-01', '2020-12-31']
+        // No granularity specified - used only for filtering
+      }],
+      timezone: 'UTC'
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    const sql = queryAndParams[0];
+
+    // Key test: no GROUP BY on time dimension when granularity is missing
+    expect(sql).not.toMatch(/GROUP BY.*created_at/i);
+  });
+
+  it('uses Oracle-specific interval arithmetic', 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];
+
+    // Key test: Oracle uses ADD_MONTHS, not PostgreSQL interval syntax
+    expect(sql).toMatch(/ADD_MONTHS/i);
+    expect(sql).not.toMatch(/interval '1 year'/i);
+  });
 });