@hypequery/datasets 0.1.0 → 0.2.1

package/dist/executor.js

@@ -1,34 +1,37 @@
 /**
- * MetricExecutor — resolves metrics to SQL and executes them.
+ * Semantic dataset client internals.
  *
- * Supports two modes:
- * 1. **Query builder** (recommended) — pass a `QueryBuilderFactoryLike` and the
- *    executor builds queries via the builder's fluent API, then calls `.execute()`.
- * 2. **Raw adapter** (deprecated) — pass a `MetricAdapter` with a `rawQuery` function
- *    and the executor generates SQL strings manually.
- *
- * The executor stays DB-agnostic via duck-typed protocol interfaces.
+ * Public callers use `createDatasetClient(...).execute(...)`. The implementation
+ * stays database-agnostic via query-builder and backend protocol interfaces.
  */
 import { validateSQLIdentifier } from './sql-utils.js';
+import { SUPPORTED_TIME_GRAINS, isSupportedTimeGrain } from './constants.js';
 import { validateFilterValue } from './validation.js';
 import { applyAggregationSpec, appendOrderLimitOffset, buildDimensionSelectionPlan, resolveFilterField, resolveTenantFilterColumn, } from './query-planner.js';
-// =============================================================================
-// VALIDATION
-// =============================================================================
-function validateQuery(metric, query) {
+import { assertMetricHandle, getMetricGrain, getMetricRef, isTenantScopedFilter, } from './utils/metric-handle.js';
+import { validateDerivedCteGrouping } from './utils/derived-cte-validation.js';
+import { buildDatasetQueryBuilder, runDatasetQuery, validateDatasetQuery, } from './dataset-query.js';
+import { buildDatasetPlan, buildMetricPlan, } from './semantic-planner.js';
+import { getRuntimeTenantId, getRuntimeTenantPredicate, validateTenantRuntime, } from './utils/tenant-runtime.js';
+import { applyPagination, overfetchLimit } from './utils/pagination.js';
+function validateQuery(metric, query, context) {
     const errors = [];
-    const ref = metric.__type === 'grained_metric_ref' ? metric.metric : metric;
+    const ref = getMetricRef(metric);
     const ds = ref.dataset;
     const dimensionNames = Object.keys(ds.dimensions);
     const filterNames = Object.keys(ds.filters).length > 0
         ? Object.keys(ds.filters)
         : dimensionNames;
-    const grain = metric.__type === 'grained_metric_ref' ? metric.grain : query.by;
+    const grain = getMetricGrain(metric, query);
     const orderableFields = new Set([
         ...(query.dimensions ?? []),
         ref.name,
         ...(grain ? ['period'] : []),
     ]);
+    const tenantRuntimeError = validateTenantRuntime(ds, context);
+    if (tenantRuntimeError) {
+        errors.push(tenantRuntimeError);
+    }
     if (metric.__type === 'grained_metric_ref' && query.by && query.by !== metric.grain) {
         errors.push(`Metric "${ref.name}" is already grained by "${metric.grain}" and cannot be queried with by="${query.by}".`);
     }
@@ -50,6 +53,10 @@ function validateQuery(metric, query) {
             continue;
         }
         const resolvedField = ds.filters[filter.field]?.field ?? filter.field;
+        if (isTenantScopedFilter(ds, filter, context)) {
+            errors.push(`Cannot filter on tenant field "${filter.field}" when runtime tenancy enforcement is active.`);
+            continue;
+        }
         const fieldType = ds.dimensions[resolvedField]?.fieldType;
         if (fieldType) {
             const filterError = validateFilterValue(filter, fieldType);
@@ -68,6 +75,16 @@ function validateQuery(metric, query) {
     if (query.by && !ds.timeKey) {
         errors.push(`Cannot use "by" grain — dataset "${ds.name}" has no timeKey.`);
     }
+    // Validate grain is one the planner can bucket on
+    if (query.by && !isSupportedTimeGrain(query.by)) {
+        errors.push(`Unsupported time grain "${query.by}". Supported: ${SUPPORTED_TIME_GRAINS.join(', ')}`);
+    }
+    if (query.limit != null && (!Number.isInteger(query.limit) || query.limit < 0)) {
+        errors.push(`Invalid limit: expected a non-negative integer.`);
+    }
+    if (query.offset != null && (!Number.isInteger(query.offset) || query.offset < 0)) {
+        errors.push(`Invalid offset: expected a non-negative integer.`);
+    }
     // Validate limits
     if (ds.limits) {
         if (ds.limits.maxDimensions && (query.dimensions?.length ?? 0) > ds.limits.maxDimensions) {
@@ -79,10 +96,16 @@ function validateQuery(metric, query) {
         if (ds.limits.maxFilters && (query.filters?.length ?? 0) > ds.limits.maxFilters) {
             errors.push(`Too many filters (${query.filters?.length}). Max: ${ds.limits.maxFilters}`);
         }
+        if (ds.limits.maxResultSize && query.limit != null && query.limit > ds.limits.maxResultSize) {
+            errors.push(`Too many results requested (${query.limit}). Max: ${ds.limits.maxResultSize}`);
+        }
     }
     return { valid: errors.length === 0, errors };
 }
-export class MetricExecutor {
+function isDatasetInstance(target) {
+    return !!target && typeof target === 'object' && '__type' in target && target.__type === 'dataset';
+}
+export class MetricQueryEngine {
     builderFactory;
     constructor(options) {
         this.builderFactory = options.builderFactory;
@@ -94,7 +117,8 @@ export class MetricExecutor {
      * Execute a metric query. Generates SQL, applies tenant/filter context, executes.
      */
     async run(metric, query = {}, context) {
-        const validation = this.validate(metric, query);
+        assertMetricHandle(metric);
+        const validation = this.validate(metric, query, context);
         if (!validation.valid) {
             throw new Error(`Invalid metric query: ${validation.errors.join('; ')}`);
         }
@@ -105,8 +129,13 @@ export class MetricExecutor {
      * Generate SQL without executing.
      */
     toSQL(metric, query = {}, context) {
-        const ref = metric.__type === 'grained_metric_ref' ? metric.metric : metric;
-        const grain = metric.__type === 'grained_metric_ref' ? metric.grain : query.by ?? undefined;
+        assertMetricHandle(metric);
+        const validation = this.validate(metric, query, context);
+        if (!validation.valid) {
+            throw new Error(`Invalid metric query: ${validation.errors.join('; ')}`);
+        }
+        const ref = getMetricRef(metric);
+        const grain = getMetricGrain(metric, query);
         const spec = ref.spec;
         if (spec.__type === 'derived_metric_spec') {
             return this.buildDerivedSQLViaBuilder(ref, spec, query, grain, context).sql;
@@ -117,30 +146,55 @@ export class MetricExecutor {
     /**
      * Validate a metric query against the metric's contract.
      */
-    validate(metric, query) {
-        return validateQuery(metric, query);
+    validate(metric, query, context) {
+        assertMetricHandle(metric);
+        const queryValidation = validateQuery(metric, query, context);
+        if (!queryValidation.valid) {
+            return queryValidation;
+        }
+        const ref = getMetricRef(metric);
+        const grain = getMetricGrain(metric, query);
+        try {
+            if (ref.spec.__type === 'derived_metric_spec') {
+                this.buildDerivedSQLViaBuilder(ref, ref.spec, query, grain, context);
+            }
+            else {
+                this.buildBaseQuery(ref, ref.spec, ref.dataset, query, grain, context).toSQLWithParams();
+            }
+        }
+        catch (error) {
+            return {
+                valid: false,
+                errors: [error instanceof Error ? error.message : String(error)],
+            };
+        }
+        return queryValidation;
     }
     // ---------------------------------------------------------------------------
     // Query builder path
     // ---------------------------------------------------------------------------
     async runViaBuilder(metric, query, context, start) {
-        const ref = metric.__type === 'grained_metric_ref' ? metric.metric : metric;
-        const grain = metric.__type === 'grained_metric_ref' ? metric.grain : query.by ?? undefined;
+        const ref = getMetricRef(metric);
+        const grain = getMetricGrain(metric, query);
         const spec = ref.spec;
         const activeBuilderFactory = context?.runtime?.builderFactory ?? this.builderFactory;
+        // Over-fetch one row so we can report `hasMore` without a count query.
+        const buildQuery = { ...query, limit: overfetchLimit(query.limit) };
         if (spec.__type === 'derived_metric_spec') {
             // Derived metrics: build CTE via builder, outer query via string, execute via rawQuery
-            const { sql, params } = this.buildDerivedSQLViaBuilder(ref, spec, query, grain, context);
-            const data = await activeBuilderFactory.rawQuery(sql, params);
+            const { sql, params } = this.buildDerivedSQLViaBuilder(ref, spec, buildQuery, grain, context);
+            const rows = await activeBuilderFactory.rawQuery(sql, params);
             const timingMs = Date.now() - start;
-            return { data, meta: { sql, timingMs, tenant: context?.runtime?.tenant?.id } };
+            const { data, pagination } = applyPagination(rows, query.limit, query.offset);
+            return { data, meta: { sql, timingMs, tenant: getRuntimeTenantId(context), rowCount: data.length, pagination } };
         }
         // Base metrics: fully use the builder's execute()
-        const builder = this.buildBaseQuery(ref, spec, ref.dataset, query, grain, context);
+        const builder = this.buildBaseQuery(ref, spec, ref.dataset, buildQuery, grain, context);
         const { sql } = builder.toSQLWithParams();
-        const data = await builder.execute();
+        const rows = await builder.execute();
         const timingMs = Date.now() - start;
-        return { data, meta: { sql, timingMs, tenant: context?.runtime?.tenant?.id } };
+        const { data, pagination } = applyPagination(rows, query.limit, query.offset);
+        return { data, meta: { sql, timingMs, tenant: getRuntimeTenantId(context), rowCount: data.length, pagination } };
     }
     buildBaseQuery(ref, spec, ds, query, grain, context) {
         const activeBuilderFactory = context?.runtime?.builderFactory ?? this.builderFactory;
@@ -157,13 +211,15 @@ export class MetricExecutor {
         }
         // Tenant auto-injection
         const tenantColumn = resolveTenantFilterColumn(ds, context);
-        const tenantId = context?.runtime?.tenant?.id;
-        const tenantHandledByBuilder = context?.runtime?.tenant?.handledByBuilder === true;
-        if (tenantId && tenantColumn && !tenantHandledByBuilder) {
-            qb = qb.where(tenantColumn, 'eq', tenantId);
+        const tenantPredicate = getRuntimeTenantPredicate(context);
+        if (tenantPredicate && tenantColumn) {
+            qb = qb.where(tenantColumn, tenantPredicate.operator, tenantPredicate.value);
         }
         // User filters
         for (const filter of query.filters ?? []) {
+            if (isTenantScopedFilter(ds, filter, context)) {
+                throw new Error(`Cannot filter on tenant field "${filter.field}" when runtime tenancy enforcement is active.`);
+            }
             const resolvedField = resolveFilterField(ds, filter.field);
             qb = qb.where(resolvedField, filter.operator, filter.value);
         }
@@ -182,6 +238,7 @@ export class MetricExecutor {
         }
         // Base aggregations
         const refAliases = {};
+        const aggregateAliases = [];
         for (const [alias, baseMetric] of Object.entries(spec.uses)) {
             const baseSpec = baseMetric.spec;
             if (baseSpec.__type !== 'aggregation_spec') {
@@ -189,22 +246,29 @@ export class MetricExecutor {
             }
             cteBuilder = applyAggregationSpec(cteBuilder, ds, baseSpec, alias);
             refAliases[alias] = alias;
+            aggregateAliases.push(alias);
         }
         if (groupByParts.length > 0) {
             cteBuilder = cteBuilder.groupBy(groupByParts);
         }
         // Filters on CTE
         const tenantColumn = resolveTenantFilterColumn(ds, context);
-        const tenantId = context?.runtime?.tenant?.id;
-        const tenantHandledByBuilder = context?.runtime?.tenant?.handledByBuilder === true;
-        if (tenantId && tenantColumn && !tenantHandledByBuilder) {
-            cteBuilder = cteBuilder.where(tenantColumn, 'eq', tenantId);
+        const tenantPredicate = getRuntimeTenantPredicate(context);
+        if (tenantPredicate && tenantColumn) {
+            cteBuilder = cteBuilder.where(tenantColumn, tenantPredicate.operator, tenantPredicate.value);
         }
         for (const filter of query.filters ?? []) {
+            if (isTenantScopedFilter(ds, filter, context)) {
+                throw new Error(`Cannot filter on tenant field "${filter.field}" when runtime tenancy enforcement is active.`);
+            }
             const resolvedField = resolveFilterField(ds, filter.field);
             cteBuilder = cteBuilder.where(resolvedField, filter.operator, filter.value);
         }
         const { sql: cteSql, parameters: cteParams } = cteBuilder.toSQLWithParams();
+        const groupingErrors = validateDerivedCteGrouping(cteSql, aggregateAliases, groupByParts);
+        if (groupingErrors.length > 0) {
+            throw new Error(groupingErrors.join('; '));
+        }
         // Outer query: trivial SELECT from the CTE — stays as string concat
         // because table('base') would fail schema typing
         const outerSelectParts = [];
@@ -242,3 +306,91 @@ export class MetricExecutor {
         return { sql, params: cteParams };
     }
 }
+export class DatasetClientImpl extends MetricQueryEngine {
+    backend;
+    constructor(options) {
+        if (!options.queryBuilder && !options.backend) {
+            throw new Error('createDatasetClient requires either queryBuilder or backend.');
+        }
+        super({
+            builderFactory: options.queryBuilder ?? {
+                table() {
+                    throw new Error('This dataset client was created with a semantic backend, not a query builder.');
+                },
+                async rawQuery() {
+                    throw new Error('This dataset client was created with a semantic backend, not a query builder.');
+                },
+            },
+        });
+        this.backend = options.backend;
+    }
+    planMetric(metric, query = {}, context) {
+        assertMetricHandle(metric);
+        const validation = validateQuery(metric, query, context);
+        if (!validation.valid) {
+            throw new Error(`Invalid metric query: ${validation.errors.join('; ')}`);
+        }
+        return buildMetricPlan(metric, query, context);
+    }
+    planDataset(ds, query = {}, context) {
+        return buildDatasetPlan(ds, query, context);
+    }
+    /**
+     * Execute a semantic target.
+     */
+    execute(target, query = {}, context) {
+        if (isDatasetInstance(target)) {
+            return this.executeDataset(target, query, context);
+        }
+        return this.executeMetric(target, query, context);
+    }
+    toSQL(target, query = {}, context) {
+        if (isDatasetInstance(target)) {
+            return this.toDatasetSQL(target, query, context);
+        }
+        return super.toSQL(target, query, context);
+    }
+    validate(target, query = {}, context) {
+        if (isDatasetInstance(target)) {
+            return validateDatasetQuery(target, query, context);
+        }
+        return super.validate(target, query, context);
+    }
+    executeMetric(metric, query, context) {
+        if (this.backend) {
+            const validation = validateQuery(metric, query, context);
+            if (!validation.valid) {
+                throw new Error(`Invalid metric query: ${validation.errors.join('; ')}`);
+            }
+            return this.backend.execute(this.planMetric(metric, query, context));
+        }
+        return this.run(metric, query, context);
+    }
+    executeDataset(ds, query, context) {
+        if (this.backend) {
+            const validation = this.validate(ds, query, context);
+            if (!validation.valid) {
+                throw new Error(`Invalid dataset query: ${validation.errors.join('; ')}`);
+            }
+            return this.backend.execute(this.planDataset(ds, query, context));
+        }
+        const validation = this.validate(ds, query, context);
+        if (!validation.valid) {
+            throw new Error(`Invalid dataset query: ${validation.errors.join('; ')}`);
+        }
+        return runDatasetQuery(ds, query, {
+            builderFactory: context?.runtime?.builderFactory ?? this.getBuilderFactory(),
+            context,
+        });
+    }
+    toDatasetSQL(ds, query, context) {
+        const builder = buildDatasetQueryBuilder(ds, query, {
+            builderFactory: context?.runtime?.builderFactory ?? this.getBuilderFactory(),
+            context,
+        });
+        return builder.toSQLWithParams().sql;
+    }
+}
+export function createDatasetClient(options) {
+    return new DatasetClientImpl(options);
+}

package/dist/formulas.d.ts

@@ -2,7 +2,7 @@
  * Formula helpers for derived metrics.
  *
  * These are symbolic — they build FormulaExpr objects that get compiled to SQL
- * by the MetricExecutor. They do not produce raw SQL strings directly.
+ * by the semantic query engine. They do not produce raw SQL strings directly.
  *
  * @example
  * ```ts

package/dist/formulas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formulas.d.ts","sourceRoot":"","sources":["../src/formulas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAgB9C,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAEpF;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAEtF;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAEtF;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAEjF;AAMD,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAE/D;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,GAAG,WAAW,CAGtG;AAMD,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,QAAQ,GAAE,MAAU,GAAG,WAAW,CAEhF;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAE1D;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAEzD"}
+{"version":3,"file":"formulas.d.ts","sourceRoot":"","sources":["../src/formulas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAkC9C,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAKpF;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAKtF;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAKtF;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAKjF;AAMD,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAK/D;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,GAAG,WAAW,CAMtG;AAMD,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,QAAQ,GAAE,MAAU,GAAG,WAAW,CAKhF;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAK1D;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAKzD"}

package/dist/formulas.js

@@ -2,7 +2,7 @@
  * Formula helpers for derived metrics.
  *
  * These are symbolic — they build FormulaExpr objects that get compiled to SQL
- * by the MetricExecutor. They do not produce raw SQL strings directly.
+ * by the semantic query engine. They do not produce raw SQL strings directly.
  *
  * @example
  * ```ts
@@ -12,8 +12,8 @@
  * });
  * ```
  */
-function expr(sqlFn) {
-    return { __type: 'formula_expr', toSQL: sqlFn };
+function expr(expression, sqlFn) {
+    return { __type: 'formula_expr', expression, toSQL: sqlFn };
 }
 /** Check if a value is a FormulaExpr. */
 function resolveArg(a) {
@@ -21,40 +21,55 @@ function resolveArg(a) {
         return a;
     return a.toSQL();
 }
+function isFormulaExpr(value) {
+    return typeof value === 'object'
+        && value !== null
+        && '__type' in value
+        && value.__type === 'formula_expr';
+}
+function resolveExpression(a) {
+    if (isFormulaExpr(a)) {
+        return a.expression;
+    }
+    if (typeof a === 'string') {
+        return { kind: 'ref', name: a };
+    }
+    return { kind: 'literal', value: a };
+}
 // ---------------------------------------------------------------------------
 // Arithmetic
 // ---------------------------------------------------------------------------
 export function divide(a, b) {
-    return expr(() => `(${resolveArg(a)}) / (${resolveArg(b)})`);
+    return expr({ kind: 'binary', operator: 'divide', left: resolveExpression(a), right: resolveExpression(b) }, () => `(${resolveArg(a)}) / (${resolveArg(b)})`);
 }
 export function multiply(a, b) {
-    return expr(() => `(${resolveArg(a)}) * (${resolveArg(b)})`);
+    return expr({ kind: 'binary', operator: 'multiply', left: resolveExpression(a), right: resolveExpression(b) }, () => `(${resolveArg(a)}) * (${resolveArg(b)})`);
 }
 export function subtract(a, b) {
-    return expr(() => `(${resolveArg(a)}) - (${resolveArg(b)})`);
+    return expr({ kind: 'binary', operator: 'subtract', left: resolveExpression(a), right: resolveExpression(b) }, () => `(${resolveArg(a)}) - (${resolveArg(b)})`);
 }
 export function add(a, b) {
-    return expr(() => `(${resolveArg(a)}) + (${resolveArg(b)})`);
+    return expr({ kind: 'binary', operator: 'add', left: resolveExpression(a), right: resolveExpression(b) }, () => `(${resolveArg(a)}) + (${resolveArg(b)})`);
 }
 // ---------------------------------------------------------------------------
 // Null handling
 // ---------------------------------------------------------------------------
 export function nullIfZero(a) {
-    return expr(() => `NULLIF(${resolveArg(a)}, 0)`);
+    return expr({ kind: 'function', name: 'nullIfZero', args: [resolveExpression(a)] }, () => `NULLIF(${resolveArg(a)}, 0)`);
 }
 export function coalesce(a, fallback) {
     const fb = typeof fallback === 'number' ? String(fallback) : resolveArg(fallback);
-    return expr(() => `COALESCE(${resolveArg(a)}, ${fb})`);
+    return expr({ kind: 'function', name: 'coalesce', args: [resolveExpression(a), resolveExpression(fallback)] }, () => `COALESCE(${resolveArg(a)}, ${fb})`);
 }
 // ---------------------------------------------------------------------------
 // Rounding
 // ---------------------------------------------------------------------------
 export function round(a, decimals = 0) {
-    return expr(() => `ROUND(${resolveArg(a)}, ${decimals})`);
+    return expr({ kind: 'function', name: 'round', args: [resolveExpression(a), resolveExpression(decimals)] }, () => `ROUND(${resolveArg(a)}, ${decimals})`);
 }
 export function floor(a) {
-    return expr(() => `FLOOR(${resolveArg(a)})`);
+    return expr({ kind: 'function', name: 'floor', args: [resolveExpression(a)] }, () => `FLOOR(${resolveArg(a)})`);
 }
 export function ceil(a) {
-    return expr(() => `CEIL(${resolveArg(a)})`);
+    return expr({ kind: 'function', name: 'ceil', args: [resolveExpression(a)] }, () => `CEIL(${resolveArg(a)})`);
 }

package/dist/in-memory-backend.d.ts

@@ -0,0 +1,5 @@
+import type { SemanticBackend } from './semantic-plan.js';
+export type InMemoryTable = Array<Record<string, unknown>>;
+export type InMemoryTables = Record<string, InMemoryTable>;
+export declare function createInMemoryBackend(tables: InMemoryTables): SemanticBackend;
+//# sourceMappingURL=in-memory-backend.d.ts.map

package/dist/in-memory-backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-backend.d.ts","sourceRoot":"","sources":["../src/in-memory-backend.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAGV,eAAe,EAIhB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,aAAa,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAC3D,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AA2K3D,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,GAAG,eAAe,CAmE7E"}