documents.js 1.63.0 → 1.65.0

package/dist/odb/sql/evaluate.js

@@ -0,0 +1,311 @@
+import { CELL_NULL, aggregateCellValues, cellComparisonKey, compareCellValues } from "../values.js";
+import { HsqldbSqlEvaluationError } from "./errors.js";
+//#region src/odb/sql/evaluate.ts
+function sqlFailure(sql) {
+	return (message) => new HsqldbSqlEvaluationError(message, sql);
+}
+function compareValues(left, right, sql) {
+	return 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 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 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 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 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 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 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 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 = cellComparisonKey(value);
+	if (key === void 0) return "unknown";
+	if (key.valueClass !== "text") throw new 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 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 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 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 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 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 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 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 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
+export { evaluateSelect };

package/dist/odb/sql/lexer.cjs

@@ -0,0 +1,282 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_odb_sql_errors = require("./errors.cjs");
+//#region src/odb/sql/lexer.ts
+const KEYWORDS = /* @__PURE__ */ new Set([
+	"SELECT",
+	"FROM",
+	"WHERE",
+	"GROUP",
+	"BY",
+	"ORDER",
+	"ASC",
+	"DESC",
+	"AND",
+	"OR",
+	"NOT",
+	"IS",
+	"NULL",
+	"LIKE",
+	"IN",
+	"BETWEEN",
+	"TRUE",
+	"FALSE",
+	"COUNT",
+	"SUM",
+	"AVG",
+	"MIN",
+	"MAX",
+	"JOIN",
+	"INNER",
+	"OUTER",
+	"LEFT",
+	"RIGHT",
+	"FULL",
+	"CROSS",
+	"NATURAL",
+	"ON",
+	"USING",
+	"UNION",
+	"INTERSECT",
+	"EXCEPT",
+	"MINUS",
+	"DISTINCT",
+	"ALL",
+	"HAVING",
+	"LIMIT",
+	"OFFSET",
+	"FETCH",
+	"TOP",
+	"AS",
+	"CASE",
+	"WHEN",
+	"THEN",
+	"ELSE",
+	"END",
+	"EXISTS",
+	"ANY",
+	"SOME",
+	"WITH",
+	"INSERT",
+	"UPDATE",
+	"DELETE",
+	"CREATE",
+	"DROP",
+	"ALTER",
+	"INTO",
+	"VALUES",
+	"SET",
+	"ESCAPE",
+	"COLLATE",
+	"NULLS",
+	"FIRST",
+	"LAST"
+]);
+const UNSUPPORTED_SYMBOLS = [
+	["--", "a SQL line comment"],
+	["/*", "a SQL block comment"],
+	["||", "the || string-concatenation operator"],
+	["!=", "the != operator (write <> instead)"],
+	["+", "an arithmetic expression"],
+	["/", "an arithmetic expression"],
+	["%", "an arithmetic expression"],
+	["?", "a parameter placeholder"],
+	[":", "a named parameter"],
+	["@", "a variable reference"],
+	["#", "a variable reference"],
+	["&", "a bitwise operator"],
+	["|", "a bitwise operator"],
+	["^", "a bitwise operator"],
+	["~", "a bitwise operator"],
+	["!", "the ! operator"]
+];
+function isDigit(character) {
+	return character >= "0" && character <= "9";
+}
+function isIdentifierStart(character) {
+	return character >= "A" && character <= "Z" || character >= "a" && character <= "z" || character === "_";
+}
+function isIdentifierPart(character) {
+	return isIdentifierStart(character) || isDigit(character) || character === "$";
+}
+function isWhitespace(character) {
+	return character === " " || character === "	" || character === "\n" || character === "\r" || character === "\f" || character === "\v";
+}
+function readNumber(sql, start) {
+	let cursor = start;
+	while (cursor < sql.length && isDigit(sql.charAt(cursor))) cursor += 1;
+	if (cursor < sql.length && sql.charAt(cursor) === ".") {
+		cursor += 1;
+		while (cursor < sql.length && isDigit(sql.charAt(cursor))) cursor += 1;
+	}
+	if (cursor < sql.length && (sql.charAt(cursor) === "e" || sql.charAt(cursor) === "E")) {
+		const exponentStart = cursor;
+		cursor += 1;
+		if (cursor < sql.length && (sql.charAt(cursor) === "+" || sql.charAt(cursor) === "-")) cursor += 1;
+		if (cursor < sql.length && isDigit(sql.charAt(cursor))) while (cursor < sql.length && isDigit(sql.charAt(cursor))) cursor += 1;
+		else cursor = exponentStart;
+	}
+	const text = sql.slice(start, cursor);
+	const value = Number(text);
+	if (!Number.isFinite(value)) throw new require_odb_sql_errors.HsqldbSqlParseError(`numeric literal "${text}" is not a finite number`, sql, start);
+	return {
+		value,
+		next: cursor
+	};
+}
+function readStringLiteral(sql, start) {
+	let cursor = start + 1;
+	let value = "";
+	while (cursor < sql.length) {
+		const character = sql.charAt(cursor);
+		if (character === "'") {
+			if (sql.charAt(cursor + 1) === "'") {
+				value += "'";
+				cursor += 2;
+				continue;
+			}
+			return {
+				value,
+				next: cursor + 1
+			};
+		}
+		value += character;
+		cursor += 1;
+	}
+	throw new require_odb_sql_errors.HsqldbSqlParseError("unterminated string literal", sql, start);
+}
+function readQuotedIdentifier(sql, start) {
+	let cursor = start + 1;
+	let name = "";
+	while (cursor < sql.length) {
+		const character = sql.charAt(cursor);
+		if (character === "\"") {
+			if (sql.charAt(cursor + 1) === "\"") {
+				name += "\"";
+				cursor += 2;
+				continue;
+			}
+			if (name === "") throw new require_odb_sql_errors.HsqldbSqlParseError("empty quoted identifier (\"\")", sql, start);
+			return {
+				name,
+				next: cursor + 1
+			};
+		}
+		name += character;
+		cursor += 1;
+	}
+	throw new require_odb_sql_errors.HsqldbSqlParseError("unterminated quoted identifier", sql, start);
+}
+function unsupportedSymbolAt(sql, cursor) {
+	for (const [symbol, construct] of UNSUPPORTED_SYMBOLS) if (sql.startsWith(symbol, cursor)) return construct;
+}
+function tokenizeSql(sql) {
+	const tokens = [];
+	let cursor = 0;
+	while (cursor < sql.length) {
+		const character = sql.charAt(cursor);
+		if (isWhitespace(character)) {
+			cursor += 1;
+			continue;
+		}
+		if (character === "'") {
+			const start = cursor;
+			const literal = readStringLiteral(sql, cursor);
+			cursor = literal.next;
+			tokens.push({
+				kind: "string",
+				value: literal.value,
+				text: sql.slice(start, cursor),
+				start
+			});
+			continue;
+		}
+		if (character === "\"") {
+			const start = cursor;
+			const identifier = readQuotedIdentifier(sql, cursor);
+			cursor = identifier.next;
+			tokens.push({
+				kind: "identifier",
+				name: identifier.name,
+				quoted: true,
+				text: sql.slice(start, cursor),
+				start
+			});
+			continue;
+		}
+		if (isDigit(character) || character === "." && isDigit(sql.charAt(cursor + 1))) {
+			const start = cursor;
+			const numeric = readNumber(sql, cursor);
+			cursor = numeric.next;
+			tokens.push({
+				kind: "number",
+				value: numeric.value,
+				text: sql.slice(start, cursor),
+				start
+			});
+			continue;
+		}
+		if (isIdentifierStart(character)) {
+			const start = cursor;
+			while (cursor < sql.length && isIdentifierPart(sql.charAt(cursor))) cursor += 1;
+			const text = sql.slice(start, cursor);
+			const folded = text.toUpperCase();
+			if (KEYWORDS.has(folded)) tokens.push({
+				kind: "keyword",
+				keyword: folded,
+				text,
+				start
+			});
+			else tokens.push({
+				kind: "identifier",
+				name: folded,
+				quoted: false,
+				text,
+				start
+			});
+			continue;
+		}
+		if (character === "<" || character === ">" || character === "=") {
+			const start = cursor;
+			const twoCharacter = sql.slice(cursor, cursor + 2);
+			if (twoCharacter === "<=" || twoCharacter === ">=" || twoCharacter === "<>") {
+				cursor += 2;
+				tokens.push({
+					kind: "operator",
+					operator: twoCharacter,
+					text: twoCharacter,
+					start
+				});
+				continue;
+			}
+			cursor += 1;
+			tokens.push({
+				kind: "operator",
+				operator: character,
+				text: character,
+				start
+			});
+			continue;
+		}
+		const unsupported = unsupportedSymbolAt(sql, cursor);
+		if (unsupported !== void 0) throw new require_odb_sql_errors.HsqldbSqlUnsupportedError(unsupported, sql);
+		if (character === "(" || character === ")" || character === "," || character === "." || character === "*" || character === ";" || character === "-") {
+			tokens.push({
+				kind: "punctuation",
+				punctuation: character,
+				text: character,
+				start: cursor
+			});
+			cursor += 1;
+			continue;
+		}
+		throw new require_odb_sql_errors.HsqldbSqlParseError(`unexpected character "${character}"`, sql, cursor);
+	}
+	tokens.push({
+		kind: "end",
+		text: "",
+		start: sql.length
+	});
+	return tokens;
+}
+//#endregion
+exports.tokenizeSql = tokenizeSql;

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

@@ -0,0 +1,2 @@
+import { i as tokenizeSql, n as SqlPunctuation, r as SqlToken, t as SqlComparisonOperator } from "../../lexer-DGPWx_f2.cjs";
+export { SqlComparisonOperator, SqlPunctuation, SqlToken, tokenizeSql };

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

@@ -0,0 +1,2 @@
+import { i as tokenizeSql, n as SqlPunctuation, r as SqlToken, t as SqlComparisonOperator } from "../../lexer-DGPWx_f2.js";
+export { SqlComparisonOperator, SqlPunctuation, SqlToken, tokenizeSql };