@hypequery/datasets 0.23.1 → 0.25.0

package/dist/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAY9E;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CA0C7F"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI1D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAgB9E;AAED,0FAA0F;AAC1F,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAG9E;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3D;AAgBD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CA6C7F"}

package/dist/validation.js

@@ -1,6 +1,8 @@
 /**
  * Shared validation utilities for semantic layer queries.
  */
+import { parseTimestampInstant } from './utils/timestamp-instants.js';
+import { isTimestampText } from './utils/timestamp-text.js';
 /**
  * Checks if a value matches the expected field type.
  *
@@ -11,16 +13,45 @@
 export function matchesFieldType(fieldType, value) {
     switch (fieldType) {
         case 'string':
-        case 'timestamp':
             return typeof value === 'string';
+        case 'timestamp':
+            return isTimestampText(value);
         case 'number':
-            return typeof value === 'number' && Number.isFinite(value);
+            // Number filters bind as Float64; an integer beyond 2^53 is already rounded
+            // and would silently match nothing against an exact Int64/UInt64 column.
+            return typeof value === 'number' && Number.isFinite(value)
+                && (!Number.isInteger(value) || Number.isSafeInteger(value));
         case 'boolean':
             return typeof value === 'boolean';
         default:
             return false;
     }
 }
+/** True when a list holds both instants (`Z` or an offset) and offset-free timestamps. */
+export function mixesInstantsAndLocalTimes(values) {
+    const instants = values.map(value => parseTimestampInstant(value) !== undefined);
+    return instants.some(Boolean) && !instants.every(Boolean);
+}
+/**
+ * An `in` list is one predicate, so every member is read in the same zone:
+ * an instant and a local time cannot share one without changing a meaning.
+ */
+export function mixedInstantListError(field) {
+    return `"in" cannot mix instants (with Z or an offset) and local timestamps for field "${field}"; use one form.`;
+}
+function typeError(filter, fieldType, plural) {
+    if (fieldType === 'timestamp') {
+        const what = plural ? 'ISO 8601 timestamps' : 'an ISO 8601 timestamp';
+        return `"${filter.operator}" expects ${what} for field "${filter.field}", such as 2026-01-31 or 2026-01-31T12:00:00Z, with a real calendar date and time.`;
+    }
+    if (fieldType === 'number') {
+        const what = plural ? 'number values' : 'a number value';
+        return `"${filter.operator}" expects ${what} for field "${filter.field}"; integers must be safe integers (within ±2^53) to compare exactly. Declare a large id as dimension.string() to filter it exactly.`;
+    }
+    return plural
+        ? `"${filter.operator}" expects ${fieldType} values for field "${filter.field}".`
+        : `"${filter.operator}" expects a ${fieldType} value for field "${filter.field}".`;
+}
 /**
  * Validates a filter value against the expected field type.
  *
@@ -34,7 +65,7 @@ export function validateFilterValue(filter, fieldType) {
         case 'neq':
             return matchesFieldType(fieldType, filter.value)
                 ? null
-                : `"${filter.operator}" expects a ${fieldType} value for field "${filter.field}".`;
+                : typeError(filter, fieldType, false);
         case 'gt':
         case 'gte':
         case 'lt':
@@ -44,7 +75,7 @@ export function validateFilterValue(filter, fieldType) {
             }
             return matchesFieldType(fieldType, filter.value)
                 ? null
-                : `"${filter.operator}" expects a ${fieldType} value for field "${filter.field}".`;
+                : typeError(filter, fieldType, false);
         case 'like':
             if (fieldType !== 'string' && fieldType !== 'timestamp') {
                 return `"like" is only supported for string or timestamp field "${filter.field}".`;
@@ -57,16 +88,19 @@ export function validateFilterValue(filter, fieldType) {
             if (!Array.isArray(filter.value) || filter.value.length === 0) {
                 return `"${filter.operator}" expects a non-empty array for field "${filter.field}".`;
             }
-            return filter.value.every(value => matchesFieldType(fieldType, value))
-                ? null
-                : `"${filter.operator}" expects ${fieldType} values for field "${filter.field}".`;
+            if (!filter.value.every(value => matchesFieldType(fieldType, value))) {
+                return typeError(filter, fieldType, true);
+            }
+            return filter.operator === 'in' && fieldType === 'timestamp' && mixesInstantsAndLocalTimes(filter.value)
+                ? mixedInstantListError(filter.field)
+                : null;
         case 'between':
             if (!Array.isArray(filter.value) || filter.value.length !== 2) {
                 return `"between" expects a two-item array for field "${filter.field}".`;
             }
             return filter.value.every(value => matchesFieldType(fieldType, value))
                 ? null
-                : `"between" expects ${fieldType} values for field "${filter.field}".`;
+                : typeError(filter, fieldType, true);
         default:
             return `Unsupported semantic filter operator "${String(filter.operator)}".`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypequery/datasets",
-  "version": "0.23.1",
+  "version": "0.25.0",
   "description": "Code-first TypeScript semantic layer for ClickHouse datasets, metrics, multi-tenancy, and AI agents",
   "keywords": [
     "semantic-layer",
@@ -24,6 +24,11 @@
       "import": "./dist/index.js",
       "require": "./dist/index.js"
     },
+    "./schemas": {
+      "types": "./dist/schemas.d.ts",
+      "import": "./dist/schemas.js",
+      "require": "./dist/schemas.js"
+    },
     "./internal": {
       "types": "./dist/internal.d.ts",
       "import": "./dist/internal.js",
@@ -34,27 +39,31 @@
     "*": {
       "internal": [
         "./dist/internal.d.ts"
+      ],
+      "schemas": [
+        "./dist/schemas.d.ts"
       ]
     }
   },
   "license": "Apache-2.0",
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.type-test.*",
+    "!dist/**/__tests__/**",
+    "!dist/**/tests/**",
+    "!dist/**/type-tests/**"
   ],
   "dependencies": {
-    "@hypequery/protocol": "^0.20.0",
-    "@noble/hashes": "^1.8.0",
-    "zod": "^3.22.4",
+    "@hypequery/protocol": "^0.22.0",
+    "@noble/hashes": "^2.4.0",
+    "zod": "^4.6.6",
     "zod-to-json-schema": "^3.25.2"
   },
   "peerDependencies": {
-    "zod": "^3.22.4",
     "@hypequery/clickhouse": ">=2.13.0"
   },
   "peerDependenciesMeta": {
-    "zod": {
-      "optional": true
-    },
     "@hypequery/clickhouse": {
       "optional": true
     }
@@ -62,9 +71,9 @@
   "devDependencies": {
     "@types/node": "^18.19.80",
     "typescript": "^6.0.3",
-    "@vitest/coverage-v8": "^5.0.2",
-    "vitest": "^5.0.2",
-    "@hypequery/protocol-conformance": "^0.15.2"
+    "@vitest/coverage-v8": "^5.0.5",
+    "vitest": "^5.0.5",
+    "@hypequery/protocol-conformance": "^0.16.1"
   },
   "repository": {
     "type": "git",

package/dist/api.type-test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=api.type-test.d.ts.map

package/dist/api.type-test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api.type-test.d.ts","sourceRoot":"","sources":["../src/api.type-test.ts"],"names":[],"mappings":""}

package/dist/api.type-test.js

@@ -1,251 +0,0 @@
-import { add, between, buildCanonicalSemanticQuerySchemas, buildProtocolDeploymentContract, createDatasetClient, dataset, desc, dimension, eq, measure, publishDatasets, publishToCloud, rehydrateProtocolDeploymentContract, } from './index.js';
-const Orders = dataset('orders', {
-    source: 'orders',
-    tenantKey: 'tenant_id',
-    timeKey: 'created_at',
-    dimensions: {
-        id: dimension.string(),
-        tenantId: dimension.string({ column: 'tenant_id' }),
-        status: dimension.string(),
-        amount: dimension.number(),
-        createdAt: dimension.timestamp({ column: 'created_at' }),
-    },
-    measures: {
-        revenue: measure.sum('amount'),
-        completedRevenue: measure.sum('amount', {
-            filters: [eq('status', 'completed')],
-        }),
-        doubledRevenue: measure.derived({
-            uses: { revenue: 'revenue' },
-            formula: ({ revenue }) => add(revenue, revenue),
-        }),
-    },
-});
-const _SegmentedOrders = dataset('segmentedOrders', {
-    source: 'orders',
-    dimensions: { status: dimension.string() },
-    measures: { revenue: measure.sum('amount') },
-    segments: { paid: { filters: [eq('status', 'paid')] } },
-});
-const validDatasetSegments = { segments: ['paid'] };
-const validMetricSegments = { segments: ['paid'] };
-void validDatasetSegments;
-void validMetricSegments;
-// @ts-expect-error only declared segment names are accepted.
-const invalidDatasetSegments = { segments: ['paidd'] };
-// @ts-expect-error only declared segment names are accepted on metric queries.
-const invalidMetricSegments = { segments: ['paidd'] };
-// @ts-expect-error a dataset without segments has no selectable segment names.
-const invalidPlainSegments = { segments: ['paid'] };
-void invalidDatasetSegments;
-void invalidMetricSegments;
-void invalidPlainSegments;
-// @ts-expect-error standalone metrics may only target base measures.
-Orders.metric('invalidDerivedMetric', { measure: 'doubledRevenue' });
-dataset('derivedDependency', {
-    source: 'orders',
-    dimensions: { amount: dimension.number() },
-    measures: {
-        revenue: measure.sum('amount'),
-        doubled: measure.derived({ uses: { value: 'revenue' }, formula: ({ value }) => add(value, value) }),
-        quadrupled: measure.derived({ uses: { value: 'doubled' }, formula: ({ value }) => add(value, value) }),
-    },
-});
-const _WindowOrders = dataset('windowOrders', {
-    source: 'orders', timeKey: 'createdAt',
-    dimensions: { createdAt: dimension.timestamp(), amount: dimension.number() },
-    measures: {
-        revenue: measure.sum('amount'),
-        trailingRevenue: measure.trailing('revenue', { amount: 7, unit: 'day' }),
-        runningRevenue: measure.cumulative('revenue'),
-        growth: measure.derived({ uses: { running: 'runningRevenue' }, formula: ({ running }) => add(running, running) }),
-    },
-});
-// @ts-expect-error standalone metrics may only target base measures, even in the unified registry.
-_WindowOrders.metric('invalidWindowMetric', { measure: 'runningRevenue' });
-dataset('invalidWindowInput', {
-    source: 'orders', timeKey: 'createdAt',
-    dimensions: { createdAt: dimension.timestamp(), amount: dimension.number() },
-    measures: {
-        revenue: measure.sum('amount'),
-        growth: measure.derived({ uses: { value: 'revenue' }, formula: ({ value }) => add(value, value) }),
-        // @ts-expect-error a window must wrap a base measure.
-        invalid: measure.cumulative('growth'),
-    },
-});
-const deploymentContract = buildProtocolDeploymentContract([Orders]);
-rehydrateProtocolDeploymentContract(deploymentContract);
-dataset('invalidDependency', {
-    source: 'orders',
-    dimensions: { amount: dimension.number() },
-    measures: {
-        revenue: measure.sum('amount'),
-        // @ts-expect-error derived inputs must name a base measure on this dataset.
-        typo: measure.derived({ uses: { value: 'reveneu' }, formula: ({ value }) => add(value, value) }),
-    },
-});
-dataset('crossDatasetDependency', {
-    source: 'orders',
-    dimensions: { amount: dimension.number() },
-    measures: {
-        revenue: measure.sum('amount'),
-        // @ts-expect-error qualified references cannot name measures from another dataset.
-        foreign: measure.derived({ uses: { value: 'other.revenue' }, formula: ({ value }) => add(value, value) }),
-    },
-});
-dataset('missingBaseMeasures', {
-    source: 'orders',
-    dimensions: { amount: dimension.number() },
-    measures: {
-        // @ts-expect-error a dataset without base measures cannot define a derived input.
-        invalid: measure.derived({ uses: { value: 'revenue' }, formula: ({ value }) => add(value, value) }),
-    },
-});
-const Customers = dataset('customers', {
-    source: 'customers',
-    dimensions: {
-        id: dimension.string(),
-        status: dimension.string(),
-    },
-    measures: {
-        customerCount: measure.count('id'),
-    },
-});
-const revenueMetric = Orders.metric('revenueMetric', { measure: 'revenue' });
-const completedRevenueMetric = Orders.metric('completedRevenueMetric', { measure: 'completedRevenue' });
-const averageRevenueMetric = Orders.metric('averageRevenueMetric', {
-    uses: { revenue: revenueMetric, completedRevenue: completedRevenueMetric },
-    formula: ({ revenue, completedRevenue }) => add(revenue, completedRevenue),
-});
-const customerCountMetric = Customers.metric('customerCountMetric', { measure: 'customerCount' });
-const _publishedDatasets = publishDatasets()
-    .publish(Orders, { metrics: { revenue: revenueMetric } })
-    .publish(Customers, {
-    alias: 'accounts',
-    metrics: { customers: customerCountMetric },
-})
-    .build();
-const _cloudPublication = publishToCloud({
-    datasets: { Orders, Customers },
-    access: { roles: [], scopes: [] },
-});
-// @ts-expect-error published metrics must belong to the dataset being published.
-publishDatasets().publish(Orders, { metrics: { customerCountMetric } });
-const canonicalSchemas = buildCanonicalSemanticQuerySchemas({
-    orders: { ...Orders, metrics: { revenueMetric } },
-});
-canonicalSchemas.queryDataset.parse({ dataset: 'orders', measures: ['revenue'] });
-const _manifestHash = canonicalSchemas.manifestHash;
-const _statusFilter = eq('status', 'completed');
-const _createdAtRange = between('createdAt', '2025-01-01', '2025-01-31');
-const _revenueSort = desc('revenueMetric');
-Orders.metric('validDerivedMetric', {
-    uses: { revenue: revenueMetric },
-    formula: ({ revenue }) => add(revenue, revenue),
-});
-// @ts-expect-error derived metrics can only use base metrics from the same dataset.
-Orders.metric('invalidCrossDatasetDerivedMetric', {
-    uses: { customerCount: customerCountMetric },
-    formula: () => add('customerCount', 'customerCount'),
-});
-// @ts-expect-error derived metrics can only use base metrics, not derived metric refs.
-Orders.metric('invalidDerivedFromDerivedMetric', {
-    uses: { averageRevenue: averageRevenueMetric },
-    formula: () => add('averageRevenue', 'averageRevenue'),
-});
-const runtimeContext = {
-    runtime: {
-        tenant: 'tenant-1',
-    },
-};
-const abortableContext = {
-    abortSignal: new AbortController().signal,
-};
-void abortableContext;
-const _legacyTenantRuntimeContext = {
-    runtime: {
-        tenant: { id: 'tenant-1' },
-    },
-};
-const _tenantSetRuntimeContext = {
-    runtime: {
-        tenant: { in: ['tenant-1', 'tenant-2'] },
-    },
-};
-const _crossTenantRuntimeContext = {
-    runtime: {
-        tenant: { scope: 'all' },
-    },
-};
-const builderFactory = {
-    table: () => ({
-        select: () => builderFactory.table('orders'),
-        sum: () => builderFactory.table('orders'),
-        count: () => builderFactory.table('orders'),
-        countDistinct: () => builderFactory.table('orders'),
-        avg: () => builderFactory.table('orders'),
-        min: () => builderFactory.table('orders'),
-        max: () => builderFactory.table('orders'),
-        argMax: () => builderFactory.table('orders'),
-        argMin: () => builderFactory.table('orders'),
-        quantile: () => builderFactory.table('orders'),
-        stddev: () => builderFactory.table('orders'),
-        variance: () => builderFactory.table('orders'),
-        where: () => builderFactory.table('orders'),
-        leftJoin: () => builderFactory.table('orders'),
-        groupBy: () => builderFactory.table('orders'),
-        orderBy: () => builderFactory.table('orders'),
-        limit: () => builderFactory.table('orders'),
-        offset: () => builderFactory.table('orders'),
-        toSQLWithParams: () => ({ sql: 'SELECT 1', parameters: [] }),
-        execute: async () => [],
-    }),
-    rawQuery: async () => [],
-};
-const analytics = createDatasetClient({ queryBuilder: builderFactory });
-const _datasetCompilation = analytics.compileDataset(Orders, { measures: ['doubledRevenue'] });
-// @ts-expect-error compilation accepts declared dataset measures only.
-analytics.compileDataset(Orders, { measures: ['missing'] });
-// @ts-expect-error compilation accepts declared dataset dimensions only.
-analytics.compileDataset(Orders, { dimensions: ['missing'] });
-// @ts-expect-error standalone metric handles are not dataset compilation targets.
-analytics.compileDataset(Orders.metric('revenue', { measure: 'revenue' }));
-const explicitAnalytics = analytics;
-const datasetQuery = { dimensions: ['status'], measures: ['revenue'] };
-analytics.validate(revenueMetric, { dimensions: ['status'] }, runtimeContext);
-analytics.toSQL(completedRevenueMetric, { dimensions: ['status'] }, runtimeContext);
-analytics.toSQL(revenueMetric, { orderBy: [desc('revenueMetric')] }, runtimeContext);
-analytics.validate(Orders, datasetQuery, runtimeContext);
-analytics.toSQL(Orders, datasetQuery, runtimeContext);
-void analytics.execute(Orders, datasetQuery, runtimeContext);
-void runtimeContext;
-void explicitAnalytics;
-// Sanity: the simulated shape reproduces the original incompatibility.
-// @ts-expect-error a schema-typed builder does not satisfy the strict protocol
-const strictRejection = simulatedTypedFactory;
-const typedAccepted = simulatedTypedFactory;
-const typedClient = createDatasetClient({ queryBuilder: simulatedTypedFactory });
-const typedRuntime = { runtime: { builderFactory: simulatedTypedFactory } };
-// @ts-expect-error non-builder objects are still rejected
-const rejectedFactory = { notABuilder: true };
-void strictRejection;
-void typedAccepted;
-void typedClient;
-void typedRuntime;
-void rejectedFactory;
-// ---------------------------------------------------------------------------
-// Portable execution exclusions carry a named reason (HQ-45)
-// ---------------------------------------------------------------------------
-import { PortableExecutionUnsupportedError as PortableUnsupported, UNSUPPORTED_CONTRACT_REASONS as REASONS, UnsupportedContractFeatureError as ContractFeatureError, } from './index.js';
-const namedReason = REASONS.ambiguousMeasureSql;
-const literalReason = 'HQ_PORTABLE_DATASET_NOT_ACTIVATED';
-// @ts-expect-error an unnamed reason is not an exclusion
-const unnamedReason = 'HQ_PORTABLE_SOMETHING_ELSE';
-const featureReason = new ContractFeatureError('orders', 'metric', 'detail', namedReason).reason;
-// The three-argument constructor stays valid for existing callers.
-const legacyFeatureError = new ContractFeatureError('orders', 'metric', 'detail');
-const executionReason = new PortableUnsupported('message', { reason: literalReason }).reason;
-void unnamedReason;
-void featureReason;
-void legacyFeatureError;
-void executionReason;

package/dist/utils/time-arithmetic-sql.d.ts

@@ -1,4 +0,0 @@
-import type { TimeGrain } from '../types.js';
-export declare function addTimeSql(time: string, amount: string | number, grain: TimeGrain): string;
-export declare function subtractTimeSql(time: string, amount: number, grain: TimeGrain): string;
-//# sourceMappingURL=time-arithmetic-sql.d.ts.map

package/dist/utils/time-arithmetic-sql.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"time-arithmetic-sql.d.ts","sourceRoot":"","sources":["../../src/utils/time-arithmetic-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAM7C,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAE1F;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAEtF"}

package/dist/utils/time-arithmetic-sql.js

@@ -1,9 +0,0 @@
-const INTERVAL_FUNCTIONS = {
-    minute: 'Minutes', hour: 'Hours', day: 'Days', week: 'Weeks', month: 'Months', quarter: 'Quarters', year: 'Years',
-};
-export function addTimeSql(time, amount, grain) {
-    return `add${INTERVAL_FUNCTIONS[grain]}(${time}, ${amount})`;
-}
-export function subtractTimeSql(time, amount, grain) {
-    return `subtract${INTERVAL_FUNCTIONS[grain]}(${time}, ${amount})`;
-}

package/dist/utils/window-aggregation-sql.d.ts

@@ -1,5 +0,0 @@
-import type { MeasureDefinition } from '../types.js';
-/** NULL for an empty non-count population, including nullable measure inputs. */
-export declare function windowAggregateSql(definition: MeasureDefinition, value: string, arg: string): string;
-export declare function isCountAggregation(definition: MeasureDefinition): boolean;
-//# sourceMappingURL=window-aggregation-sql.d.ts.map

package/dist/utils/window-aggregation-sql.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"window-aggregation-sql.d.ts","sourceRoot":"","sources":["../../src/utils/window-aggregation-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,iFAAiF;AACjF,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAYpG;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,GAAG,OAAO,CAEzE"}

package/dist/utils/window-aggregation-sql.js

@@ -1,17 +0,0 @@
-/** NULL for an empty non-count population, including nullable measure inputs. */
-export function windowAggregateSql(definition, value, arg) {
-    switch (definition.aggregation) {
-        case 'count': return `count(${value})`;
-        case 'countDistinct': return `uniqExact(${value})`;
-        case 'approxCountDistinct': return `uniq(${value})`;
-        case 'percentile': return `quantileOrNull(${definition.level})(${value})`;
-        case 'argMax': return `argMaxOrNull(${value}, ${arg})`;
-        case 'argMin': return `argMinOrNull(${value}, ${arg})`;
-        case 'stddev': return `stddevSampOrNull(${value})`;
-        case 'variance': return `varSampOrNull(${value})`;
-        default: return `${definition.aggregation}OrNull(${value})`;
-    }
-}
-export function isCountAggregation(definition) {
-    return ['count', 'countDistinct', 'approxCountDistinct'].includes(definition.aggregation);
-}