documents.js 1.63.0 → 1.64.0

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 };