@hypequery/datasets 0.23.1 → 0.24.0

package/dist/utils/query-timezone.d.ts

@@ -1,9 +1,47 @@
-import type { AnyDatasetInstance } from '../types.js';
+import type { DatasetSqlDialectRules } from '../dataset-sql-dialect.js';
+import type { AnyDatasetInstance, MetricFilter, MetricFilterOperator } from '../types.js';
 /** Named zones only: reject fixed offsets, invalid zones, and SQL fragments. */
 export declare function isQueryTimezone(value: unknown): value is string;
 export declare function queryTimezoneErrors(timezone: unknown): string[];
 /** Conversion preserves timestamp instants and interprets Date values as local dates. */
-export declare function queryTimeSql(expression: string, timezone: string | undefined): string;
+export declare function queryTimeSql(dialect: DatasetSqlDialectRules, expression: string, timezone: string | undefined): string;
+/** True when a local filter field reads the dataset's time-key column. */
+export declare function isTimeKeyFilter(ds: AnyDatasetInstance, field: string): boolean;
 /** Apply the query zone to time-key predicates, including semantic filter aliases. */
-export declare function queryTimeFilterSql(ds: AnyDatasetInstance, field: string, expression: string, timezone: string | undefined): string;
+export declare function queryTimeFilterSql(dialect: DatasetSqlDialectRules, ds: AnyDatasetInstance, field: string, expression: string, timezone: string | undefined): string;
+/** One `where` call: the column side, its operator, and the value to bind. */
+export interface QueryTimePredicate {
+    /** The column side of the predicate, converted to a zone when the value needs one. */
+    readonly expression: string;
+    readonly operator: MetricFilterOperator;
+    /** The value to bind, with instants rewritten to the wall clock of that zone. */
+    readonly value: unknown;
+}
+export interface QueryTimeFilterOptions {
+    /**
+     * How `filter.field` names its dimension. Caller filters (`'filter'`, the
+     * default) go through the dataset's filter aliases and read the time key in
+     * the query zone. Segment filters (`'dimension'`) name a dimension directly
+     * and keep the column's own zone for offset-free values.
+     */
+    readonly field?: 'filter' | 'dimension';
+}
+/**
+ * The `where` predicates for one filter under the query zone.
+ *
+ * A timestamp value carrying `Z` or an offset is an instant, which ClickHouse
+ * cannot read as a DateTime64 literal. Such a value is rewritten to its UTC
+ * wall clock and compared against the column converted to UTC, where no wall
+ * clock is ambiguous, so the comparison stays exact in every query zone.
+ * Offset-free values keep the predicate they had: the query zone for a
+ * caller filter on the time key, the column's own zone otherwise.
+ *
+ * A range or exclusion list mixing both kinds splits into one predicate per
+ * kind, so an instant bound never loses its offset to a local one. A mixed
+ * `in` list cannot split (its members are alternatives, and predicates only
+ * combine with AND), so it is rejected rather than read in one zone that
+ * changes a member's meaning. Non-timestamp fields and `like` patterns are
+ * bound unchanged.
+ */
+export declare function queryTimeFilter(dialect: DatasetSqlDialectRules, ds: AnyDatasetInstance, filter: MetricFilter, expression: string, timezone: string | undefined, options?: QueryTimeFilterOptions): QueryTimePredicate[];
 //# sourceMappingURL=query-timezone.d.ts.map

package/dist/utils/query-timezone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-timezone.d.ts","sourceRoot":"","sources":["../../src/utils/query-timezone.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD,gFAAgF;AAChF,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAS/D;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,EAAE,CAG/D;AAED,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAMrF;AAED,sFAAsF;AACtF,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GACtF,MAAM,CAMR"}
+{"version":3,"file":"query-timezone.d.ts","sourceRoot":"","sources":["../../src/utils/query-timezone.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAK1F,gFAAgF;AAChF,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAS/D;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,EAAE,CAG/D;AASD,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,OAAO,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAEtH;AAED,0EAA0E;AAC1E,wBAAgB,eAAe,CAAC,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAM9E;AAED,sFAAsF;AACtF,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,sBAAsB,EAC/B,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GACtF,MAAM,CAER;AAED,8EAA8E;AAC9E,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAC;IACxC,iFAAiF;IACjF,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,sBAAsB;IACrC;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC;CACzC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,sBAAsB,EAC/B,EAAE,EAAE,kBAAkB,EACtB,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,OAAO,GAAE,sBAA2B,GACnC,kBAAkB,EAAE,CAwCtB"}

package/dist/utils/query-timezone.js

@@ -1,3 +1,6 @@
+import { resolveDimensionFieldType, resolveFilterFieldType } from './filter-field-type.js';
+import { instantWallClock, parseTimestampInstant } from './timestamp-instants.js';
+import { mixedInstantListError } from '../validation.js';
 /** Named zones only: reject fixed offsets, invalid zones, and SQL fragments. */
 export function isQueryTimezone(value) {
     if (typeof value !== 'string' || value.length > 100
@@ -15,21 +18,85 @@ export function queryTimezoneErrors(timezone) {
     return timezone === undefined || isQueryTimezone(timezone)
         ? [] : ['Invalid timezone: use an IANA name such as UTC or America/New_York.'];
 }
-/** Conversion preserves timestamp instants and interprets Date values as local dates. */
-export function queryTimeSql(expression, timezone) {
+function canonicalTimezone(timezone) {
     timezone ??= 'UTC';
     const errors = queryTimezoneErrors(timezone);
     if (errors.length)
         throw new Error(errors[0]);
-    const name = new Intl.DateTimeFormat('en', { timeZone: timezone }).resolvedOptions().timeZone;
-    return `toDateTime64(${expression}, 9, '${name}')`;
+    return new Intl.DateTimeFormat('en', { timeZone: timezone }).resolvedOptions().timeZone;
 }
-/** Apply the query zone to time-key predicates, including semantic filter aliases. */
-export function queryTimeFilterSql(ds, field, expression, timezone) {
+/** Conversion preserves timestamp instants and interprets Date values as local dates. */
+export function queryTimeSql(dialect, expression, timezone) {
+    return dialect.toQueryTimezone(expression, canonicalTimezone(timezone));
+}
+/** True when a local filter field reads the dataset's time-key column. */
+export function isTimeKeyFilter(ds, field) {
     if (!ds.timeKey || field.includes('.'))
-        return expression;
+        return false;
     const resolved = ds.filters[field]?.field ?? field;
     const column = ds.dimensions[resolved]?.column ?? resolved;
     const timeColumn = ds.dimensions[ds.timeKey]?.column ?? ds.timeKey;
-    return column === timeColumn ? queryTimeSql(expression, timezone) : expression;
+    return column === timeColumn;
+}
+/** Apply the query zone to time-key predicates, including semantic filter aliases. */
+export function queryTimeFilterSql(dialect, ds, field, expression, timezone) {
+    return isTimeKeyFilter(ds, field) ? queryTimeSql(dialect, expression, timezone) : expression;
+}
+const INSTANT_ZONE = 'UTC';
+/**
+ * The `where` predicates for one filter under the query zone.
+ *
+ * A timestamp value carrying `Z` or an offset is an instant, which ClickHouse
+ * cannot read as a DateTime64 literal. Such a value is rewritten to its UTC
+ * wall clock and compared against the column converted to UTC, where no wall
+ * clock is ambiguous, so the comparison stays exact in every query zone.
+ * Offset-free values keep the predicate they had: the query zone for a
+ * caller filter on the time key, the column's own zone otherwise.
+ *
+ * A range or exclusion list mixing both kinds splits into one predicate per
+ * kind, so an instant bound never loses its offset to a local one. A mixed
+ * `in` list cannot split (its members are alternatives, and predicates only
+ * combine with AND), so it is rejected rather than read in one zone that
+ * changes a member's meaning. Non-timestamp fields and `like` patterns are
+ * bound unchanged.
+ */
+export function queryTimeFilter(dialect, ds, filter, expression, timezone, options = {}) {
+    const callerFilter = options.field !== 'dimension';
+    const fieldType = callerFilter
+        ? resolveFilterFieldType(ds, filter.field)
+        : resolveDimensionFieldType(ds, filter.field);
+    const localExpression = callerFilter && isTimeKeyFilter(ds, filter.field)
+        ? queryTimeSql(dialect, expression, timezone)
+        : expression;
+    const local = { expression: localExpression, operator: filter.operator, value: filter.value };
+    if (fieldType !== 'timestamp' || filter.operator === 'like')
+        return [local];
+    const values = Array.isArray(filter.value) ? filter.value : [filter.value];
+    const instants = values.map(parseTimestampInstant);
+    if (!instants.some(Boolean))
+        return [local];
+    const instantExpression = dialect.toQueryTimezone(expression, INSTANT_ZONE);
+    const rewrite = (zone) => values.map((value, index) => {
+        const instant = instants[index];
+        return instant ? instantWallClock(instant, zone) : value;
+    });
+    if (instants.every(Boolean)) {
+        const rewritten = rewrite(INSTANT_ZONE);
+        return [{ expression: instantExpression, operator: filter.operator, value: Array.isArray(filter.value) ? rewritten : rewritten[0] }];
+    }
+    switch (filter.operator) {
+        case 'between': {
+            const bound = (index, operator) => instants[index]
+                ? { expression: instantExpression, operator, value: instantWallClock(instants[index], INSTANT_ZONE) }
+                : { expression: localExpression, operator, value: values[index] };
+            return [bound(0, 'gte'), bound(1, 'lte')];
+        }
+        case 'notIn':
+            return [
+                { expression: localExpression, operator: 'notIn', value: values.filter((_, index) => !instants[index]) },
+                { expression: instantExpression, operator: 'notIn', value: rewrite(INSTANT_ZONE).filter((_, index) => instants[index]) },
+            ];
+        default:
+            throw new Error(mixedInstantListError(filter.field));
+    }
 }

package/dist/utils/raw-sql-dialect-check.d.ts

@@ -0,0 +1,12 @@
+import type { DatasetRawSqlExpressionError, DatasetSqlDialectRules } from '../dataset-sql-dialect.js';
+import type { AnyDatasetInstance } from '../types.js';
+export declare function rawSqlErrorMessage(kind: 'dimension' | 'measure', name: string, error: DatasetRawSqlExpressionError): string;
+/**
+ * Re-check a dataset's raw `sql` fields under the active engine's lexical
+ * rules before planning. Definitions are validated with ClickHouse rules, and
+ * engines disagree on what hides a terminator: with standard-conforming
+ * strings, `'\'; DROP TABLE x; --'` ends its literal early on Postgres. A
+ * ClickHouse-rule dialect is skipped; it was checked at definition time.
+ */
+export declare function assertRawSqlForDialect(ds: AnyDatasetInstance, dialect: DatasetSqlDialectRules): void;
+//# sourceMappingURL=raw-sql-dialect-check.d.ts.map

package/dist/utils/raw-sql-dialect-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw-sql-dialect-check.d.ts","sourceRoot":"","sources":["../../src/utils/raw-sql-dialect-check.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACtG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAGtD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,4BAA4B,GAAG,MAAM,CAK3H;AAID;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,kBAAkB,EAAE,OAAO,EAAE,sBAAsB,GAAG,IAAI,CAiBpG"}

package/dist/utils/raw-sql-dialect-check.js

@@ -0,0 +1,37 @@
+import { clickhouseDatasetSqlDialect } from './clickhouse-dataset-sql-dialect.js';
+export function rawSqlErrorMessage(kind, name, error) {
+    return error === 'unterminated-literal'
+        ? `${kind} "${name}" sql has an unterminated quoted literal.`
+        : `${kind} "${name}" sql must be a single expression without statement terminators or `
+            + 'comments (";", "--", "/*") outside a quoted literal.';
+}
+const checked = new WeakMap();
+/**
+ * Re-check a dataset's raw `sql` fields under the active engine's lexical
+ * rules before planning. Definitions are validated with ClickHouse rules, and
+ * engines disagree on what hides a terminator: with standard-conforming
+ * strings, `'\'; DROP TABLE x; --'` ends its literal early on Postgres. A
+ * ClickHouse-rule dialect is skipped; it was checked at definition time.
+ */
+export function assertRawSqlForDialect(ds, dialect) {
+    if (dialect.rawSqlExpressionError === clickhouseDatasetSqlDialect.rawSqlExpressionError)
+        return;
+    let dialects = checked.get(ds);
+    if (dialects?.has(dialect))
+        return;
+    const fields = [
+        ...Object.entries(ds.dimensions).map(([name, definition]) => ['dimension', name, definition.sql]),
+        ...Object.entries(ds.measures).map(([name, definition]) => ['measure', name, 'sql' in definition ? definition.sql : undefined]),
+    ];
+    for (const [kind, name, sql] of fields) {
+        if (sql === undefined)
+            continue;
+        const error = dialect.rawSqlExpressionError(sql);
+        if (error) {
+            throw new Error(`Invalid dataset "${ds.name}" for the ${dialect.name} datasets dialect: ${rawSqlErrorMessage(kind, name, error)}`);
+        }
+    }
+    if (!dialects)
+        checked.set(ds, dialects = new WeakSet());
+    dialects.add(dialect);
+}

package/dist/utils/relationship-builder-plan.d.ts

@@ -1,5 +1,5 @@
 import type { RelationshipKey } from '../types.js';
-import type { DatasetSqlDialect } from '../dataset-sql-dialect.js';
+import type { DatasetSqlDialectRules } from '../dataset-sql-dialect.js';
 /**
  * Query-builder-path planning for to-one relationship joins.
  *
@@ -9,6 +9,13 @@ import type { DatasetSqlDialect } from '../dataset-sql-dialect.js';
  * name, and aliases joined selections back to their quoted qualified name. When
  * no qualified field is referenced, no context is produced and the builder path
  * behaves exactly as before.
+ *
+ * Every joined target is a projection carrying a match marker (see
+ * `relationshipJoinSource`), and every joined dimension or filter reads through
+ * it: a base row without a match yields NULL for the target's columns
+ * regardless of the engine's `join_use_nulls` setting, so a missing or
+ * other-tenant target never surfaces as `''`/`0` and never passes a `neq`
+ * filter. This mirrors the Python planner.
  */
 import type { AnyDatasetInstance, DatasetQuery, ExecutionContext, MetricQuery } from '../types.js';
 import type { QueryBuilderLike } from '../query-builder-protocol.js';
@@ -16,9 +23,10 @@ import { type TenantPredicate } from './tenant-runtime.js';
 export interface ResolvedBuilderJoin {
     /** Relationship name, used as the joined table's SQL alias. */
     relationship: string;
-    /** Physical target source table. */
+    /** Joined source: the target projected with its match marker. */
     source: string;
-    matchMarker?: string;
+    /** Column of `source` that is non-null only when the target matched. */
+    matchMarker: string;
     keys?: readonly RelationshipKey[];
     /** Base join column (unqualified). */
     from: string;
@@ -33,6 +41,8 @@ export interface RelationshipBuilderContext {
     baseSource: string;
     joins: ResolvedBuilderJoin[];
     joinByRelationship: Map<string, ResolvedBuilderJoin>;
+    /** Dialect the join sources and match guards were rendered with. */
+    dialect: DatasetSqlDialectRules;
 }
 type QueryLike = Pick<DatasetQuery & MetricQuery, 'dimensions' | 'filters' | 'orderBy'> & Pick<DatasetQuery, 'measures'>;
 /**
@@ -40,15 +50,22 @@ type QueryLike = Pick<DatasetQuery & MetricQuery, 'dimensions' | 'filters' | 'or
  * references no relationship-qualified fields. Validation runs first, so any
  * qualified name that fails to resolve here is skipped defensively.
  */
-export declare function buildRelationshipBuilderContext(ds: AnyDatasetInstance, query: QueryLike, context?: ExecutionContext, dialect?: DatasetSqlDialect): RelationshipBuilderContext | undefined;
+export declare function buildRelationshipBuilderContext(ds: AnyDatasetInstance, query: QueryLike, context?: ExecutionContext, dialect?: DatasetSqlDialectRules): RelationshipBuilderContext | undefined;
 /** Qualifies a base physical column with the base source when joins are active. */
 export declare function qualifyBaseColumn(ctx: RelationshipBuilderContext | undefined, column: string): string;
 /**
- * Resolves a relationship-qualified field to its SQL column reference
- * (`<relationship>.<targetColumn>`). Throws if the name cannot be resolved,
- * which should be unreachable after validation.
+ * Resolves a relationship-qualified field to a null-guarded SQL expression:
+ * the target column when the join matched, NULL otherwise
+ * (`if(isNotNull(<relationship>.<marker>), <relationship>.<column>, NULL)`).
+ * Throws if the name cannot be resolved, which should be unreachable after
+ * validation.
+ *
+ * Without the guard, ClickHouse fills unmatched LEFT JOIN columns with type
+ * defaults unless `join_use_nulls` is on, so an order without a customer would
+ * group under `''` and pass a `neq` filter. The guard makes the planner's
+ * documented NULL semantics hold whatever the server setting.
  */
-export declare function resolveQualifiedColumn(ds: AnyDatasetInstance, name: string): string;
+export declare function resolveQualifiedExpression(ds: AnyDatasetInstance, name: string, ctx: RelationshipBuilderContext): string;
 /**
  * Applies each relationship join to the builder as a single-match LEFT JOIN
  * (`leftAnyJoin`, e.g. ClickHouse `LEFT ANY JOIN`) and, when runtime tenancy

package/dist/utils/relationship-builder-plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relationship-builder-plan.d.ts","sourceRoot":"","sources":["../../src/utils/relationship-builder-plan.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAGnE;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAA6B,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGtF,MAAM,WAAW,mBAAmB;IAClC,+DAA+D;IAC/D,YAAY,EAAE,MAAM,CAAC;IACrB,oCAAoC;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;IAClC,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,kEAAkE;IAClE,MAAM,CAAC,EAAE,eAAe,GAAG;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9C;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CACtD;AAED,KAAK,SAAS,GAAG,IAAI,CAAC,YAAY,GAAG,WAAW,EAAE,YAAY,GAAG,SAAS,GAAG,SAAS,CAAC,GAAG,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;AAEzH;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,SAAS,EAChB,OAAO,CAAC,EAAE,gBAAgB,EAC1B,OAAO,GAAE,iBAA+C,GACvD,0BAA0B,GAAG,SAAS,CA+CxC;AAED,mFAAmF;AACnF,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,0BAA0B,GAAG,SAAS,EAC3C,MAAM,EAAE,MAAM,GACb,MAAM,CAER;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,MAAM,GACX,MAAM,CAOR;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,gBAAgB,EACpB,GAAG,EAAE,0BAA0B,GAAG,SAAS,GAC1C,gBAAgB,CAoClB"}
+{"version":3,"file":"relationship-builder-plan.d.ts","sourceRoot":"","sources":["../../src/utils/relationship-builder-plan.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAGxE;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAA6B,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGtF,MAAM,WAAW,mBAAmB;IAClC,+DAA+D;IAC/D,YAAY,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;IAClC,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,kEAAkE;IAClE,MAAM,CAAC,EAAE,eAAe,GAAG;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9C;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACrD,oEAAoE;IACpE,OAAO,EAAE,sBAAsB,CAAC;CACjC;AAED,KAAK,SAAS,GAAG,IAAI,CAAC,YAAY,GAAG,WAAW,EAAE,YAAY,GAAG,SAAS,GAAG,SAAS,CAAC,GAAG,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;AAEzH;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,SAAS,EAChB,OAAO,CAAC,EAAE,gBAAgB,EAC1B,OAAO,GAAE,sBAAoD,GAC5D,0BAA0B,GAAG,SAAS,CAgDxC;AAED,mFAAmF;AACnF,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,0BAA0B,GAAG,SAAS,EAC3C,MAAM,EAAE,MAAM,GACb,MAAM,CAER;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,0BAA0B,GAC9B,MAAM,CAaR;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,gBAAgB,EACpB,GAAG,EAAE,0BAA0B,GAAG,SAAS,GAC1C,gBAAgB,CAoClB"}

package/dist/utils/relationship-builder-plan.js

@@ -1,5 +1,5 @@
 import { relationshipKeys } from './relationship-keys.js';
-import { relationshipMeasureSource } from './relationship-measure-sql.js';
+import { relationshipJoinSource } from './relationship-measure-sql.js';
 import { clickhouseDatasetSqlDialect } from './clickhouse-dataset-sql-dialect.js';
 import { resolveRelationshipReference } from './relationship-measures.js';
 import { getRuntimeTenantPredicate } from './tenant-runtime.js';
@@ -34,11 +34,11 @@ export function buildRelationshipBuilderContext(ds, query, context, dialect = cl
             .filter(name => name.startsWith(`${relationshipName}.`))
             .map(name => name.slice(relationshipName.length + 1));
         const keys = relationshipKeys(relationship);
-        const projected = measureNames.length ? relationshipMeasureSource(target, keys.map(key => key.to), measureNames, dialect) : undefined;
+        const projected = relationshipJoinSource(target, keys.map(key => key.to), measureNames, dialect);
         joinByRelationship.set(relationshipName, {
             relationship: relationshipName,
-            source: projected?.source ?? target.source,
-            matchMarker: projected?.marker,
+            source: projected.source,
+            matchMarker: projected.marker,
             from: relationship.from,
             to: relationship.to,
             keys,
@@ -51,6 +51,7 @@ export function buildRelationshipBuilderContext(ds, query, context, dialect = cl
         baseSource: ds.source,
         joins: Array.from(joinByRelationship.values()),
         joinByRelationship,
+        dialect,
     };
 }
 /** Qualifies a base physical column with the base source when joins are active. */
@@ -58,17 +59,30 @@ export function qualifyBaseColumn(ctx, column) {
     return ctx ? `${ctx.baseSource}.${column}` : column;
 }
 /**
- * Resolves a relationship-qualified field to its SQL column reference
- * (`<relationship>.<targetColumn>`). Throws if the name cannot be resolved,
- * which should be unreachable after validation.
+ * Resolves a relationship-qualified field to a null-guarded SQL expression:
+ * the target column when the join matched, NULL otherwise
+ * (`if(isNotNull(<relationship>.<marker>), <relationship>.<column>, NULL)`).
+ * Throws if the name cannot be resolved, which should be unreachable after
+ * validation.
+ *
+ * Without the guard, ClickHouse fills unmatched LEFT JOIN columns with type
+ * defaults unless `join_use_nulls` is on, so an order without a customer would
+ * group under `''` and pass a `neq` filter. The guard makes the planner's
+ * documented NULL semantics hold whatever the server setting.
  */
-export function resolveQualifiedColumn(ds, name) {
+export function resolveQualifiedExpression(ds, name, ctx) {
     const resolution = resolveQualifiedField(ds, name);
     if (!resolution || !resolution.resolved) {
         throw new Error(resolution?.error ?? `Cannot resolve relationship field "${name}".`);
     }
     const { relationshipName, targetColumn } = resolution.resolved;
-    return `${relationshipName}.${targetColumn}`;
+    const join = ctx.joinByRelationship.get(relationshipName);
+    if (!join) {
+        throw new Error(`Relationship "${relationshipName}" referenced by "${name}" was not planned as a join.`);
+    }
+    const { dialect } = ctx;
+    const matched = dialect.isNotNull(`${relationshipName}.${join.matchMarker}`);
+    return dialect.ifElse(matched, `${relationshipName}.${targetColumn}`, 'NULL');
 }
 /**
  * Applies each relationship join to the builder as a single-match LEFT JOIN

package/dist/utils/relationship-measure-sql.d.ts

@@ -1,12 +1,22 @@
 import type { AnyDatasetInstance } from '../types.js';
 import type { RelationshipBuilderContext } from './relationship-builder-plan.js';
-import type { DatasetSqlDialect } from '../dataset-sql-dialect.js';
-/** Explicit projection avoids marker collisions and makes absent targets detectable under join_use_nulls=0. */
-export declare function relationshipMeasureSource(target: AnyDatasetInstance, to: readonly string[], names: readonly string[], dialect: DatasetSqlDialect): {
+import type { DatasetSqlDialectRules } from '../dataset-sql-dialect.js';
+/**
+ * The joined target as a projection whose marker is non-null only on a match.
+ *
+ * Without `join_use_nulls`, an unmatched LEFT JOIN row carries column defaults
+ * such as `0` and `''`, which `min` or `countDistinct` would count and which
+ * joined dimensions would expose as data. The marker is the one value that
+ * tells a match from a default, and an explicit projection keeps it from
+ * colliding with a target column. `names` are the related measures selected
+ * from the target (possibly none); the projection always carries the join
+ * keys, the tenant key and every column-backed dimension.
+ */
+export declare function relationshipJoinSource(target: AnyDatasetInstance, to: readonly string[], names: readonly string[], dialect: DatasetSqlDialectRules): {
     source: string;
     marker: string;
 };
-export declare function relationshipMeasureExpressions(ds: AnyDatasetInstance, name: string, joinCtx: RelationshipBuilderContext): {
+export declare function relationshipMeasureExpressions(ds: AnyDatasetInstance, name: string, joinCtx: RelationshipBuilderContext, dialect: DatasetSqlDialectRules): {
     definition: import("../types.js").MeasureDefinition;
     field: string;
     arg: string | undefined;

package/dist/utils/relationship-measure-sql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relationship-measure-sql.d.ts","sourceRoot":"","sources":["../../src/utils/relationship-measure-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAmB,MAAM,aAAa,CAAC;AAEvE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAIjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,+GAA+G;AAC/G,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,kBAAkB,EAAE,EAAE,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,iBAAiB;;;EAgBhJ;AAED,wBAAgB,8BAA8B,CAAC,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,0BAA0B;;;;EAevH"}
+{"version":3,"file":"relationship-measure-sql.d.ts","sourceRoot":"","sources":["../../src/utils/relationship-measure-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAmB,MAAM,aAAa,CAAC;AAEvE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAIjF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAExE;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,kBAAkB,EAAE,EAAE,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,sBAAsB;;;EAkBlJ;AAeD,wBAAgB,8BAA8B,CAAC,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,0BAA0B,EAAE,OAAO,EAAE,sBAAsB;;;;EAexJ"}

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

@@ -2,8 +2,18 @@ import { resolveRelationshipMeasure } from './relationship-measures.js';
 import { resolveDimensionExpression } from '../query-planner.js';
 import { measureToAggregationSpec } from './dataset-normalization.js';
 import { applyFilteredAggregationExpression } from './filtered-aggregation-sql.js';
-/** Explicit projection avoids marker collisions and makes absent targets detectable under join_use_nulls=0. */
-export function relationshipMeasureSource(target, to, names, dialect) {
+/**
+ * The joined target as a projection whose marker is non-null only on a match.
+ *
+ * Without `join_use_nulls`, an unmatched LEFT JOIN row carries column defaults
+ * such as `0` and `''`, which `min` or `countDistinct` would count and which
+ * joined dimensions would expose as data. The marker is the one value that
+ * tells a match from a default, and an explicit projection keeps it from
+ * colliding with a target column. `names` are the related measures selected
+ * from the target (possibly none); the projection always carries the join
+ * keys, the tenant key and every column-backed dimension.
+ */
+export function relationshipJoinSource(target, to, names, dialect) {
     const columns = new Set([...to, ...(target.tenantKey ? [target.tenantKey] : [])]);
     for (const [name, dimension] of Object.entries(target.dimensions))
         if (!dimension.sql)
@@ -21,11 +31,24 @@ export function relationshipMeasureSource(target, to, names, dialect) {
     while (columns.has(marker))
         marker += '_';
     const quote = dialect.quoteIdentifier;
-    const source = target.source.split('.').map(quote).join('.');
-    const projection = [...columns].map(quote);
-    return { source: `(SELECT ${[...projection, `toNullable(1) AS ${quote(marker)}`].join(', ')} FROM ${source})`, marker };
+    const source = relationshipTargetTable(target, dialect);
+    // Sorted so the SQL is byte-identical however the target's dimensions are
+    // ordered (authored vs. rehydrated catalogs declare them differently).
+    const projection = [...columns].sort().map(quote);
+    return { source: `(SELECT ${[...projection, `${dialect.toNullable('1')} AS ${quote(marker)}`].join(', ')} FROM ${source})`, marker };
 }
-export function relationshipMeasureExpressions(ds, name, joinCtx) {
+/** The target's quoted table, read with `FINAL` when the target dataset requires it. */
+function relationshipTargetTable(target, dialect) {
+    const quoted = dialect.quoteQualifiedName(target.source);
+    if (!target.final)
+        return quoted;
+    if (!dialect.finalTable) {
+        throw new Error(`Dataset "${target.name}" is declared final: true, but the "${dialect.name}" SQL dialect has no FINAL ` +
+            'modifier, so it cannot be joined without counting unmerged row versions.');
+    }
+    return dialect.finalTable(quoted);
+}
+export function relationshipMeasureExpressions(ds, name, joinCtx, dialect) {
     const resolved = resolveRelationshipMeasure(ds, name);
     const { relationshipName, target, definition } = resolved;
     const marker = joinCtx.joinByRelationship.get(relationshipName)?.matchMarker;
@@ -33,12 +56,12 @@ export function relationshipMeasureExpressions(ds, name, joinCtx) {
         throw new Error(`Missing match marker for relationship measure "${name}".`);
     const ownerContext = { ...joinCtx, baseSource: relationshipName };
     const spec = measureToAggregationSpec(name, definition);
-    const matched = `isNotNull(${relationshipName}.${marker})`;
+    const matched = dialect.isNotNull(`${relationshipName}.${marker}`);
     const field = definition.field === '*' ? `${relationshipName}.${marker}` : resolveDimensionExpression(target, definition.field, ownerContext);
-    const filtered = applyFilteredAggregationExpression(target, spec, field, ownerContext);
+    const filtered = applyFilteredAggregationExpression(target, spec, field, ownerContext, dialect);
     return {
         definition,
-        field: `if(${matched}, ${filtered}, NULL)`,
-        arg: definition.argField ? `if(${matched}, ${resolveDimensionExpression(target, definition.argField, ownerContext)}, NULL)` : undefined,
+        field: dialect.ifElse(matched, filtered, 'NULL'),
+        arg: definition.argField ? dialect.ifElse(matched, resolveDimensionExpression(target, definition.argField, ownerContext), 'NULL') : undefined,
     };
 }

package/dist/utils/relationship-measures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relationship-measures.d.ts","sourceRoot":"","sources":["../../src/utils/relationship-measures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAMjG,MAAM,WAAW,2BAA2B;IAC1C,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,sBAAsB,CAAC;IACrC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,UAAU,EAAE,iBAAiB,CAAC;CAC/B;AAED,iFAAiF;AACjF,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,GAAG,2BAA2B,CAkB5G;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAS9H;AAED,yGAAyG;AACzG,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,kBAAkB,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,kEAM1F;AAED,kFAAkF;AAClF,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,SAAS,MAAM,EAAO;;;;;;;;SAIlH"}
+{"version":3,"file":"relationship-measures.d.ts","sourceRoot":"","sources":["../../src/utils/relationship-measures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAMjG,MAAM,WAAW,2BAA2B;IAC1C,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,sBAAsB,CAAC;IACrC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,UAAU,EAAE,iBAAiB,CAAC;CAC/B;AAED,iFAAiF;AACjF,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,GAAG,2BAA2B,CAqB5G;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAS9H;AAED,yGAAyG;AACzG,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,kBAAkB,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,kEAM1F;AAED,kFAAkF;AAClF,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,SAAS,MAAM,EAAO;;;;;;;;SAIlH"}

package/dist/utils/relationship-measures.js

@@ -17,6 +17,9 @@ export function resolveRelationshipMeasure(ds, name) {
         throw new Error(`Unknown measure "${parsed.field}" on relationship target "${target.name}".`);
     if (!isBaseMeasure(definition))
         throw new Error(`Measure "${name}" must reference a base aggregate; derived, window, and shift measures are not selectable through relationships.`);
+    if (definition.aggregation === 'merge') {
+        throw new Error(`Measure "${name}" cannot merge aggregate states through a relationship: joined rows would repeat or drop states. Query the target dataset directly.`);
+    }
     if (relationship.kind === 'belongsTo' && !DUPLICATE_INSENSITIVE.has(definition.aggregation)) {
         throw new Error(`Measure "${name}" cannot use ${definition.aggregation} through belongsTo: repeated target rows would inflate the aggregation. Use a duplicate-insensitive measure or query the target dataset.`);
     }

package/dist/utils/semantic-tool.d.ts

@@ -1,5 +1,5 @@
-import type { ZodTypeAny } from 'zod';
+import type { ZodType } from 'zod';
 export declare function semanticToolNamePart(name: string): string;
-export declare function parseCanonicalToolInput(schema: ZodTypeAny, input: Record<string, unknown>, label: string): Record<string, unknown>;
+export declare function parseCanonicalToolInput(schema: ZodType, input: Record<string, unknown>, label: string): Record<string, unknown>;
 export declare function redactSemanticToolSql(result: unknown, includeSql: boolean): unknown;
 //# sourceMappingURL=semantic-tool.d.ts.map

package/dist/utils/semantic-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"semantic-tool.d.ts","sourceRoot":"","sources":["../../src/utils/semantic-tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAEtC,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUzB;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAenF"}
+{"version":3,"file":"semantic-tool.d.ts","sourceRoot":"","sources":["../../src/utils/semantic-tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUzB;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAenF"}

package/dist/utils/semantic-tool.js

@@ -6,7 +6,7 @@ export function parseCanonicalToolInput(schema, input, label) {
     const result = schema.safeParse(input);
     if (!result.success) {
         const issues = result.error.issues.map((issue) => {
-            const path = issue.path.length > 0 ? issue.path.join('.') : 'input';
+            const path = issue.path.length > 0 ? issue.path.map(String).join('.') : 'input';
             return `${path}: ${issue.message}`;
         }).join('; ');
         throw new Error(`Invalid ${label}: ${issues}`);

package/dist/utils/shift-measure-sql.d.ts

@@ -1,7 +1,8 @@
+import type { DatasetSqlDialectRules } from '../dataset-sql-dialect.js';
 import type { ShiftMeasureDefinition } from '../types.js';
 import type { TimeMeasureAxis } from './time-measure-axis.js';
 /** Preserve the selected portion of a bucket and both authored endpoint operators. */
-export declare function shiftRangeSql(shift: ShiftMeasureDefinition, axis: TimeMeasureAxis, period?: string): {
+export declare function shiftRangeSql(dialect: DatasetSqlDialectRules, shift: ShiftMeasureDefinition, axis: TimeMeasureAxis, period?: string): {
     lower: string;
     upper: string;
     lowerInclusive: string;
@@ -9,11 +10,11 @@ export declare function shiftRangeSql(shift: ShiftMeasureDefinition, axis: TimeM
 };
 export declare function shiftRangePredicateSql(time: string, range: ReturnType<typeof shiftRangeSql>): string;
 /** Check the shifted scan independently of whether it contains source rows. */
-export declare function shiftCalendarGuardSql(shift: ShiftMeasureDefinition, axis: TimeMeasureAxis, axisGuard: string): string;
+export declare function shiftCalendarGuardSql(dialect: DatasetSqlDialectRules, shift: ShiftMeasureDefinition, axis: TimeMeasureAxis, axisGuard: string): string;
 /** Validate each output bucket after the series exists, including empty source populations. */
-export declare function shiftWallTimeSeriesGuardSql(shift: ShiftMeasureDefinition, grain: TimeMeasureAxis['grain']): string;
+export declare function shiftWallTimeSeriesGuardSql(dialect: DatasetSqlDialectRules, shift: ShiftMeasureDefinition, grain: TimeMeasureAxis['grain']): string;
 /** Map output buckets to their earlier half-open ranges, retaining calendar arithmetic. */
-export declare function shiftBucketCtes(shift: ShiftMeasureDefinition, axis: TimeMeasureAxis, index: number): {
+export declare function shiftBucketCtes(dialect: DatasetSqlDialectRules, shift: ShiftMeasureDefinition, axis: TimeMeasureAxis, index: number): {
     ctes: string[];
     rowsSql: string;
     sourceTimesSql: string;

package/dist/utils/shift-measure-sql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shift-measure-sql.d.ts","sourceRoot":"","sources":["../../src/utils/shift-measure-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAI1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAK9D,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,MAAM;;;;;EAoBlG;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,GAAG,MAAM,CAGpG;AAED,+EAA+E;AAC/E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAOrH;AAED,+FAA+F;AAC/F,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,sBAAsB,EAAE,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,GAAG,MAAM,CAMlH;AAED,2FAA2F;AAC3F,wBAAgB,eAAe,CAAC,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAsBhK"}
+{"version":3,"file":"shift-measure-sql.d.ts","sourceRoot":"","sources":["../../src/utils/shift-measure-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAE1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAK9D,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,MAAM;;;;;EAoBnI;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,GAAG,MAAM,CAGpG;AAED,+EAA+E;AAC/E,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAOtJ;AAED,+FAA+F;AAC/F,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,sBAAsB,EAAE,KAAK,EAAE,eAAe,CAAC,OAAO,CAAC,GAAG,MAAM,CAMnJ;AAED,2FAA2F;AAC3F,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAuBjM"}