documents.js 1.63.0 → 1.64.0

package/dist/odb/sql/parser.js

@@ -0,0 +1,478 @@
+import { HsqldbSqlParseError, HsqldbSqlUnsupportedError } from "./errors.js";
+import { tokenizeSql } from "./lexer.js";
+//#region src/odb/sql/parser.ts
+const AGGREGATE_FUNCTIONS = /* @__PURE__ */ new Set([
+	"COUNT",
+	"SUM",
+	"AVG",
+	"MIN",
+	"MAX"
+]);
+function isAggregateFunction(keyword) {
+	return AGGREGATE_FUNCTIONS.has(keyword);
+}
+const OUT_OF_SCOPE_KEYWORDS = /* @__PURE__ */ new Map([
+	["JOIN", "a JOIN"],
+	["INNER", "a JOIN"],
+	["OUTER", "a JOIN"],
+	["LEFT", "a JOIN"],
+	["RIGHT", "a JOIN"],
+	["FULL", "a JOIN"],
+	["CROSS", "a JOIN"],
+	["NATURAL", "a JOIN"],
+	["ON", "a JOIN"],
+	["USING", "a JOIN"],
+	["UNION", "UNION"],
+	["INTERSECT", "INTERSECT"],
+	["EXCEPT", "EXCEPT"],
+	["MINUS", "EXCEPT (MINUS)"],
+	["DISTINCT", "DISTINCT"],
+	["ALL", "the ALL quantifier"],
+	["HAVING", "HAVING"],
+	["LIMIT", "a row-limit clause (LIMIT)"],
+	["OFFSET", "a row-limit clause (OFFSET)"],
+	["FETCH", "a row-limit clause (FETCH)"],
+	["TOP", "a row-limit clause (TOP)"],
+	["AS", "a column or table alias (AS)"],
+	["CASE", "a CASE expression"],
+	["WHEN", "a CASE expression"],
+	["THEN", "a CASE expression"],
+	["ELSE", "a CASE expression"],
+	["END", "a CASE expression"],
+	["EXISTS", "an EXISTS subquery"],
+	["ANY", "a quantified subquery predicate (ANY)"],
+	["SOME", "a quantified subquery predicate (SOME)"],
+	["WITH", "a common table expression (WITH)"],
+	["INTO", "a SELECT ... INTO clause"],
+	["INSERT", "a non-SELECT statement (INSERT)"],
+	["UPDATE", "a non-SELECT statement (UPDATE)"],
+	["DELETE", "a non-SELECT statement (DELETE)"],
+	["CREATE", "a non-SELECT statement (CREATE)"],
+	["DROP", "a non-SELECT statement (DROP)"],
+	["ALTER", "a non-SELECT statement (ALTER)"],
+	["ESCAPE", "a LIKE ... ESCAPE clause"],
+	["COLLATE", "a COLLATE clause"],
+	["NULLS", "an ORDER BY NULLS FIRST/LAST clause"]
+]);
+function describeToken(token) {
+	switch (token.kind) {
+		case "keyword": return `keyword "${token.keyword}"`;
+		case "identifier": return `identifier "${token.text}"`;
+		case "string": return `string literal ${token.text}`;
+		case "number": return `numeric literal ${token.text}`;
+		case "operator": return `operator "${token.operator}"`;
+		case "punctuation": return `"${token.punctuation}"`;
+		case "end": return "end of statement";
+	}
+}
+function rejectOutOfScopeConstructs(tokens, sql) {
+	tokens.forEach((token, index) => {
+		if (token.kind === "keyword") {
+			const construct = OUT_OF_SCOPE_KEYWORDS.get(token.keyword);
+			if (construct !== void 0) throw new HsqldbSqlUnsupportedError(construct, sql);
+			if (token.keyword === "SELECT" && index > 0) throw new HsqldbSqlUnsupportedError("a subquery", sql);
+			return;
+		}
+		if (token.kind === "identifier") {
+			const next = tokens[index + 1];
+			if (next?.kind === "punctuation" && next.punctuation === "(") throw new HsqldbSqlUnsupportedError(`a scalar function (${token.text})`, sql);
+		}
+	});
+}
+var SqlParser = class {
+	tokens;
+	sql;
+	index = 0;
+	constructor(sql) {
+		this.sql = sql;
+		this.tokens = tokenizeSql(sql);
+		rejectOutOfScopeConstructs(this.tokens, sql);
+	}
+	peek() {
+		const token = this.tokens[this.index];
+		if (token === void 0) throw new HsqldbSqlParseError("unexpected end of statement", this.sql, this.sql.length);
+		return token;
+	}
+	advance() {
+		const token = this.peek();
+		if (token.kind !== "end") this.index += 1;
+		return token;
+	}
+	fail(expected) {
+		const token = this.peek();
+		throw new HsqldbSqlParseError(`expected ${expected}, found ${describeToken(token)}`, this.sql, token.start);
+	}
+	atKeyword(keyword) {
+		const token = this.peek();
+		return token.kind === "keyword" && token.keyword === keyword;
+	}
+	atPunctuation(punctuation) {
+		const token = this.peek();
+		return token.kind === "punctuation" && token.punctuation === punctuation;
+	}
+	takeKeyword(keyword) {
+		if (!this.atKeyword(keyword)) this.fail(`keyword ${keyword}`);
+		this.advance();
+	}
+	takePunctuation(punctuation) {
+		if (!this.atPunctuation(punctuation)) this.fail(`"${punctuation}"`);
+		this.advance();
+	}
+	takeName(what) {
+		const token = this.peek();
+		if (token.kind !== "identifier") this.fail(what);
+		this.advance();
+		return {
+			name: token.name,
+			quoted: token.quoted
+		};
+	}
+	parseColumnRef() {
+		const start = this.peek().start;
+		const first = this.takeName("a column name");
+		if (this.atPunctuation(".")) {
+			this.advance();
+			return {
+				qualifier: first,
+				column: this.takeName("a column name after \".\""),
+				text: this.sql.slice(start, this.previousEnd())
+			};
+		}
+		return {
+			qualifier: void 0,
+			column: first,
+			text: this.sql.slice(start, this.previousEnd())
+		};
+	}
+	previousEnd() {
+		const previous = this.tokens[this.index - 1];
+		if (previous === void 0) throw new HsqldbSqlParseError("unexpected end of statement", this.sql, this.sql.length);
+		return previous.start + previous.text.length;
+	}
+	parseAggregate(aggregate) {
+		this.advance();
+		this.takePunctuation("(");
+		if (this.atPunctuation("*")) {
+			if (aggregate !== "COUNT") this.fail(`a column name -- ${aggregate}(*) is not valid SQL, only COUNT(*) is`);
+			this.advance();
+			this.takePunctuation(")");
+			return {
+				kind: "aggregate",
+				aggregate,
+				argument: { kind: "star" },
+				outputName: "COUNT(*)"
+			};
+		}
+		const column = this.parseColumnRef();
+		this.takePunctuation(")");
+		return {
+			kind: "aggregate",
+			aggregate,
+			argument: {
+				kind: "column",
+				column
+			},
+			outputName: `${aggregate}(${column.column.name})`
+		};
+	}
+	parseSelectItem() {
+		const token = this.peek();
+		if (token.kind === "keyword" && isAggregateFunction(token.keyword)) return this.parseAggregate(token.keyword);
+		return {
+			kind: "column",
+			column: this.parseColumnRef()
+		};
+	}
+	parseSelectList() {
+		if (this.atPunctuation("*")) {
+			this.advance();
+			if (this.atPunctuation(",")) throw new HsqldbSqlUnsupportedError("a select list mixing \"*\" with named columns", this.sql);
+			return [{ kind: "star" }];
+		}
+		const items = [this.parseSelectItem()];
+		while (this.atPunctuation(",")) {
+			this.advance();
+			if (this.atPunctuation("*")) throw new HsqldbSqlUnsupportedError("a select list mixing \"*\" with named columns", this.sql);
+			items.push(this.parseSelectItem());
+		}
+		return items;
+	}
+	parseLiteral() {
+		const token = this.peek();
+		if (token.kind === "punctuation" && token.punctuation === "-") {
+			this.advance();
+			const number = this.peek();
+			if (number.kind !== "number") throw new HsqldbSqlUnsupportedError("an arithmetic expression", this.sql);
+			this.advance();
+			return {
+				kind: "number",
+				value: -number.value
+			};
+		}
+		if (token.kind === "number") {
+			this.advance();
+			return {
+				kind: "number",
+				value: token.value
+			};
+		}
+		if (token.kind === "string") {
+			this.advance();
+			return {
+				kind: "string",
+				value: token.value
+			};
+		}
+		if (token.kind === "keyword" && (token.keyword === "TRUE" || token.keyword === "FALSE")) {
+			this.advance();
+			return {
+				kind: "boolean",
+				value: token.keyword === "TRUE"
+			};
+		}
+		if (token.kind === "keyword" && token.keyword === "NULL") {
+			this.advance();
+			return { kind: "null" };
+		}
+		this.fail("a literal value");
+	}
+	parseOperand() {
+		const token = this.peek();
+		if (token.kind === "identifier") return {
+			kind: "column",
+			column: this.parseColumnRef()
+		};
+		if (token.kind === "punctuation" && token.punctuation === "(") throw new HsqldbSqlUnsupportedError("a parenthesised value expression", this.sql);
+		return {
+			kind: "literal",
+			literal: this.parseLiteral()
+		};
+	}
+	parseInList(operand, negated) {
+		this.takePunctuation("(");
+		const values = [];
+		for (;;) {
+			if (this.peek().kind === "identifier") throw new HsqldbSqlUnsupportedError("a column reference inside an IN list", this.sql);
+			values.push(this.parseLiteral());
+			if (this.atPunctuation(",")) {
+				this.advance();
+				continue;
+			}
+			break;
+		}
+		this.takePunctuation(")");
+		return {
+			kind: "in",
+			operand,
+			values,
+			negated
+		};
+	}
+	parseLike(operand, negated) {
+		const token = this.peek();
+		if (token.kind !== "string") {
+			if (token.kind === "identifier") throw new HsqldbSqlUnsupportedError("a non-literal LIKE pattern", this.sql);
+			this.fail("a string literal LIKE pattern");
+		}
+		this.advance();
+		return {
+			kind: "like",
+			operand,
+			pattern: token.value,
+			negated
+		};
+	}
+	parseBetween(operand, negated) {
+		const lower = this.parseOperand();
+		this.takeKeyword("AND");
+		return {
+			kind: "between",
+			operand,
+			lower,
+			upper: this.parseOperand(),
+			negated
+		};
+	}
+	parseNegatedPostfix(operand) {
+		this.advance();
+		if (this.atKeyword("LIKE")) {
+			this.advance();
+			return this.parseLike(operand, true);
+		}
+		if (this.atKeyword("IN")) {
+			this.advance();
+			return this.parseInList(operand, true);
+		}
+		if (this.atKeyword("BETWEEN")) {
+			this.advance();
+			return this.parseBetween(operand, true);
+		}
+		this.fail("keyword LIKE, IN or BETWEEN after NOT");
+	}
+	parsePostfix(operand) {
+		const token = this.peek();
+		if (token.kind === "operator") {
+			this.advance();
+			return {
+				kind: "comparison",
+				operator: token.operator,
+				left: operand,
+				right: this.parseOperand()
+			};
+		}
+		if (token.kind === "punctuation" && (token.punctuation === "*" || token.punctuation === "-")) throw new HsqldbSqlUnsupportedError("an arithmetic expression", this.sql);
+		if (token.kind === "keyword") {
+			if (token.keyword === "IS") {
+				this.advance();
+				const negated = this.atKeyword("NOT");
+				if (negated) this.advance();
+				this.takeKeyword("NULL");
+				return {
+					kind: "isNull",
+					operand,
+					negated
+				};
+			}
+			if (token.keyword === "LIKE") {
+				this.advance();
+				return this.parseLike(operand, false);
+			}
+			if (token.keyword === "IN") {
+				this.advance();
+				return this.parseInList(operand, false);
+			}
+			if (token.keyword === "BETWEEN") {
+				this.advance();
+				return this.parseBetween(operand, false);
+			}
+			if (token.keyword === "NOT") return this.parseNegatedPostfix(operand);
+		}
+		this.fail("a comparison operator, or keyword IS, LIKE, IN or BETWEEN");
+	}
+	parsePrimary() {
+		if (this.atPunctuation("(")) {
+			this.advance();
+			const predicate = this.parsePredicate();
+			this.takePunctuation(")");
+			return predicate;
+		}
+		return this.parsePostfix(this.parseOperand());
+	}
+	parseNot() {
+		if (this.atKeyword("NOT")) {
+			this.advance();
+			return {
+				kind: "not",
+				predicate: this.parseNot()
+			};
+		}
+		return this.parsePrimary();
+	}
+	parseAnd() {
+		let predicate = this.parseNot();
+		while (this.atKeyword("AND")) {
+			this.advance();
+			predicate = {
+				kind: "and",
+				left: predicate,
+				right: this.parseNot()
+			};
+		}
+		return predicate;
+	}
+	parsePredicate() {
+		let predicate = this.parseAnd();
+		while (this.atKeyword("OR")) {
+			this.advance();
+			predicate = {
+				kind: "or",
+				left: predicate,
+				right: this.parseAnd()
+			};
+		}
+		return predicate;
+	}
+	parseGroupBy() {
+		this.takeKeyword("GROUP");
+		this.takeKeyword("BY");
+		const columns = [this.parseGroupByColumn()];
+		while (this.atPunctuation(",")) {
+			this.advance();
+			columns.push(this.parseGroupByColumn());
+		}
+		return columns;
+	}
+	parseGroupByColumn() {
+		const token = this.peek();
+		if (token.kind === "keyword" && isAggregateFunction(token.keyword)) this.fail("a column name -- an aggregate function is not valid in GROUP BY");
+		return this.parseColumnRef();
+	}
+	parseOrderBy() {
+		this.takeKeyword("ORDER");
+		this.takeKeyword("BY");
+		const terms = [this.parseOrderByTerm()];
+		while (this.atPunctuation(",")) {
+			this.advance();
+			terms.push(this.parseOrderByTerm());
+		}
+		return terms;
+	}
+	parseOrderByTerm() {
+		const token = this.peek();
+		if (token.kind === "keyword" && isAggregateFunction(token.keyword)) throw new HsqldbSqlUnsupportedError("an aggregate function in ORDER BY", this.sql);
+		if (token.kind === "number") throw new HsqldbSqlUnsupportedError("an ordinal column reference in ORDER BY (ORDER BY 1)", this.sql);
+		const column = this.parseColumnRef();
+		if (this.atKeyword("ASC")) {
+			this.advance();
+			return {
+				column,
+				direction: "asc"
+			};
+		}
+		if (this.atKeyword("DESC")) {
+			this.advance();
+			return {
+				column,
+				direction: "desc"
+			};
+		}
+		return {
+			column,
+			direction: "asc"
+		};
+	}
+	parseStatement() {
+		const first = this.peek();
+		if (!(first.kind === "keyword" && first.keyword === "SELECT")) this.fail("keyword SELECT");
+		this.advance();
+		const items = this.parseSelectList();
+		this.takeKeyword("FROM");
+		if (this.atPunctuation("(")) throw new HsqldbSqlUnsupportedError("a derived table in FROM", this.sql);
+		const from = this.takeName("a table name");
+		if (this.atPunctuation(".")) throw new HsqldbSqlUnsupportedError("a schema-qualified table name", this.sql);
+		if (this.atPunctuation(",")) throw new HsqldbSqlUnsupportedError("a JOIN", this.sql);
+		if (this.peek().kind === "identifier") throw new HsqldbSqlUnsupportedError("a table alias", this.sql);
+		let where;
+		if (this.atKeyword("WHERE")) {
+			this.advance();
+			where = this.parsePredicate();
+		}
+		const groupBy = this.atKeyword("GROUP") ? this.parseGroupBy() : [];
+		const orderBy = this.atKeyword("ORDER") ? this.parseOrderBy() : [];
+		if (this.atPunctuation(";")) this.advance();
+		if (this.peek().kind !== "end") this.fail("end of statement");
+		return {
+			sql: this.sql,
+			items,
+			from,
+			where,
+			groupBy,
+			orderBy
+		};
+	}
+};
+function parseSelect(sql) {
+	return new SqlParser(sql).parseStatement();
+}
+//#endregion
+export { parseSelect };

package/dist/odb/values.cjs

@@ -0,0 +1,75 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/odb/values.ts
+const CELL_NULL = { kind: "empty" };
+function cellComparisonKey(value) {
+	switch (value.kind) {
+		case "number":
+		case "percentage":
+		case "currency": return {
+			valueClass: "numeric",
+			numeric: value.value
+		};
+		case "boolean": return {
+			valueClass: "boolean",
+			boolean: value.value
+		};
+		case "date":
+		case "time":
+		case "dateTime":
+		case "string":
+		case "error": return {
+			valueClass: "text",
+			text: value.value
+		};
+		case "empty": return;
+	}
+}
+function compareCellKeys(left, right, fail) {
+	if (left.valueClass === "numeric" && right.valueClass === "numeric") return left.numeric === right.numeric ? 0 : left.numeric < right.numeric ? -1 : 1;
+	if (left.valueClass === "boolean" && right.valueClass === "boolean") return left.boolean === right.boolean ? 0 : left.boolean ? 1 : -1;
+	if (left.valueClass === "text" && right.valueClass === "text") return left.text === right.text ? 0 : left.text < right.text ? -1 : 1;
+	throw fail(`cannot compare a ${left.valueClass} value with a ${right.valueClass} value`);
+}
+function compareCellValues(left, right, fail) {
+	const leftKey = cellComparisonKey(left);
+	const rightKey = cellComparisonKey(right);
+	if (leftKey === void 0 || rightKey === void 0) throw fail("a NULL value reached a comparison that had already ruled NULL out");
+	return compareCellKeys(leftKey, rightKey, fail);
+}
+function cellValuesEqual(left, right) {
+	const leftKey = cellComparisonKey(left);
+	const rightKey = cellComparisonKey(right);
+	if (leftKey === void 0 || rightKey === void 0) return leftKey === rightKey;
+	if (leftKey.valueClass === "numeric" && rightKey.valueClass === "numeric") return leftKey.numeric === rightKey.numeric;
+	if (leftKey.valueClass === "boolean" && rightKey.valueClass === "boolean") return leftKey.boolean === rightKey.boolean;
+	return leftKey.valueClass === "text" && rightKey.valueClass === "text" && leftKey.text === rightKey.text;
+}
+function numericOf(value, aggregate, fail) {
+	const key = cellComparisonKey(value);
+	if (key?.valueClass !== "numeric") throw fail(`${aggregate} requires numeric values, but found a ${value.kind} value`);
+	return key.numeric;
+}
+function aggregateCellValues(aggregate, values, fail) {
+	const present = values.filter((value) => value.kind !== "empty");
+	if (aggregate === "COUNT") return {
+		kind: "number",
+		value: present.length
+	};
+	const first = present[0];
+	if (first === void 0) return CELL_NULL;
+	if (aggregate === "SUM" || aggregate === "AVG") {
+		const total = present.reduce((sum, value) => sum + numericOf(value, aggregate, fail), 0);
+		return {
+			kind: "number",
+			value: aggregate === "SUM" ? total : total / present.length
+		};
+	}
+	return present.reduce((best, value) => (aggregate === "MIN" ? compareCellValues(value, best, fail) < 0 : compareCellValues(value, best, fail) > 0) ? value : best, first);
+}
+//#endregion
+exports.CELL_NULL = CELL_NULL;
+exports.aggregateCellValues = aggregateCellValues;
+exports.cellComparisonKey = cellComparisonKey;
+exports.cellValuesEqual = cellValuesEqual;
+exports.compareCellKeys = compareCellKeys;
+exports.compareCellValues = compareCellValues;

package/dist/odb/values.d.cts

@@ -0,0 +1,2 @@
+import { a as CellValueFailure, c as cellValuesEqual, i as CellValueClass, l as compareCellKeys, n as CellAggregateFunction, o as aggregateCellValues, r as CellComparisonKey, s as cellComparisonKey, t as CELL_NULL, u as compareCellValues } from "../values-BetetbaH.cjs";
+export { CELL_NULL, CellAggregateFunction, CellComparisonKey, CellValueClass, CellValueFailure, aggregateCellValues, cellComparisonKey, cellValuesEqual, compareCellKeys, compareCellValues };

package/dist/odb/values.d.ts

@@ -0,0 +1,2 @@
+import { a as CellValueFailure, c as cellValuesEqual, i as CellValueClass, l as compareCellKeys, n as CellAggregateFunction, o as aggregateCellValues, r as CellComparisonKey, s as cellComparisonKey, t as CELL_NULL, u as compareCellValues } from "../values-BetetbaH.js";
+export { CELL_NULL, CellAggregateFunction, CellComparisonKey, CellValueClass, CellValueFailure, aggregateCellValues, cellComparisonKey, cellValuesEqual, compareCellKeys, compareCellValues };

package/dist/odb/values.js

@@ -0,0 +1,69 @@
+//#region src/odb/values.ts
+const CELL_NULL = { kind: "empty" };
+function cellComparisonKey(value) {
+	switch (value.kind) {
+		case "number":
+		case "percentage":
+		case "currency": return {
+			valueClass: "numeric",
+			numeric: value.value
+		};
+		case "boolean": return {
+			valueClass: "boolean",
+			boolean: value.value
+		};
+		case "date":
+		case "time":
+		case "dateTime":
+		case "string":
+		case "error": return {
+			valueClass: "text",
+			text: value.value
+		};
+		case "empty": return;
+	}
+}
+function compareCellKeys(left, right, fail) {
+	if (left.valueClass === "numeric" && right.valueClass === "numeric") return left.numeric === right.numeric ? 0 : left.numeric < right.numeric ? -1 : 1;
+	if (left.valueClass === "boolean" && right.valueClass === "boolean") return left.boolean === right.boolean ? 0 : left.boolean ? 1 : -1;
+	if (left.valueClass === "text" && right.valueClass === "text") return left.text === right.text ? 0 : left.text < right.text ? -1 : 1;
+	throw fail(`cannot compare a ${left.valueClass} value with a ${right.valueClass} value`);
+}
+function compareCellValues(left, right, fail) {
+	const leftKey = cellComparisonKey(left);
+	const rightKey = cellComparisonKey(right);
+	if (leftKey === void 0 || rightKey === void 0) throw fail("a NULL value reached a comparison that had already ruled NULL out");
+	return compareCellKeys(leftKey, rightKey, fail);
+}
+function cellValuesEqual(left, right) {
+	const leftKey = cellComparisonKey(left);
+	const rightKey = cellComparisonKey(right);
+	if (leftKey === void 0 || rightKey === void 0) return leftKey === rightKey;
+	if (leftKey.valueClass === "numeric" && rightKey.valueClass === "numeric") return leftKey.numeric === rightKey.numeric;
+	if (leftKey.valueClass === "boolean" && rightKey.valueClass === "boolean") return leftKey.boolean === rightKey.boolean;
+	return leftKey.valueClass === "text" && rightKey.valueClass === "text" && leftKey.text === rightKey.text;
+}
+function numericOf(value, aggregate, fail) {
+	const key = cellComparisonKey(value);
+	if (key?.valueClass !== "numeric") throw fail(`${aggregate} requires numeric values, but found a ${value.kind} value`);
+	return key.numeric;
+}
+function aggregateCellValues(aggregate, values, fail) {
+	const present = values.filter((value) => value.kind !== "empty");
+	if (aggregate === "COUNT") return {
+		kind: "number",
+		value: present.length
+	};
+	const first = present[0];
+	if (first === void 0) return CELL_NULL;
+	if (aggregate === "SUM" || aggregate === "AVG") {
+		const total = present.reduce((sum, value) => sum + numericOf(value, aggregate, fail), 0);
+		return {
+			kind: "number",
+			value: aggregate === "SUM" ? total : total / present.length
+		};
+	}
+	return present.reduce((best, value) => (aggregate === "MIN" ? compareCellValues(value, best, fail) < 0 : compareCellValues(value, best, fail) > 0) ? value : best, first);
+}
+//#endregion
+export { CELL_NULL, aggregateCellValues, cellComparisonKey, cellValuesEqual, compareCellKeys, compareCellValues };