@voltro/database 0.85.0 → 0.87.0

package/dist/sqliteDecimalCte.js

@@ -0,0 +1,154 @@
+import { decimal as e, text as t } from "./columns.js";
+import { sqliteDecimalOutputs as n } from "./sqliteDecimalOutputs.js";
+import { compileSqliteDecimalEncodedSource as r } from "./sqliteDecimalEncodeSql.js";
+//#region src/sqliteDecimalCte.ts
+var i = (e) => e.replace(/[A-Z]/g, (e) => e.toLowerCase()), a = (e) => {
+	let t = /* @__PURE__ */ new Set(), n = (e) => {
+		"and" in e ? e.and.forEach(n) : "or" in e ? e.or.forEach(n) : "not" in e ? n(e.not) : "subquery" in e && r(e.subquery);
+	}, r = (e) => {
+		t.add(i(e.table));
+		for (let r of e.joins ?? []) t.add(i(r.table)), n(r.on);
+		for (let n of e.ctes ?? []) t.add(i(n.name)), r(n.descriptor);
+		e.setOp?.queries.forEach(r), e.predicate && n(e.predicate), e.having && n(e.having);
+	};
+	r(e);
+	let a = 0;
+	return () => {
+		let e;
+		do
+			e = `__voltro_decimal_cte_${a++}`;
+		while (t.has(e));
+		return t.add(e), e;
+	};
+}, o = (r, s, c = () => void 0, l = a(r)) => {
+	let u = /* @__PURE__ */ new Map();
+	for (let e of r.ctes ?? []) {
+		let t = i(e.name);
+		if (u.has(t)) throw Error("Duplicate exact decimal CTE name");
+		u.set(t, e);
+	}
+	let d = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Set(), p = [], m = (r) => {
+		let a = i(r), h = u.get(a);
+		if (!h) return c(a);
+		let g = d.get(a);
+		if (g) return g;
+		if (h.recursive) throw Error("Recursive exact decimal CTE composition is not integrated yet");
+		if (f.has(a)) throw Error(`Circular exact decimal CTE dependency: ${h.name}`);
+		f.add(a);
+		let _ = o(h.descriptor, s, m, l), v = n(_, s);
+		if (new Set(v.map((e) => i(e.name))).size !== v.length) throw Error("Duplicate exact decimal CTE output");
+		let y = l(), b = {
+			tableName: y,
+			fields: Object.fromEntries(v.map((n) => [n.name, n.decimal ? {
+				...e(n.decimal.precision, n.decimal.scale).__definition(),
+				sqliteDecimalEncoding: "sortable-v1"
+			} : n.definition ?? t().__definition()]))
+		};
+		return d.set(a, b), f.delete(a), p.push({
+			...h,
+			name: y,
+			descriptor: _
+		}), b;
+	};
+	for (let e of u.keys()) m(e);
+	let h = (e) => "and" in e ? { and: e.and.map(h) } : "or" in e ? { or: e.or.map(h) } : "not" in e ? { not: h(e.not) } : "subquery" in e ? {
+		...e,
+		subquery: o(e.subquery, s, m, l)
+	} : e, g = m(r.table), { ctes: _, ...v } = r;
+	return {
+		...v,
+		...p?.length ? { ctes: p } : {},
+		...g ? {
+			table: g.tableName,
+			alias: r.alias ?? r.table,
+			sourceTable: g
+		} : {},
+		...r.joins ? { joins: r.joins.map((e) => {
+			let t = m(e.table);
+			return {
+				...e,
+				...t ? {
+					table: t.tableName,
+					sourceTable: t
+				} : {},
+				on: h(e.on)
+			};
+		}) } : {},
+		...r.predicate ? { predicate: h(r.predicate) } : {},
+		...r.having ? { having: h(r.having) } : {},
+		...r.setOp ? { setOp: {
+			...r.setOp,
+			queries: r.setOp.queries.map((e) => o(e, s, m, l))
+		} } : {}
+	};
+}, s = (e, t) => {
+	let n = [], r = (e) => "and" in e ? { and: e.and.map(r) } : "or" in e ? { or: e.or.map(r) } : "not" in e ? { not: r(e.not) } : "subquery" in e ? {
+		...e,
+		subquery: i(e.subquery)
+	} : e, i = (e) => {
+		let { ctes: t, ...a } = e;
+		for (let e of t ?? []) {
+			let t = i(e.descriptor);
+			n.push({
+				...e,
+				descriptor: t
+			});
+		}
+		return {
+			...a,
+			...a.joins ? { joins: a.joins.map((e) => ({
+				...e,
+				on: r(e.on)
+			})) } : {},
+			...a.predicate ? { predicate: r(a.predicate) } : {},
+			...a.having ? { having: r(a.having) } : {},
+			...a.setOp ? { setOp: {
+				...a.setOp,
+				queries: a.setOp.queries.map(i)
+			} } : {}
+		};
+	}, a = i(o(e, t));
+	return n.length ? {
+		...a,
+		ctes: n
+	} : a;
+}, c = (e, t, a, o) => {
+	let s = (e.ctes ?? []).flatMap((e, s) => {
+		let c = n(e.descriptor, a), [l] = o(e.descriptor).compile(), u = (e) => "\"" + e.replaceAll("\"", "\"\"") + "\"", d = `decimal_cte_${s}_`, f = i(l + e.name);
+		for (; f.includes(d);) d += "_";
+		let p = c.map((e, t) => `${d}column_${t}`), m = [], h = /* @__PURE__ */ new Set(), [g, _] = o(e.descriptor, {
+			prefix: `${d}window_`,
+			append: (e, t) => {
+				m.push(`${e} AS MATERIALIZED (${t})`);
+			},
+			encodedOutput: (e) => {
+				h.add(e);
+			}
+		}).compile();
+		m.push(`${d}input AS (${g})`);
+		let v = (e, t) => {
+			m.push(`${e} AS (${t})`);
+		}, y = `${d}columns`;
+		v(y, `SELECT ${c.map((e, t) => `${u(e.name)} AS ${p[t]}`).join(",")} FROM ${d}input`);
+		for (let [e, t] of c.entries()) {
+			if (!t.decimal || h.has(t.name)) continue;
+			let n = p.filter((t, n) => n !== e), i = `SELECT ${p[e]} AS value${n.map((e) => "," + e).join("")} FROM ${y}`, a = r(i, t.decimal, n, {
+				prefix: `${d}${e}_`,
+				append: v
+			});
+			y = `${d}encoded_${e}`, v(y, `SELECT ${p.map((t, n) => n === e ? `value AS ${t}` : t).join(",")} FROM ${a}`);
+		}
+		let b = c.map((e, t) => `${p[t]} AS ${u(e.name)}`).join(",");
+		return [t.unsafe(m.join(","), _), t`${t(e.name)} AS (${t.unsafe(`SELECT ${b} FROM ${y}`)})`];
+	}), { ctes: c, ...l } = e, [u] = o(l).compile(), d = "decimal_cte_result_", f = i(u + s.map((e) => e.compile()[0]).join(""));
+	for (; f.includes(d);) d += "_";
+	let p = [], [m, h] = o(l, void 0, {
+		prefix: d,
+		append: (e, t) => {
+			p.push(`${e} AS MATERIALIZED (${t})`);
+		}
+	}).compile(), g = p.length ? t`WITH ${t.join(", ", !1)([...s, t.unsafe(p.join(","), h)])} ${t.unsafe(m)}` : t`WITH ${t.join(", ", !1)(s)} SELECT * FROM (${t.unsafe(m, h)})`;
+	return t.unsafe(...g.compile());
+};
+//#endregion
+export { c as compileSqliteDecimalCtes, s as resolveSqliteDecimalSources };

package/dist/sqliteDecimalEncodeSql.js

@@ -0,0 +1,32 @@
+import { encodeSqliteDecimal as e } from "./sqliteDecimal.js";
+//#region src/sqliteDecimalEncodeSql.ts
+var t = (t, n, r = [], i) => {
+	e("0", n);
+	let a = /* @__PURE__ */ new Set([
+		"value",
+		"negative",
+		"unsigned",
+		"integer_part",
+		"fraction",
+		"magnitude",
+		"padded",
+		"trimmed",
+		"alphabetic",
+		"complement"
+	]);
+	if (new Set(r).size !== r.length || r.some((e) => !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(e) || a.has(e.toLowerCase()))) throw Error("Invalid decimal source carry column");
+	if (i && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(i.prefix)) throw Error("Invalid decimal encoding stage prefix");
+	let o = (e) => (i?.prefix ?? "") + "decimal_encode_" + e, s = "0".repeat(n.precision), c = "substr(trimmed,1,length(trimmed)-1)";
+	for (let e = 0; e < 10; e++) c = `replace(${c},'${e}','${String.fromCharCode(97 + e)}')`;
+	let l = c;
+	c = "alphabetic";
+	for (let e = 0; e < 10; e++) c = `replace(${c},'${String.fromCharCode(97 + e)}','${9 - e}')`;
+	let u = [], d = (e) => i?.reference?.(o(e)) ?? o(e), f = (e, t) => {
+		i ? i.append(o(e), t) : u.push(`${o(e)} AS (${t})`);
+	};
+	f("input", `SELECT * FROM (${t}) LIMIT -1 OFFSET 0`), f("sign", `SELECT *,substr(value,1,1)='-' AS negative,CASE WHEN substr(value,1,1) IN ('-','+') THEN substr(value,2) ELSE value END AS unsigned FROM ${d("input")} LIMIT -1 OFFSET 0`), f("parts", `SELECT *,CASE WHEN instr(unsigned,'.')=0 THEN unsigned ELSE substr(unsigned,1,instr(unsigned,'.')-1) END AS integer_part,CASE WHEN instr(unsigned,'.')=0 THEN '' ELSE substr(unsigned,instr(unsigned,'.')+1) END AS fraction FROM ${d("sign")} LIMIT -1 OFFSET 0`), f("magnitude", `SELECT *,coalesce(nullif(ltrim(integer_part||substr(fraction||'${"0".repeat(n.scale)}',1,${n.scale}),'0'),''),'0') AS magnitude FROM ${d("parts")} LIMIT -1 OFFSET 0`), f("padded", `SELECT *,substr('${s}'||magnitude,-${n.precision}) AS padded FROM ${d("magnitude")} LIMIT -1 OFFSET 0`), f("trimmed", `SELECT *,rtrim(padded,'0') AS trimmed FROM ${d("padded")} LIMIT -1 OFFSET 0`), f("alphabetic", `SELECT *,${l} AS alphabetic FROM ${d("trimmed")} LIMIT -1 OFFSET 0`), f("complement", `SELECT *,${c} AS complement FROM ${d("alphabetic")} LIMIT -1 OFFSET 0`);
+	let p = `typeof(value)<>'text' OR instr(value,char(0))<>0 OR unsigned GLOB '*[^0-9.]*' OR instr(fraction,'.')<>0 OR length(integer_part)+length(fraction)=0 OR length(magnitude)>${n.precision} OR substr(fraction,${n.scale + 1}) GLOB '*[1-9]*'`;
+	return `(${i ? "" : `WITH ${u.join(",")} `}SELECT ${r.map((e) => `"${e}",`).join("")}CASE WHEN value IS NULL THEN NULL WHEN ${p} THEN abs(-9223372036854775808) WHEN negative AND magnitude<>'0' THEN 'D0'||complement||CAST(10-CAST(substr(trimmed,-1) AS INTEGER) AS TEXT)||substr(padded,length(trimmed)+1) ELSE 'D1'||padded END AS value FROM ${d("complement")})`;
+};
+//#endregion
+export { t as compileSqliteDecimalEncodedSource };

package/dist/sqliteDecimalOutputs.js

@@ -0,0 +1,74 @@
+import { integer as e } from "./columns.js";
+import { getTable as t } from "./tableRegistry.js";
+import { isSqliteDecimalEncodedColumn as n } from "./sqliteDecimalStorage.js";
+import { projectedColumn as r } from "./projectedColumn.js";
+//#region src/sqliteDecimalOutputs.ts
+var i = (a, o) => {
+	if (a.setOp) {
+		let e = a.setOp.queries.map((e) => i(e, o));
+		if (e.length < 2) throw Error("Exact set operations require at least two inputs");
+		let t = e[0];
+		if (e.some((e) => e.length !== t.length)) throw Error("Exact set operation column counts differ");
+		return t.map((t, n) => {
+			let r = e.map((e) => e[n].decimal);
+			if (r.some(Boolean) && !r.every(Boolean)) throw Error("Exact set operation decimal and nondecimal outputs cannot be mixed");
+			if (!t.decimal) return t;
+			let i = Math.max(...r.map((e) => e.scale)), a = Math.max(...r.map((e) => e.precision - e.scale));
+			return {
+				name: t.name,
+				decimal: {
+					precision: a + i,
+					scale: i
+				}
+			};
+		});
+	}
+	let s = a.aggregations ?? [];
+	if (s.length) return s.map((t) => {
+		let i = r(t.column ?? "", a);
+		if (!n(i) || t.op.startsWith("count") || [
+			"window-row-number",
+			"window-rank",
+			"window-dense-rank"
+		].includes(t.op)) return {
+			name: t.alias,
+			definition: t.op.startsWith("count") || [
+				"window-row-number",
+				"window-rank",
+				"window-dense-rank"
+			].includes(t.op) ? e().__definition() : i ?? e().__definition()
+		};
+		let s = ["avg", "window-avg-over"].includes(t.op) ? o ?? i.scale : i.scale, c = [
+			"sum",
+			"avg",
+			"window-sum-over",
+			"window-avg-over"
+		].includes(t.op);
+		return {
+			name: t.alias,
+			decimal: {
+				precision: i.precision + (c ? 20 : 0) + Math.max(0, s - i.scale),
+				scale: s
+			}
+		};
+	});
+	let c = a.sourceTable?.tableName === a.table ? a.sourceTable : t(a.table), l = a.joinedProjection ?? (a.projection?.length ? a.projection : Object.keys(c?.fields ?? {})).map((e) => ({
+		source: e,
+		outputKey: e.split(".").at(-1)
+	}));
+	if (!l.length) throw Error("Exact set operation requires declared output columns");
+	return l.map((e) => {
+		let t = r(e.source, a);
+		if (!t) throw Error("Exact set operation requires declared output columns");
+		return {
+			name: e.outputKey,
+			definition: t,
+			...n(t) ? { decimal: {
+				precision: t.precision,
+				scale: t.scale
+			} } : {}
+		};
+	});
+};
+//#endregion
+export { i as sqliteDecimalOutputs };

package/dist/sqliteDecimalPredicate.js

@@ -0,0 +1,66 @@
+import { encodeSqliteDecimal as e } from "./sqliteDecimal.js";
+import { sqliteDecimalResultKey as t } from "./sqliteDecimalResultSql.js";
+//#region src/sqliteDecimalPredicate.ts
+var n = (n, r, i) => {
+	if (e("0", r), n.path?.length) throw Error("Decimal JSON-path predicates are unsupported");
+	if (n.op === "isNull" || n.op === "isNotNull") return n;
+	if (![
+		"eq",
+		"neq",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"in",
+		"notIn"
+	].includes(n.op)) throw Error("Unsupported exact decimal predicate");
+	let a = 10n ** BigInt(r.precision), o = -a + 1n, s = a - 1n, c = (e) => i === "aggregate" ? t(String(e), r.precision) : "D" + (e + a).toString().padStart(r.precision + 1, "0"), l = (e) => {
+		if (typeof e != "string" || !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/.test(e)) throw TypeError("Exact decimal predicate requires a fixed-point decimal string");
+		let [t = "", n = ""] = e.replace(/^[+-]/, "").split("."), i = BigInt((t || "0") + n.slice(0, r.scale).padEnd(r.scale, "0")), a = /[1-9]/.test(n.slice(r.scale)), o = e.startsWith("-"), s = o ? -i : i;
+		return {
+			floor: s - (o && a ? 1n : 0n),
+			ceil: s + (!o && a ? 1n : 0n),
+			exact: !a
+		};
+	}, u = (e) => {
+		if (e === null) return null;
+		let t = l(e);
+		return t.exact && t.floor >= o && t.floor <= s ? c(t.floor) : "!decimal-unrepresentable";
+	};
+	if (n.op === "in" || n.op === "notIn") {
+		if (!Array.isArray(n.value)) throw TypeError("Decimal IN predicate requires an array");
+		return {
+			...n,
+			value: n.value.map(u)
+		};
+	}
+	if (n.op === "eq" || n.op === "neq") return {
+		...n,
+		value: u(n.value)
+	};
+	if (n.value === null) return n;
+	let d = l(n.value), f = n.op === "gte" || n.op === "lt" ? d.ceil : d.floor, p = (e) => ({
+		...n,
+		op: e ? "gte" : "lt",
+		value: c(o)
+	});
+	if (n.op === "gte") {
+		if (f <= o) return p(!0);
+		if (f > s) return p(!1);
+	} else if (n.op === "gt") {
+		if (f < o) return p(!0);
+		if (f >= s) return p(!1);
+	} else if (n.op === "lt") {
+		if (f <= o) return p(!1);
+		if (f > s) return p(!0);
+	} else {
+		if (f < o) return p(!1);
+		if (f >= s) return p(!0);
+	}
+	return {
+		...n,
+		value: c(f)
+	};
+};
+//#endregion
+export { n as lowerSqliteDecimalPredicate };

package/dist/sqliteDecimalQuery.js

@@ -0,0 +1,183 @@
+import { columnComparisonOperators as e, isColumnReference as t } from "./columnReference.js";
+import { isSqliteDecimalEncodedColumn as n } from "./sqliteDecimalStorage.js";
+import { prepareProjectedColumn as r } from "./projectedColumn.js";
+import { compileSqliteDecimalCtes as i, resolveSqliteDecimalSources as a } from "./sqliteDecimalCte.js";
+import { qualifyTable as o } from "./namespace.js";
+import { compileSqliteDecimalSubquery as s } from "./sqliteDecimalSubquery.js";
+import { compileSqliteDecimalSetQuery as c } from "./sqliteDecimalSetQuery.js";
+import { compileSqliteDecimalResult as l, compileSqliteDecimalResultComparison as u } from "./sqliteDecimalResultSql.js";
+import { lowerSqliteDecimalPredicate as d } from "./sqliteDecimalPredicate.js";
+import { compileSqliteDecimalSource as f } from "./sqliteDecimalSource.js";
+import { compileSqliteDecimalRowQuery as p } from "./sqliteDecimalRowQuery.js";
+import { compileSqliteDecimalAvg as m, compileSqliteDecimalSum as ee } from "./sqliteDecimalAggregateSql.js";
+import { compileSqliteDecimalWindowQuery as h } from "./sqliteDecimalWindowQuery.js";
+import { compilePredicate as g } from "./sqlCompiler.js";
+//#region src/sqliteDecimalQuery.ts
+var _ = (a, o, v, y, b, x) => {
+	if (!o.onDialectOrElse({
+		sqlite: () => !0,
+		orElse: () => !1
+	})) throw Error("Encoded decimal query integration requires a SQLite-family compiler");
+	if (a.ctes?.length) return i(a, o, v.resultScale, (e, t, n) => _(e, o, v, y, t, n));
+	if (a.setOp) return c(a, o, v, (e) => _(e, o, v, y));
+	let S = {
+		compile: (e) => _(e, o, v, y),
+		resultScale: v.resultScale,
+		sourceTable: y
+	}, C = a.aggregations ?? [];
+	if (C.length > 0 && C.every((e) => e.op === "column") && !a.groupBy?.length && !a.having || C.some((e) => e.op.startsWith("window-"))) return h(a, o, v, S, b, x);
+	let w = C.length === 0, T = C.filter((e) => e.op !== "column"), E = !w && T.length === 0, D = {
+		sum: "SUM",
+		avg: "AVG",
+		min: "MIN",
+		max: "MAX",
+		count: "COUNT",
+		"count-distinct": "COUNT"
+	};
+	if (E && !a.groupBy?.length || T.some((e) => !(e.op in D)) || a.setOp || a.distinctOn || a.ctes || a.annClause || a.spatialClause || a.fullTextSearch) throw Error("Exact decimal query integration requires supported grouped aggregate projections");
+	if (new Set(C.map((e) => e.alias)).size !== C.length) throw Error("Duplicate decimal result alias");
+	let O = r(a), k = a.groupBy ?? [], A = /* @__PURE__ */ new Map();
+	k.forEach((e, t) => {
+		A.has(e) || A.set(e, t);
+	});
+	for (let e of k) if (O(e) === void 0) throw Error("Exact decimal grouping requires declared source columns");
+	for (let e of C) if (e.op === "column" && !A.has(e.column ?? "")) throw Error("Projected group column is absent from GROUP BY");
+	let j = "__decimal_group_identity";
+	for (; C.some((e) => e.alias === j);) j += "_";
+	let M = [...(E ? [{
+		op: "count",
+		alias: j
+	}] : T).map((e) => ({
+		aggregate: e,
+		projection: e
+	})), ...C.filter((e) => e.op === "column" && n(O(e.column ?? ""))).map((e) => ({
+		aggregate: {
+			...e,
+			op: "min"
+		},
+		projection: e
+	}))].map(({ aggregate: e, projection: t }, r) => {
+		if (e.column === void 0 && e.op !== "count") throw Error("Aggregate requires a source column");
+		let i = O(e.column ?? "");
+		if (e.column !== void 0 && i === void 0) throw Error("Aggregate requires a declared source column");
+		let a = n(i) && !e.op.startsWith("count");
+		if (a && (i.precision === void 0 || i.scale === void 0)) throw Error("Exact decimal aggregate requires declared precision and scale");
+		let o = a ? i.precision : 0, s = a ? i.scale : 0, c = e.op === "avg" ? v.resultScale ?? s : s;
+		return {
+			aggregate: e,
+			projection: t,
+			index: r,
+			exact: a,
+			precision: o,
+			inputScale: s,
+			scale: c,
+			digits: o + 20 + Math.max(0, c - s)
+		};
+	}), N = new Map(M.map((e) => [e.projection, e])), P = new Map(M.map((e) => [e.projection.alias, e])), F = /* @__PURE__ */ new Map(), I = C.map((e) => {
+		let t = N.get(e);
+		if (t) return F.set(e.alias, `result${t.index}.${t.exact ? "decimal_key" : "result_value"}`), o`${o(`result${t.index}.${t.exact ? "decimal_value" : "result_value"}`)} AS ${o(e.alias)}`;
+		let n = A.get(e.column ?? "") ?? -1;
+		if (n < 0) throw Error("Projected group column is absent from GROUP BY");
+		return F.set(e.alias, `result0.key${n}`), o`${o(`result0.key${n}`)} AS ${o(e.alias)}`;
+	}), L = (e) => {
+		if ("and" in e) return { and: e.and.map(L) };
+		if ("or" in e) return { or: e.or.map(L) };
+		if ("not" in e) return { not: L(e.not) };
+		if ("subquery" in e || !("column" in e) || !("op" in e)) throw Error("Decimal subquery predicates are not integrated yet");
+		if (t(e.value)) throw Error("Column references require result comparison lowering");
+		let n = P.get(e.column), r = F.get(e.column);
+		if (r === void 0) throw Error("HAVING references an unknown projected aggregate or group key");
+		return n?.exact ? d({
+			...e,
+			column: r
+		}, {
+			precision: n.digits,
+			scale: n.scale
+		}, "aggregate") : {
+			...e,
+			column: r
+		};
+	}, R = [...M.flatMap((e) => e.aggregate.column === void 0 ? [] : [{
+		source: e.aggregate.column,
+		outputKey: `value${e.index}`
+	}]), ...k.map((e, t) => ({
+		source: e,
+		outputKey: `group${t}`
+	}))], te = R.length ? o.join(", ", !1)(R.map((e) => o`${o(e.source)} AS ${o(e.outputKey)}`)) : o`1 AS decimal_query_row`, { from: z, where: B } = f(a, o, S);
+	if (w) return p(a, o, S, b, x);
+	let V = o`SELECT ${te} FROM ${z}${B}`.compile(), H = (e) => "\"" + e.replace(/"/g, "\"\"") + "\"", U = k.map((e, t) => `group${t}`), W = U.map((e, t) => `${H(e)} AS ${H(`key${t}`)}`).join(","), G = U.length ? ` GROUP BY ${U.map(H).join(",")}` : "", K = v.materialized ? "decimal_query_source" : `(${V[0]})`, q = M.map((e) => {
+		let { aggregate: t, index: n, precision: r, inputScale: i, scale: a, digits: o } = e, s = t.column === void 0 ? "*" : H(`value${n}`);
+		if (!e.exact) return `SELECT ${W ? W + "," : ""}${D[t.op]}(${t.op === "count-distinct" ? "DISTINCT " : ""}${s}) AS result_value FROM ${K}${G}`;
+		let c = {
+			sourceSql: t.op === "min" || t.op === "max" ? `SELECT ${U.length ? U.map(H).join(",") + "," : ""}${D[t.op]}(${s}) AS value FROM ${K}${G}` : `SELECT ${U.length ? U.map(H).join(",") + "," : ""}${s} AS value FROM ${K}`,
+			precision: r,
+			materialized: v.materialized,
+			...k.length ? { scope: {
+				kind: "group",
+				columns: U
+			} } : {}
+		}, u = t.op === "avg" ? m({
+			...c,
+			inputScale: i,
+			resultScale: a,
+			rounding: v.rounding ?? "half-even"
+		}) : ee(c);
+		return l({
+			sourceSql: u,
+			digits: o,
+			scale: a,
+			materialized: v.materialized
+		});
+	}), J = [...v.materialized ? [`decimal_query_source AS MATERIALIZED (${V[0]})`] : [], ...q.map((e, t) => {
+		let n = v.materialized ? e : `SELECT * FROM (${e}) LIMIT -1 OFFSET 0`;
+		return `result${t} AS${v.materialized ? " MATERIALIZED" : ""} (${n})`;
+	})].join(","), Y = M.slice(1).map((e) => k.length ? ` JOIN result${e.index} ON ${k.map((t, n) => `result0.${H(`key${n}`)} IS result${e.index}.${H(`key${n}`)}`).join(" AND ")}` : ` CROSS JOIN result${e.index}`).join(""), X = (n) => {
+		if ("not" in n) return o`NOT (${X(n.not)})`;
+		if ("and" in n) return n.and.length ? o.and(n.and.map(X)) : o`TRUE`;
+		if ("or" in n) return n.or.length ? o.or(n.or.map(X)) : o`FALSE`;
+		if ("subquery" in n) return s(n, o, S, (e) => {
+			let t = F.get(e);
+			if (!t) throw Error("HAVING references an unknown projected aggregate or group key");
+			let n = P.get(e);
+			return n?.exact ? {
+				value: o`${o(`result${n.index}.decimal_value`)}`,
+				scale: n.scale
+			} : { value: o`${o(t)}` };
+		});
+		if (!("value" in n) || !t(n.value)) return g(L(n), o);
+		let r = F.get(n.column), i = F.get(n.value.column);
+		if (r === void 0 || i === void 0) throw Error("HAVING references an unknown projected aggregate or group key");
+		let a = P.get(n.column), c = n.value.column, l = P.get(c);
+		if (!a?.exact && !l?.exact) return g({
+			...n,
+			column: r,
+			value: {
+				...n.value,
+				column: i
+			}
+		}, o);
+		if (!a?.exact || !l?.exact) throw Error("Exact aggregate comparisons require two decimal results");
+		if (!e.includes(n.op) || n.path?.length) throw Error("Unsupported exact decimal result comparison");
+		return o.unsafe(u({
+			expression: o`${o(r)}`.compile()[0],
+			digits: a.digits,
+			scale: a.scale
+		}, n.op, {
+			expression: o`${o(i)}`.compile()[0],
+			digits: l.digits,
+			scale: l.scale
+		}));
+	}, Z = a.having === void 0 ? o`` : o` WHERE ${X(a.having)}`, Q = a.order.length === 0 ? o`` : o` ORDER BY ${o.join(", ", !1)(a.order.map((e) => {
+		let t = F.get(e.column);
+		if (t === void 0) throw Error("Ordering references an unknown decimal result projection");
+		return e.direction === "desc" ? o`${o(t)} DESC` : o`${o(t)} ASC`;
+	}))}`;
+	for (let e of [a.take, a.skip]) if (e !== void 0 && (!Number.isSafeInteger(e) || e < 0)) throw Error("Invalid exact decimal pagination");
+	let ne = a.take === void 0 ? a.skip === void 0 ? o`` : o` LIMIT -1` : o` LIMIT ${a.take}`, re = a.skip === void 0 ? o`` : o` OFFSET ${a.skip}`, $ = o`WITH ${o.unsafe(J)} SELECT ${a.distinct ? o`DISTINCT ` : o``}${o.join(", ", !1)(I)} FROM result0${o.unsafe(Y)}${Z}${Q}${ne}${re}`.compile(), ie = v.materialized ? V[1] : M.flatMap(() => V[1]);
+	return o.unsafe($[0], [...ie, ...$[1]]);
+}, v = (e, t, n, r = null) => {
+	let i = a(e, n.resultScale), s = new Set((i.ctes ?? []).map((e) => e.name));
+	return _(i, t, n, (e) => s.has(e) ? e : o(r, e));
+};
+//#endregion
+export { v as compileSqliteDecimalQuery };

package/dist/sqliteDecimalQueryPlan.js

@@ -0,0 +1,37 @@
+import { getTable as e } from "./tableRegistry.js";
+import { isSqliteDecimalEncodedColumn as t } from "./sqliteDecimalStorage.js";
+//#region src/sqliteDecimalQueryPlan.ts
+var n = (e) => e.replace(/[A-Z]/g, (e) => e.toLowerCase()), r = (e) => {
+	if (Object.getPrototypeOf(e) !== Object.prototype) return !1;
+	for (let t of Object.values(Object.getOwnPropertyDescriptors(e))) {
+		if (!("value" in t) || !t.value || Object.getPrototypeOf(t.value) !== Object.prototype) return !1;
+		for (let e of [
+			"type",
+			"sqliteDecimalEncoding",
+			"precision",
+			"scale"
+		]) {
+			let n = Object.getOwnPropertyDescriptor(t.value, e);
+			if (n && !("value" in n)) return !1;
+		}
+	}
+	return !0;
+}, i = (i) => {
+	let a, o = !1, s, c = (e, t) => e ? "and" in e ? e.and.some((e) => c(e, t)) : "or" in e ? e.or.some((e) => c(e, t)) : "not" in e ? c(e.not, t) : "subquery" in e && l(e.subquery, t) : !1, l = (i, u) => {
+		let d = /* @__PURE__ */ new Set([...u, ...(i.ctes ?? []).map((e) => n(e.name))]), f = (i, c) => {
+			if (d.has(n(i))) return !1;
+			let l = c?.tableName === i ? c : e(i);
+			if (l === void 0) return !1;
+			if (a === void 0) return a = l, o = Object.values(l.fields).some(t), o;
+			s ??= /* @__PURE__ */ new Map([[a, { result: o }]]);
+			let u = s.get(l);
+			if (u !== void 0 && (u.ordinary ??= r(l.fields), u.ordinary)) return u.result;
+			let f = Object.values(l.fields).some(t);
+			return u === void 0 && s.set(l, { result: f }), f;
+		};
+		return f(i.table, i.sourceTable) || (i.joins ?? []).some((e) => f(e.table, e.sourceTable) || c(e.on, d)) || (i.ctes ?? []).some((e) => l(e.descriptor, d)) || (i.setOp?.queries ?? []).some((e) => l(e, d)) || c(i.predicate, d) || c(i.having, d);
+	};
+	return l(i, /* @__PURE__ */ new Set());
+};
+//#endregion
+export { i as hasEncodedSqliteDecimalSource };

package/dist/sqliteDecimalResultSql.js

@@ -0,0 +1,44 @@
+//#region src/sqliteDecimalResultSql.ts
+var e = (e, t) => {
+	if (!Number.isSafeInteger(e) || e < 1 || !Number.isSafeInteger(t) || t < 0 || t > e) throw RangeError("Invalid decimal result shape");
+}, t = (t, n) => {
+	if (e(n, 0), !/^-?(?:0|[1-9]\d*)$/.test(t)) throw TypeError("Expected canonical decimal units");
+	let r = t.replace(/^-/, "");
+	if (r.length > n) throw RangeError("Decimal result exceeds declared width");
+	let i = r.padStart(n, "0");
+	return t.startsWith("-") && r !== "0" ? "0" + i.replace(/\d/g, (e) => String(9 - Number(e))) : "1" + i;
+}, n = ({ sourceSql: t, digits: n, scale: r, materialized: i = !1, stages: a }) => {
+	e(n, r);
+	let o = "0".repeat(n), s = "ltrim(units,'-')", c = `substr('${o}'||${s},-${n})`, l = c;
+	for (let e = 0; e < 10; e++) l = `replace(${l},'${e}','${String.fromCharCode(97 + e)}')`;
+	let u = l;
+	l = "decimal_complement";
+	for (let e = 0; e < 10; e++) l = `replace(${l},'${String.fromCharCode(97 + e)}','${9 - e}')`;
+	let d = `substr(units,1,1)='-' AND ${s}<>'0'`, f = `CASE WHEN ${d} THEN '0'||${l} ELSE '1'||${c} END`, p = `substr('${"0".repeat(r + 1)}'||${s},-max(length(${s}),${r + 1}))`, m = r === 0 ? s : `substr(${p},1,length(${p})-${r})||'.'||substr(${p},-${r})`, h = `WHEN length(${s})>${n} THEN abs(-9223372036854775808)`, g = i ? t : `SELECT * FROM (${t}) LIMIT -1 OFFSET 0`;
+	if (a && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(a.prefix)) throw Error("Invalid decimal stage prefix");
+	let _ = (a?.prefix ?? "") + "decimal_result_source", v = _ + "_encoded", y = (e) => a?.reference?.(e) ?? e;
+	a && a.append(_, t, i);
+	let b = `SELECT ${_}.*,${u} AS decimal_complement FROM ${y(_)}`;
+	return a && a.append(v, b, i), `${a ? "" : `WITH ${_} AS${i ? " MATERIALIZED" : ""} (${g}), ${v} AS${i ? " MATERIALIZED" : ""} (${b}) `}SELECT ${v}.*,
+    CASE WHEN units IS NULL THEN NULL ${h} ELSE ${f} END AS decimal_key,
+    CASE WHEN units IS NULL THEN NULL ${h} ELSE (CASE WHEN ${d} THEN '-' ELSE '' END)||${m} END AS decimal_value
+    FROM ${y(v)}`;
+}, r = (t, n, r) => {
+	e(t.digits, t.scale), e(r.digits, r.scale);
+	let i = {
+		eq: "=",
+		neq: "<>",
+		gt: ">",
+		gte: ">=",
+		lt: "<",
+		lte: "<="
+	}[n];
+	if (i === void 0) throw RangeError("Invalid decimal result comparison");
+	let a = Math.max(t.scale, r.scale), o = Math.max(t.digits - t.scale, r.digits - r.scale), s = ({ expression: e, digits: t, scale: n }) => {
+		let r = o - (t - n), i = a - n;
+		return `(CASE WHEN substr((${e}),1,1)='0' THEN '0${"9".repeat(r)}'||substr((${e}),2)||'${"9".repeat(i)}' ELSE '1${"0".repeat(r)}'||substr((${e}),2)||'${"0".repeat(i)}' END) COLLATE BINARY`;
+	};
+	return `(${s(t)} ${i} ${s(r)})`;
+};
+//#endregion
+export { n as compileSqliteDecimalResult, r as compileSqliteDecimalResultComparison, t as sqliteDecimalResultKey };

package/dist/sqliteDecimalRowQuery.js

@@ -0,0 +1,63 @@
+import { getTable as e } from "./tableRegistry.js";
+import { isSqliteDecimalEncodedColumn as t } from "./sqliteDecimalStorage.js";
+import { prepareProjectedColumn as n } from "./projectedColumn.js";
+import { compileSqliteDecimalDecodedRows as r } from "./sqliteDecimalColumnSql.js";
+import { compileSqliteDecimalSource as i } from "./sqliteDecimalSource.js";
+//#region src/sqliteDecimalRowQuery.ts
+var a = (a, o, s, c, l) => {
+	if (a.groupBy?.length || a.having) throw Error("Row queries cannot contain aggregate clauses");
+	let u = n(a), d = a.sourceTable?.tableName === a.table ? a.sourceTable : e(a.table), f = a.joinedProjection ?? (a.projection?.length ? a.projection : Object.keys(d?.fields ?? {})).map((e) => ({
+		source: e.includes(".") ? e : `${a.alias ?? a.table}.${e}`,
+		outputKey: e.split(".").at(-1)
+	}));
+	if (!f.length) throw Error("Exact row projection requires declared source columns");
+	if (new Set(f.map((e) => e.outputKey)).size !== f.length) throw Error("Duplicate exact row output key");
+	let p = a.order.length >= 8 && f.length >= 8 ? new Map(f.map((e) => [e.outputKey, e.source])) : void 0, m = f.map((e, t) => {
+		let n = u(e.source);
+		if (!n) throw Error("Exact row projection requires declared source columns");
+		return {
+			...e,
+			field: n,
+			internal: `v${t}`
+		};
+	}), h = a.order.map((e, t) => {
+		let n = (p === void 0 ? f.find((t) => t.outputKey === e.column)?.source : p.get(e.column)) ?? e.column, r = u(n);
+		if (!r) throw Error("Exact row order requires a declared source column");
+		return {
+			...e,
+			source: n,
+			field: r,
+			internal: `o${t}`
+		};
+	});
+	for (let e of [a.take, a.skip]) if (e !== void 0 && (!Number.isSafeInteger(e) || e < 0)) throw Error("Invalid exact decimal pagination");
+	let { from: g, where: _ } = i(a, o, s), v = [...m, ...h], [y, b] = o`SELECT ${o.join(", ", !1)(v.map((e) => o`${o(e.source)} AS ${o(e.internal)}`))} FROM ${g}${_}`.compile(), x = l ?? c, S = x?.prefix ?? "__voltro_decimal_rows_";
+	for (; y.toLowerCase().includes(S.toLowerCase());) S += "_";
+	let C = [], w = (e, t) => {
+		x ? x.append(e, t) : C.push(`${e} AS MATERIALIZED (${t})`);
+	}, T = `${S}input`;
+	w(T, y);
+	let E = m.filter((e) => t(e.field));
+	if (c) for (let e of E) c.encodedOutput(e.outputKey);
+	let D = r(T, c ? [] : E.map((e) => ({
+		name: e.internal,
+		shape: {
+			precision: e.field.precision,
+			scale: e.field.scale
+		}
+	})), v.map((e) => e.internal), {
+		prefix: S,
+		append: w
+	});
+	T = D.source;
+	let O = m.map((e) => {
+		let t = D.values.get(e.internal);
+		return o`${t ? o.unsafe(t) : e.field.type === "bigint" ? o`CAST(${o(e.internal)} AS TEXT)` : o`${o(e.internal)}`} AS ${o(e.outputKey)}`;
+	}), k = h.length ? o` ORDER BY ${o.join(", ", !1)(h.map((e) => {
+		let n = t(e.field) ? o`${o(e.internal)} COLLATE BINARY` : o`${o(e.internal)}`;
+		return e.direction === "desc" ? o`${n} DESC` : o`${n} ASC`;
+	}))}` : o``, A = a.take === void 0 ? a.skip === void 0 ? o`` : o` LIMIT -1` : o` LIMIT ${a.take}`, j = a.skip === void 0 ? o`` : o` OFFSET ${a.skip}`, M = C.length ? `WITH ${C.join(",")} ` : "", N = o`SELECT ${a.distinct ? o`DISTINCT ` : o``}${o.join(", ", !1)(O)} FROM ${o(T)}${k}${A}${j}`.compile();
+	return o.unsafe(M + N[0], [...b, ...N[1]]);
+};
+//#endregion
+export { a as compileSqliteDecimalRowQuery };