documents.js 1.63.0 → 1.65.0

package/dist/odb/report/render.js

@@ -0,0 +1,106 @@
+import { PAGE_SIZE_A4 } from "../../model/geometry.js";
+import { displayTextFor } from "../../hsqldb/script.js";
+import { evaluateRptBandOutsideData, runRptReport } from "../formula/evaluate.js";
+import { odbReportGroupChain, rptBandDefinition, rptDefinitionFromReport } from "../formula/definition.js";
+import { CONTENT_FORMAT_VERSION } from "document-schema.js";
+//#region src/odb/report/render.ts
+const MARGIN_PT = 56.69291338582677;
+const CONTENT_WIDTH_PT = PAGE_SIZE_A4.widthPt - 2 * MARGIN_PT;
+const REPORT_HEADER_STYLE = "Report Header";
+const PAGE_HEADER_STYLE = "Page Header";
+const DETAIL_STYLE = "Detail";
+const PAGE_FOOTER_STYLE = "Page Footer";
+const REPORT_FOOTER_STYLE = "Report Footer";
+function groupBandStyle(kind, level) {
+	return `${kind === "group-header" ? "Group Header" : "Group Footer"} ${String(level + 1)}`;
+}
+function printedBand(band, styleId, values) {
+	if (band === void 0) throw new Error(`rpt report render: a "${styleId}" band instance was emitted for a band this report does not declare`);
+	return {
+		styleId,
+		elements: band.elements,
+		values
+	};
+}
+function bandOfInstance(report, groups, instance) {
+	switch (instance.kind) {
+		case "report-header": return printedBand(report.reportHeader, REPORT_HEADER_STYLE, instance.values);
+		case "detail": return printedBand(report.detail, DETAIL_STYLE, instance.values);
+		case "report-footer": return printedBand(report.reportFooter, REPORT_FOOTER_STYLE, instance.values);
+		case "group-header":
+		case "group-footer": {
+			const level = instance.groupLevel;
+			if (level === void 0) throw new Error(`rpt report render: a ${instance.kind} band instance carries no group level`);
+			const group = groups[level];
+			if (group === void 0) throw new Error(`rpt report render: a ${instance.kind} band instance names group level ${String(level)}, which this report's own chain of ${String(groups.length)} group(s) does not reach`);
+			return printedBand(instance.kind === "group-header" ? group.header : group.footer, groupBandStyle(instance.kind, level), instance.values);
+		}
+	}
+}
+function elementText(element, value) {
+	if (element.formula === void 0) return element.text ?? "";
+	if (value === void 0) throw new Error(`rpt report render: control "${element.formula}" carries a formula but the run produced no value for it`);
+	return displayTextFor(value);
+}
+function cellParagraph(element, value, styleId) {
+	const text = elementText(element, value);
+	return {
+		kind: "paragraph",
+		styleId,
+		runs: text === "" ? [] : [{ text }]
+	};
+}
+function bandTable(band) {
+	if (band.elements.length === 0) return;
+	if (band.values.length !== band.elements.length) throw new Error(`rpt report render: the "${band.styleId}" band printed ${String(band.values.length)} values for ${String(band.elements.length)} control(s)`);
+	const columnWidthPt = CONTENT_WIDTH_PT / band.elements.length;
+	return {
+		kind: "table",
+		columnWidthsPt: band.elements.map(() => columnWidthPt),
+		rows: [{ cells: band.elements.map((element, index) => ({ blocks: [cellParagraph(element, band.values[index], band.styleId)] })) }]
+	};
+}
+function bandBlocks(bands) {
+	return bands.flatMap((band) => {
+		const table = bandTable(band);
+		return table === void 0 ? [] : [table];
+	});
+}
+function pageBands(definition, band, styleId, resultSet) {
+	if (band === void 0) return [];
+	return [{
+		styleId,
+		elements: band.elements,
+		values: evaluateRptBandOutsideData(definition, rptBandDefinition(band), resultSet)
+	}];
+}
+function renderOdbReportContent(report, resultSet) {
+	const definition = rptDefinitionFromReport(report);
+	const groups = odbReportGroupChain(report);
+	const instances = runRptReport(definition, resultSet).bands;
+	const printed = (matches) => instances.filter((instance) => matches(instance.kind)).map((instance) => bandOfInstance(report, groups, instance));
+	const section = {
+		pageSize: PAGE_SIZE_A4,
+		margins: {
+			topPt: MARGIN_PT,
+			rightPt: MARGIN_PT,
+			bottomPt: MARGIN_PT,
+			leftPt: MARGIN_PT
+		},
+		blocks: [
+			...bandBlocks(printed((kind) => kind === "report-header")),
+			...bandBlocks(pageBands(definition, report.pageHeader, PAGE_HEADER_STYLE, resultSet)),
+			...bandBlocks(printed((kind) => kind !== "report-header" && kind !== "report-footer")),
+			...bandBlocks(pageBands(definition, report.pageFooter, PAGE_FOOTER_STYLE, resultSet)),
+			...bandBlocks(printed((kind) => kind === "report-footer"))
+		]
+	};
+	return {
+		kind: "wordprocessing",
+		formatVersion: CONTENT_FORMAT_VERSION,
+		metadata: { title: report.caption ?? report.name },
+		sections: [section]
+	};
+}
+//#endregion
+export { renderOdbReportContent };

package/dist/odb/report/source.cjs

@@ -0,0 +1,45 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_odb_read = require("../read.cjs");
+const require_odb_sql_evaluate = require("../sql/evaluate.cjs");
+const require_odb_sql_parser = require("../sql/parser.cjs");
+let odf_js = require("odf.js");
+//#region src/odb/report/source.ts
+var OdbReportDataSourceError = class extends Error {
+	reportName;
+	command;
+	commandType;
+	constructor(message, report) {
+		super(`Report "${report.name}" data source: ${message}`);
+		this.name = "OdbReportDataSourceError";
+		this.reportName = report.name;
+		this.command = report.command;
+		this.commandType = report.commandType;
+	}
+};
+function quotedIdentifier(name) {
+	return `"${name.replace(/"/g, "\"\"")}"`;
+}
+function savedQueryCommand(report, commandName, queries) {
+	const query = queries.find((candidate) => candidate.name === commandName);
+	if (query === void 0) throw new OdbReportDataSourceError(`rpt:command-type is "query" and rpt:command names "${commandName}", but this .odb declares no such saved query -- available quer${queries.length === 1 ? "y" : "ies"}: ${queries.length === 0 ? "(none)" : queries.map((candidate) => candidate.name).join(", ")}`, report);
+	return query.command;
+}
+function odbReportCommandSql(report, queries) {
+	const command = report.command;
+	if (command === void 0) throw new OdbReportDataSourceError("the report declares no rpt:command, so there is no table, query, or statement to read its rows from", report);
+	switch (report.commandType) {
+		case "table": return `SELECT * FROM ${quotedIdentifier(command)}`;
+		case "query": return savedQueryCommand(report, command, queries);
+		case "command": return command;
+		case void 0: throw new OdbReportDataSourceError(`the report declares rpt:command "${command}" but no rpt:command-type, so whether that names a table, a saved query, or a literal statement is undetermined`, report);
+		default: throw new OdbReportDataSourceError(`rpt:command-type "${report.commandType}" is not one of the three values this package resolves ("table", "query", "command")`, report);
+	}
+}
+function resolveOdbReportRows(pkg, report, options) {
+	const sql = odbReportCommandSql(report, (0, odf_js.readOdbInventory)(pkg).queries);
+	return require_odb_sql_evaluate.evaluateSelect(require_odb_sql_parser.parseSelect(sql), require_odb_read.readOdbTables(pkg, options));
+}
+//#endregion
+exports.OdbReportDataSourceError = OdbReportDataSourceError;
+exports.odbReportCommandSql = odbReportCommandSql;
+exports.resolveOdbReportRows = resolveOdbReportRows;

package/dist/odb/report/source.d.cts

@@ -0,0 +1,14 @@
+import { n as HsqldbDecodeOptions } from "../../rowformat-Cl2exlEh.cjs";
+import { t as SqlResultSet } from "../../evaluate-BhMXY6DM.cjs";
+import { OdbQueryInfo, OdbReport, Package } from "odf.js";
+//#region src/odb/report/source.d.ts
+declare class OdbReportDataSourceError extends Error {
+  readonly reportName: string;
+  readonly command: string | undefined;
+  readonly commandType: string | undefined;
+  constructor(message: string, report: OdbReport);
+}
+declare function odbReportCommandSql(report: OdbReport, queries: readonly OdbQueryInfo[]): string;
+declare function resolveOdbReportRows(pkg: Package, report: OdbReport, options?: HsqldbDecodeOptions): SqlResultSet;
+//#endregion
+export { OdbReportDataSourceError, odbReportCommandSql, resolveOdbReportRows };

package/dist/odb/report/source.d.ts

@@ -0,0 +1,14 @@
+import { n as HsqldbDecodeOptions } from "../../rowformat-Cl2exlEh.js";
+import { t as SqlResultSet } from "../../evaluate-BU5N1Jk1.js";
+import { OdbQueryInfo, OdbReport, Package } from "odf.js";
+//#region src/odb/report/source.d.ts
+declare class OdbReportDataSourceError extends Error {
+  readonly reportName: string;
+  readonly command: string | undefined;
+  readonly commandType: string | undefined;
+  constructor(message: string, report: OdbReport);
+}
+declare function odbReportCommandSql(report: OdbReport, queries: readonly OdbQueryInfo[]): string;
+declare function resolveOdbReportRows(pkg: Package, report: OdbReport, options?: HsqldbDecodeOptions): SqlResultSet;
+//#endregion
+export { OdbReportDataSourceError, odbReportCommandSql, resolveOdbReportRows };

package/dist/odb/report/source.js

@@ -0,0 +1,42 @@
+import { readOdbTables } from "../read.js";
+import { evaluateSelect } from "../sql/evaluate.js";
+import { parseSelect } from "../sql/parser.js";
+import { readOdbInventory } from "odf.js";
+//#region src/odb/report/source.ts
+var OdbReportDataSourceError = class extends Error {
+	reportName;
+	command;
+	commandType;
+	constructor(message, report) {
+		super(`Report "${report.name}" data source: ${message}`);
+		this.name = "OdbReportDataSourceError";
+		this.reportName = report.name;
+		this.command = report.command;
+		this.commandType = report.commandType;
+	}
+};
+function quotedIdentifier(name) {
+	return `"${name.replace(/"/g, "\"\"")}"`;
+}
+function savedQueryCommand(report, commandName, queries) {
+	const query = queries.find((candidate) => candidate.name === commandName);
+	if (query === void 0) throw new OdbReportDataSourceError(`rpt:command-type is "query" and rpt:command names "${commandName}", but this .odb declares no such saved query -- available quer${queries.length === 1 ? "y" : "ies"}: ${queries.length === 0 ? "(none)" : queries.map((candidate) => candidate.name).join(", ")}`, report);
+	return query.command;
+}
+function odbReportCommandSql(report, queries) {
+	const command = report.command;
+	if (command === void 0) throw new OdbReportDataSourceError("the report declares no rpt:command, so there is no table, query, or statement to read its rows from", report);
+	switch (report.commandType) {
+		case "table": return `SELECT * FROM ${quotedIdentifier(command)}`;
+		case "query": return savedQueryCommand(report, command, queries);
+		case "command": return command;
+		case void 0: throw new OdbReportDataSourceError(`the report declares rpt:command "${command}" but no rpt:command-type, so whether that names a table, a saved query, or a literal statement is undetermined`, report);
+		default: throw new OdbReportDataSourceError(`rpt:command-type "${report.commandType}" is not one of the three values this package resolves ("table", "query", "command")`, report);
+	}
+}
+function resolveOdbReportRows(pkg, report, options) {
+	const sql = odbReportCommandSql(report, readOdbInventory(pkg).queries);
+	return evaluateSelect(parseSelect(sql), readOdbTables(pkg, options));
+}
+//#endregion
+export { OdbReportDataSourceError, odbReportCommandSql, resolveOdbReportRows };

package/dist/odb/spreadsheet.d.cts

@@ -1,4 +1,4 @@
-import { HsqldbTable } from "../hsqldb/script.cjs";
+import { r as HsqldbTable } from "../script-DsGGIzGU.cjs";
 import { ContentDocument } from "document-schema.js";
 //#region src/odb/spreadsheet.d.ts
 declare function odbTablesToSpreadsheetDocument(tables: readonly HsqldbTable[]): ContentDocument;

package/dist/odb/spreadsheet.d.ts

@@ -1,4 +1,4 @@
-import { HsqldbTable } from "../hsqldb/script.js";
+import { r as HsqldbTable } from "../script-DsGGIzGU.js";
 import { ContentDocument } from "document-schema.js";
 //#region src/odb/spreadsheet.d.ts
 declare function odbTablesToSpreadsheetDocument(tables: readonly HsqldbTable[]): ContentDocument;

package/dist/odb/sql/errors.cjs

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/odb/sql/errors.ts
+const MESSAGE_SQL_PREVIEW_LENGTH = 200;
+function truncateForMessage(sql) {
+	return sql.length > MESSAGE_SQL_PREVIEW_LENGTH ? `${sql.slice(0, MESSAGE_SQL_PREVIEW_LENGTH)}...` : sql;
+}
+var HsqldbSqlUnsupportedError = class extends Error {
+	construct;
+	sql;
+	constructor(construct, sql) {
+		super(`HSQLDB SQL: ${construct} is not supported by this bounded single-table query engine -- in statement: ${truncateForMessage(sql)}`);
+		this.name = "HsqldbSqlUnsupportedError";
+		this.construct = construct;
+		this.sql = sql;
+	}
+};
+var HsqldbSqlParseError = class extends Error {
+	sql;
+	offset;
+	constructor(message, sql, offset) {
+		super(`HSQLDB SQL parse error at offset ${String(offset)}: ${message} -- in statement: ${truncateForMessage(sql)}`);
+		this.name = "HsqldbSqlParseError";
+		this.sql = sql;
+		this.offset = offset;
+	}
+};
+var HsqldbSqlEvaluationError = class extends Error {
+	sql;
+	constructor(message, sql) {
+		super(`HSQLDB SQL evaluation error: ${message} -- in statement: ${truncateForMessage(sql)}`);
+		this.name = "HsqldbSqlEvaluationError";
+		this.sql = sql;
+	}
+};
+//#endregion
+exports.HsqldbSqlEvaluationError = HsqldbSqlEvaluationError;
+exports.HsqldbSqlParseError = HsqldbSqlParseError;
+exports.HsqldbSqlUnsupportedError = HsqldbSqlUnsupportedError;

package/dist/odb/sql/errors.d.cts

@@ -0,0 +1,17 @@
+//#region src/odb/sql/errors.d.ts
+declare class HsqldbSqlUnsupportedError extends Error {
+  readonly construct: string;
+  readonly sql: string;
+  constructor(construct: string, sql: string);
+}
+declare class HsqldbSqlParseError extends Error {
+  readonly sql: string;
+  readonly offset: number;
+  constructor(message: string, sql: string, offset: number);
+}
+declare class HsqldbSqlEvaluationError extends Error {
+  readonly sql: string;
+  constructor(message: string, sql: string);
+}
+//#endregion
+export { HsqldbSqlEvaluationError, HsqldbSqlParseError, HsqldbSqlUnsupportedError };

package/dist/odb/sql/errors.d.ts

@@ -0,0 +1,17 @@
+//#region src/odb/sql/errors.d.ts
+declare class HsqldbSqlUnsupportedError extends Error {
+  readonly construct: string;
+  readonly sql: string;
+  constructor(construct: string, sql: string);
+}
+declare class HsqldbSqlParseError extends Error {
+  readonly sql: string;
+  readonly offset: number;
+  constructor(message: string, sql: string, offset: number);
+}
+declare class HsqldbSqlEvaluationError extends Error {
+  readonly sql: string;
+  constructor(message: string, sql: string);
+}
+//#endregion
+export { HsqldbSqlEvaluationError, HsqldbSqlParseError, HsqldbSqlUnsupportedError };

package/dist/odb/sql/errors.js

@@ -0,0 +1,35 @@
+//#region src/odb/sql/errors.ts
+const MESSAGE_SQL_PREVIEW_LENGTH = 200;
+function truncateForMessage(sql) {
+	return sql.length > MESSAGE_SQL_PREVIEW_LENGTH ? `${sql.slice(0, MESSAGE_SQL_PREVIEW_LENGTH)}...` : sql;
+}
+var HsqldbSqlUnsupportedError = class extends Error {
+	construct;
+	sql;
+	constructor(construct, sql) {
+		super(`HSQLDB SQL: ${construct} is not supported by this bounded single-table query engine -- in statement: ${truncateForMessage(sql)}`);
+		this.name = "HsqldbSqlUnsupportedError";
+		this.construct = construct;
+		this.sql = sql;
+	}
+};
+var HsqldbSqlParseError = class extends Error {
+	sql;
+	offset;
+	constructor(message, sql, offset) {
+		super(`HSQLDB SQL parse error at offset ${String(offset)}: ${message} -- in statement: ${truncateForMessage(sql)}`);
+		this.name = "HsqldbSqlParseError";
+		this.sql = sql;
+		this.offset = offset;
+	}
+};
+var HsqldbSqlEvaluationError = class extends Error {
+	sql;
+	constructor(message, sql) {
+		super(`HSQLDB SQL evaluation error: ${message} -- in statement: ${truncateForMessage(sql)}`);
+		this.name = "HsqldbSqlEvaluationError";
+		this.sql = sql;
+	}
+};
+//#endregion
+export { HsqldbSqlEvaluationError, HsqldbSqlParseError, HsqldbSqlUnsupportedError };

package/dist/odb/sql/evaluate.cjs

@@ -0,0 +1,312 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_odb_values = require("../values.cjs");
+const require_odb_sql_errors = require("./errors.cjs");
+//#region src/odb/sql/evaluate.ts
+function sqlFailure(sql) {
+	return (message) => new require_odb_sql_errors.HsqldbSqlEvaluationError(message, sql);
+}
+function compareValues(left, right, sql) {
+	return require_odb_values.compareCellValues(left, right, sqlFailure(sql));
+}
+function truthOfComparison(ordering, operator) {
+	switch (operator) {
+		case "=": return ordering === 0 ? "true" : "false";
+		case "<>": return ordering === 0 ? "false" : "true";
+		case "<": return ordering < 0 ? "true" : "false";
+		case ">": return ordering > 0 ? "true" : "false";
+		case "<=": return ordering <= 0 ? "true" : "false";
+		case ">=": return ordering >= 0 ? "true" : "false";
+	}
+}
+function notTruth(truth) {
+	if (truth === "true") return "false";
+	return truth === "false" ? "true" : "unknown";
+}
+function andTruth(left, right) {
+	if (left === "false" || right === "false") return "false";
+	return left === "true" && right === "true" ? "true" : "unknown";
+}
+function orTruth(left, right) {
+	if (left === "true" || right === "true") return "true";
+	return left === "false" && right === "false" ? "false" : "unknown";
+}
+function literalToValue(literal) {
+	switch (literal.kind) {
+		case "number": return {
+			kind: "number",
+			value: literal.value
+		};
+		case "string": return {
+			kind: "string",
+			value: literal.value
+		};
+		case "boolean": return {
+			kind: "boolean",
+			value: literal.value
+		};
+		case "null": return require_odb_values.CELL_NULL;
+	}
+}
+function likePatternToRegExp(pattern) {
+	let source = "^";
+	for (const character of pattern) if (character === "%") source += "[\\s\\S]*";
+	else if (character === "_") source += "[\\s\\S]";
+	else source += character.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return new RegExp(`${source}$`);
+}
+function resolveName(candidates, ref, what, sql) {
+	const exact = candidates.find((candidate) => candidate === ref.name);
+	if (exact !== void 0) return exact;
+	if (!ref.quoted) {
+		const folded = candidates.filter((candidate) => candidate.toUpperCase() === ref.name);
+		if (folded.length > 1) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`${what} "${ref.name}" is ambiguous -- it matches ${folded.join(", ")} case-insensitively`, sql);
+		const only = folded[0];
+		if (only !== void 0) return only;
+	}
+	throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`${what} "${ref.name}" not found -- available: ${candidates.length === 0 ? "(none)" : candidates.join(", ")}`, sql);
+}
+function resolveTable(tables, ref, sql) {
+	const resolvedName = resolveName(tables.map((table) => table.tableName), ref, "table", sql);
+	const table = tables.find((candidate) => candidate.tableName === resolvedName);
+	if (table === void 0) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`table "${resolvedName}" not found`, sql);
+	return table;
+}
+var ColumnResolver = class {
+	table;
+	sql;
+	cache = /* @__PURE__ */ new Map();
+	columnNames;
+	constructor(table, sql) {
+		this.table = table;
+		this.sql = sql;
+		this.columnNames = table.columns.map((column) => column.name);
+	}
+	nameAt(index) {
+		const name = this.columnNames[index];
+		if (name === void 0) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`column index ${String(index)} is outside table "${this.table.tableName}"`, this.sql);
+		return name;
+	}
+	indexOf(ref) {
+		const cached = this.cache.get(ref);
+		if (cached !== void 0) return cached;
+		if (ref.qualifier !== void 0) {
+			if (resolveName([this.table.tableName], ref.qualifier, "table qualifier", this.sql) !== this.table.tableName) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`table qualifier "${ref.qualifier.name}" does not name the table in FROM ("${this.table.tableName}")`, this.sql);
+		}
+		const index = this.columnNames.indexOf(resolveName(this.columnNames, ref.column, "column", this.sql));
+		this.cache.set(ref, index);
+		return index;
+	}
+	valueAt(index, row) {
+		const value = row[index];
+		if (value === void 0) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`malformed table "${this.table.tableName}": a row carries ${String(row.length)} values but the table declares ${String(this.columnNames.length)} columns`, this.sql);
+		return value;
+	}
+	valueOf(ref, row) {
+		return this.valueAt(this.indexOf(ref), row);
+	}
+};
+function operandValue(operand, row, resolver) {
+	return operand.kind === "literal" ? literalToValue(operand.literal) : resolver.valueOf(operand.column, row);
+}
+function evaluateLike(value, pattern, sql) {
+	const key = require_odb_values.cellComparisonKey(value);
+	if (key === void 0) return "unknown";
+	if (key.valueClass !== "text") throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`LIKE requires a text value, but its left operand is a ${key.valueClass} value`, sql);
+	return likePatternToRegExp(pattern).test(key.text) ? "true" : "false";
+}
+function evaluateIn(value, values, sql) {
+	if (value.kind === "empty") return "unknown";
+	let sawNull = false;
+	for (const literal of values) {
+		const candidate = literalToValue(literal);
+		if (candidate.kind === "empty") {
+			sawNull = true;
+			continue;
+		}
+		if (compareValues(value, candidate, sql) === 0) return "true";
+	}
+	return sawNull ? "unknown" : "false";
+}
+function evaluatePredicate(predicate, row, resolver, sql) {
+	switch (predicate.kind) {
+		case "comparison": {
+			const left = operandValue(predicate.left, row, resolver);
+			const right = operandValue(predicate.right, row, resolver);
+			if (left.kind === "empty" || right.kind === "empty") return "unknown";
+			return truthOfComparison(compareValues(left, right, sql), predicate.operator);
+		}
+		case "isNull": {
+			const isNull = operandValue(predicate.operand, row, resolver).kind === "empty";
+			return (predicate.negated ? !isNull : isNull) ? "true" : "false";
+		}
+		case "like": {
+			const truth = evaluateLike(operandValue(predicate.operand, row, resolver), predicate.pattern, sql);
+			return predicate.negated ? notTruth(truth) : truth;
+		}
+		case "in": {
+			const truth = evaluateIn(operandValue(predicate.operand, row, resolver), predicate.values, sql);
+			return predicate.negated ? notTruth(truth) : truth;
+		}
+		case "between": {
+			const value = operandValue(predicate.operand, row, resolver);
+			const lower = operandValue(predicate.lower, row, resolver);
+			const upper = operandValue(predicate.upper, row, resolver);
+			if (value.kind === "empty" || lower.kind === "empty" || upper.kind === "empty") return "unknown";
+			const truth = andTruth(truthOfComparison(compareValues(value, lower, sql), ">="), truthOfComparison(compareValues(value, upper, sql), "<="));
+			return predicate.negated ? notTruth(truth) : truth;
+		}
+		case "not": return notTruth(evaluatePredicate(predicate.predicate, row, resolver, sql));
+		case "and": return andTruth(evaluatePredicate(predicate.left, row, resolver, sql), evaluatePredicate(predicate.right, row, resolver, sql));
+		case "or": return orTruth(evaluatePredicate(predicate.left, row, resolver, sql), evaluatePredicate(predicate.right, row, resolver, sql));
+	}
+}
+function aggregateOverValues(aggregate, values, sql) {
+	return require_odb_values.aggregateCellValues(aggregate, values, sqlFailure(sql));
+}
+function compareForSort(left, right, sql) {
+	const leftNull = left.kind === "empty";
+	const rightNull = right.kind === "empty";
+	if (leftNull || rightNull) {
+		if (leftNull && rightNull) return 0;
+		return leftNull ? 1 : -1;
+	}
+	return compareValues(left, right, sql);
+}
+function sortRows(rows, directions, sql) {
+	return [...rows].sort((left, right) => {
+		for (const [index, direction] of directions.entries()) {
+			const leftKey = left.sortKeys[index];
+			const rightKey = right.sortKeys[index];
+			if (leftKey === void 0 || rightKey === void 0) throw new require_odb_sql_errors.HsqldbSqlEvaluationError("an ORDER BY term has no sort key on this row", sql);
+			const ordering = compareForSort(leftKey, rightKey, sql);
+			if (ordering !== 0) return direction === "asc" ? ordering : -ordering;
+		}
+		return 0;
+	}).map((row) => row.output);
+}
+function groupKeyOf(values) {
+	return values.map((value) => {
+		switch (value.kind) {
+			case "empty": return "null";
+			case "boolean": return `boolean:${String(value.value)}`;
+			case "number":
+			case "percentage":
+			case "currency": return `numeric:${String(value.value)}`;
+			case "date":
+			case "time":
+			case "dateTime":
+			case "string":
+			case "error": return `text:${value.value}`;
+		}
+	}).join("\0");
+}
+function planSelectList(statement, table, resolver) {
+	const plan = [];
+	for (const item of statement.items) switch (item.kind) {
+		case "star":
+			for (const [index] of table.columns.entries()) plan.push({
+				kind: "column",
+				index,
+				text: resolver.nameAt(index)
+			});
+			break;
+		case "column":
+			plan.push({
+				kind: "column",
+				index: resolver.indexOf(item.column),
+				text: item.column.text
+			});
+			break;
+		case "aggregate": plan.push({
+			kind: "aggregate",
+			aggregate: item.aggregate,
+			argumentIndex: item.argument.kind === "star" ? void 0 : resolver.indexOf(item.argument.column),
+			outputName: item.outputName
+		});
+	}
+	return plan;
+}
+function planColumnNames(plan, resolver) {
+	return plan.map((item) => item.kind === "column" ? resolver.nameAt(item.index) : item.outputName);
+}
+function evaluateUngrouped(statement, plan, matching, resolver) {
+	const projection = plan.map((item) => {
+		if (item.kind !== "column") throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`${item.outputName} is an aggregate, so every other select-list item must be grouped`, statement.sql);
+		return item.index;
+	});
+	const orderIndices = statement.orderBy.map((term) => resolver.indexOf(term.column));
+	const sortable = matching.map((row) => ({
+		output: projection.map((index) => resolver.valueAt(index, row)),
+		sortKeys: orderIndices.map((index) => resolver.valueAt(index, row))
+	}));
+	return {
+		columns: planColumnNames(plan, resolver),
+		rows: sortRows(sortable, statement.orderBy.map((term) => term.direction), statement.sql)
+	};
+}
+function partitionIntoGroups(rows, groupIndices, resolver) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const keyValues = groupIndices.map((index) => resolver.valueAt(index, row));
+		const key = groupKeyOf(keyValues);
+		const existing = groups.get(key);
+		if (existing === void 0) groups.set(key, {
+			keyValues,
+			rows: [row]
+		});
+		else existing.rows.push(row);
+	}
+	return [...groups.values()];
+}
+function evaluateGrouped(statement, plan, matching, resolver) {
+	const groupIndices = statement.groupBy.map((ref) => resolver.indexOf(ref));
+	for (const item of plan) if (item.kind === "column" && !groupIndices.includes(item.index)) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`column "${item.text}" is neither grouped nor aggregated -- add it to GROUP BY or wrap it in an aggregate`, statement.sql);
+	const groups = groupIndices.length === 0 ? [{
+		keyValues: [],
+		rows: [...matching]
+	}] : partitionIntoGroups(matching, groupIndices, resolver);
+	const orderPositions = statement.orderBy.map((term) => {
+		const position = groupIndices.indexOf(resolver.indexOf(term.column));
+		if (position < 0) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`ORDER BY column "${term.column.text}" is not a GROUP BY column -- a grouped result has no single value for it`, statement.sql);
+		return position;
+	});
+	const sortable = groups.map((group) => ({
+		output: plan.map((item) => {
+			if (item.kind === "aggregate") {
+				const argumentIndex = item.argumentIndex;
+				if (argumentIndex === void 0) return {
+					kind: "number",
+					value: group.rows.length
+				};
+				return aggregateOverValues(item.aggregate, group.rows.map((row) => resolver.valueAt(argumentIndex, row)), statement.sql);
+			}
+			const keyValue = group.keyValues[groupIndices.indexOf(item.index)];
+			if (keyValue === void 0) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`grouped column "${item.text}" has no value on this group`, statement.sql);
+			return keyValue;
+		}),
+		sortKeys: orderPositions.map((position) => {
+			const keyValue = group.keyValues[position];
+			if (keyValue === void 0) throw new require_odb_sql_errors.HsqldbSqlEvaluationError("an ORDER BY term resolved to a GROUP BY column with no value on this group", statement.sql);
+			return keyValue;
+		})
+	}));
+	return {
+		columns: planColumnNames(plan, resolver),
+		rows: sortRows(sortable, statement.orderBy.map((term) => term.direction), statement.sql)
+	};
+}
+function evaluateSelect(statement, tables) {
+	const table = resolveTable(tables, statement.from, statement.sql);
+	const resolver = new ColumnResolver(table, statement.sql);
+	const plan = planSelectList(statement, table, resolver);
+	const where = statement.where;
+	const matching = where === void 0 ? table.rows : table.rows.filter((row) => evaluatePredicate(where, row, resolver, statement.sql) === "true");
+	const hasAggregate = plan.some((item) => item.kind === "aggregate");
+	if (statement.groupBy.length > 0 || hasAggregate) {
+		if (statement.groupBy.length > 0 && statement.items.some((item) => item.kind === "star")) throw new require_odb_sql_errors.HsqldbSqlEvaluationError("SELECT * is not valid with GROUP BY -- name the grouped columns and the aggregates explicitly", statement.sql);
+		return evaluateGrouped(statement, plan, matching, resolver);
+	}
+	return evaluateUngrouped(statement, plan, matching, resolver);
+}
+//#endregion
+exports.evaluateSelect = evaluateSelect;

package/dist/odb/sql/evaluate.d.cts

@@ -0,0 +1,2 @@
+import { n as evaluateSelect, t as SqlResultSet } from "../../evaluate-BhMXY6DM.cjs";
+export { SqlResultSet, evaluateSelect };

package/dist/odb/sql/evaluate.d.ts

@@ -0,0 +1,2 @@
+import { n as evaluateSelect, t as SqlResultSet } from "../../evaluate-BU5N1Jk1.js";
+export { SqlResultSet, evaluateSelect };