fix(tesseract): generate the time series in SQL on Snowflake

docs-mintlify/reference/data-modeling/measures.mdx

@@ -463,6 +463,13 @@ for the series of time windows.
 With Tesseract, the [next-generation data modeling engine][link-tesseract],
 rolling window calculations don't require the date range for the time dimension. In versions before v1.7.0, Tesseract was not enabled by default.
 
+Omitting the date range requires the data source to generate the time series in
+SQL. It is supported for Amazon Athena, Databricks, Google BigQuery, Microsoft SQL
+Server, Postgres, Presto, Snowflake, and Trino, as well as for MySQL with the
+`CUBEJS_DB_MYSQL_USE_GENERATED_TIME_SERIES` environment variable set. With other
+data sources, and with [custom granularities][ref-custom-granularities] on Google
+BigQuery, Microsoft SQL Server, and Snowflake, the date range is still required.
+
 </Warning>
 
 #### `offset`
@@ -1504,6 +1511,7 @@ cube(`orders`, {
 [ref-nested-aggregate]: /docs/data-modeling/measures#nested-aggregates
 [ref-calendar-cubes]: /docs/data-modeling/concepts/calendar-cubes
 [ref-switch-dimensions]: /reference/data-modeling/dimensions#type
+[ref-custom-granularities]: /reference/data-modeling/dimensions#granularities
 [ref-filters-query]: /reference/core-data-apis/rest-api/query-format#filters-format
 [ref-data-masking]: /docs/data-modeling/data-access-policies#data-masking
 [link-d3-format]: https://d3js.org/d3-format

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

@@ -12,6 +12,9 @@ const GRANULARITY_TO_INTERVAL = {
   year: 'YEAR'
 };
 
+// Ordered from the smallest, so the first match is the interval's own unit.
+const INTERVAL_UNITS = ['second', 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'];
+
 class SnowflakeFilter extends BaseFilter {
   public likeIgnoreCase(column: string, not: boolean, param: any, type: string) {
     const p = (!type || type === 'contains' || type === 'ends') ? '\'%\' || ' : '';
@@ -84,6 +87,19 @@ export class SnowflakeQuery extends BaseQuery {
     return `${value}::timestamp_tz`;
   }
 
+  /**
+   * The generated time series steps with DATEADD, which takes a time unit and a
+   * row number rather than an interval, so it needs the unit the interval is
+   * actually expressed in. `diffTimeUnitForInterval` answers a different
+   * question - it degrades WEEK to DAY and QUARTER to MONTH, which DATEADD would
+   * then step by, producing seven or three times as many periods as asked for.
+   */
+  public override intervalAndMinimalTimeUnit(interval: string): [string, string] {
+    const unit = INTERVAL_UNITS.find(u => new RegExp(u, 'i').test(interval));
+
+    return [interval, unit || 'year'];
+  }
+
   public defaultRefreshKeyRenewalThreshold() {
     return 120;
   }
@@ -146,6 +162,26 @@ export class SnowflakeQuery extends BaseQuery {
     // the same reason described there.
     templates.tesseract.ilike = '{{ expr }} {% if negated %}NOT {% endif %}ILIKE {{ pattern }} ESCAPE \'\\\\\'';
     templates.tesseract.join_types_full = 'FULL';
+    // Snowflake has no generate_series, and GENERATOR only takes a literal row
+    // count. ARRAY_GENERATE_RANGE does accept arbitrary expressions for its
+    // bounds, so the series covers whatever range the query turns out to need;
+    // the only ceiling is the maximum size of a single ARRAY value.
+    //
+    // Its row number is a count of whole time units, which is all DATEADD can
+    // step by. A custom granularity's interval carries no such count, so
+    // `supportGeneratedSeriesForCustomTd` stays off and those queries keep
+    // asking for an explicit date range.
+    //
+    // Snowflake folds unquoted identifiers to upper case while the planner reads
+    // the series back by lower-case name, so the two output columns are quoted.
+    templates.statements.generated_time_series_select = 'SELECT series_date AS "date_from",\n' +
+      'DATEADD(MILLISECOND, -1, DATEADD({{ minimal_time_unit }}, 1, series_date)) AS "date_to"\n' +
+      'FROM (SELECT DATEADD({{ minimal_time_unit }}, series_index.value::int, {{ start }}::timestamp_ntz) AS series_date\n' +
+      'FROM TABLE(FLATTEN(input => ARRAY_GENERATE_RANGE(0, DATEDIFF({{ minimal_time_unit }}, {{ start }}::timestamp_ntz, {{ end }}::timestamp_ntz) + 1))) AS series_index) AS series';
+    templates.statements.generated_time_series_with_cte_range_source = 'SELECT series_date AS "date_from",\n' +
+      'DATEADD(MILLISECOND, -1, DATEADD({{ minimal_time_unit }}, 1, series_date)) AS "date_to"\n' +
+      'FROM (SELECT DATEADD({{ minimal_time_unit }}, series_index.value::int, {{ range_source }}."{{ min_name }}") AS series_date\n' +
+      'FROM {{ range_source }}, LATERAL FLATTEN(input => ARRAY_GENERATE_RANGE(0, DATEDIFF({{ minimal_time_unit }}, {{ range_source }}."{{ min_name }}", {{ range_source }}."{{ max_name }}") + 1)) AS series_index) AS series';
     delete templates.types.interval;
     return templates;
   }

packages/cubejs-schema-compiler/test/unit/generated-time-series.test.ts

@@ -0,0 +1,121 @@
+/* eslint-disable no-restricted-syntax */
+import { PostgresQuery } from '../../src/adapter/PostgresQuery';
+import { SnowflakeQuery } from '../../src/adapter/SnowflakeQuery';
+import { prepareYamlCompiler } from './PrepareCompiler';
+
+/**
+ * A rolling window asked for at some granularity but with no date range has to
+ * derive the bounds of its time series in SQL, from the data itself. The planner
+ * can only do that where the dialect defines `generated_time_series_select`;
+ * without it there is nowhere to take the bounds from and the query is rejected
+ * with "Date range is required for time series".
+ */
+describe('generated time series', () => {
+  const { compiler, joinGraph, cubeEvaluator } = prepareYamlCompiler(`
+cubes:
+  - name: events
+    sql: "SELECT 1 AS user_id, '2024-01-01' AS invited_at"
+    dimensions:
+      - name: invited_at
+        sql: invited_at
+        type: time
+        granularities:
+          - name: two_weeks
+            interval: 2 weeks
+            origin: "2024-01-01"
+    measures:
+      - name: cumulative_users
+        sql: user_id
+        type: count_distinct
+        rolling_window:
+          trailing: unbounded
+      - name: rolling_30d_users
+        sql: user_id
+        type: count_distinct
+        rolling_window:
+          trailing: "30 day"
+`);
+
+  const buildSql = async (
+    QueryClass: any,
+    { granularity = 'month', dateRange, measure = 'events.cumulative_users' }: {
+      granularity?: string, dateRange?: [string, string], measure?: string
+    } = {}
+  ) => {
+    await compiler.compile();
+
+    const query = new QueryClass({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [measure],
+      timeDimensions: [{
+        dimension: 'events.invited_at',
+        granularity,
+        ...(dateRange ? { dateRange } : {}),
+      }],
+      timezone: 'UTC',
+      useNativeSqlPlanner: true,
+    });
+
+    return query.buildSqlAndParams()[0];
+  };
+
+  // Every dialect that generates the series in SQL has to accept the same query,
+  // so the guard is stated once over all of them rather than per dialect.
+  const GENERATING_DIALECTS: [string, any][] = [
+    ['Postgres', PostgresQuery],
+    ['Snowflake', SnowflakeQuery],
+  ];
+
+  const PREDEFINED_GRANULARITIES = ['second', 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'];
+
+  describe.each(GENERATING_DIALECTS)('%s', (_name, QueryClass) => {
+    it.each(PREDEFINED_GRANULARITIES)('plans a rolling window at %s granularity with no date range', async (granularity) => {
+      const sql = await buildSql(QueryClass, { granularity });
+
+      expect(sql).toContain('time_series');
+    });
+
+    it('keeps planning a rolling window with an explicit date range', async () => {
+      const sql = await buildSql(QueryClass, { dateRange: ['2024-01-01', '2024-12-31'] });
+
+      expect(sql).toContain('time_series');
+    });
+
+    it('plans a bounded rolling window with no date range', async () => {
+      const sql = await buildSql(QueryClass, { measure: 'events.rolling_30d_users' });
+
+      expect(sql).toContain('time_series');
+    });
+  });
+
+  describe('Snowflake', () => {
+    it('steps the series by the granularity itself, not by its smallest time unit', async () => {
+      const weekly = await buildSql(SnowflakeQuery, { granularity: 'week' });
+      const quarterly = await buildSql(SnowflakeQuery, { granularity: 'quarter' });
+
+      expect(weekly).toContain('DATEDIFF(week');
+      expect(quarterly).toContain('DATEDIFF(quarter');
+    });
+
+    it('names the series columns so that they survive identifier folding', async () => {
+      const sql = await buildSql(SnowflakeQuery);
+
+      expect(sql).toContain('"date_from"');
+      expect(sql).toContain('"date_to"');
+    });
+
+    // Snowflake cannot multiply an arbitrary interval by a row number, so a
+    // granularity that is not one whole time unit still needs the range spelled
+    // out and the series built outside the database.
+    it('still requires a date range for a custom granularity', async () => {
+      await expect(buildSql(SnowflakeQuery, { granularity: 'two_weeks' }))
+        .rejects.toThrow('Date range is required for time series');
+
+      const sql = await buildSql(SnowflakeQuery, {
+        granularity: 'two_weeks',
+        dateRange: ['2024-01-01', '2024-12-31'],
+      });
+
+      expect(sql).toContain('time_series');
+    });
+  });
+});

packages/cubejs-testing-drivers/fixtures/snowflake.json

@@ -321,11 +321,6 @@
     "SQL API: Extended nested Rollup over asterisk",
     "SQL API: SQL push down push to cube quoted alias",
 
-
-
-    "querying BigECommerce: rolling window by 2 day without date range",
-    "querying BigECommerce: rolling window by 2 month without date range",
-    "querying BigECommerce: rolling window YTD without date range",
     "querying custom granularities (with preaggregation) ECommerce: totalQuantity by half_year + no dimension",
 
     "---- Different results comparing to baseQuery version. Need to investigate ----",