@hypequery/datasets 0.21.0 → 0.23.0

package/dist/utils/compile-dataset-query.js

@@ -0,0 +1,72 @@
+import { queryMeasureDefinitions } from './relationship-measures.js';
+import { buildDatasetQueryBuilder } from './build-dataset-query-builder.js';
+import { baseMeasureNames } from './dataset-measures.js';
+import { buildDerivedDatasetSql, hasSelectedDerivedMeasure, needsOuterDatasetQuery } from './dataset-derived-query.js';
+import { measureDependencyNames } from './measure-dependencies.js';
+import { overfetchLimit } from './pagination.js';
+import { resolveResultLimit } from './result-limits.js';
+import { buildTimeMeasureDatasetSql } from './time-measure-dataset-sql.js';
+import { selectedTimeMeasures } from './time-query-measures.js';
+/** The one dispatch point for dataset preview and query-builder execution. */
+export function prepareDatasetQuery(dataset, input, options, mode = 'execution') {
+    const query = structuredClone({
+        ...input,
+        limit: mode === 'execution' ? resolveResultLimit(input.limit, dataset.limits).limit : input.limit,
+    });
+    // Preserve omission while validating/planning: maxMeasures constrains an
+    // explicit selection, not the dataset's default set of base measures.
+    const measures = query.measures ?? baseMeasureNames(dataset.measures);
+    const executionLimit = mode === 'execution' ? overfetchLimit(query.limit) : query.limit;
+    const executionOptions = { ...options, executionLimit };
+    const preflightStatements = [];
+    let statement;
+    let execute;
+    let plan;
+    const abortSignal = options.context?.abortSignal;
+    if (selectedTimeMeasures(dataset, query).size) {
+        plan = 'time';
+        const compiled = buildTimeMeasureDatasetSql(dataset, query, executionOptions);
+        statement = compiled;
+        preflightStatements.push({ sql: compiled.timeAxisSql, parameters: compiled.parameters });
+        execute = async () => {
+            await options.builderFactory.rawQuery(compiled.timeAxisSql, compiled.parameters, { abortSignal });
+            return options.builderFactory.rawQuery(compiled.sql, compiled.parameters, { abortSignal });
+        };
+    }
+    else if (needsOuterDatasetQuery(dataset, query)) {
+        plan = hasSelectedDerivedMeasure(dataset, query) ? 'derived' : 'aggregate';
+        statement = buildDerivedDatasetSql(dataset, query, executionOptions, buildDatasetQueryBuilder);
+        execute = () => options.builderFactory.rawQuery(statement.sql, statement.parameters, { abortSignal });
+    }
+    else {
+        plan = 'aggregate';
+        const builder = buildDatasetQueryBuilder(dataset, query, executionOptions);
+        statement = builder.toSQLWithParams();
+        // Retain builder execution: custom builders may carry adapter settings.
+        execute = () => builder.execute({ abortSignal });
+    }
+    const description = Object.freeze({
+        kind: 'dataset-compilation', version: 1, dataset: dataset.name, plan,
+        dimensions: Object.freeze([...(query.dimensions ?? [])]),
+        measures: Object.freeze([...measures]),
+        measureDependencies: Object.freeze(measureDependencyNames(queryMeasureDefinitions(dataset, measures), measures)),
+        filters: Object.freeze((query.filters ?? []).map(({ field, operator }) => Object.freeze({ field, operator }))),
+        having: Object.freeze((query.having ?? []).map(({ measure, operator }) => Object.freeze({ measure, operator }))),
+        segments: Object.freeze([...(query.segments ?? [])]),
+        by: query.by, timezone: query.timezone,
+        effectiveLimit: query.limit, executionLimit, offset: query.offset ?? 0,
+        parameterCount: statement.parameters.length,
+        preflightStatementCount: preflightStatements.length,
+    });
+    const compilation = Object.freeze({
+        sql: statement.sql,
+        parameters: Object.freeze(structuredClone(statement.parameters)),
+        query: Object.freeze(structuredClone({ ...query, measures })),
+        preflightStatements: Object.freeze(preflightStatements.map(preflight => Object.freeze({
+            sql: preflight.sql, parameters: Object.freeze(structuredClone(preflight.parameters)),
+        }))),
+        describe: () => description,
+        toJSON: () => description,
+    });
+    return { compilation, execute };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"composite-time-measure-sql.d.ts","sourceRoot":"","sources":["../../src/utils/composite-time-measure-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAW9D,mFAAmF;AACnF,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,4BAA4B,EAAE,IAAI,EAAE,eAAe;;;;EAgDrJ"}
+{"version":3,"file":"composite-time-measure-sql.d.ts","sourceRoot":"","sources":["../../src/utils/composite-time-measure-sql.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAW9D,mFAAmF;AACnF,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,4BAA4B,EAAE,IAAI,EAAE,eAAe;;;;EAgDrJ"}

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

@@ -1,3 +1,4 @@
+import { queryMeasureDefinitions } from './relationship-measures.js';
 import { quoteSQLIdentifier } from '../sql-utils.js';
 import { isDerivedMeasure, isWindowMeasure } from './dataset-measures.js';
 import { buildMeasureEvaluationGraph, evaluationFormula } from './measure-evaluation-graph.js';
@@ -9,7 +10,7 @@ import { derivedProjection } from './derived-measure-sql.js';
 import { buildTimeMeasureResultSql } from './time-measure-result-sql.js';
 /** Aggregate each dependency in its evaluation context, then evaluate formulas. */
 export function buildCompositeTimeMeasureSql(ds, query, options, axis) {
-    const graph = buildMeasureEvaluationGraph(ds.measures, query.measures ?? []);
+    const graph = buildMeasureEvaluationGraph(queryMeasureDefinitions(ds, query.measures ?? []), query.measures ?? []);
     const leaves = graph.nodes.filter(node => !isDerivedMeasure(node.definition));
     const baseNames = new Set(leaves.map(node => isWindowMeasure(node.definition) ? node.definition.measure : node.name));
     const source = buildTimeMeasureSourceSql(ds, query, baseNames, axis.filters, options);

package/dist/utils/dataset-definition-validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataset-definition-validation.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-definition-validation.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,EACvB,MAAM,aAAa,CAAC;AAOrB,KAAK,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AACzD,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;AAC5D,KAAK,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;AA+M/D;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,CAAC,aAAa,EAAE,WAAW,EAAE,gBAAgB,CAAC,GAClE,IAAI,CA0DN"}
+{"version":3,"file":"dataset-definition-validation.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-definition-validation.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,wBAAwB,EACxB,mBAAmB,EAEnB,sBAAsB,EAEvB,MAAM,aAAa,CAAC;AAQrB,KAAK,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AACzD,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;AAC5D,KAAK,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;AAwR/D;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,CAAC,aAAa,EAAE,WAAW,EAAE,gBAAgB,CAAC,GAClE,IAAI,CA2DN"}

package/dist/utils/dataset-definition-validation.js

@@ -1,5 +1,6 @@
 import { validateShiftMeasures } from './shift-measure-validation.js';
 import { escapeRegExp, isSafeSQLIdentifier, stripSqlLiterals } from '../sql-utils.js';
+import { SEMANTIC_FILTER_OPERATORS, isSemanticFilterOperator } from '../constants.js';
 import { validateDerivedMeasures } from './derived-measure-validation.js';
 import { isDerivedMeasure, isWindowMeasure, isShiftMeasure } from './dataset-measures.js';
 import { validateWindowMeasures } from './window-measure-validation.js';
@@ -113,7 +114,54 @@ function validateDimensions(datasetName, dimensions) {
         assertSafeColumn(datasetName, definition.column ?? name, `dimension "${name}" column`);
     }
 }
-function validateMeasures(datasetName, measures, dimensions) {
+function assertSemanticOperator(datasetName, operator, context) {
+    if (!isSemanticFilterOperator(operator)) {
+        fail(datasetName, `${context} uses unsupported operator "${String(operator)}". ` +
+            `Supported: ${SEMANTIC_FILTER_OPERATORS.join(', ')}.`);
+    }
+}
+/**
+ * Validates the declared filter map. A filter's `field` names the dimension it
+ * filters on; when it is not a declared dimension it falls through to SQL as a
+ * bare column, so it must then be a safe identifier.
+ */
+function validateFilters(datasetName, filters, dimensions) {
+    for (const [name, definition] of Object.entries(filters ?? {})) {
+        // JavaScript callers can omit `field`; never let it stringify to "undefined".
+        if (typeof definition.field !== 'string') {
+            fail(datasetName, `filter "${name}" must name a field.`);
+        }
+        if (!Object.hasOwn(dimensions, definition.field)) {
+            assertSafeColumn(datasetName, definition.field, `filter "${name}" field`);
+        }
+        for (const operator of definition.operators ?? []) {
+            assertSemanticOperator(datasetName, operator, `filter "${name}"`);
+        }
+    }
+}
+/**
+ * Validates a measure's fixed filters. These are rendered straight into the
+ * aggregate's `if(...)` condition, so the field must resolve to a declared
+ * dimension or filter, or else be a safe (optionally relationship-qualified)
+ * identifier, and the operator must be one the renderer knows.
+ */
+function validateMeasureFilters(datasetName, measureName, filters, dimensions, declaredFilters) {
+    for (const filter of filters) {
+        const context = `measure "${measureName}" filter on "${String(filter.field)}"`;
+        if (typeof filter.field !== 'string') {
+            fail(datasetName, `${context} must name a field.`);
+        }
+        const declared = Object.hasOwn(dimensions, filter.field)
+            || (declaredFilters !== undefined && Object.hasOwn(declaredFilters, filter.field));
+        if (!declared && !isSafeQualifiedName(filter.field, 2)) {
+            fail(datasetName, `${context} is not a declared dimension or a safe column identifier. Measure filter ` +
+                'fields are interpolated into SQL, so they must contain only letters, numbers and ' +
+                'underscores (optionally "<relationship>.<field>").');
+        }
+        assertSemanticOperator(datasetName, filter.operator, context);
+    }
+}
+function validateMeasures(datasetName, measures, dimensions, declaredFilters) {
     for (const [name, definition] of Object.entries(measures)) {
         assertSafeName(datasetName, 'measure', name);
         if (typeof definition !== 'object' || definition === null) {
@@ -127,6 +175,7 @@ function validateMeasures(datasetName, measures, dimensions) {
         if (definition.sql !== undefined) {
             validateRawSql(datasetName, 'measure', name, definition.sql, definition.dependencies);
         }
+        validateMeasureFilters(datasetName, name, definition.filters ?? [], dimensions, declaredFilters);
         // `field` and `argField` name either a declared dimension or a physical
         // column that the model deliberately does not expose (the `allowHiddenField`
         // case in metric validation). Either way the value reaches SQL, so a name
@@ -199,11 +248,12 @@ export function validateDatasetDefinition(name, config) {
     // measure-only model is a legitimate thing to define.
     const dimensions = config.dimensions ?? {};
     validateDimensions(name, dimensions);
+    validateFilters(name, config.filters, dimensions);
     const measures = config.measures ?? {};
     validateWindowMeasures(name, config.timeKey, measures);
     validateShiftMeasures(name, config.timeKey, measures);
     validateDerivedMeasures(name, measures);
-    validateMeasures(name, measures, dimensions);
+    validateMeasures(name, measures, dimensions, config.filters);
     validateLimits(name, config.limits);
     validateDatasetAgentMetadata(name, config);
 }

package/dist/utils/dataset-derived-query.d.ts

@@ -1,12 +1,16 @@
-import type { AnyDatasetInstance, DatasetQuery, DatasetQueryResult } from '../types.js';
+import type { AnyDatasetInstance, DatasetQuery } from '../types.js';
 import type { QueryBuilderLike } from '../query-builder-protocol.js';
 import type { DatasetQueryExecutionOptions } from '../dataset-query.js';
 type BuildBaseQuery = (dataset: AnyDatasetInstance, query: DatasetQuery, options: DatasetQueryExecutionOptions) => QueryBuilderLike;
 export declare function hasSelectedDerivedMeasure(ds: AnyDatasetInstance, query: DatasetQuery): boolean;
+/**
+ * True when the query needs an outer query over the grouped result: derived
+ * measures are computed there, and `having` conditions filter there.
+ */
+export declare function needsOuterDatasetQuery(ds: AnyDatasetInstance, query: DatasetQuery): boolean;
 export declare function buildDerivedDatasetSql(ds: AnyDatasetInstance, query: DatasetQuery, options: DatasetQueryExecutionOptions, buildBaseQuery: BuildBaseQuery): {
     sql: string;
     parameters: unknown[];
 };
-export declare function runDerivedDatasetQuery(ds: AnyDatasetInstance, query: DatasetQuery, options: DatasetQueryExecutionOptions, buildBaseQuery: BuildBaseQuery): Promise<DatasetQueryResult>;
 export {};
 //# sourceMappingURL=dataset-derived-query.d.ts.map

package/dist/utils/dataset-derived-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataset-derived-query.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-derived-query.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACxF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAKrE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAExE,KAAK,cAAc,GAAG,CACpB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,KAClC,gBAAgB,CAAC;AAEtB,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAE9F;AAED,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,EACrC,cAAc,EAAE,cAAc,GAC7B;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,EAAE,CAAA;CAAE,CA2CxC;AAED,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,EACrC,cAAc,EAAE,cAAc,GAC7B,OAAO,CAAC,kBAAkB,CAAC,CAgB7B"}
+{"version":3,"file":"dataset-derived-query.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-derived-query.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAGrE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAGxE,KAAK,cAAc,GAAG,CACpB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,KAClC,gBAAgB,CAAC;AAEtB,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAE9F;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAE3F;AAED,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,EACrC,cAAc,EAAE,cAAc,GAC7B;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,EAAE,CAAA;CAAE,CAqDxC"}

package/dist/utils/dataset-derived-query.js

@@ -1,27 +1,37 @@
+import { queryMeasureDefinitions } from './relationship-measures.js';
+import { semanticOrderDirection } from './semantic-query-syntax.js';
 import { measureDependencyNames } from './measure-dependencies.js';
 import { derivedExpressionSql } from './derived-measure-sql.js';
 import { baseMeasureNames, getBaseMeasure, getDerivedMeasure } from './dataset-measures.js';
-import { quoteSQLIdentifier } from '../sql-utils.js';
+import { resolveDatasetSqlDialect } from './dataset-sql-dialect.js';
 import { validateDatasetQueryInput } from './dataset-query-validation.js';
-import { overfetchLimit } from './pagination.js';
-import { toDatasetQueryResult } from './dataset-query-result.js';
+import { datasetHavingSql } from './dataset-having.js';
 export function hasSelectedDerivedMeasure(ds, query) {
     return (query.measures ?? []).some(name => getDerivedMeasure(ds.measures, name) !== undefined);
 }
+/**
+ * True when the query needs an outer query over the grouped result: derived
+ * measures are computed there, and `having` conditions filter there.
+ */
+export function needsOuterDatasetQuery(ds, query) {
+    return hasSelectedDerivedMeasure(ds, query) || (query.having?.length ?? 0) > 0;
+}
 export function buildDerivedDatasetSql(ds, query, options, buildBaseQuery) {
     const validation = validateDatasetQueryInput(ds, query, options.context);
     if (!validation.valid) {
         throw new Error(`Invalid dataset query: ${validation.errors.join('; ')}`);
     }
+    const dialect = resolveDatasetSqlDialect(options.builderFactory);
     const selected = query.measures ?? baseMeasureNames(ds.measures);
-    const baseMeasures = measureDependencyNames(ds.measures, selected).filter(name => getBaseMeasure(ds.measures, name));
+    const baseMeasures = measureDependencyNames(queryMeasureDefinitions(ds, selected), selected).filter(name => name.includes('.') || getBaseMeasure(ds.measures, name));
     const resolve = (name) => {
         const derived = getDerivedMeasure(ds.measures, name);
-        return derived ? `(${derivedExpressionSql(derived, resolve)})` : quoteSQLIdentifier(name);
+        return derived ? `(${derivedExpressionSql(derived, resolve)})` : dialect.quoteIdentifier(name);
     };
     const inner = buildBaseQuery(ds, {
         ...query,
         measures: [...baseMeasures],
+        having: undefined,
         orderBy: undefined,
         limit: undefined,
         offset: undefined,
@@ -29,21 +39,28 @@ export function buildDerivedDatasetSql(ds, query, options, buildBaseQuery) {
     const { sql: innerSql, parameters } = inner.toSQLWithParams();
     const projections = [];
     if (query.by)
-        projections.push(quoteSQLIdentifier('period'));
+        projections.push(dialect.quoteIdentifier('period'));
     for (const dimension of query.dimensions ?? [])
-        projections.push(quoteSQLIdentifier(dimension));
+        projections.push(dialect.quoteIdentifier(dimension));
     for (const name of selected) {
         const derived = getDerivedMeasure(ds.measures, name);
         projections.push(derived
-            ? `${derivedExpressionSql(derived, resolve)} AS ${quoteSQLIdentifier(name)}`
-            : quoteSQLIdentifier(name));
+            ? `${derivedExpressionSql(derived, resolve)} AS ${dialect.quoteIdentifier(name)}`
+            : dialect.quoteIdentifier(name));
     }
     let sql = `WITH base AS (${innerSql}) SELECT ${projections.join(', ')} FROM base`;
+    // Conditions read the same expression the projection does, never the output
+    // alias, so the predicate stays valid on dialects without alias resolution.
+    if (query.having?.length) {
+        const having = datasetHavingSql(query.having, resolve);
+        sql += ` WHERE ${having.sql}`;
+        parameters.push(...having.parameters);
+    }
     if (query.orderBy?.length) {
-        sql += ` ORDER BY ${query.orderBy.map(order => (`${quoteSQLIdentifier(order.field)} ${order.direction === 'asc' ? 'ASC' : 'DESC'}`)).join(', ')}`;
+        sql += ` ORDER BY ${query.orderBy.map(order => (`${dialect.quoteIdentifier(order.field)} ${semanticOrderDirection(order.direction)}`)).join(', ')}`;
     }
     else if (query.by) {
-        sql += ` ORDER BY ${quoteSQLIdentifier('period')} ASC`;
+        sql += ` ORDER BY ${dialect.quoteIdentifier('period')} ASC`;
     }
     const limit = options.executionLimit ?? query.limit;
     if (limit !== undefined)
@@ -52,18 +69,3 @@ export function buildDerivedDatasetSql(ds, query, options, buildBaseQuery) {
         sql += ` OFFSET ${query.offset}`;
     return { sql, parameters };
 }
-export async function runDerivedDatasetQuery(ds, query, options, buildBaseQuery) {
-    const start = Date.now();
-    const { sql, parameters } = buildDerivedDatasetSql(ds, query, {
-        ...options,
-        executionLimit: overfetchLimit(query.limit),
-    }, buildBaseQuery);
-    const rows = await options.builderFactory.rawQuery(sql, parameters, { abortSignal: options.context?.abortSignal });
-    return toDatasetQueryResult(rows, {
-        dataset: ds,
-        query,
-        sql,
-        timingMs: Date.now() - start,
-        context: options.context,
-    });
-}

package/dist/utils/dataset-filter-types.d.ts

@@ -0,0 +1,28 @@
+import type { DatasetInstance, DimensionDefinition, MetricFilter, MetricFilterOperator, RelationshipDefinition, SemanticFilterDefinition, SemanticFiltersDefinition } from '../types.js';
+/** The generated allowlist mirrors normalizeFilters; explicit maps replace it. */
+export type NormalizedDatasetFilters<TDimensions extends Record<string, DimensionDefinition>, TFilters extends SemanticFiltersDefinition | undefined> = TFilters extends SemanticFiltersDefinition ? TFilters : {
+    [K in keyof TDimensions as TDimensions[K] extends {
+        filterable: false;
+    } ? never : K]: SemanticFilterDefinition & {
+        field: K & string;
+    };
+};
+type FilterOperators<TDefinition> = TDefinition extends {
+    operators: readonly (infer TOperator extends MetricFilterOperator)[];
+} ? TOperator : MetricFilterOperator;
+type LocalFilterFor<TFilters extends SemanticFiltersDefinition> = {
+    [K in keyof TFilters & string]: K extends `${string}.${string}` ? never : MetricFilter<K, unknown, FilterOperators<TFilters[K]>>;
+}[keyof TFilters & string];
+type RelationshipFilterFor<TRelationships extends Record<string, RelationshipDefinition>> = {
+    [R in keyof TRelationships & string]: TRelationships[R] extends RelationshipDefinition<infer TTarget, infer TKind> ? TKind extends 'hasMany' ? never : TTarget extends DatasetInstance<any, any, any, any> ? {
+        [K in keyof TTarget['filters'] & keyof TTarget['dimensions'] & string]: TTarget['dimensions'][K] extends {
+            sql: string;
+        } ? never : K extends TTarget['filters'][K]['field'] ? MetricFilter<`${R}.${K}`, unknown, FilterOperators<TTarget['filters'][K]>> : never;
+    }[keyof TTarget['filters'] & keyof TTarget['dimensions'] & string] : never : never;
+}[keyof TRelationships & string];
+/** Filter names and operator policies exposed by a dataset and its to-one targets. */
+export type DatasetFilterFor<TDataset extends DatasetInstance<any, any, any, any>> = LocalFilterFor<TDataset['filters']> | RelationshipFilterFor<TDataset['relationships']>;
+/** Names in the normalized filter allowlist, including one-hop relationship filters. */
+export type DatasetFilterNames<TDataset extends DatasetInstance<any, any, any, any>> = DatasetFilterFor<TDataset>['field'];
+export {};
+//# sourceMappingURL=dataset-filter-types.d.ts.map

package/dist/utils/dataset-filter-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-filter-types.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-filter-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,YAAY,EACZ,oBAAoB,EACpB,sBAAsB,EACtB,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,aAAa,CAAC;AAErB,kFAAkF;AAClF,MAAM,MAAM,wBAAwB,CAClC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,EACvD,QAAQ,SAAS,yBAAyB,GAAG,SAAS,IACpD,QAAQ,SAAS,yBAAyB,GAAG,QAAQ,GAAG;KACzD,CAAC,IAAI,MAAM,WAAW,IAAI,WAAW,CAAC,CAAC,CAAC,SAAS;QAAE,UAAU,EAAE,KAAK,CAAA;KAAE,GAAG,KAAK,GAAG,CAAC,GAAG,wBAAwB,GAAG;QAC/G,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC;KACnB;CACF,CAAC;AAEF,KAAK,eAAe,CAAC,WAAW,IAAI,WAAW,SAAS;IACtD,SAAS,EAAE,SAAS,CAAC,MAAM,SAAS,SAAS,oBAAoB,CAAC,EAAE,CAAC;CACtE,GAAG,SAAS,GAAG,oBAAoB,CAAC;AAErC,KAAK,cAAc,CAAC,QAAQ,SAAS,yBAAyB,IAAI;KAC/D,CAAC,IAAI,MAAM,QAAQ,GAAG,MAAM,GAAG,CAAC,SAAS,GAAG,MAAM,IAAI,MAAM,EAAE,GAC3D,KAAK,GACL,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CAC3D,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,CAAC;AAE3B,KAAK,qBAAqB,CAAC,cAAc,SAAS,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,IAAI;KACzF,CAAC,IAAI,MAAM,cAAc,GAAG,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,SAAS,sBAAsB,CAAC,MAAM,OAAO,EAAE,MAAM,KAAK,CAAC,GAC9G,KAAK,SAAS,SAAS,GAAG,KAAK,GAC7B,OAAO,SAAS,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GACjD;SACC,CAAC,IAAI,MAAM,OAAO,CAAC,SAAS,CAAC,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC,GAAG,MAAM,GACnE,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,GAAG,KAAK,GACpD,CAAC,SAAS,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GACtC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAC1E,KAAK;KACd,CAAC,MAAM,OAAO,CAAC,SAAS,CAAC,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC,GAAG,MAAM,CAAC,GAChE,KAAK,GACT,KAAK;CACV,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,CAAC;AAEjC,sFAAsF;AACtF,MAAM,MAAM,gBAAgB,CAAC,QAAQ,SAAS,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,IAC7E,cAAc,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,GACnC,qBAAqB,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC;AAErD,wFAAwF;AACxF,MAAM,MAAM,kBAAkB,CAAC,QAAQ,SAAS,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,IACjF,gBAAgB,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC"}

package/dist/utils/dataset-filter-types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/dataset-having.d.ts

@@ -0,0 +1,21 @@
+import type { AnyDatasetInstance, DatasetHavingCondition, DatasetQuery } from '../types.js';
+/**
+ * Validates `having` conditions against the query they belong to.
+ *
+ * A condition may only reference a measure the query selects: that is the
+ * value the condition reads, and it keeps every rendered reference an output
+ * alias rather than an expression taken from input.
+ */
+export declare function datasetHavingErrors(ds: AnyDatasetInstance, query: DatasetQuery, selectedMeasures: readonly string[]): string[];
+/**
+ * Renders validated `having` conditions as one parameterized predicate.
+ *
+ * `measureSql` maps a selected measure to the expression that reads its
+ * aggregated value in the outer query. Values are only ever bound as `?`
+ * parameters, appended in placeholder order.
+ */
+export declare function datasetHavingSql(conditions: readonly DatasetHavingCondition[], measureSql: (measure: string) => string): {
+    sql: string;
+    parameters: unknown[];
+};
+//# sourceMappingURL=dataset-having.d.ts.map

package/dist/utils/dataset-having.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-having.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-having.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAmC5F;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,gBAAgB,EAAE,SAAS,MAAM,EAAE,GAClC,MAAM,EAAE,CA0CV;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,SAAS,sBAAsB,EAAE,EAC7C,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GACtC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,EAAE,CAAA;CAAE,CAmBxC"}

package/dist/utils/dataset-having.js

@@ -0,0 +1,106 @@
+import { SEMANTIC_HAVING_OPERATORS } from '../constants.js';
+import { selectedTimeMeasures } from './time-query-measures.js';
+const HAVING_OPERATORS = new Set(SEMANTIC_HAVING_OPERATORS);
+const COMPARISONS = {
+    eq: '=',
+    neq: '!=',
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+};
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function conditionValueError(condition) {
+    const { measure, operator, value } = condition;
+    if (operator === 'between') {
+        return Array.isArray(value) && value.length === 2 && value.every(isFiniteNumber)
+            ? undefined
+            : `Having "between" on "${measure}" expects a two-item array of finite numbers.`;
+    }
+    if (operator === 'in' || operator === 'notIn') {
+        return Array.isArray(value) && value.length > 0 && value.every(isFiniteNumber)
+            ? undefined
+            : `Having "${operator}" on "${measure}" expects a non-empty array of finite numbers.`;
+    }
+    return isFiniteNumber(value)
+        ? undefined
+        : `Having "${operator}" on "${measure}" expects a finite number.`;
+}
+/**
+ * Validates `having` conditions against the query they belong to.
+ *
+ * A condition may only reference a measure the query selects: that is the
+ * value the condition reads, and it keeps every rendered reference an output
+ * alias rather than an expression taken from input.
+ */
+export function datasetHavingErrors(ds, query, selectedMeasures) {
+    if (query.having === undefined)
+        return [];
+    if (!Array.isArray(query.having))
+        return ['Having must be an array of conditions.'];
+    if (query.having.length === 0)
+        return [];
+    const errors = [];
+    if (selectedTimeMeasures(ds, query).size > 0) {
+        errors.push('Having is not supported on queries that select window or shift measures.');
+    }
+    // `maxFilters` bounds every predicate the query adds, before and after
+    // aggregation alike. Filters alone over the limit are reported separately.
+    const maxFilters = ds.limits?.maxFilters;
+    const filterCount = Array.isArray(query.filters) ? query.filters.length : 0;
+    const conditionCount = filterCount + query.having.length;
+    if (maxFilters && conditionCount > maxFilters && filterCount <= maxFilters) {
+        errors.push(`Too many filters and having conditions: ${conditionCount} (max ${maxFilters})`);
+    }
+    const selected = new Set(selectedMeasures);
+    for (const condition of query.having) {
+        if (typeof condition !== 'object' || condition === null) {
+            errors.push('Each having condition must be an object with measure, operator and value.');
+            continue;
+        }
+        const { measure, operator } = condition;
+        if (typeof measure !== 'string' || !selected.has(measure)) {
+            errors.push(`Having measure "${String(measure)}" must be one of the selected measures: ${[...selected].join(', ')}`);
+            continue;
+        }
+        if (typeof operator !== 'string' || !HAVING_OPERATORS.has(operator)) {
+            errors.push(`Unsupported having operator "${String(operator)}" on "${measure}". ` +
+                `Supported: ${SEMANTIC_HAVING_OPERATORS.join(', ')}`);
+            continue;
+        }
+        const valueError = conditionValueError(condition);
+        if (valueError)
+            errors.push(valueError);
+    }
+    return errors;
+}
+/**
+ * Renders validated `having` conditions as one parameterized predicate.
+ *
+ * `measureSql` maps a selected measure to the expression that reads its
+ * aggregated value in the outer query. Values are only ever bound as `?`
+ * parameters, appended in placeholder order.
+ */
+export function datasetHavingSql(conditions, measureSql) {
+    const parameters = [];
+    const predicates = conditions.map((condition) => {
+        const column = measureSql(condition.measure);
+        if (condition.operator === 'between') {
+            parameters.push(condition.value[0], condition.value[1]);
+            return `${column} BETWEEN ? AND ?`;
+        }
+        if (condition.operator === 'in' || condition.operator === 'notIn') {
+            parameters.push(...condition.value);
+            const placeholders = condition.value.map(() => '?').join(', ');
+            return `${column} ${condition.operator === 'in' ? 'IN' : 'NOT IN'} (${placeholders})`;
+        }
+        const comparison = COMPARISONS[condition.operator];
+        if (!comparison)
+            throw new Error(`Unsupported having operator "${String(condition.operator)}".`);
+        parameters.push(condition.value);
+        return `${column} ${comparison} ?`;
+    });
+    return { sql: predicates.join(' AND '), parameters };
+}

package/dist/utils/dataset-normalization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataset-normalization.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-normalization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,wBAAwB,EACxB,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACtB,yBAAyB,EAC1B,MAAM,aAAa,CAAC;AAErB,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;AAC5D,KAAK,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;AAE/D,wBAAgB,mBAAmB,CAAC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,EACzF,MAAM,EAAE,aAAa,CAAC,WAAW,EAAE,WAAW,EAAE,gBAAgB,CAAC,GAChE,WAAW,CAEb;AAED,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,EAC/C,OAAO,CAAC,EAAE,yBAAyB,GAClC,yBAAyB,CAgB3B;AAED,wBAAgB,iBAAiB,CAAC,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,EAC1F,QAAQ,EAAE,SAAS,GAAG,SAAS,GAC9B,SAAS,CAEX;AAED,wBAAgB,sBAAsB,CAAC,cAAc,SAAS,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,EAClG,aAAa,EAAE,cAAc,GAAG,SAAS,EACzC,MAAM,EAAE,MAAM,GACb,cAAc,CAgBhB;AAED,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,iBAAiB,GAC5B,eAAe,CAcjB"}
+{"version":3,"file":"dataset-normalization.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-normalization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,wBAAwB,EACxB,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACtB,yBAAyB,EAC1B,MAAM,aAAa,CAAC;AAGrB,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;AAC5D,KAAK,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;AAE/D,wBAAgB,mBAAmB,CAAC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,EACzF,MAAM,EAAE,aAAa,CAAC,WAAW,EAAE,WAAW,EAAE,gBAAgB,CAAC,GAChE,WAAW,CAEb;AAED,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,EAC/C,OAAO,CAAC,EAAE,yBAAyB,GAClC,yBAAyB,CAgB3B;AAED,wBAAgB,iBAAiB,CAAC,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,EAC1F,QAAQ,EAAE,SAAS,GAAG,SAAS,GAC9B,SAAS,CAEX;AAED,wBAAgB,sBAAsB,CAAC,cAAc,SAAS,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,EAClG,aAAa,EAAE,cAAc,GAAG,SAAS,EACzC,MAAM,EAAE,MAAM,GACb,cAAc,CAkBhB;AAED,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,iBAAiB,GAC5B,eAAe,CAcjB"}

package/dist/utils/dataset-normalization.js

@@ -1,3 +1,4 @@
+import { relationshipKeys } from './relationship-keys.js';
 export function normalizeDimensions(config) {
     return config.dimensions;
 }
@@ -19,7 +20,10 @@ export function normalizeMeasures(measures) {
     return (measures ?? {});
 }
 export function normalizeRelationships(relationships, source) {
-    for (const name of Object.keys(relationships ?? {})) {
+    for (const [name, relationship] of Object.entries(relationships ?? {})) {
+        // Hand-built definitions skip the helpers, so check composite keys here.
+        if (relationship.keys)
+            relationshipKeys(relationship);
         if (name === source) {
             throw new Error(`Invalid relationship "${name}": the name matches the dataset source table, so the join ` +
                 'alias would shadow the base table and produce ambiguous SQL. Rename the relationship.');

package/dist/utils/dataset-query-validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataset-query-validation.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-query-validation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EACjB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAuB,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAiB9E,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,gBAAgB,GACzB,gBAAgB,CAmKlB"}
+{"version":3,"file":"dataset-query-validation.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-query-validation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EACjB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAuB,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAkB9E,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,gBAAgB,GACzB,gBAAgB,CAyKlB"}

package/dist/utils/dataset-query-validation.js

@@ -1,3 +1,5 @@
+import { resolveRelationshipMeasure } from './relationship-measures.js';
+import { semanticQuerySyntaxErrors } from './semantic-query-syntax.js';
 import { queryTimezoneErrors } from './query-timezone.js';
 import { baseMeasureNames } from './dataset-measures.js';
 import { validateFilterValue } from '../validation.js';
@@ -7,12 +9,18 @@ import { isQualifiedField, resolveQualifiedField, } from './relationship-fields.
 import { validateQualifiedFilter, validateRelationshipTenantRuntime, } from './relationship-validation.js';
 import { segmentSelectionErrors } from './segments.js';
 import { analyzeTimeMeasureAxis } from './time-measure-axis.js';
+import { datasetHavingErrors } from './dataset-having.js';
 export function validateDatasetQueryInput(ds, query, context) {
-    const errors = queryTimezoneErrors(query.timezone);
+    const errors = [...semanticQuerySyntaxErrors(query), ...queryTimezoneErrors(query.timezone)];
     const dimensionNames = Object.keys(ds.dimensions);
     const measureNames = Object.keys(ds.measures);
     const selectedDimensions = query.dimensions ?? [];
     const selectedMeasures = query.measures ?? baseMeasureNames(ds.measures);
+    for (const name of selectedDimensions) {
+        if (selectedMeasures.includes(name)) {
+            errors.push(`Output "${name}" cannot be selected as both a dimension and a measure. Select one or give the definitions distinct names.`);
+        }
+    }
     const filterNames = Object.keys(ds.filters);
     const orderableFields = new Set([
         ...selectedDimensions,
@@ -47,7 +55,12 @@ export function validateDatasetQueryInput(ds, query, context) {
     if (query.measures) {
         for (const measure of query.measures) {
             if (isQualifiedField(measure)) {
-                errors.push(`Measure "${measure}" is relationship-qualified. Measures can only be defined on the base dataset "${ds.name}", not traversed through relationships.`);
+                try {
+                    resolveRelationshipMeasure(ds, measure);
+                }
+                catch (error) {
+                    errors.push(error.message);
+                }
                 continue;
             }
             if (!measureNames.includes(measure)) {
@@ -95,7 +108,7 @@ export function validateDatasetQueryInput(ds, query, context) {
     if (query.orderBy) {
         const invalid = [];
         for (const order of query.orderBy) {
-            if (isQualifiedField(order.field)) {
+            if (isQualifiedField(order.field) && !selectedMeasures.includes(order.field)) {
                 const resolution = resolveQualifiedField(ds, order.field);
                 if (resolution?.error) {
                     errors.push(resolution.error);
@@ -135,6 +148,7 @@ export function validateDatasetQueryInput(ds, query, context) {
     if (ds.limits?.maxMeasures && query.measures && query.measures.length > ds.limits.maxMeasures) {
         errors.push(`Too many measures: ${query.measures.length} (max ${ds.limits.maxMeasures})`);
     }
+    errors.push(...datasetHavingErrors(ds, query, selectedMeasures));
     if (ds.limits?.maxFilters && query.filters && query.filters.length > ds.limits.maxFilters) {
         errors.push(`Too many filters: ${query.filters.length} (max ${ds.limits.maxFilters})`);
     }

package/dist/utils/dataset-sql-dialect.d.ts

@@ -0,0 +1,5 @@
+import type { DatasetSqlDialect } from '../dataset-sql-dialect.js';
+import type { QueryBuilderFactoryInput } from '../query-builder-protocol.js';
+/** Resolve from the active factory, so a runtime builder override carries its dialect. */
+export declare function resolveDatasetSqlDialect(factory: QueryBuilderFactoryInput): DatasetSqlDialect;
+//# sourceMappingURL=dataset-sql-dialect.d.ts.map

package/dist/utils/dataset-sql-dialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-sql-dialect.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-sql-dialect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAG7E,0FAA0F;AAC1F,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,wBAAwB,GAAG,iBAAiB,CAE7F"}

package/dist/utils/dataset-sql-dialect.js

@@ -0,0 +1,5 @@
+import { clickhouseDatasetSqlDialect } from './clickhouse-dataset-sql-dialect.js';
+/** Resolve from the active factory, so a runtime builder override carries its dialect. */
+export function resolveDatasetSqlDialect(factory) {
+    return factory.datasetSqlDialect ?? clickhouseDatasetSqlDialect;
+}

package/dist/utils/dataset-target.d.ts

@@ -0,0 +1,3 @@
+import type { AnyDatasetInstance } from '../types.js';
+export declare function isDatasetInstance(target: unknown): target is AnyDatasetInstance;
+//# sourceMappingURL=dataset-target.d.ts.map

package/dist/utils/dataset-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-target.d.ts","sourceRoot":"","sources":["../../src/utils/dataset-target.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,kBAAkB,CAE/E"}

package/dist/utils/dataset-target.js

@@ -0,0 +1,3 @@
+export function isDatasetInstance(target) {
+    return !!target && typeof target === 'object' && '__type' in target && target.__type === 'dataset';
+}

package/dist/utils/filter-definition.d.ts

@@ -0,0 +1,3 @@
+import type { MetricFilter, MetricFilterOperator } from '../types.js';
+export declare function createFilter<const TField extends string, const TValue, TOperator extends MetricFilterOperator>(field: TField, operator: TOperator, value: TValue): MetricFilter<TField, TValue, TOperator>;
+//# sourceMappingURL=filter-definition.d.ts.map

package/dist/utils/filter-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-definition.d.ts","sourceRoot":"","sources":["../../src/utils/filter-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAEtE,wBAAgB,YAAY,CAC1B,KAAK,CAAC,MAAM,SAAS,MAAM,EAC3B,KAAK,CAAC,MAAM,EACZ,SAAS,SAAS,oBAAoB,EACtC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,CAE5F"}

package/dist/utils/filter-definition.js

@@ -0,0 +1,3 @@
+export function createFilter(field, operator, value) {
+    return { field, operator, value };
+}

package/dist/utils/metric-derived-query.d.ts

@@ -0,0 +1,8 @@
+import type { MetricRef, MetricQuery, ExecutionContext, TimeGrain } from '../types.js';
+import type { QueryBuilderFactoryLike } from '../query-builder-protocol.js';
+import type { DerivedMetricSpec } from '../types.js';
+export declare function buildDerivedMetricSql(ref: MetricRef, spec: DerivedMetricSpec, query: MetricQuery, grain: TimeGrain | undefined, builderFactory: QueryBuilderFactoryLike, context?: ExecutionContext): {
+    sql: string;
+    params: unknown[];
+};
+//# sourceMappingURL=metric-derived-query.d.ts.map

package/dist/utils/metric-derived-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metric-derived-query.d.ts","sourceRoot":"","sources":["../../src/utils/metric-derived-query.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAE,uBAAuB,EAAoB,MAAM,8BAA8B,CAAC;AAiB9F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAKrD,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,cAAc,EAAE,uBAAuB,EACvC,OAAO,CAAC,EAAE,gBAAgB,GACzB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAiHpC"}