documents.js 1.63.0 → 1.64.0

package/dist/odb/sql/parser.cjs

@@ -0,0 +1,479 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_odb_sql_errors = require("./errors.cjs");
+const require_odb_sql_lexer = require("./lexer.cjs");
+//#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 require_odb_sql_errors.HsqldbSqlUnsupportedError(construct, sql);
+			if (token.keyword === "SELECT" && index > 0) throw new require_odb_sql_errors.HsqldbSqlUnsupportedError("a subquery", sql);
+			return;
+		}
+		if (token.kind === "identifier") {
+			const next = tokens[index + 1];
+			if (next?.kind === "punctuation" && next.punctuation === "(") throw new require_odb_sql_errors.HsqldbSqlUnsupportedError(`a scalar function (${token.text})`, sql);
+		}
+	});
+}
+var SqlParser = class {
+	tokens;
+	sql;
+	index = 0;
+	constructor(sql) {
+		this.sql = sql;
+		this.tokens = require_odb_sql_lexer.tokenizeSql(sql);
+		rejectOutOfScopeConstructs(this.tokens, sql);
+	}
+	peek() {
+		const token = this.tokens[this.index];
+		if (token === void 0) throw new require_odb_sql_errors.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 require_odb_sql_errors.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 require_odb_sql_errors.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 require_odb_sql_errors.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 require_odb_sql_errors.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 require_odb_sql_errors.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 require_odb_sql_errors.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 require_odb_sql_errors.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 require_odb_sql_errors.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 require_odb_sql_errors.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 require_odb_sql_errors.HsqldbSqlUnsupportedError("an aggregate function in ORDER BY", this.sql);
+		if (token.kind === "number") throw new require_odb_sql_errors.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 require_odb_sql_errors.HsqldbSqlUnsupportedError("a derived table in FROM", this.sql);
+		const from = this.takeName("a table name");
+		if (this.atPunctuation(".")) throw new require_odb_sql_errors.HsqldbSqlUnsupportedError("a schema-qualified table name", this.sql);
+		if (this.atPunctuation(",")) throw new require_odb_sql_errors.HsqldbSqlUnsupportedError("a JOIN", this.sql);
+		if (this.peek().kind === "identifier") throw new require_odb_sql_errors.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
+exports.parseSelect = parseSelect;

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

@@ -0,0 +1,2 @@
+import { a as SqlNameRef, c as SqlPredicate, d as SqlSortDirection, f as parseSelect, i as SqlLiteral, l as SqlSelectItem, n as SqlAggregateFunction, o as SqlOperand, r as SqlColumnRef, s as SqlOrderByTerm, t as SqlAggregateArgument, u as SqlSelectStatement } from "../../parser-B9vC1T6T.cjs";
+export { SqlAggregateArgument, SqlAggregateFunction, SqlColumnRef, SqlLiteral, SqlNameRef, SqlOperand, SqlOrderByTerm, SqlPredicate, SqlSelectItem, SqlSelectStatement, SqlSortDirection, parseSelect };

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

@@ -0,0 +1,2 @@
+import { a as SqlNameRef, c as SqlPredicate, d as SqlSortDirection, f as parseSelect, i as SqlLiteral, l as SqlSelectItem, n as SqlAggregateFunction, o as SqlOperand, r as SqlColumnRef, s as SqlOrderByTerm, t as SqlAggregateArgument, u as SqlSelectStatement } from "../../parser-DQSgYJzQ.js";
+export { SqlAggregateArgument, SqlAggregateFunction, SqlColumnRef, SqlLiteral, SqlNameRef, SqlOperand, SqlOrderByTerm, SqlPredicate, SqlSelectItem, SqlSelectStatement, SqlSortDirection, parseSelect };