@hypequery/datasets 0.23.0 → 0.24.0

package/dist/utils/shift-measure-sql.js

@@ -1,27 +1,25 @@
-import { GRAIN_FUNCTIONS } from '../constants.js';
-import { addTimeSql, subtractTimeSql } from './time-arithmetic-sql.js';
 import { calendarBucketGuardSql } from './time-axis-calendar-guard.js';
 import { calendarShiftAtFineGrain } from './shift-measure-grains.js';
 import { shiftWallTimeGuardSql } from './shift-wall-time-sql.js';
 import { anchoredCalendarShiftSql } from './calendar-shift-sql.js';
 /** Preserve the selected portion of a bucket and both authored endpoint operators. */
-export function shiftRangeSql(shift, axis, period) {
+export function shiftRangeSql(dialect, shift, axis, period) {
     const first = period ?? '_hq_first';
     const last = period ?? '_hq_last';
-    const end = addTimeSql(last, 1, axis.grain);
+    const end = dialect.addTime(last, 1, axis.grain);
     const calendar = calendarShiftAtFineGrain(shift.interval, axis.grain);
     // Clamp the bucket anchor, then retain its width. Independently clamping both
     // dates would turn March 30–31 into February 28–28, dropping an entire day.
     // A partial bucket keeps the matching slice of that shifted range, so both
     // bounds are placed relative to the anchor rather than shifted on their own.
     const shiftBound = (point, anchor) => calendar
-        ? anchoredCalendarShiftSql(point, anchor, shift.interval)
-        : subtractTimeSql(point, shift.interval.amount, shift.interval.unit);
-    const upper = shiftBound(`least(${end}, _hq_upper)`, last);
-    const shiftedEnd = addTimeSql(subtractTimeSql(last, shift.interval.amount, shift.interval.unit), 1, axis.grain);
+        ? anchoredCalendarShiftSql(dialect, point, anchor, shift.interval)
+        : dialect.subtractTime(point, shift.interval.amount, shift.interval.unit);
+    const upper = shiftBound(dialect.least(end, '_hq_upper'), last);
+    const shiftedEnd = dialect.addTime(dialect.subtractTime(last, shift.interval.amount, shift.interval.unit), 1, axis.grain);
     return {
-        lower: shiftBound(`greatest(${first}, _hq_lower)`, first),
-        upper: calendar ? `if(_hq_upper >= ${end}, ${shiftedEnd}, ${upper})` : upper,
+        lower: shiftBound(dialect.greatest(first, '_hq_lower'), first),
+        upper: calendar ? dialect.ifElse(`_hq_upper >= ${end}`, shiftedEnd, upper) : upper,
         lowerInclusive: period ? `(${period} > _hq_lower OR ${Number(axis.lowerInclusive)})` : String(Number(axis.lowerInclusive)),
         upperInclusive: `(_hq_upper < ${end} AND ${Number(axis.upperInclusive)})`,
     };
@@ -31,29 +29,30 @@ export function shiftRangePredicateSql(time, range) {
         + ` AND (${time} < ${range.upper} OR (${range.upperInclusive} AND ${time} = ${range.upper}))`;
 }
 /** Check the shifted scan independently of whether it contains source rows. */
-export function shiftCalendarGuardSql(shift, axis, axisGuard) {
+export function shiftCalendarGuardSql(dialect, shift, axis, axisGuard) {
     const { grain } = axis;
-    const { lower, upper } = shiftRangeSql(shift, axis);
-    const first = `${GRAIN_FUNCTIONS[grain]}(${lower})`;
-    const last = `${GRAIN_FUNCTIONS[grain]}(${upper})`;
-    const count = `dateDiff('${grain}', ${first}, ${last}) + ${axisGuard}`;
-    return calendarBucketGuardSql(first, count, grain);
+    const { lower, upper } = shiftRangeSql(dialect, shift, axis);
+    const first = dialect.truncateTime(lower, grain);
+    const last = dialect.truncateTime(upper, grain);
+    const count = `${dialect.timeDiff(grain, first, last)} + ${axisGuard}`;
+    return calendarBucketGuardSql(dialect, first, count, grain);
 }
 /** Validate each output bucket after the series exists, including empty source populations. */
-export function shiftWallTimeSeriesGuardSql(shift, grain) {
-    const end = addTimeSql('_hq_period', 1, grain);
-    return shiftWallTimeGuardSql(shift.interval, grain, '_hq_series CROSS JOIN _hq_bounds', '_hq_period', 'greatest(_hq_period, _hq_lower)', `least(${end}, _hq_upper)`, end);
+export function shiftWallTimeSeriesGuardSql(dialect, shift, grain) {
+    const end = dialect.addTime('_hq_period', 1, grain);
+    return shiftWallTimeGuardSql(dialect, shift.interval, grain, '_hq_series CROSS JOIN _hq_bounds', '_hq_period', dialect.greatest('_hq_period', '_hq_lower'), dialect.least(end, '_hq_upper'), end);
 }
 /** Map output buckets to their earlier half-open ranges, retaining calendar arithmetic. */
-export function shiftBucketCtes(shift, axis, index) {
+export function shiftBucketCtes(dialect, shift, axis, index) {
     const { grain } = axis;
     const ranges = `_hq_shift_ranges${index}`;
     const keys = `_hq_shift_keys${index}`;
-    const range = shiftRangeSql(shift, axis, '_hq_period');
-    const bucket = `${GRAIN_FUNCTIONS[grain]}(_hq_shift_lower)`;
-    const upperBucket = `${GRAIN_FUNCTIONS[grain]}(_hq_shift_upper)`;
-    const count = `greatest(0, dateDiff('${grain}', ${bucket}, ${upperBucket}) + if(_hq_shift_upper > ${upperBucket} OR _hq_shift_upper_inclusive, 1, 0))`;
-    const join = ` AS r INNER JOIN ${keys} AS b ON ${GRAIN_FUNCTIONS[grain]}(r._hq_time) = b._hq_source_period WHERE ${shiftRangePredicateSql('r._hq_time', { lower: 'b._hq_shift_lower', upper: 'b._hq_shift_upper', lowerInclusive: 'b._hq_shift_lower_inclusive', upperInclusive: 'b._hq_shift_upper_inclusive' })}`;
+    const range = shiftRangeSql(dialect, shift, axis, '_hq_period');
+    const bucket = dialect.truncateTime('_hq_shift_lower', grain);
+    const upperBucket = dialect.truncateTime('_hq_shift_upper', grain);
+    const partialUpper = dialect.ifElse(`_hq_shift_upper > ${upperBucket} OR _hq_shift_upper_inclusive`, '1', '0');
+    const count = dialect.greatest('0', `${dialect.timeDiff(grain, bucket, upperBucket)} + ${partialUpper}`);
+    const join = ` AS r INNER JOIN ${keys} AS b ON ${dialect.truncateTime('r._hq_time', grain)} = b._hq_source_period WHERE ${shiftRangePredicateSql('r._hq_time', { lower: 'b._hq_shift_lower', upper: 'b._hq_shift_upper', lowerInclusive: 'b._hq_shift_lower_inclusive', upperInclusive: 'b._hq_shift_upper_inclusive' })}`;
     return {
         // Membership preserves duplicate source rows while excluding dates and
         // partial ranges that no output bucket maps to, including clamped overlaps.
@@ -63,7 +62,7 @@ export function shiftBucketCtes(shift, axis, index) {
             // A DST transition can map a one-hour output bucket to zero or two
             // source hours. Enumerate source bucket keys and keep exact endpoints.
             // The equality join avoids a source-rows × output-series Cartesian product.
-            `${keys} AS (SELECT *, ${addTimeSql(bucket, `arrayJoin(range(toUInt64(${count})))`, grain)} AS _hq_source_period FROM ${ranges})`,
+            `${keys} AS (SELECT *, ${dialect.addTime(bucket, dialect.seriesIndex(count), grain)} AS _hq_source_period FROM ${ranges})`,
         ],
         rowsSql: `SELECT r.*, b._hq_period FROM _hq_scanned${join}`,
     };

package/dist/utils/shift-wall-time-sql.d.ts

@@ -1,4 +1,5 @@
+import type { DatasetSqlDialectRules } from '../dataset-sql-dialect.js';
 import type { MeasureTimeInterval, TimeGrain } from '../types.js';
 /** Reject DST normalization that moves a shifted sub-day bucket to another local time. */
-export declare function shiftWallTimeGuardSql(interval: MeasureTimeInterval, grain: TimeGrain, source: string, period: string, lower: string, upper: string, end: string): string;
+export declare function shiftWallTimeGuardSql(dialect: DatasetSqlDialectRules, interval: MeasureTimeInterval, grain: TimeGrain, source: string, period: string, lower: string, upper: string, end: string): string;
 //# sourceMappingURL=shift-wall-time-sql.d.ts.map

package/dist/utils/shift-wall-time-sql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shift-wall-time-sql.d.ts","sourceRoot":"","sources":["../../src/utils/shift-wall-time-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIlE,0FAA0F;AAC1F,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV,MAAM,CAYR"}
+{"version":3,"file":"shift-wall-time-sql.d.ts","sourceRoot":"","sources":["../../src/utils/shift-wall-time-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAuB,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAC7F,OAAO,KAAK,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAKlE,0FAA0F;AAC1F,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV,MAAM,CAaR"}

package/dist/utils/shift-wall-time-sql.js

@@ -1,17 +1,17 @@
-import { subtractTimeSql } from './time-arithmetic-sql.js';
 import { calendarShiftAtFineGrain } from './shift-measure-grains.js';
+const CLOCK_PARTS = ['Hour', 'Minute', 'Second'];
 /** Reject DST normalization that moves a shifted sub-day bucket to another local time. */
-export function shiftWallTimeGuardSql(interval, grain, source, period, lower, upper, end) {
+export function shiftWallTimeGuardSql(dialect, interval, grain, source, period, lower, upper, end) {
     if (!calendarShiftAtFineGrain(interval, grain) || (grain !== 'minute' && grain !== 'hour'))
         return '0';
     const changesWallTime = (value) => {
-        const shifted = subtractTimeSql(value, interval.amount, interval.unit);
-        return ['Hour', 'Minute', 'Second']
-            .map(part => `to${part}(${value}) != to${part}(${shifted})`)
+        const shifted = dialect.subtractTime(value, interval.amount, interval.unit);
+        return CLOCK_PARTS
+            .map(part => `${dialect.clockPart(part, value)} != ${dialect.clockPart(part, shifted)}`)
             .join(' OR ');
     };
     const changed = `(${changesWallTime(period)}) OR (${changesWallTime(lower)})`
         + ` OR (${upper} != ${end} AND (${changesWallTime(upper)}))`;
-    return `(SELECT throwIf(countIf(${changed}) > 0, `
-        + `'Calendar shift lands on a nonexistent local time; use a UTC query timezone.') FROM ${source})`;
+    const guard = dialect.guard(`${dialect.countIf(changed)} > 0`, 'Calendar shift lands on a nonexistent local time; use a UTC query timezone.');
+    return `(SELECT ${guard} FROM ${source})`;
 }

package/dist/utils/statement-parameters.d.ts

@@ -0,0 +1,58 @@
+import type { DatasetSqlDialectRules, DatasetSqlParameterType } from '../dataset-sql-dialect.js';
+/** A compiled builder statement: SQL with positional `?` markers and their values. */
+export interface BuilderStatement {
+    readonly sql: string;
+    readonly parameters: readonly unknown[];
+}
+/** A query builder, as far as embedding its compiled statement is concerned. */
+export interface EmbeddableBuilder {
+    toSQLWithParams(): BuilderStatement;
+    toSQLWithPlaceholders?(placeholder: (value: unknown) => string): string;
+}
+/** An executable statement, rendered for its dialect. */
+export interface RenderedStatement {
+    sql: string;
+    parameters: unknown[];
+}
+/**
+ * Planner output that still carries markers. Not executable: only
+ * {@link renderStatement} turns it into SQL, so markers cannot reach callers.
+ */
+export interface PlannedStatement {
+    readonly text: string;
+    readonly parameters: StatementParameters;
+}
+/**
+ * Owns every value bound into one statement family (a statement and its
+ * preflight statements). Values are bound behind opaque markers; the dialect
+ * spells placeholders once, at render time, in the order the markers appear
+ * in the final text. See specs/datasets/0001-statement-parameters.md.
+ */
+export declare class StatementParameters {
+    readonly dialect: DatasetSqlDialectRules;
+    private readonly nonce;
+    private readonly values;
+    private readonly pieces;
+    constructor(dialect: DatasetSqlDialectRules);
+    /** Bind one value; place the returned marker where the value belongs. */
+    bind(value: unknown, type?: DatasetSqlParameterType): string;
+    /** Embed a builder statement whose SQL carries its own positional `?` markers. */
+    embed(piece: BuilderStatement): string;
+    /**
+     * Embed a query builder's statement.
+     *
+     * On positional `?` dialects the builder's own statement is embedded as one
+     * block, exactly as before: `toSQLWithPlaceholders` is not called, so a
+     * duck-typed builder that answers any method name keeps working. Dialects
+     * that number placeholders need each value bound here, so they require the
+     * builder to render through `toSQLWithPlaceholders`. A caller that already
+     * compiled the builder positionally can pass that statement to reuse it.
+     */
+    embedBuilder(builder: EmbeddableBuilder, compiled?: BuilderStatement): string;
+    /** Replace every marker in text order. Fails closed on foreign or malformed markers. */
+    render(text: string): RenderedStatement;
+    private marker;
+}
+/** Render planner output for execution. The only exit from a {@link PlannedStatement}. */
+export declare function renderStatement(statement: PlannedStatement): RenderedStatement;
+//# sourceMappingURL=statement-parameters.d.ts.map

package/dist/utils/statement-parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statement-parameters.d.ts","sourceRoot":"","sources":["../../src/utils/statement-parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA4B,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAE3H,sFAAsF;AACtF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,SAAS,OAAO,EAAE,CAAC;CACzC;AAED,gFAAgF;AAChF,MAAM,WAAW,iBAAiB;IAChC,eAAe,IAAI,gBAAgB,CAAC;IACpC,qBAAqB,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,GAAG,MAAM,CAAC;CACzE;AAED,yDAAyD;AACzD,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,OAAO,EAAE,CAAC;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;CAC1C;AAaD;;;;;GAKG;AACH,qBAAa,mBAAmB;IAKlB,QAAQ,CAAC,OAAO,EAAE,sBAAsB;IAJpD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IACzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;gBAE5B,OAAO,EAAE,sBAAsB;IAEpD,yEAAyE;IACzE,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,uBAAuB,GAAG,MAAM;IAK5D,kFAAkF;IAClF,KAAK,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM;IActC;;;;;;;;;OASG;IACH,YAAY,CAAC,OAAO,EAAE,iBAAiB,EAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAG,MAAM;IAa7E,wFAAwF;IACxF,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB;IA2BvC,OAAO,CAAC,MAAM;CAGf;AAED,0FAA0F;AAC1F,wBAAgB,eAAe,CAAC,SAAS,EAAE,gBAAgB,GAAG,iBAAiB,CAE9E"}

package/dist/utils/statement-parameters.js

@@ -0,0 +1,101 @@
+// Private-use code points never appear in generated SQL, and the nonce makes
+// a marker unforgeable by any text that reaches a statement.
+const OPEN = '\uE000';
+const CLOSE = '\uE001';
+const MARKER = /\uE000([0-9a-f]+):([vb]):(\d+)\uE001/g;
+function createNonce() {
+    const bytes = globalThis.crypto.getRandomValues(new Uint8Array(8));
+    return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
+}
+/**
+ * Owns every value bound into one statement family (a statement and its
+ * preflight statements). Values are bound behind opaque markers; the dialect
+ * spells placeholders once, at render time, in the order the markers appear
+ * in the final text. See specs/datasets/0001-statement-parameters.md.
+ */
+export class StatementParameters {
+    dialect;
+    nonce = createNonce();
+    values = [];
+    pieces = [];
+    constructor(dialect) {
+        this.dialect = dialect;
+    }
+    /** Bind one value; place the returned marker where the value belongs. */
+    bind(value, type) {
+        this.values.push(type === undefined ? { value } : { value, type });
+        return this.marker('v', this.values.length - 1);
+    }
+    /** Embed a builder statement whose SQL carries its own positional `?` markers. */
+    embed(piece) {
+        if (!this.dialect.embedsPositionalPieces) {
+            throw new Error(`The "${this.dialect.name}" datasets dialect cannot embed positional query builder SQL; `
+                + 'the query builder must render placeholders for the datasets planner.');
+        }
+        if (piece.sql.includes(OPEN) || piece.sql.includes(CLOSE)) {
+            throw new Error('Query builder SQL cannot contain datasets statement markers.');
+        }
+        this.pieces.push({ sql: piece.sql, parameters: [...piece.parameters] });
+        return this.marker('b', this.pieces.length - 1);
+    }
+    /**
+     * Embed a query builder's statement.
+     *
+     * On positional `?` dialects the builder's own statement is embedded as one
+     * block, exactly as before: `toSQLWithPlaceholders` is not called, so a
+     * duck-typed builder that answers any method name keeps working. Dialects
+     * that number placeholders need each value bound here, so they require the
+     * builder to render through `toSQLWithPlaceholders`. A caller that already
+     * compiled the builder positionally can pass that statement to reuse it.
+     */
+    embedBuilder(builder, compiled) {
+        if (this.dialect.embedsPositionalPieces)
+            return this.embed(compiled ?? builder.toSQLWithParams());
+        if (typeof builder.toSQLWithPlaceholders !== 'function') {
+            throw new Error(`The "${this.dialect.name}" datasets dialect numbers placeholders; `
+                + 'the query builder must implement toSQLWithPlaceholders.');
+        }
+        const sql = builder.toSQLWithPlaceholders(value => this.bind(value));
+        if (typeof sql !== 'string')
+            throw new Error('Query builder toSQLWithPlaceholders must return SQL text.');
+        return sql;
+    }
+    /** Replace every marker in text order. Fails closed on foreign or malformed markers. */
+    render(text) {
+        const parameters = [];
+        const reused = new Map();
+        const sql = text.replace(MARKER, (_match, nonce, kind, position) => {
+            if (nonce !== this.nonce)
+                throw new Error('Statement contains a marker from another compilation.');
+            const index = Number(position);
+            if (kind === 'b') {
+                const piece = this.pieces[index];
+                if (!piece)
+                    throw new Error('Statement contains an unknown builder marker.');
+                parameters.push(...piece.parameters);
+                return piece.sql;
+            }
+            const bound = this.values[index];
+            if (!bound)
+                throw new Error('Statement contains an unknown parameter marker.');
+            const existing = this.dialect.reusesPlaceholders ? reused.get(index) : undefined;
+            if (existing !== undefined)
+                return existing;
+            const placeholder = this.dialect.placeholder(parameters.length, bound);
+            parameters.push(bound.value);
+            reused.set(index, placeholder);
+            return placeholder;
+        });
+        if (sql.includes(OPEN) || sql.includes(CLOSE)) {
+            throw new Error('Statement contains a malformed parameter marker.');
+        }
+        return { sql, parameters };
+    }
+    marker(kind, index) {
+        return `${OPEN}${this.nonce}:${kind}:${index}${CLOSE}`;
+    }
+}
+/** Render planner output for execution. The only exit from a {@link PlannedStatement}. */
+export function renderStatement(statement) {
+    return statement.parameters.render(statement.text);
+}

package/dist/utils/time-axis-calendar-guard.d.ts

@@ -1,3 +1,4 @@
+import type { DatasetSqlDialectRules } from '../dataset-sql-dialect.js';
 import type { TimeGrain } from '../types.js';
 /**
  * Calendar arithmetic can clamp a nonexistent date onto the previous bucket
@@ -5,5 +6,5 @@ import type { TimeGrain } from '../types.js';
  * repeating them would duplicate aggregates and cumulative contributions.
  * `count` must already include the series/fanout guards, bounding enumeration.
  */
-export declare function calendarBucketGuardSql(start: string, count: string, grain: TimeGrain): string;
+export declare function calendarBucketGuardSql(dialect: DatasetSqlDialectRules, start: string, count: string, grain: TimeGrain): string;
 //# sourceMappingURL=time-axis-calendar-guard.d.ts.map

package/dist/utils/time-axis-calendar-guard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-axis-calendar-guard.d.ts","sourceRoot":"","sources":["../../src/utils/time-axis-calendar-guard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAQ7F"}
+{"version":3,"file":"time-axis-calendar-guard.d.ts","sourceRoot":"","sources":["../../src/utils/time-axis-calendar-guard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAU9H"}

package/dist/utils/time-axis-calendar-guard.js

@@ -1,17 +1,15 @@
-import { addTimeSql } from './time-arithmetic-sql.js';
 /**
  * Calendar arithmetic can clamp a nonexistent date onto the previous bucket
  * (for example Pacific/Apia, 2011-12-30). Reject non-increasing bucket starts:
  * repeating them would duplicate aggregates and cumulative contributions.
  * `count` must already include the series/fanout guards, bounding enumeration.
  */
-export function calendarBucketGuardSql(start, count, grain) {
+export function calendarBucketGuardSql(dialect, start, count, grain) {
     if (grain === 'minute' || grain === 'hour')
         return '0';
-    const current = addTimeSql(start, '_hq_calendar_index', grain);
-    const next = addTimeSql(start, '_hq_calendar_index + 1', grain);
+    const index = '_hq_calendar_index';
+    const current = dialect.addTime(start, index, grain);
+    const next = dialect.addTime(start, `${index} + 1`, grain);
     // Include the end boundary, which also bounds the source-row scan.
-    const indices = `range(toUInt64(greatest(1, ${count})))`;
-    return `throwIf(arrayExists(_hq_calendar_index -> ${next} <= ${current}, ${indices}), `
-        + "'Time range crosses a skipped local calendar bucket; use a UTC time key for this range.')";
+    return dialect.guard(dialect.anyIndex(index, dialect.greatest('1', count), `${next} <= ${current}`), 'Time range crosses a skipped local calendar bucket; use a UTC time key for this range.');
 }

package/dist/utils/time-measure-axis-sql.d.ts

@@ -1,3 +1,4 @@
+import type { StatementParameters } from './statement-parameters.js';
 import type { TimeMeasureAxis } from './time-measure-axis.js';
 import type { TimeMeasureSqlSource } from './time-measure-source-sql.js';
 import type { ShiftMeasureDefinition } from '../types.js';
@@ -9,5 +10,5 @@ export interface TimeMeasureSqlAxis {
     postSeriesGuard: string;
 }
 /** Build bounded output buckets using the query timezone. */
-export declare function buildTimeMeasureAxisSql(source: TimeMeasureSqlSource, axis: TimeMeasureAxis, shifts?: readonly ShiftMeasureDefinition[]): TimeMeasureSqlAxis;
+export declare function buildTimeMeasureAxisSql(statement: StatementParameters, source: TimeMeasureSqlSource, axis: TimeMeasureAxis, shifts?: readonly ShiftMeasureDefinition[]): TimeMeasureSqlAxis;
 //# sourceMappingURL=time-measure-axis-sql.d.ts.map

package/dist/utils/time-measure-axis-sql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-measure-axis-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-axis-sql.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAGzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAG1D,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;CACzB;AAMD,6DAA6D;AAC7D,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,oBAAoB,EAC5B,IAAI,EAAE,eAAe,EACrB,MAAM,GAAE,SAAS,sBAAsB,EAAO,GAC7C,kBAAkB,CAyCpB"}
+{"version":3,"file":"time-measure-axis-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-axis-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAG1D,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,6DAA6D;AAC7D,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,mBAAmB,EAC9B,MAAM,EAAE,oBAAoB,EAC5B,IAAI,EAAE,eAAe,EACrB,MAAM,GAAE,SAAS,sBAAsB,EAAO,GAC7C,kBAAkB,CA2CpB"}

package/dist/utils/time-measure-axis-sql.js

@@ -1,42 +1,39 @@
-import { GRAIN_FUNCTIONS } from '../constants.js';
-import { addTimeSql as add, subtractTimeSql as subtract } from './time-arithmetic-sql.js';
 import { calendarBucketGuardSql } from './time-axis-calendar-guard.js';
 import { shiftCalendarGuardSql, shiftWallTimeSeriesGuardSql } from './shift-measure-sql.js';
-function literal(value) {
-    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "''")}'`;
-}
 /** Build bounded output buckets using the query timezone. */
-export function buildTimeMeasureAxisSql(source, axis, shifts = []) {
-    const first = `${GRAIN_FUNCTIONS[axis.grain]}(_hq_lower)`;
-    const upperBucket = `${GRAIN_FUNCTIONS[axis.grain]}(_hq_upper)`;
+export function buildTimeMeasureAxisSql(statement, source, axis, shifts = []) {
+    const { dialect } = statement;
+    const first = dialect.truncateTime('_hq_lower', axis.grain);
+    const upperBucket = dialect.truncateTime('_hq_upper', axis.grain);
     const last = axis.upperInclusive
         ? upperBucket
-        : `if(_hq_upper = ${upperBucket}, ${subtract(upperBucket, 1, axis.grain)}, ${upperBucket})`;
-    const count = `dateDiff('${axis.grain}', _hq_first, _hq_last) + 1`;
+        : dialect.ifElse(`_hq_upper = ${upperBucket}`, dialect.subtractTime(upperBucket, 1, axis.grain), upperBucket);
+    const count = `${dialect.timeDiff(axis.grain, '_hq_first', '_hq_last')} + 1`;
     const emptyRange = axis.lowerInclusive && axis.upperInclusive ? '' : ' OR _hq_lower = _hq_upper';
-    const rangeGuard = `throwIf(_hq_lower > _hq_upper${emptyRange}, 'Window measure time range must be non-empty and ordered.')`;
+    const rangeGuard = dialect.guard(`_hq_lower > _hq_upper${emptyRange}`, 'Window measure time range must be non-empty and ordered.');
     const limitGuard = axis.resultLimit === undefined
         ? '0'
-        : `throwIf(${count} > ${axis.resultLimit}, 'Window series exceeds the effective result limit of ${axis.resultLimit} buckets.')`;
-    const calendarGuard = calendarBucketGuardSql('_hq_first', `${count} + ${limitGuard} + ${rangeGuard}`, axis.grain);
-    const physicalTimeType = `toTypeName(tupleElement((SELECT ${source.rowAlias} FROM _hq_raw LIMIT 0), 1))`;
+        : dialect.guard(`${count} > ${axis.resultLimit}`, `Window series exceeds the effective result limit of ${axis.resultLimit} buckets.`);
+    const calendarGuard = calendarBucketGuardSql(dialect, '_hq_first', `${count} + ${limitGuard} + ${rangeGuard}`, axis.grain);
+    const physicalTime = dialect.rowElement(`(SELECT ${source.rowAlias} FROM _hq_raw LIMIT 0)`, 1);
     const physicalGuard = axis.grain === 'minute' || axis.grain === 'hour'
-        ? `throwIf(position(${physicalTimeType}, 'Date') > 0 AND position(${physicalTimeType}, 'DateTime') = 0, 'Sub-day time measures require a time-of-day column; Date and Date32 are not supported.')`
+        ? dialect.guard(dialect.isDateOnlyType(physicalTime), 'Sub-day time measures require a time-of-day column; Date and Date32 are not supported.')
         : '0';
-    const shiftGuards = shifts.map(shift => shiftCalendarGuardSql(shift, axis, `${limitGuard} + ${rangeGuard}`));
+    const shiftGuards = shifts.map(shift => shiftCalendarGuardSql(dialect, shift, axis, `${limitGuard} + ${rangeGuard}`));
     const guard = [limitGuard, physicalGuard, calendarGuard, ...shiftGuards].join(' + ');
-    const postSeriesGuard = shifts.map(shift => shiftWallTimeSeriesGuardSql(shift, axis.grain)).join(' + ') || '0';
+    const postSeriesGuard = shifts.map(shift => shiftWallTimeSeriesGuardSql(dialect, shift, axis.grain)).join(' + ') || '0';
     // A zero-row scalar retains the converted timestamp type and query timezone.
     // Reading any(time) here would scan the entire population just for its type.
-    const timezone = 'timezoneOf(assumeNotNull((SELECT _hq_time FROM _hq_source LIMIT 0)))';
+    const timezone = dialect.timezoneOf(dialect.assumeNotNull('(SELECT _hq_time FROM _hq_source LIMIT 0)'));
     const bounds = [
-        `parseDateTime64BestEffort(${literal(axis.lower)}, 9, ${timezone}) AS _hq_lower`,
-        `parseDateTime64BestEffort(${literal(axis.upper)}, 9, ${timezone}) AS _hq_upper`,
+        // The bounds come from the caller's time filter: bind them, never inline them.
+        `${dialect.parseTimestamp(statement.bind(axis.lower, 'string'), timezone)} AS _hq_lower`,
+        `${dialect.parseTimestamp(statement.bind(axis.upper, 'string'), timezone)} AS _hq_upper`,
         `${first} AS _hq_first`,
         `${last} AS _hq_last`,
     ];
-    const bucketIndices = `arrayJoin(range(toUInt64(${count} + ${guard} + ${rangeGuard})))`;
-    const period = add('_hq_first', bucketIndices, axis.grain);
+    const bucketIndices = dialect.seriesIndex(`${count} + ${guard} + ${rangeGuard}`);
+    const period = dialect.addTime('_hq_first', bucketIndices, axis.grain);
     const ctes = [
         `_hq_bounds AS (SELECT ${bounds.join(', ')})`,
         `_hq_series AS (SELECT ${period} AS _hq_period FROM _hq_bounds)`,

package/dist/utils/time-measure-context-sql.d.ts

@@ -1,6 +1,7 @@
+import type { DatasetSqlDialectRules } from '../dataset-sql-dialect.js';
 import type { MeasureEvaluationContext } from './measure-evaluation-graph.js';
 import type { TimeMeasureAxis } from './time-measure-axis.js';
 /** Keep output coordinates separate from each shifted evaluation interval. */
-export declare function timeMeasureContextCtes(contexts: readonly MeasureEvaluationContext[], axis: TimeMeasureAxis): string[];
-export declare function timeMeasureContextGuard(context: MeasureEvaluationContext, axis: TimeMeasureAxis): string;
+export declare function timeMeasureContextCtes(dialect: DatasetSqlDialectRules, contexts: readonly MeasureEvaluationContext[], axis: TimeMeasureAxis): string[];
+export declare function timeMeasureContextGuard(dialect: DatasetSqlDialectRules, context: MeasureEvaluationContext, axis: TimeMeasureAxis): string;
 //# sourceMappingURL=time-measure-context-sql.d.ts.map

package/dist/utils/time-measure-context-sql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-measure-context-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-context-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAO9D,8EAA8E;AAC9E,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,SAAS,wBAAwB,EAAE,EAAE,IAAI,EAAE,eAAe,GAAG,MAAM,EAAE,CAerH;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,EAAE,IAAI,EAAE,eAAe,GAAG,MAAM,CAOxG"}
+{"version":3,"file":"time-measure-context-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-context-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAM9D,8EAA8E;AAC9E,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,sBAAsB,EAAE,QAAQ,EAAE,SAAS,wBAAwB,EAAE,EAAE,IAAI,EAAE,eAAe,GAAG,MAAM,EAAE,CAgBtJ;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,sBAAsB,EAAE,OAAO,EAAE,wBAAwB,EAAE,IAAI,EAAE,eAAe,GAAG,MAAM,CAOzI"}

package/dist/utils/time-measure-context-sql.js

@@ -1,27 +1,27 @@
-import { addTimeSql as add, subtractTimeSql as subtract } from './time-arithmetic-sql.js';
 import { calendarShiftAtFineGrain } from './shift-measure-grains.js';
 import { calendarBucketGuardSql } from './time-axis-calendar-guard.js';
 import { shiftWallTimeGuardSql } from './shift-wall-time-sql.js';
 import { anchoredCalendarShiftSql } from './calendar-shift-sql.js';
 /** Keep output coordinates separate from each shifted evaluation interval. */
-export function timeMeasureContextCtes(contexts, axis) {
-    const end = add('_hq_period', 1, axis.grain);
-    const root = `_hq_context0 AS (SELECT _hq_period, _hq_period AS _hq_eval_period, ${end} AS _hq_eval_end, greatest(_hq_period, _hq_lower) AS _hq_eval_lower, least(${end}, _hq_upper) AS _hq_eval_upper, (_hq_period > _hq_lower OR ${Number(axis.lowerInclusive)}) AS _hq_lower_inclusive, (_hq_upper < ${end} AND ${Number(axis.upperInclusive)}) AS _hq_upper_inclusive FROM _hq_series CROSS JOIN _hq_bounds)`;
+export function timeMeasureContextCtes(dialect, contexts, axis) {
+    const end = dialect.addTime('_hq_period', 1, axis.grain);
+    const root = `_hq_context0 AS (SELECT _hq_period, _hq_period AS _hq_eval_period, ${end} AS _hq_eval_end, ${dialect.greatest('_hq_period', '_hq_lower')} AS _hq_eval_lower, ${dialect.least(end, '_hq_upper')} AS _hq_eval_upper, (_hq_period > _hq_lower OR ${Number(axis.lowerInclusive)}) AS _hq_lower_inclusive, (_hq_upper < ${end} AND ${Number(axis.upperInclusive)}) AS _hq_upper_inclusive FROM _hq_series CROSS JOIN _hq_bounds)`;
     return [root, ...contexts.slice(1).map(context => {
             const interval = context.interval;
             const calendar = calendarShiftAtFineGrain(interval, axis.grain);
-            const shift = (value) => subtract(`p.${value}`, interval.amount, interval.unit);
+            const shift = (value) => dialect.subtractTime(`p.${value}`, interval.amount, interval.unit);
             // Partial bounds stay inside the shifted bucket; see anchoredCalendarShiftSql.
             const shiftBound = (value) => calendar
-                ? anchoredCalendarShiftSql(`p.${value}`, 'p._hq_eval_period', interval)
+                ? anchoredCalendarShiftSql(dialect, `p.${value}`, 'p._hq_eval_period', interval)
                 : shift(value);
             const period = shift('_hq_eval_period');
-            const shiftedEnd = calendar ? add(period, 1, axis.grain) : shift('_hq_eval_end');
-            return `_hq_context${context.id} AS (SELECT p._hq_period, ${period} AS _hq_eval_period, ${shiftedEnd} AS _hq_eval_end, ${shiftBound('_hq_eval_lower')} AS _hq_eval_lower, if(p._hq_eval_upper = p._hq_eval_end, ${shiftedEnd}, ${shiftBound('_hq_eval_upper')}) AS _hq_eval_upper, p._hq_lower_inclusive, p._hq_upper_inclusive FROM _hq_context${context.parent} AS p)`;
+            const shiftedEnd = calendar ? dialect.addTime(period, 1, axis.grain) : shift('_hq_eval_end');
+            const upper = dialect.ifElse('p._hq_eval_upper = p._hq_eval_end', shiftedEnd, shiftBound('_hq_eval_upper'));
+            return `_hq_context${context.id} AS (SELECT p._hq_period, ${period} AS _hq_eval_period, ${shiftedEnd} AS _hq_eval_end, ${shiftBound('_hq_eval_lower')} AS _hq_eval_lower, ${upper} AS _hq_eval_upper, p._hq_lower_inclusive, p._hq_upper_inclusive FROM _hq_context${context.parent} AS p)`;
         })];
 }
-export function timeMeasureContextGuard(context, axis) {
-    const guard = calendarBucketGuardSql('_hq_eval_period', '1', axis.grain);
-    const wallTimeGuard = context.interval === undefined ? '0' : shiftWallTimeGuardSql(context.interval, axis.grain, `_hq_context${context.parent} AS p`, 'p._hq_eval_period', 'p._hq_eval_lower', 'p._hq_eval_upper', 'p._hq_eval_end');
+export function timeMeasureContextGuard(dialect, context, axis) {
+    const guard = calendarBucketGuardSql(dialect, '_hq_eval_period', '1', axis.grain);
+    const wallTimeGuard = context.interval === undefined ? '0' : shiftWallTimeGuardSql(dialect, context.interval, axis.grain, `_hq_context${context.parent} AS p`, 'p._hq_eval_period', 'p._hq_eval_lower', 'p._hq_eval_upper', 'p._hq_eval_end');
     return `(SELECT coalesce(max(${guard}), 0) FROM _hq_context${context.id}) + ${wallTimeGuard}`;
 }

package/dist/utils/time-measure-dataset-sql.d.ts

@@ -1,9 +1,11 @@
 import type { AnyDatasetInstance, DatasetQuery } from '../types.js';
 import type { DatasetQueryExecutionOptions } from '../dataset-query.js';
+import { type PlannedStatement } from './statement-parameters.js';
+/** A time-measure statement and the axis check that must run before it. */
+export interface PlannedTimeMeasureStatements {
+    readonly statement: PlannedStatement;
+    readonly preflight: PlannedStatement;
+}
 /** Plan source rows → output axis → window/shift values → final projection. */
-export declare function buildTimeMeasureDatasetSql(ds: AnyDatasetInstance, query: DatasetQuery, options: DatasetQueryExecutionOptions): {
-    sql: string;
-    parameters: unknown[];
-    timeAxisSql: string;
-};
+export declare function buildTimeMeasureDatasetSql(ds: AnyDatasetInstance, query: DatasetQuery, options: DatasetQueryExecutionOptions): PlannedTimeMeasureStatements;
 //# sourceMappingURL=time-measure-dataset-sql.d.ts.map

package/dist/utils/time-measure-dataset-sql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-measure-dataset-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-dataset-sql.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAYxE,+EAA+E;AAC/E,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,GACpC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAmE7D"}
+{"version":3,"file":"time-measure-dataset-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-dataset-sql.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAOxE,OAAO,EAAuB,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAOvF,2EAA2E;AAC3E,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC;CACtC;AAED,+EAA+E;AAC/E,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,GACpC,4BAA4B,CAsE9B"}

package/dist/utils/time-measure-dataset-sql.js

@@ -5,7 +5,9 @@ import { getBaseMeasure, getDerivedMeasure, isShiftMeasure, isWindowMeasure } fr
 import { selectedTimeMeasures } from './time-query-measures.js';
 import { analyzeTimeMeasureAxis } from './time-measure-axis.js';
 import { validateDatasetQueryInput } from './dataset-query-validation.js';
-import { addTimeSql as add } from './time-arithmetic-sql.js';
+import { resolveDatasetSqlDialect } from './dataset-sql-dialect.js';
+import { assertRawSqlForDialect } from './raw-sql-dialect-check.js';
+import { StatementParameters } from './statement-parameters.js';
 import { shiftBucketCtes } from './shift-measure-sql.js';
 import { buildTimeMeasureSourceSql } from './time-measure-source-sql.js';
 import { buildTimeMeasureAxisSql } from './time-measure-axis-sql.js';
@@ -16,6 +18,8 @@ export function buildTimeMeasureDatasetSql(ds, query, options) {
     const validation = validateDatasetQueryInput(ds, query, options.context);
     if (!validation.valid)
         throw new Error(`Invalid dataset query: ${validation.errors.join('; ')}`);
+    const dialect = resolveDatasetSqlDialect(options.builderFactory);
+    assertRawSqlForDialect(ds, dialect);
     const { axis } = analyzeTimeMeasureAxis(ds, query);
     if (!axis || !ds.timeKey)
         throw new Error('Window measures require a bounded time axis.');
@@ -27,8 +31,9 @@ export function buildTimeMeasureDatasetSql(ds, query, options) {
         const derived = getDerivedMeasure(ds.measures, name);
         return derived && Object.values(derived.uses).some(input => getDerivedMeasure(ds.measures, input));
     });
+    const parameters = new StatementParameters(dialect);
     if (composite)
-        return buildCompositeTimeMeasureSql(ds, query, options, axis);
+        return buildCompositeTimeMeasureSql(ds, query, options, axis, parameters);
     const timeMeasures = selectedTimeMeasures(ds, query);
     const windows = [...timeMeasures.values()].filter(isWindowMeasure);
     const shifts = [...timeMeasures.values()].filter(isShiftMeasure);
@@ -39,25 +44,25 @@ export function buildTimeMeasureDatasetSql(ds, query, options) {
             Object.values(derived.uses).forEach(input => needed.add(input));
     }
     const baseNames = new Set([...needed].map(name => timeMeasures.get(name)?.measure ?? name));
-    const source = buildTimeMeasureSourceSql(ds, query, baseNames, axis.filters, options);
-    const timeAxis = buildTimeMeasureAxisSql(source, axis, shifts);
+    const source = buildTimeMeasureSourceSql(ds, query, baseNames, axis.filters, options, parameters);
+    const timeAxis = buildTimeMeasureAxisSql(parameters, source, axis, shifts);
     const shiftedInputs = new Map();
     [...needed].forEach((name, index) => {
         const measure = timeMeasures.get(name);
         if (isShiftMeasure(measure))
-            shiftedInputs.set(name, shiftBucketCtes(measure, axis, index));
+            shiftedInputs.set(name, shiftBucketCtes(dialect, measure, axis, index));
     });
     // Scan only requested populations: intervening rows must not introduce dimensions.
-    const end = add('_hq_last', 1, axis.grain);
+    const end = dialect.addTime('_hq_last', 1, axis.grain);
     const populations = [];
     if ([...needed].some(name => name.includes('.') || getBaseMeasure(ds.measures, name))) {
         populations.push(`(_hq_time >= _hq_first AND _hq_time < ${end})`);
     }
     if (windows.length) {
         const starts = windows.filter(window => !window.cumulative)
-            .map(window => windowScanStartSql(window, axis.grain));
+            .map(window => windowScanStartSql(dialect, window, axis.grain));
         const lower = windows.some(window => window.cumulative)
-            ? '' : ` AND _hq_time >= least(${starts.join(', ')})`;
+            ? '' : ` AND _hq_time >= ${dialect.least(...starts)}`;
         populations.push(`(_hq_time < ${end}${lower})`);
     }
     for (const shifted of shiftedInputs.values())
@@ -73,9 +78,9 @@ export function buildTimeMeasureDatasetSql(ds, query, options) {
             const shifted = shiftedInputs.get(name);
             return { name, base, rowsSql: shifted.rowsSql, restrictToAxis: false };
         }
-        return { name, base, window, rowsSql: windowMeasureRowsSql(window, axis) };
+        return { name, base, window, rowsSql: windowMeasureRowsSql(dialect, window, axis) };
     });
-    const values = buildTimeMeasureValuesSql(source.dimensions, inputs, axis);
-    const sql = buildTimeMeasureResultSql(ds, query, options, source.dimensions, [...source.ctes, ...timeAxis.ctes, ...[...shiftedInputs.values()].flatMap(input => input.ctes), scanCte, ...values], `${timeAxis.guard} + ${timeAxis.rangeGuard} + ${timeAxis.postSeriesGuard}`);
-    return { sql, parameters: source.parameters, timeAxisSql: timeAxis.timeAxisSql };
+    const values = buildTimeMeasureValuesSql(dialect, source.dimensions, inputs, axis);
+    const text = buildTimeMeasureResultSql(ds, query, options, source.dimensions, [...source.ctes, ...timeAxis.ctes, ...[...shiftedInputs.values()].flatMap(input => input.ctes), scanCte, ...values], `${timeAxis.guard} + ${timeAxis.rangeGuard} + ${timeAxis.postSeriesGuard}`);
+    return { statement: { text, parameters }, preflight: { text: timeAxis.timeAxisSql, parameters } };
 }

package/dist/utils/time-measure-leaf-sql.d.ts

@@ -1,8 +1,9 @@
+import type { DatasetSqlDialectRules } from '../dataset-sql-dialect.js';
 import type { WindowMeasureDefinition } from '../types.js';
 import type { TimeMeasureAxis } from './time-measure-axis.js';
 import type { TimeMeasureSqlBase, TimeMeasureSqlDimension } from './time-measure-source-sql.js';
 /** Keyed source membership retains distinct/average semantics and row multiplicity. */
-export declare function timeMeasureLeafSql(id: number, context: number, base: TimeMeasureSqlBase, window: WindowMeasureDefinition | undefined, axis: TimeMeasureAxis, dims: readonly TimeMeasureSqlDimension[]): {
+export declare function timeMeasureLeafSql(dialect: DatasetSqlDialectRules, id: number, context: number, base: TimeMeasureSqlBase, window: WindowMeasureDefinition | undefined, axis: TimeMeasureAxis, dims: readonly TimeMeasureSqlDimension[]): {
     ctes: string[];
     population: string;
     aggregate: string;

package/dist/utils/time-measure-leaf-sql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-measure-leaf-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-leaf-sql.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAMhG,uFAAuF;AACvF,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,EAAE,uBAAuB,GAAG,SAAS,EAAE,IAAI,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,uBAAuB,EAAE;;;;;;;;EA6CrM"}
+{"version":3,"file":"time-measure-leaf-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-leaf-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAKhG,uFAAuF;AACvF,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,sBAAsB,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,EAAE,uBAAuB,GAAG,SAAS,EAAE,IAAI,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,uBAAuB,EAAE;;;;;;;;EA8CtO"}