@hypequery/datasets 0.19.0 → 0.21.0

package/dist/utils/time-axis-intervals.d.ts

@@ -0,0 +1,13 @@
+import type { TimeGrain, WindowMeasureDefinition } from '../types.js';
+import type { ParsedTimeBound } from './time-axis-bounds.js';
+/** Exact conversions from RFC 0015; calendar months never become days. */
+export declare function intervalBuckets(amount: number, unit: TimeGrain, grain: TimeGrain): number | undefined;
+/** UTC estimate; SQL uses the time expression's timezone for exact buckets. */
+export declare function utcBucketStart(timestamp: number, grain: TimeGrain): number;
+/** Check the authored window's compatibility and maximum per-row contribution. */
+export declare function windowGrainErrors(name: string, window: WindowMeasureDefinition, grain: TimeGrain): string[];
+/** Estimate only: SQL determines exact bucket counts in the query timezone. */
+export declare function estimateTimeAxisBuckets(start: ParsedTimeBound, end: ParsedTimeBound, upperInclusive: boolean, grain: TimeGrain): number;
+/** Leave mixed bounds and local sub-day ranges to SQL's timezone-aware check. */
+export declare function exceedsEstimatedTimeAxisLimit(start: ParsedTimeBound, end: ParsedTimeBound, grain: TimeGrain, bucketCount: number, resultLimit: number | undefined): boolean;
+//# sourceMappingURL=time-axis-intervals.d.ts.map

package/dist/utils/time-axis-intervals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-axis-intervals.d.ts","sourceRoot":"","sources":["../../src/utils/time-axis-intervals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAa7D,0EAA0E;AAC1E,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAQrG;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAgB1E;AAED,kFAAkF;AAClF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,uBAAuB,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,EAAE,CAU3G;AAED,+EAA+E;AAC/E,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,OAAO,EACvB,KAAK,EAAE,SAAS,GACf,MAAM,CAcR;AAED,iFAAiF;AACjF,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE,SAAS,EAChB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAAG,SAAS,GAC9B,OAAO,CAMT"}

package/dist/utils/time-axis-intervals.js

@@ -0,0 +1,81 @@
+const FIXED_MINUTES = { minute: 1, hour: 60, day: 1440, week: 10080 };
+const CALENDAR_MONTHS = { month: 1, quarter: 3, year: 12 };
+const MAX_TO_DATE_BUCKETS = {
+    hour: { minute: 60 },
+    day: { minute: 1440, hour: 24 },
+    week: { minute: 10080, hour: 168, day: 7 },
+    month: { minute: 44640, hour: 744, day: 31 },
+    quarter: { minute: 132480, hour: 2208, day: 92, month: 3 },
+    year: { minute: 527040, hour: 8784, day: 366, month: 12, quarter: 4 },
+};
+/** Exact conversions from RFC 0015; calendar months never become days. */
+export function intervalBuckets(amount, unit, grain) {
+    const units = FIXED_MINUTES[unit] ?? CALENDAR_MONTHS[unit];
+    const buckets = FIXED_MINUTES[grain] ?? CALENDAR_MONTHS[grain];
+    const bothFixed = FIXED_MINUTES[unit] !== undefined && FIXED_MINUTES[grain] !== undefined;
+    const bothCalendar = CALENDAR_MONTHS[unit] !== undefined && CALENDAR_MONTHS[grain] !== undefined;
+    if (units === undefined || buckets === undefined || (!bothFixed && !bothCalendar))
+        return undefined;
+    const count = amount * units / buckets;
+    return Number.isSafeInteger(count) && count > 0 ? count : undefined;
+}
+/** UTC estimate; SQL uses the time expression's timezone for exact buckets. */
+export function utcBucketStart(timestamp, grain) {
+    const date = new Date(timestamp);
+    if (grain === 'minute') {
+        date.setUTCSeconds(0, 0);
+        return date.getTime();
+    }
+    if (grain === 'hour') {
+        date.setUTCMinutes(0, 0, 0);
+        return date.getTime();
+    }
+    date.setUTCHours(0, 0, 0, 0);
+    if (grain === 'week')
+        date.setUTCDate(date.getUTCDate() - date.getUTCDay());
+    if (grain === 'month' || grain === 'quarter' || grain === 'year')
+        date.setUTCDate(1);
+    if (grain === 'quarter')
+        date.setUTCMonth(Math.floor(date.getUTCMonth() / 3) * 3);
+    if (grain === 'year')
+        date.setUTCMonth(0);
+    return date.getTime();
+}
+/** Check the authored window's compatibility and maximum per-row contribution. */
+export function windowGrainErrors(name, window, grain) {
+    const count = window.trailing
+        ? intervalBuckets(window.trailing.amount, window.trailing.unit, grain)
+        : window.toDate ? MAX_TO_DATE_BUCKETS[window.toDate]?.[grain] : 1;
+    if (count === undefined) {
+        const toDateRequirement = window.toDate ? ' at a strictly coarser grain' : '';
+        return [`Window measure "${name}" must span whole "${grain}" buckets${toDateRequirement}.`];
+    }
+    if (count > 1000)
+        return [`Window measure "${name}" would make a row contribute to more than 1,000 buckets.`];
+    return [];
+}
+/** Estimate only: SQL determines exact bucket counts in the query timezone. */
+export function estimateTimeAxisBuckets(start, end, upperInclusive, grain) {
+    const first = utcBucketStart(start.milliseconds, grain);
+    const upperBucket = utcBucketStart(end.milliseconds, grain);
+    const excludesUpperBucket = !upperInclusive && !end.subMillisecond && end.milliseconds === upperBucket;
+    const last = utcBucketStart(end.milliseconds - (excludesUpperBucket ? 1 : 0), grain);
+    const calendar = CALENDAR_MONTHS[grain];
+    if (calendar !== undefined) {
+        const firstDate = new Date(first);
+        const lastDate = new Date(last);
+        const months = (lastDate.getUTCFullYear() - firstDate.getUTCFullYear()) * 12
+            + lastDate.getUTCMonth() - firstDate.getUTCMonth();
+        return months / calendar + 1;
+    }
+    return (last - first) / ((FIXED_MINUTES[grain] ?? 1) * 60000) + 1;
+}
+/** Leave mixed bounds and local sub-day ranges to SQL's timezone-aware check. */
+export function exceedsEstimatedTimeAxisLimit(start, end, grain, bucketCount, resultLimit) {
+    if (resultLimit === undefined)
+        return false;
+    const canEstimate = start.hasOffset === end.hasOffset
+        && (start.hasOffset || (grain !== 'minute' && grain !== 'hour'));
+    // Allow two boundary buckets because the query timezone is unknown.
+    return resultLimit === 0 || (canEstimate && bucketCount - 2 > resultLimit);
+}

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

@@ -0,0 +1,13 @@
+import type { TimeMeasureAxis } from './time-measure-axis.js';
+import type { TimeMeasureSqlSource } from './time-measure-source-sql.js';
+import type { ShiftMeasureDefinition } from '../types.js';
+export interface TimeMeasureSqlAxis {
+    ctes: string[];
+    timeAxisSql: string;
+    guard: string;
+    rangeGuard: string;
+    postSeriesGuard: string;
+}
+/** Build bounded output buckets using the query timezone. */
+export declare function buildTimeMeasureAxisSql(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

@@ -0,0 +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"}

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

@@ -0,0 +1,48 @@
+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)`;
+    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`;
+    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 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))`;
+    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.')`
+        : '0';
+    const shiftGuards = shifts.map(shift => shiftCalendarGuardSql(shift, axis, `${limitGuard} + ${rangeGuard}`));
+    const guard = [limitGuard, physicalGuard, calendarGuard, ...shiftGuards].join(' + ');
+    const postSeriesGuard = shifts.map(shift => shiftWallTimeSeriesGuardSql(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 bounds = [
+        `parseDateTime64BestEffort(${literal(axis.lower)}, 9, ${timezone}) AS _hq_lower`,
+        `parseDateTime64BestEffort(${literal(axis.upper)}, 9, ${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 ctes = [
+        `_hq_bounds AS (SELECT ${bounds.join(', ')})`,
+        `_hq_series AS (SELECT ${period} AS _hq_period FROM _hq_bounds)`,
+    ];
+    // Always check the singleton axis before aggregating. ClickHouse can skip
+    // a series guard when a dimensional CROSS JOIN has an empty population.
+    const timeAxisSql = `WITH ${[...source.ctes, ...ctes].join(',\n')} SELECT ${guard} + ${rangeGuard} + ${postSeriesGuard} AS _hq_validated FROM _hq_bounds`;
+    return { ctes, timeAxisSql, guard, rangeGuard, postSeriesGuard };
+}

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

@@ -0,0 +1,19 @@
+import type { AnyDatasetInstance, DatasetQuery, MetricFilter, TimeGrain } from '../types.js';
+export { intervalBuckets, utcBucketStart } from './time-axis-intervals.js';
+export interface TimeMeasureAxis {
+    grain: TimeGrain;
+    lower: string;
+    upper: string;
+    lowerInclusive: boolean;
+    upperInclusive: boolean;
+    filters: MetricFilter[];
+    /** UTC estimate; execution enforces the exact timezone-aware count. */
+    bucketCount: number;
+    resultLimit?: number;
+}
+/** Validate time-measure grains, resolve bounds, then estimate the output series. */
+export declare function analyzeTimeMeasureAxis(dataset: AnyDatasetInstance, query: DatasetQuery): {
+    axis?: TimeMeasureAxis;
+    errors: string[];
+};
+//# sourceMappingURL=time-measure-axis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"time-measure-axis.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-axis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAS7F,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE3E,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qFAAqF;AACrF,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,YAAY,GAClB;IAAE,IAAI,CAAC,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAmC9C"}

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

@@ -0,0 +1,46 @@
+import { isSupportedTimeGrain } from '../constants.js';
+import { selectedTimeMeasures } from './time-query-measures.js';
+import { isShiftMeasure } from './dataset-measures.js';
+import { resolveTimeAxisRange, isDefinitelyEmptyTimeRange } from './time-axis-bounds.js';
+import { windowGrainErrors, estimateTimeAxisBuckets, exceedsEstimatedTimeAxisLimit } from './time-axis-intervals.js';
+import { supportsShiftGrain } from './shift-measure-grains.js';
+export { intervalBuckets, utcBucketStart } from './time-axis-intervals.js';
+/** Validate time-measure grains, resolve bounds, then estimate the output series. */
+export function analyzeTimeMeasureAxis(dataset, query) {
+    const timeMeasures = selectedTimeMeasures(dataset, query);
+    if (timeMeasures.size === 0)
+        return { errors: [] };
+    const errors = [];
+    const subjects = [...timeMeasures.values()].some(isShiftMeasure) ? 'Window and shift measures' : 'Window measures';
+    if (!isSupportedTimeGrain(query.by))
+        return { errors: [`${subjects} require a supported "by" grain.`] };
+    const grain = query.by;
+    for (const [name, window] of timeMeasures) {
+        if (isShiftMeasure(window)) {
+            if (!supportsShiftGrain(window.interval, grain))
+                errors.push(`Shift measure "${name}" must span whole "${grain}" buckets.`);
+            continue;
+        }
+        errors.push(...windowGrainErrors(name, window, grain));
+    }
+    const range = resolveTimeAxisRange(dataset, query.filters ?? []);
+    if (!range) {
+        return { errors: [...errors, `${subjects} require exactly one bounded time range: between, or gt/gte with lt/lte, using ISO timestamps.`] };
+    }
+    if (isDefinitelyEmptyTimeRange(range)) {
+        return { errors: [...errors, 'Window measure time range must be non-empty and ordered.'] };
+    }
+    const { start, end, lowerInclusive, upperInclusive, filters } = range;
+    const bucketCount = estimateTimeAxisBuckets(start, end, upperInclusive, grain);
+    const resultLimit = query.limit ?? dataset.limits?.maxResultSize;
+    if (exceedsEstimatedTimeAxisLimit(start, end, grain, bucketCount, resultLimit)) {
+        errors.push(`Window series exceeds the effective result limit of ${resultLimit} buckets.`);
+    }
+    return {
+        errors,
+        axis: {
+            grain, lower: start.text, upper: end.text,
+            lowerInclusive, upperInclusive, filters, bucketCount, resultLimit,
+        },
+    };
+}

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

@@ -0,0 +1,6 @@
+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;
+//# sourceMappingURL=time-measure-context-sql.d.ts.map

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

@@ -0,0 +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;AAM9D,8EAA8E;AAC9E,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,SAAS,wBAAwB,EAAE,EAAE,IAAI,EAAE,eAAe,GAAG,MAAM,EAAE,CAUrH;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,EAAE,IAAI,EAAE,eAAe,GAAG,MAAM,CAOxG"}

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

@@ -0,0 +1,21 @@
+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';
+/** 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)`;
+    return [root, ...contexts.slice(1).map(context => {
+            const interval = context.interval;
+            const shift = (value) => subtract(`p.${value}`, interval.amount, interval.unit);
+            const period = shift('_hq_eval_period');
+            const shiftedEnd = calendarShiftAtFineGrain(interval, axis.grain) ? 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, ${shift('_hq_eval_lower')} AS _hq_eval_lower, if(p._hq_eval_upper = p._hq_eval_end, ${shiftedEnd}, ${shift('_hq_eval_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');
+    return `(SELECT coalesce(max(${guard}), 0) FROM _hq_context${context.id}) + ${wallTimeGuard}`;
+}

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

@@ -0,0 +1,9 @@
+import type { AnyDatasetInstance, DatasetQuery } from '../types.js';
+import type { DatasetQueryExecutionOptions } from '../dataset-query.js';
+/** 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;
+};
+//# sourceMappingURL=time-measure-dataset-sql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"time-measure-dataset-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-dataset-sql.ts"],"names":[],"mappings":"AAEA,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"}

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

@@ -0,0 +1,80 @@
+import { buildCompositeTimeMeasureSql } from './composite-time-measure-sql.js';
+import { measureDependencyNames } from './measure-dependencies.js';
+import { getBaseMeasure, getDerivedMeasure, isShiftMeasure, isWindowMeasure } from './dataset-measures.js';
+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 { shiftBucketCtes } from './shift-measure-sql.js';
+import { buildTimeMeasureSourceSql } from './time-measure-source-sql.js';
+import { buildTimeMeasureAxisSql } from './time-measure-axis-sql.js';
+import { buildTimeMeasureValuesSql, windowMeasureRowsSql, windowScanStartSql } from './time-measure-values-sql.js';
+import { buildTimeMeasureResultSql } from './time-measure-result-sql.js';
+/** Plan source rows → output axis → window/shift values → final projection. */
+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 { axis } = analyzeTimeMeasureAxis(ds, query);
+    if (!axis || !ds.timeKey)
+        throw new Error('Window measures require a bounded time axis.');
+    const dependencies = measureDependencyNames(ds.measures, query.measures ?? []);
+    const composite = dependencies.some(name => {
+        const definition = ds.measures[name];
+        if (isShiftMeasure(definition))
+            return !getBaseMeasure(ds.measures, definition.measure);
+        const derived = getDerivedMeasure(ds.measures, name);
+        return derived && Object.values(derived.uses).some(input => getDerivedMeasure(ds.measures, input));
+    });
+    if (composite)
+        return buildCompositeTimeMeasureSql(ds, query, options, axis);
+    const timeMeasures = selectedTimeMeasures(ds, query);
+    const windows = [...timeMeasures.values()].filter(isWindowMeasure);
+    const shifts = [...timeMeasures.values()].filter(isShiftMeasure);
+    const needed = new Set((query.measures ?? []).filter(name => !getDerivedMeasure(ds.measures, name)));
+    for (const name of query.measures ?? []) {
+        const derived = getDerivedMeasure(ds.measures, name);
+        if (derived)
+            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 shiftedInputs = new Map();
+    [...needed].forEach((name, index) => {
+        const measure = timeMeasures.get(name);
+        if (isShiftMeasure(measure))
+            shiftedInputs.set(name, shiftBucketCtes(measure, axis, index));
+    });
+    // Scan only requested populations: intervening rows must not introduce dimensions.
+    const end = add('_hq_last', 1, axis.grain);
+    const populations = [];
+    if ([...needed].some(name => 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));
+        const lower = windows.some(window => window.cumulative)
+            ? '' : ` AND _hq_time >= least(${starts.join(', ')})`;
+        populations.push(`(_hq_time < ${end}${lower})`);
+    }
+    for (const shifted of shiftedInputs.values())
+        populations.push(`(_hq_time IN (${shifted.sourceTimesSql}))`);
+    const scanCte = `_hq_scanned AS (SELECT * FROM _hq_source CROSS JOIN _hq_bounds WHERE ${populations.join(' OR ')})`;
+    const inputs = [...needed].map(name => {
+        const timeMeasure = timeMeasures.get(name);
+        const window = isWindowMeasure(timeMeasure) ? timeMeasure : undefined;
+        const base = source.bases.find(base => base.name === (timeMeasure?.measure ?? name));
+        if (!base)
+            throw new Error(`Missing base input for measure "${name}".`);
+        if (isShiftMeasure(timeMeasure)) {
+            const shifted = shiftedInputs.get(name);
+            return { name, base, rowsSql: shifted.rowsSql, restrictToAxis: false };
+        }
+        return { name, base, window, rowsSql: windowMeasureRowsSql(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 };
+}

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

@@ -0,0 +1,14 @@
+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[]): {
+    ctes: string[];
+    population: string;
+    aggregate: string;
+    context: number;
+    cumulative: boolean;
+    guard: string;
+    count: boolean;
+};
+//# sourceMappingURL=time-measure-leaf-sql.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,52 @@
+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 { shiftRangePredicateSql } from './shift-measure-sql.js';
+import { isCountAggregation, windowAggregateSql } from './window-aggregation-sql.js';
+/** Keyed source membership retains distinct/average semantics and row multiplicity. */
+export function timeMeasureLeafSql(id, context, base, window, axis, dims) {
+    const keys = dims.map(dim => dim.alias);
+    const ranges = `_hq_ranges${id}`;
+    const rows = `_hq_rows${id}`;
+    const aggregate = `_hq_leaf${id}`;
+    const value = `_hq_value${id}`;
+    const group = `_hq_period${keys.length ? `, ${keys.join(', ')}` : ''}`;
+    const expression = windowAggregateSql(base.definition, base.value, base.arg);
+    if (window?.cumulative) {
+        const population = `_hq_history${id}`;
+        const partial = `_hq_partial${id}`;
+        const operation = base.definition.aggregation === 'count' ? 'sum' : base.definition.aggregation;
+        const partition = keys.length ? `tuple(${keys.join(', ')})` : 'tuple(0)';
+        const historyGroup = `_hq_time${keys.length ? `, ${keys.join(', ')}` : ''}`;
+        return {
+            ctes: [
+                `${population} AS (SELECT * FROM _hq_source WHERE _hq_time < (SELECT max(_hq_eval_end) FROM _hq_context${context}))`,
+                `${partial} AS (SELECT ${historyGroup}, ${partition} AS _hq_partition, toNullable(${expression}) AS _hq_partial FROM ${population} GROUP BY ${historyGroup})`,
+                `${aggregate} AS (SELECT _hq_time, _hq_partition, ${operation}OrNull(_hq_partial) OVER (PARTITION BY _hq_partition ORDER BY _hq_time ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS ${value} FROM ${partial})`,
+            ],
+            population, aggregate, context, cumulative: true, guard: '0',
+            count: isCountAggregation(base.definition),
+        };
+    }
+    const lower = window?.trailing ? subtract('_hq_eval_end', window.trailing.amount, window.trailing.unit)
+        : window?.toDate ? `${GRAIN_FUNCTIONS[window.toDate]}(_hq_eval_period)` : '_hq_eval_lower';
+    const upper = window ? '_hq_eval_end' : '_hq_eval_upper';
+    const lowerInclusive = window ? '1' : '_hq_lower_inclusive';
+    const upperInclusive = window ? '0' : '_hq_upper_inclusive';
+    const first = `${GRAIN_FUNCTIONS[axis.grain]}(_hq_scan_lower)`;
+    const last = `${GRAIN_FUNCTIONS[axis.grain]}(_hq_scan_upper)`;
+    const count = `greatest(0, dateDiff('${axis.grain}', ${first}, ${last}) + if(_hq_scan_upper > ${last} OR _hq_scan_upper_inclusive, 1, 0))`;
+    const fanout = window ? `throwIf(${count} > 1000, 'A window row contributes to more than 1000 buckets.')` : '0';
+    const guard = `${fanout} + ${calendarBucketGuardSql(first, `${count} + ${fanout}`, axis.grain)}`;
+    const predicate = shiftRangePredicateSql('r._hq_time', { lower: 'b._hq_scan_lower', upper: 'b._hq_scan_upper', lowerInclusive: 'b._hq_scan_lower_inclusive', upperInclusive: 'b._hq_scan_upper_inclusive' });
+    return {
+        ctes: [
+            `${ranges} AS (SELECT _hq_period, ${lower} AS _hq_scan_lower, ${upper} AS _hq_scan_upper, ${lowerInclusive} AS _hq_scan_lower_inclusive, ${upperInclusive} AS _hq_scan_upper_inclusive FROM _hq_context${context})`,
+            `_hq_keys${id} AS (SELECT *, ${add(first, `arrayJoin(range(toUInt64(${count} + ${guard})))`, axis.grain)} AS _hq_source_period FROM ${ranges})`,
+            `${rows} AS (SELECT r.*, b._hq_period FROM _hq_source AS r INNER JOIN _hq_keys${id} AS b ON ${GRAIN_FUNCTIONS[axis.grain]}(r._hq_time) = b._hq_source_period WHERE ${predicate})`,
+            `${aggregate} AS (SELECT ${group}, toNullable(${expression}) AS ${value} FROM ${rows} GROUP BY ${group})`,
+        ],
+        population: rows, aggregate, context, cumulative: false,
+        guard: `(SELECT coalesce(max(${guard}), 0) FROM ${ranges})`, count: isCountAggregation(base.definition),
+    };
+}

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

@@ -0,0 +1,6 @@
+import type { AnyDatasetInstance, DatasetQuery } from '../types.js';
+import type { DatasetQueryExecutionOptions } from '../dataset-query.js';
+import type { TimeMeasureSqlDimension } from './time-measure-source-sql.js';
+/** Evaluate formulas after aggregation, then apply output ordering and pagination. */
+export declare function buildTimeMeasureResultSql(ds: AnyDatasetInstance, query: DatasetQuery, options: DatasetQueryExecutionOptions, dims: readonly TimeMeasureSqlDimension[], ctes: readonly string[], validationGuard: string, formulasEvaluated?: boolean): string;
+//# sourceMappingURL=time-measure-result-sql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"time-measure-result-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-result-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAIxE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5E,sFAAsF;AACtF,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,EACrC,IAAI,EAAE,SAAS,uBAAuB,EAAE,EACxC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,eAAe,EAAE,MAAM,EACvB,iBAAiB,UAAQ,GACxB,MAAM,CAuBR"}

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

@@ -0,0 +1,30 @@
+import { quoteSQLIdentifier } from '../sql-utils.js';
+import { getDerivedMeasure } from './dataset-measures.js';
+import { derivedProjection } from './derived-measure-sql.js';
+/** Evaluate formulas after aggregation, then apply output ordering and pagination. */
+export function buildTimeMeasureResultSql(ds, query, options, dims, ctes, validationGuard, formulasEvaluated = false) {
+    const selected = query.measures ?? [];
+    const projections = [
+        quoteSQLIdentifier('period'),
+        ...dims.map(dimension => quoteSQLIdentifier(dimension.name)),
+        ...selected.map(name => {
+            const derived = getDerivedMeasure(ds.measures, name);
+            return derived && !formulasEvaluated ? derivedProjection(name, derived) : quoteSQLIdentifier(name);
+        }),
+    ];
+    // Keep toSQL independently guarded too. This branch produces no valid
+    // result rows, and forces axis validation even when _hq_values is empty.
+    const outputNames = ['period', ...dims.map(dimension => dimension.name), ...selected];
+    const nullProjections = outputNames.map(name => `NULL AS ${quoteSQLIdentifier(name)}`).join(', ');
+    const resultCte = `_hq_result AS (SELECT ${projections.join(', ')} FROM _hq_values`
+        + ` UNION ALL SELECT ${nullProjections} FROM _hq_bounds WHERE ${validationGuard} = 1)`;
+    let sql = `WITH ${[...ctes, resultCte].join(',\n')} SELECT ${outputNames.map(quoteSQLIdentifier).join(', ')} FROM _hq_result`;
+    const order = query.orderBy?.length ? query.orderBy : [{ field: 'period', direction: 'asc' }];
+    sql += ` ORDER BY ${order.map(item => `${quoteSQLIdentifier(item.field)} ${item.direction === 'asc' ? 'ASC' : 'DESC'}`).join(', ')}`;
+    const limit = options.executionLimit ?? query.limit;
+    if (limit !== undefined)
+        sql += ` LIMIT ${limit}`;
+    if (query.offset !== undefined)
+        sql += ` OFFSET ${query.offset}`;
+    return sql;
+}

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

@@ -0,0 +1,22 @@
+import type { AnyDatasetInstance, DatasetQuery, MeasureDefinition, MetricFilter } from '../types.js';
+import type { DatasetQueryExecutionOptions } from '../dataset-query.js';
+export interface TimeMeasureSqlDimension {
+    name: string;
+    alias: string;
+}
+export interface TimeMeasureSqlBase {
+    name: string;
+    definition: MeasureDefinition;
+    value: string;
+    arg: string;
+}
+export interface TimeMeasureSqlSource {
+    ctes: string[];
+    parameters: unknown[];
+    dimensions: TimeMeasureSqlDimension[];
+    bases: TimeMeasureSqlBase[];
+    rowAlias: string;
+}
+/** Isolate authored expressions, joins, tenancy and filters from internal SQL aliases. */
+export declare function buildTimeMeasureSourceSql(ds: AnyDatasetInstance, query: DatasetQuery, baseNames: Iterable<string>, filters: readonly MetricFilter[], options: DatasetQueryExecutionOptions): TimeMeasureSqlSource;
+//# sourceMappingURL=time-measure-source-sql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"time-measure-source-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-source-sql.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACrG,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAUxE,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,iBAAiB,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,EAAE,OAAO,EAAE,CAAC;IACtB,UAAU,EAAE,uBAAuB,EAAE,CAAC;IACtC,KAAK,EAAE,kBAAkB,EAAE,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,0FAA0F;AAC1F,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC3B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,OAAO,EAAE,4BAA4B,GACpC,oBAAoB,CA2DtB"}

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

@@ -0,0 +1,75 @@
+import { queryTimeSql } from './query-timezone.js';
+import { resolveDimensionExpression, resolveFilterField, resolveTenantFilterColumn } from '../query-planner.js';
+import { applyRelationshipJoins, buildRelationshipBuilderContext, qualifyBaseColumn } from './relationship-builder-plan.js';
+import { getRuntimeTenantPredicate } from './tenant-runtime.js';
+import { segmentFilters } from './segments.js';
+import { getBaseMeasure } from './dataset-measures.js';
+import { measureToAggregationSpec } from './dataset-normalization.js';
+import { applyFilteredAggregationExpression } from './filtered-aggregation-sql.js';
+import { assertNoRawSqlUnderJoins } from './sql-under-joins.js';
+/** Isolate authored expressions, joins, tenancy and filters from internal SQL aliases. */
+export function buildTimeMeasureSourceSql(ds, query, baseNames, filters, options) {
+    const bases = [];
+    const joinCtx = buildRelationshipBuilderContext(ds, query, options.context);
+    // Keep source expressions in their own SELECT scope: internal aliases cannot
+    // capture authored SQL identifiers, even if a physical column shares a name.
+    let raw = applyRelationshipJoins(options.builderFactory.table(ds.source), joinCtx);
+    const dims = (query.dimensions ?? []).map((name, i) => ({ name, alias: `_hq_d${i}` }));
+    const sourceParts = [resolveDimensionExpression(ds, ds.timeKey, joinCtx)];
+    for (const dimension of dims)
+        sourceParts.push(resolveDimensionExpression(ds, dimension.name, joinCtx));
+    for (const name of baseNames) {
+        const definition = getBaseMeasure(ds.measures, name);
+        if (!definition)
+            throw new Error(`Window input "${name}" is not a base measure.`);
+        const spec = measureToAggregationSpec(name, definition);
+        if (spec.sql)
+            assertNoRawSqlUnderJoins('measure', name, spec.sql, joinCtx);
+        const value = `_hq_v${bases.length}`;
+        const arg = `_hq_a${bases.length}`;
+        bases.push({ name, definition, value, arg });
+        const expression = spec.sql ?? resolveDimensionExpression(ds, spec.field, joinCtx);
+        sourceParts.push(applyFilteredAggregationExpression(ds, spec, expression, joinCtx));
+        sourceParts.push(spec.argField ? resolveDimensionExpression(ds, spec.argField, joinCtx) : 'NULL');
+    }
+    // A positional tuple isolates internal names from the source table's names.
+    const sourceIdentifiers = [
+        ...sourceParts,
+        ...Object.keys(ds.dimensions),
+        ...Object.values(ds.dimensions).map(dimension => dimension.sql ?? dimension.column ?? ''),
+        ...Object.values(ds.filters).map(filter => filter.field ?? ''),
+        ds.tenantKey ?? '',
+    ];
+    let rowAlias = '_hq_row';
+    while (sourceIdentifiers.some(text => text.includes(rowAlias)))
+        rowAlias += '_';
+    raw = raw.select([`tuple(${sourceParts.join(', ')}) AS ${rowAlias}`]);
+    const tenant = getRuntimeTenantPredicate(options.context);
+    const tenantColumn = resolveTenantFilterColumn(ds, options.context);
+    if (tenant && tenantColumn)
+        raw = raw.where(qualifyBaseColumn(joinCtx, tenantColumn), tenant.operator, tenant.value);
+    for (const filter of filters) {
+        raw = raw.where(resolveFilterField(ds, filter.field, joinCtx), filter.operator, filter.value);
+    }
+    for (const filter of segmentFilters(ds, query.segments)) {
+        raw = raw.where(resolveDimensionExpression(ds, filter.field, joinCtx), filter.operator, filter.value);
+    }
+    const { sql: rawSql, parameters } = raw.toSQLWithParams();
+    const sourceColumns = [`${queryTimeSql(`assumeNotNull(tupleElement(${rowAlias}, 1))`, query.timezone)} AS _hq_time`];
+    dims.forEach((dimension, i) => sourceColumns.push(`tupleElement(${rowAlias}, ${i + 2}) AS ${dimension.alias}`));
+    bases.forEach((base, i) => {
+        const valuePosition = dims.length + 2 + i * 2;
+        sourceColumns.push(`tupleElement(${rowAlias}, ${valuePosition}) AS ${base.value}`);
+        sourceColumns.push(`tupleElement(${rowAlias}, ${valuePosition + 1}) AS ${base.arg}`);
+    });
+    return {
+        ctes: [
+            `_hq_raw AS (${rawSql})`,
+            `_hq_source AS (SELECT ${sourceColumns.join(', ')} FROM _hq_raw WHERE isNotNull(tupleElement(${rowAlias}, 1)))`,
+        ],
+        parameters,
+        dimensions: dims,
+        bases,
+        rowAlias,
+    };
+}

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

@@ -0,0 +1,20 @@
+import type { TimeGrain, WindowMeasureDefinition } from '../types.js';
+import type { TimeMeasureAxis } from './time-measure-axis.js';
+import type { TimeMeasureSqlBase, TimeMeasureSqlDimension } from './time-measure-source-sql.js';
+export interface TimeMeasureSqlInput {
+    name: string;
+    base: TimeMeasureSqlBase;
+    window?: WindowMeasureDefinition;
+    /** Source rows mapped to output periods before aggregation. */
+    rowsSql: string;
+    /** Extra population CTEs, such as aligned shift ranges. */
+    rowCtes?: string[];
+    /** Shift populations already map exclusively to the requested output series. */
+    restrictToAxis?: boolean;
+}
+export declare function windowScanStartSql(window: WindowMeasureDefinition, grain: TimeGrain): string;
+/** Base measures respect partial endpoints; windows use entire contributing buckets. */
+export declare function windowMeasureRowsSql(window: WindowMeasureDefinition | undefined, axis: TimeMeasureAxis): string;
+/** Fill dimension combinations, aggregate populations, and join measure values onto the series. */
+export declare function buildTimeMeasureValuesSql(dims: readonly TimeMeasureSqlDimension[], inputs: readonly TimeMeasureSqlInput[], axis: TimeMeasureAxis): string[];
+//# sourceMappingURL=time-measure-values-sql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"time-measure-values-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-measure-values-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAGtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAKhG,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,kBAAkB,CAAC;IACzB,MAAM,CAAC,EAAE,uBAAuB,CAAC;IACjC,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gFAAgF;IAChF,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAwBD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,uBAAuB,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAI5F;AAED,wFAAwF;AACxF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,uBAAuB,GAAG,SAAS,EAAE,IAAI,EAAE,eAAe,GAAG,MAAM,CAG/G;AAED,mGAAmG;AACnG,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,SAAS,uBAAuB,EAAE,EACxC,MAAM,EAAE,SAAS,mBAAmB,EAAE,EACtC,IAAI,EAAE,eAAe,GACpB,MAAM,EAAE,CA0CV"}