@uptimizr/db 0.8.2 → 1.0.1

package/dist/query/mssqlDialect.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Microsoft SQL Server (T-SQL) dialect for the query layer (ADR 0020, #85).
+ *
+ * SQL Server is the optional single-tenant *relational* store for self-hosters
+ * standardized on SQL Server / Azure SQL: a multi-writer server, so several
+ * collector instances can share one database. Like the Postgres dialect it is a
+ * *re-home + dialect emitter* — every aggregation stays authored once in
+ * `aggregations.ts` — but it is the heaviest relational port, because T-SQL
+ * lacks three things the shared SQL takes for granted:
+ *
+ * 1. **No array type.** Vector columns (`position`, `direction`, `hit_point`,
+ *    `ray_origin`, `ray_direction`, `screen`, `rotation`, `scale`) are stored
+ *    as JSON number arrays (`'[x,y,z]'`, `nvarchar`). Every element access goes
+ *    through {@link mssqlVectorElement} (`JSON_VALUE(col, '$[i]')` +
+ *    `TRY_CONVERT(float)`), including the shared SQL's inline `position[1]`
+ *    indexing, which {@link toTsql} rewrites — this is the single place where
+ *    the JSON-vector representation is known. `vectorNorm` and `arrayLength`
+ *    are built over the same representation.
+ * 2. **No `ASOF JOIN`.** `asofJoin` renders the shared nearest-row emulation
+ *    (`renderNearestRowJoin`, `relational.ts`) as `CROSS APPLY` / `OUTER APPLY
+ *    (SELECT TOP 1 … ORDER BY ts DESC)`.
+ * 3. **No aggregate percentile.** T-SQL's `PERCENTILE_CONT` is a *window*
+ *    function only, so it cannot appear in a `GROUP BY` select list next to
+ *    `avg`/`count`. `quantile` therefore packs the group's values with
+ *    `STRING_AGG` — a real aggregate — and a small T-SQL scalar function
+ *    (`dbo.uptimizr_quantile`, created by the `@uptimizr/db-mssql` migrations)
+ *    sorts them and computes the type-7 linear interpolation DuckDB's
+ *    `quantile_cont` / Postgres' `percentile_cont` use. Exact, O(n log n) per
+ *    group; documented as the store's performance trade-off.
+ *
+ * Two further T-SQL syntax gaps are closed by {@link toTsql} rather than by the
+ * `Dialect` members, because the shared SQL cannot express them portably:
+ * `LIMIT n` (→ `OFFSET 0 ROWS FETCH NEXT n ROWS ONLY`) and `GROUP BY <select
+ * alias>`, which T-SQL rejects (`Invalid column name`) and is replaced by the
+ * alias's defining expression. `toTsql` is applied once, at execution time, by
+ * `runMssqlQuery` in `@uptimizr/db-mssql`.
+ *
+ * Other notes:
+ * - `epochMs` / `timeBucketMs` return `float` (exact for epoch milliseconds,
+ *   which are far below 2^53). `bigint` would come back as a *string* from the
+ *   TDS driver and `avg(bigint)` truncates in T-SQL; `float` avoids both.
+ * - Integer `avg` truncates in T-SQL, so `avgIf` / `avgMerge` / `quantile`
+ *   cast their input to `float`; the promoted numeric columns are `float`
+ *   already.
+ * - String columns use the binary collation {@link MSSQL_BIN_COLLATION}, so
+ *   equality, `GROUP BY` and ordering are case-sensitive and code-point ordered
+ *   exactly like DuckDB / Postgres; JSON extractions carry the same collation.
+ * - Parameters are emitted as named `$name` tokens (cast in place for `f64`,
+ *   `timestamp`, `date`) and rewritten to positional `@p1…@pn` by the shared
+ *   `toPositionalParams`; timestamp params are bound as ISO-8601 `T`-separated
+ *   naive-UTC strings (language/`DATEFORMAT`-independent) against
+ *   `datetime2(3)` columns.
+ * - Requires SQL Server 2022 (16.x) / Azure SQL: `GREATEST` / `LEAST` (2022),
+ *   `STRING_AGG` / `STRING_SPLIT` / `JSON_VALUE` / `DATEDIFF_BIG` (2016+).
+ */
+import type { Dialect } from "./dialect.js";
+import { type NearestRowJoinTokens } from "./relational.js";
+/**
+ * Format an epoch-millisecond timestamp as an ISO-8601 naive-UTC
+ * `YYYY-MM-DDTHH:MM:SS.mmm` string for binding to a `datetime2(3)` column /
+ * parameter. The `T` separator makes the literal language- and
+ * `SET DATEFORMAT`-independent; the wall-clock value is the same one the DuckDB
+ * / ClickHouse / Postgres stores bind.
+ */
+export declare function toMssqlTimestamp(epochMs: number): string;
+/** Join keywords for the SQL Server flavour of the nearest-row ASOF emulation. */
+export declare const MSSQL_NEAREST_ROW_JOIN: NearestRowJoinTokens;
+/**
+ * Binary (case-sensitive, code-point ordered) collation applied to every string
+ * column and JSON extraction, so string semantics match DuckDB / Postgres
+ * instead of SQL Server's case-insensitive default.
+ */
+export declare const MSSQL_BIN_COLLATION = "Latin1_General_100_BIN2";
+/** Schema-qualified name of the quantile helper function (see module doc). */
+export declare const MSSQL_QUANTILE_FUNCTION = "dbo.uptimizr_quantile";
+/**
+ * The `index0`-th (0-based) element of a JSON number array as `float`, or NULL
+ * when the array is shorter / the value is not numeric. The one place that
+ * knows vectors are JSON on SQL Server (see module doc).
+ */
+export declare function mssqlVectorElement(expr: string, index0: number): string;
+export declare const mssqlDialect: Dialect;
+/**
+ * Rewrite a query rendered with {@link mssqlDialect} into T-SQL. Three
+ * constructs of the shared SQL are not T-SQL and cannot be expressed through a
+ * `Dialect` member without touching every aggregation:
+ *
+ * - `col[n]` (1-based vector indexing) → {@link mssqlVectorElement}`(col, n-1)`.
+ * - `LIMIT n` → `OFFSET 0 ROWS FETCH NEXT n ROWS ONLY` (T-SQL requires an
+ *   `ORDER BY`, which every `LIMIT` in the shared SQL has).
+ * - `GROUP BY <alias>` → the alias's select-list expression (T-SQL: "Invalid
+ *   column name"). Both DuckDB and Postgres accept output-column aliases in
+ *   `GROUP BY`; T-SQL only accepts input columns and expressions.
+ *
+ * Plus the spelling difference `atan2` → `ATN2`. Pure and idempotent; applied
+ * once per query by `runMssqlQuery`.
+ */
+export declare function toTsql(sql: string): string;
+//# sourceMappingURL=mssqlDialect.d.ts.map

package/dist/query/mssqlDialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mssqlDialect.d.ts","sourceRoot":"","sources":["../../src/query/mssqlDialect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAa,MAAM,cAAc,CAAC;AACvD,OAAO,EAAwB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAElF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAOxD;AAED,kFAAkF;AAClF,eAAO,MAAM,sBAAsB,EAAE,oBAMpC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,4BAA4B,CAAC;AAE7D,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB,0BAA0B,CAAC;AAK/D;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEvE;AA0BD,eAAO,MAAM,YAAY,EAAE,OA4F1B,CAAC;AAgBF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO1C"}

package/dist/query/mssqlDialect.js

@@ -0,0 +1,398 @@
+/**
+ * Microsoft SQL Server (T-SQL) dialect for the query layer (ADR 0020, #85).
+ *
+ * SQL Server is the optional single-tenant *relational* store for self-hosters
+ * standardized on SQL Server / Azure SQL: a multi-writer server, so several
+ * collector instances can share one database. Like the Postgres dialect it is a
+ * *re-home + dialect emitter* — every aggregation stays authored once in
+ * `aggregations.ts` — but it is the heaviest relational port, because T-SQL
+ * lacks three things the shared SQL takes for granted:
+ *
+ * 1. **No array type.** Vector columns (`position`, `direction`, `hit_point`,
+ *    `ray_origin`, `ray_direction`, `screen`, `rotation`, `scale`) are stored
+ *    as JSON number arrays (`'[x,y,z]'`, `nvarchar`). Every element access goes
+ *    through {@link mssqlVectorElement} (`JSON_VALUE(col, '$[i]')` +
+ *    `TRY_CONVERT(float)`), including the shared SQL's inline `position[1]`
+ *    indexing, which {@link toTsql} rewrites — this is the single place where
+ *    the JSON-vector representation is known. `vectorNorm` and `arrayLength`
+ *    are built over the same representation.
+ * 2. **No `ASOF JOIN`.** `asofJoin` renders the shared nearest-row emulation
+ *    (`renderNearestRowJoin`, `relational.ts`) as `CROSS APPLY` / `OUTER APPLY
+ *    (SELECT TOP 1 … ORDER BY ts DESC)`.
+ * 3. **No aggregate percentile.** T-SQL's `PERCENTILE_CONT` is a *window*
+ *    function only, so it cannot appear in a `GROUP BY` select list next to
+ *    `avg`/`count`. `quantile` therefore packs the group's values with
+ *    `STRING_AGG` — a real aggregate — and a small T-SQL scalar function
+ *    (`dbo.uptimizr_quantile`, created by the `@uptimizr/db-mssql` migrations)
+ *    sorts them and computes the type-7 linear interpolation DuckDB's
+ *    `quantile_cont` / Postgres' `percentile_cont` use. Exact, O(n log n) per
+ *    group; documented as the store's performance trade-off.
+ *
+ * Two further T-SQL syntax gaps are closed by {@link toTsql} rather than by the
+ * `Dialect` members, because the shared SQL cannot express them portably:
+ * `LIMIT n` (→ `OFFSET 0 ROWS FETCH NEXT n ROWS ONLY`) and `GROUP BY <select
+ * alias>`, which T-SQL rejects (`Invalid column name`) and is replaced by the
+ * alias's defining expression. `toTsql` is applied once, at execution time, by
+ * `runMssqlQuery` in `@uptimizr/db-mssql`.
+ *
+ * Other notes:
+ * - `epochMs` / `timeBucketMs` return `float` (exact for epoch milliseconds,
+ *   which are far below 2^53). `bigint` would come back as a *string* from the
+ *   TDS driver and `avg(bigint)` truncates in T-SQL; `float` avoids both.
+ * - Integer `avg` truncates in T-SQL, so `avgIf` / `avgMerge` / `quantile`
+ *   cast their input to `float`; the promoted numeric columns are `float`
+ *   already.
+ * - String columns use the binary collation {@link MSSQL_BIN_COLLATION}, so
+ *   equality, `GROUP BY` and ordering are case-sensitive and code-point ordered
+ *   exactly like DuckDB / Postgres; JSON extractions carry the same collation.
+ * - Parameters are emitted as named `$name` tokens (cast in place for `f64`,
+ *   `timestamp`, `date`) and rewritten to positional `@p1…@pn` by the shared
+ *   `toPositionalParams`; timestamp params are bound as ISO-8601 `T`-separated
+ *   naive-UTC strings (language/`DATEFORMAT`-independent) against
+ *   `datetime2(3)` columns.
+ * - Requires SQL Server 2022 (16.x) / Azure SQL: `GREATEST` / `LEAST` (2022),
+ *   `STRING_AGG` / `STRING_SPLIT` / `JSON_VALUE` / `DATEDIFF_BIG` (2016+).
+ */
+import { renderNearestRowJoin } from "./relational.js";
+/**
+ * Format an epoch-millisecond timestamp as an ISO-8601 naive-UTC
+ * `YYYY-MM-DDTHH:MM:SS.mmm` string for binding to a `datetime2(3)` column /
+ * parameter. The `T` separator makes the literal language- and
+ * `SET DATEFORMAT`-independent; the wall-clock value is the same one the DuckDB
+ * / ClickHouse / Postgres stores bind.
+ */
+export function toMssqlTimestamp(epochMs) {
+    const d = new Date(epochMs);
+    const p = (n, w = 2) => String(n).padStart(w, "0");
+    return (`${d.getUTCFullYear()}-${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())}T` +
+        `${p(d.getUTCHours())}:${p(d.getUTCMinutes())}:${p(d.getUTCSeconds())}.${p(d.getUTCMilliseconds(), 3)}`);
+}
+/** Join keywords for the SQL Server flavour of the nearest-row ASOF emulation. */
+export const MSSQL_NEAREST_ROW_JOIN = {
+    inner: "CROSS APPLY",
+    left: "OUTER APPLY",
+    onTrue: "",
+    selectPrefix: "SELECT TOP 1",
+    selectSuffix: "",
+};
+/**
+ * Binary (case-sensitive, code-point ordered) collation applied to every string
+ * column and JSON extraction, so string semantics match DuckDB / Postgres
+ * instead of SQL Server's case-insensitive default.
+ */
+export const MSSQL_BIN_COLLATION = "Latin1_General_100_BIN2";
+/** Schema-qualified name of the quantile helper function (see module doc). */
+export const MSSQL_QUANTILE_FUNCTION = "dbo.uptimizr_quantile";
+/** The Unix epoch as a `datetime2(3)` literal (ISO-8601, language-neutral). */
+const MSSQL_EPOCH = "CAST('1970-01-01T00:00:00' AS datetime2(3))";
+/**
+ * The `index0`-th (0-based) element of a JSON number array as `float`, or NULL
+ * when the array is shorter / the value is not numeric. The one place that
+ * knows vectors are JSON on SQL Server (see module doc).
+ */
+export function mssqlVectorElement(expr, index0) {
+    return `TRY_CONVERT(float, JSON_VALUE(${expr}, '$[${index0}]'))`;
+}
+/** Render a trusted compile-time key path as a SQL Server JSON path. */
+function jsonPath(path) {
+    // Numeric components index a JSON array (0-based); the others are quoted
+    // object keys so any key spelling is safe.
+    return `$${path.map((k) => (/^\d+$/.test(k) ? `[${k}]` : `."${k}"`)).join("")}`;
+}
+/** `JSON_VALUE(column, '$.path')` — the value at `path` as text (NULL when absent). */
+function jsonAt(column, path) {
+    return `JSON_VALUE(${column}, '${jsonPath(path)}')`;
+}
+/**
+ * The group's non-NULL values of `expr` packed into one comma-separated
+ * `varchar(max)` of round-trippable floats (`CONVERT` style 3 = 17 significant
+ * digits), consumed (and sorted) by `dbo.uptimizr_quantile`. Deliberately not
+ * `WITHIN GROUP (ORDER BY …)`: T-SQL rejects two ordered aggregates with
+ * different orderings in one scope, and the shared SQL routinely computes
+ * quantiles of several expressions side by side.
+ */
+function packedValues(expr) {
+    return `STRING_AGG(CONVERT(varchar(max), CONVERT(varchar(30), CAST((${expr}) AS float), 3)), ',')`;
+}
+export const mssqlDialect = {
+    name: "mssql",
+    placeholder(name, type) {
+        // The TDS driver infers `int`/`float`/`nvarchar` from the JS value; cast in
+        // place where the inferred type could differ from the logical one (an
+        // integral `f64` would bind as `int`) or where a string must become a date.
+        switch (type) {
+            case "f64":
+                return `CAST($${name} AS float)`;
+            case "timestamp":
+                return `CAST($${name} AS datetime2(3))`;
+            case "date":
+                return `CAST($${name} AS date)`;
+            default:
+                return `$${name}`;
+        }
+    },
+    timestampValue(epochMs) {
+        return toMssqlTimestamp(epochMs);
+    },
+    quantile(expr, q) {
+        return `${MSSQL_QUANTILE_FUNCTION}(${packedValues(expr)}, ${q})`;
+    },
+    vectorNorm(expr) {
+        // No arrays: sum the squares of the JSON elements. All callers guard with
+        // `arrayLength(expr) = 3`; up to four components are covered (quaternions)
+        // and absent components contribute 0.
+        const terms = [0, 1, 2, 3].map((i) => `power(coalesce(${mssqlVectorElement(expr, i)}, 0), 2)`);
+        return `sqrt(${terms.join(" + ")})`;
+    },
+    arrayLength(expr) {
+        // Vectors are flat JSON number arrays written by the store itself, so the
+        // element count is the comma count + 1 (0 for `[]`). Pure scalar text
+        // arithmetic — usable in WHERE, SELECT and GROUP BY alike (no subquery).
+        return `(CASE WHEN ${expr} IS NULL OR ${expr} = N'[]' THEN 0 ELSE LEN(${expr}) - LEN(REPLACE(${expr}, ',', '')) + 1 END)`;
+    },
+    avgIf(value, cond) {
+        return `avg(CASE WHEN ${cond} THEN CAST((${value}) AS float) END)`;
+    },
+    anyValue(expr) {
+        // `min` is a valid "any" (callers use it on values constant within the
+        // group) and ignores NULLs like DuckDB's `any_value`.
+        return `min(${expr})`;
+    },
+    timeBucketMs(tsExpr, intervalPlaceholder) {
+        // Float epoch-ms floored to the interval grid (same arithmetic as DuckDB /
+        // ClickHouse / Postgres); the interval param is an `int`, the division is
+        // float so it can never truncate.
+        const bucket = `(${intervalPlaceholder} * 1000)`;
+        return `(floor(${this.epochMs(tsExpr)} / ${bucket}) * ${bucket})`;
+    },
+    epochMs(tsExpr) {
+        // `datetime2(3)` holds wall-clock UTC; DATEDIFF_BIG from the epoch is exact
+        // milliseconds, returned as float (see module doc).
+        return `CAST(DATEDIFF_BIG(millisecond, ${MSSQL_EPOCH}, ${tsExpr}) AS float)`;
+    },
+    toDate(expr) {
+        return `CAST(${expr} AS date)`;
+    },
+    toText(expr) {
+        // Style 121 renders dates as `YYYY-MM-DD` and datetime2 as
+        // `YYYY-MM-DD HH:MM:SS.fff` (ISO, language-neutral); the shared SQL only
+        // applies it to date-typed rollup columns.
+        return `CONVERT(nvarchar(30), ${expr}, 121)`;
+    },
+    jsonText(column, ...path) {
+        return `${jsonAt(column, path)} COLLATE ${MSSQL_BIN_COLLATION}`;
+    },
+    jsonInt(column, ...path) {
+        // `TRY_CONVERT(bigint)` yields NULL for absent / non-integer text exactly
+        // like DuckDB's `TRY_CAST(... AS BIGINT)`; widened to float so it never
+        // reaches the driver as a bigint string nor truncates under `avg`.
+        return `CAST(TRY_CONVERT(bigint, ${jsonAt(column, path)}) AS float)`;
+    },
+    jsonFloat(column, ...path) {
+        return `TRY_CONVERT(float, ${jsonAt(column, path)})`;
+    },
+    // The daily rollups are query-time views (pre-grouped by day), so each read
+    // GROUP BY sees exactly one source row per group and the "merge" of a single
+    // precomputed value is a plain pass-through aggregate — as on DuckDB.
+    countMerge(stateExpr) {
+        return `sum(${stateExpr})`;
+    },
+    avgMerge(stateExpr) {
+        return `avg(CAST((${stateExpr}) AS float))`;
+    },
+    quantileMerge(stateExpr, q) {
+        return `${MSSQL_QUANTILE_FUNCTION}(${packedValues(stateExpr)}, ${q})`;
+    },
+    asofJoin(spec) {
+        return renderNearestRowJoin(spec, MSSQL_NEAREST_ROW_JOIN);
+    },
+};
+// ---------------------------------------------------------------------------
+// T-SQL adaptation of the shared SQL (see module doc)
+// ---------------------------------------------------------------------------
+/**
+ * Inline 1-based array indexing in the shared SQL: `position[1]`,
+ * `m.direction[3]`, … Never matches the dialect's own JSON paths (`'$[0]'`,
+ * `'$."uv"[0]'`), because those have no identifier directly before the `[`.
+ */
+const VECTOR_INDEX = /(?<![\w.$"])((?:[A-Za-z_]\w*\.)?[A-Za-z_]\w*)\[(\d+)\]/g;
+/** `LIMIT <param|literal>` — always the last clause of a block in the shared SQL. */
+const LIMIT_CLAUSE = /\bLIMIT\s+(\$[A-Za-z_]\w*|\d+)\b/g;
+/**
+ * Rewrite a query rendered with {@link mssqlDialect} into T-SQL. Three
+ * constructs of the shared SQL are not T-SQL and cannot be expressed through a
+ * `Dialect` member without touching every aggregation:
+ *
+ * - `col[n]` (1-based vector indexing) → {@link mssqlVectorElement}`(col, n-1)`.
+ * - `LIMIT n` → `OFFSET 0 ROWS FETCH NEXT n ROWS ONLY` (T-SQL requires an
+ *   `ORDER BY`, which every `LIMIT` in the shared SQL has).
+ * - `GROUP BY <alias>` → the alias's select-list expression (T-SQL: "Invalid
+ *   column name"). Both DuckDB and Postgres accept output-column aliases in
+ *   `GROUP BY`; T-SQL only accepts input columns and expressions.
+ *
+ * Plus the spelling difference `atan2` → `ATN2`. Pure and idempotent; applied
+ * once per query by `runMssqlQuery`.
+ */
+export function toTsql(sql) {
+    return rewriteGroupByAliases(sql)
+        .replace(VECTOR_INDEX, (_m, expr, index) => mssqlVectorElement(expr, Number(index) - 1))
+        .replace(/\batan2\s*\(/gi, "ATN2(")
+        .replace(LIMIT_CLAUSE, "OFFSET 0 ROWS FETCH NEXT $1 ROWS ONLY");
+}
+/** Keywords that end a `GROUP BY` list within the same block. */
+const GROUP_TERMINATORS = /^(HAVING|ORDER\s+BY|LIMIT|OFFSET|UNION|EXCEPT|INTERSECT|WINDOW)\b/i;
+/**
+ * One pass over the SQL text: paren depth, string literals skipped, and the
+ * clause keywords that matter for block detection. `WITHIN GROUP (` is not a
+ * `GROUP BY`; keywords inside `OVER (…)` / subqueries sit at a deeper depth.
+ */
+function scanClauses(sql) {
+    const clauses = [];
+    let depth = 0;
+    for (let i = 0; i < sql.length;) {
+        const ch = sql[i];
+        if (ch === "'") {
+            // Skip a string literal ('' is an escaped quote).
+            let j = i + 1;
+            while (j < sql.length) {
+                if (sql[j] === "'") {
+                    if (sql[j + 1] === "'")
+                        j += 2;
+                    else
+                        break;
+                }
+                else
+                    j++;
+            }
+            i = j + 1;
+            continue;
+        }
+        if (ch === "(") {
+            depth++;
+            i++;
+            continue;
+        }
+        if (ch === ")") {
+            clauses.push({ kind: "close", depth, start: i, end: i + 1 });
+            depth--;
+            i++;
+            continue;
+        }
+        if (/[A-Za-z_]/.test(ch) && !/[\w.$]/.test(sql[i - 1] ?? " ")) {
+            const rest = sql.slice(i);
+            const word = /^[A-Za-z_]\w*/.exec(rest)[0];
+            const upper = word.toUpperCase();
+            let match;
+            if (upper === "SELECT")
+                match = { kind: "select", length: word.length };
+            else if (upper === "FROM")
+                match = { kind: "from", length: word.length };
+            else if (upper === "GROUP") {
+                const by = /^GROUP\s+BY\b/i.exec(rest);
+                if (by)
+                    match = { kind: "groupBy", length: by[0].length };
+            }
+            else {
+                const term = GROUP_TERMINATORS.exec(rest);
+                if (term)
+                    match = { kind: "terminator", length: term[0].length };
+            }
+            if (match)
+                clauses.push({ kind: match.kind, depth, start: i, end: i + match.length });
+            i += word.length;
+            continue;
+        }
+        i++;
+    }
+    return clauses;
+}
+/** Split on commas that sit outside parentheses and string literals. */
+function splitTopLevel(text) {
+    const parts = [];
+    let depth = 0;
+    let inString = false;
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (ch === "'") {
+                if (text[i + 1] === "'")
+                    i++;
+                else
+                    inString = false;
+            }
+            continue;
+        }
+        if (ch === "'")
+            inString = true;
+        else if (ch === "(")
+            depth++;
+        else if (ch === ")")
+            depth--;
+        else if (ch === "," && depth === 0) {
+            parts.push(text.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(text.slice(start));
+    return parts;
+}
+const ALIASED_ITEM = /^([\s\S]*\S)\s+AS\s+([A-Za-z_]\w*)\s*$/i;
+const BARE_IDENTIFIER = /^\s*([A-Za-z_]\w*)\s*$/;
+/**
+ * Replace output-column aliases in every `GROUP BY` list with the expression
+ * that defines them in the owning `SELECT` list (nearest preceding `SELECT` at
+ * the same paren depth; its list ends at the first `FROM` at that depth).
+ */
+function rewriteGroupByAliases(sql) {
+    const clauses = scanClauses(sql);
+    let out = sql;
+    // Walk backwards so earlier offsets stay valid after each replacement.
+    for (let g = clauses.length - 1; g >= 0; g--) {
+        const group = clauses[g];
+        if (group.kind !== "groupBy")
+            continue;
+        let selectIdx = -1;
+        for (let s = g - 1; s >= 0; s--) {
+            const c = clauses[s];
+            if (c.kind === "select" && c.depth === group.depth) {
+                selectIdx = s;
+                break;
+            }
+        }
+        if (selectIdx < 0)
+            continue;
+        const from = clauses
+            .slice(selectIdx + 1, g)
+            .find((c) => c.kind === "from" && c.depth === group.depth);
+        if (!from)
+            continue;
+        const selectList = out
+            .slice(clauses[selectIdx].end, from.start)
+            .replace(/^\s*(DISTINCT|TOP\s+\d+)\b/i, "");
+        const aliases = new Map();
+        for (const item of splitTopLevel(selectList)) {
+            const m = ALIASED_ITEM.exec(item.trim());
+            if (m && m[1].trim() !== m[2])
+                aliases.set(m[2], m[1].trim());
+        }
+        if (aliases.size === 0)
+            continue;
+        const terminator = clauses
+            .slice(g + 1)
+            .find((c) => (c.kind === "terminator" && c.depth === group.depth) ||
+            (c.kind === "close" && c.depth === group.depth));
+        const listEnd = terminator ? terminator.start : out.length;
+        const list = out.slice(group.end, listEnd);
+        const rewritten = splitTopLevel(list)
+            .map((item) => {
+            const id = BARE_IDENTIFIER.exec(item);
+            const expr = id ? aliases.get(id[1]) : undefined;
+            return expr ? item.replace(id[1], expr) : item;
+        })
+            .join(",");
+        out = out.slice(0, group.end) + rewritten + out.slice(listEnd);
+    }
+    return out;
+}
+//# sourceMappingURL=mssqlDialect.js.map

package/dist/query/mssqlDialect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mssqlDialect.js","sourceRoot":"","sources":["../../src/query/mssqlDialect.ts"],"names":[],"mappings":"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"}

package/dist/query/postgresDialect.d.ts

@@ -0,0 +1,48 @@
+/**
+ * PostgreSQL dialect for the query layer (ADR 0020, #84).
+ *
+ * Postgres is the optional single-tenant *relational* store: a multi-writer
+ * server many self-hosters already operate, for shops that "only want Postgres"
+ * and have outgrown DuckDB's single read-write process. This dialect renders the
+ * engine-specific fragments of each shared aggregation (`aggregations.ts`) to
+ * Postgres SQL, so the bulk of every query stays shared with DuckDB/ClickHouse.
+ *
+ * Like the other dialects it is *single-tenant* — no `org_id`, no tenant
+ * isolation — which keeps it relocatable across the open-core boundary.
+ *
+ * Binding model: parameters are emitted as named `$name::type` placeholders
+ * (every logical {@link ParamType} carries an explicit cast so Postgres never has
+ * to infer a parameter type from context) and rewritten to positional `$1…$n`
+ * by `toPositionalParams` in the `@uptimizr/db-postgres` runner. Timestamp params
+ * are bound as naive-UTC strings (see {@link toPostgresTimestamp}) against
+ * `timestamp` (without time zone) columns, so ordering, bucketing, and `::date`
+ * truncation are wall-clock-UTC exactly as on DuckDB and ClickHouse, independent
+ * of the session `TimeZone`.
+ *
+ * Row-store fit gaps (issue #84) and how they are closed here:
+ * - **No `ASOF JOIN`.** `asofJoin` renders the shared nearest-row emulation
+ *   (`renderNearestRowJoin`, `relational.ts`) as `JOIN LATERAL (… ORDER BY ts
+ *   DESC LIMIT 1) ON TRUE`.
+ * - **No MergeTree rollups.** The daily rollups are plain views that recompute
+ *   at query time (see the `@uptimizr/db-postgres` migrations), so the `-Merge`
+ *   combinators reduce to pass-through aggregates, as on DuckDB.
+ * - **Arrays are 1-indexed** — the same convention DuckDB and ClickHouse use, so
+ *   `position[1]` in the shared SQL needs no translation; `arrayLength` maps to
+ *   `cardinality` and `vectorNorm` unnests the array.
+ * - **JSON** lives in a `jsonb` column; extraction is `#>>` with a text[] path,
+ *   and the numeric extractors regex-guard the cast (Postgres has no `TRY_CAST`)
+ *   so an absent / non-numeric key yields NULL exactly like DuckDB's `TRY_CAST`.
+ */
+import type { Dialect } from "./dialect.js";
+import { type NearestRowJoinTokens } from "./relational.js";
+/**
+ * Format an epoch-millisecond timestamp as a naive-UTC `YYYY-MM-DD HH:MM:SS.mmm`
+ * string for binding to a Postgres `timestamp` (without time zone) column/param.
+ * Mirrors the DuckDB / ClickHouse literal format so all stores order and bucket
+ * time identically.
+ */
+export declare function toPostgresTimestamp(epochMs: number): string;
+/** Join keywords for the Postgres flavour of the nearest-row ASOF emulation. */
+export declare const POSTGRES_NEAREST_ROW_JOIN: NearestRowJoinTokens;
+export declare const postgresDialect: Dialect;
+//# sourceMappingURL=postgresDialect.d.ts.map

package/dist/query/postgresDialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgresDialect.d.ts","sourceRoot":"","sources":["../../src/query/postgresDialect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAa,MAAM,cAAc,CAAC;AACvD,OAAO,EAAwB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAkBlF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAO3D;AAED,gFAAgF;AAChF,eAAO,MAAM,yBAAyB,EAAE,oBAMvC,CAAC;AAsBF,eAAO,MAAM,eAAe,EAAE,OAiF7B,CAAC"}